mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-07 04:35:49 +00:00
282 lines
7.7 KiB
Python
Executable File
282 lines
7.7 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
# This file is part of rippled: https://github.com/ripple/rippled
|
|
# Copyright (c) 2012 - 2015 Ripple Labs Inc.
|
|
#
|
|
# Permission to use, copy, modify, and/or distribute this software for any
|
|
# purpose with or without fee is hereby granted, provided that the above
|
|
# copyright notice and this permission notice appear in all copies.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
# ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
"""
|
|
Invocation:
|
|
|
|
./Builds/Test.py - builds and tests all configurations
|
|
|
|
The build must succeed without shell aliases for this to work.
|
|
|
|
To pass flags to scons, put them at the very end of the command line, after
|
|
the -- flag - like this:
|
|
|
|
./Builds/Test.py -- -j4 # Pass -j4 to scons.
|
|
|
|
|
|
Common problems:
|
|
|
|
1) Boost not found. Solution: export BOOST_ROOT=[path to boost folder]
|
|
|
|
2) OpenSSL not found. Solution: export OPENSSL_ROOT=[path to OpenSSL folder]
|
|
|
|
3) scons is an alias. Solution: Create a script named "scons" somewhere in
|
|
your $PATH (eg. ~/bin/scons will often work).
|
|
|
|
#!/bin/sh
|
|
python /C/Python27/Scripts/scons.py "${@}"
|
|
|
|
"""
|
|
from __future__ import absolute_import, division, print_function, unicode_literals
|
|
|
|
import argparse
|
|
import itertools
|
|
import os
|
|
import platform
|
|
import re
|
|
import shutil
|
|
import sys
|
|
import subprocess
|
|
|
|
|
|
def powerset(iterable):
|
|
"""powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"""
|
|
s = list(iterable)
|
|
return itertools.chain.from_iterable(itertools.combinations(s, r) for r in range(len(s) + 1))
|
|
|
|
IS_WINDOWS = platform.system().lower() == 'windows'
|
|
IS_OS_X = platform.system().lower() == 'darwin'
|
|
|
|
if IS_WINDOWS or IS_OS_X:
|
|
ALL_TARGETS = [('debug',), ('release',)]
|
|
else:
|
|
ALL_TARGETS = [(cc + "." + target,)
|
|
for cc in ['gcc', 'clang']
|
|
for target in ['debug', 'release', 'coverage', 'profile',
|
|
'debug.nounity', 'release.nounity', 'coverage.nounity', 'profile.nounity']]
|
|
|
|
# list of tuples of all possible options
|
|
if IS_WINDOWS or IS_OS_X:
|
|
ALL_OPTIONS = [tuple(x) for x in powerset(['--assert'])]
|
|
else:
|
|
ALL_OPTIONS = list(set(
|
|
[tuple(x) for x in powerset(['--ninja', '--static', '--assert', '--sanitize=address'])] +
|
|
[tuple(x) for x in powerset(['--ninja', '--static', '--assert', '--sanitize=thread'])]))
|
|
|
|
# list of tuples of all possible options + all possible targets
|
|
ALL_BUILDS = [options + target
|
|
for target in ALL_TARGETS
|
|
for options in ALL_OPTIONS]
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description='Test.py - run ripple tests'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--all', '-a',
|
|
action='store_true',
|
|
help='Build all configurations.',
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--keep_going', '-k',
|
|
action='store_true',
|
|
help='Keep going after one configuration has failed.',
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--silent', '-s',
|
|
action='store_true',
|
|
help='Silence all messages except errors',
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--verbose', '-v',
|
|
action='store_true',
|
|
help=('Report more information about which commands are executed and the '
|
|
'results.'),
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--test', '-t',
|
|
default='',
|
|
help='Add a prefix for unit tests',
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--nonpm', '-n',
|
|
action='store_true',
|
|
help='Do not run npm tests',
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--clean', '-c',
|
|
action='store_true',
|
|
help='delete all build artifacts after testing',
|
|
)
|
|
|
|
parser.add_argument(
|
|
'scons_args',
|
|
default=(),
|
|
nargs='*'
|
|
)
|
|
|
|
ARGS = parser.parse_args()
|
|
|
|
|
|
def shell(cmd, args=(), silent=False):
|
|
""""Execute a shell command and return the output."""
|
|
silent = ARGS.silent or silent
|
|
verbose = not silent and ARGS.verbose
|
|
if verbose:
|
|
print('$' + cmd, *args)
|
|
|
|
command = (cmd,) + args
|
|
|
|
process = subprocess.Popen(
|
|
command,
|
|
stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
shell=IS_WINDOWS)
|
|
lines = []
|
|
count = 0
|
|
for line in process.stdout:
|
|
# Python 2 vs. Python 3
|
|
if isinstance(line, str):
|
|
decoded = line
|
|
else:
|
|
decoded = line.decode()
|
|
lines.append(decoded)
|
|
if verbose:
|
|
print(decoded, end='')
|
|
elif not silent:
|
|
count += 1
|
|
if count >= 80:
|
|
print()
|
|
count = 0
|
|
else:
|
|
print('.', end='')
|
|
|
|
if not verbose and count:
|
|
print()
|
|
process.wait()
|
|
return process.returncode, lines
|
|
|
|
|
|
def run_tests(args):
|
|
failed = []
|
|
if IS_WINDOWS:
|
|
binary_re = re.compile(r'build\\([^\\]+)\\rippled.exe')
|
|
else:
|
|
binary_re = re.compile(r'build/([^/]+)/rippled')
|
|
_, lines = shell('scons', ('-n', '--tree=derived',) + args, silent=True)
|
|
for line in lines:
|
|
match = binary_re.search(line)
|
|
if match:
|
|
executable, target = match.group(0, 1)
|
|
|
|
print('Unit tests for', target)
|
|
testflag = '--unittest'
|
|
if ARGS.test:
|
|
testflag += ('=' + ARGS.test)
|
|
resultcode, lines = shell(executable, (testflag,))
|
|
|
|
if resultcode:
|
|
if not ARGS.verbose:
|
|
print('ERROR:', *lines, sep='')
|
|
failed.append([target, 'unittest'])
|
|
if not ARGS.keep_going:
|
|
break
|
|
|
|
if not ARGS.nonpm:
|
|
print('npm tests for', target)
|
|
resultcode, lines = shell('npm', ('test', '--rippled=' + executable,))
|
|
if resultcode:
|
|
if not ARGS.verbose:
|
|
print('ERROR:\n', *lines, sep='')
|
|
failed.append([target, 'npm'])
|
|
if not ARGS.keep_going:
|
|
break
|
|
return failed
|
|
|
|
|
|
def run_build(args=None):
|
|
print('Building:', *args or ('(default)',))
|
|
resultcode, lines = shell('scons', args)
|
|
|
|
if resultcode:
|
|
print('Build FAILED:')
|
|
if not ARGS.verbose:
|
|
print(*lines, sep='')
|
|
sys.exit(1)
|
|
if '--ninja' in args:
|
|
resultcode, lines = shell('ninja')
|
|
|
|
if resultcode:
|
|
print('Ninja build FAILED:')
|
|
if not ARGS.verbose:
|
|
print(*lines, sep='')
|
|
sys.exit(1)
|
|
|
|
|
|
def main():
|
|
if ARGS.all:
|
|
to_build = ALL_BUILDS
|
|
else:
|
|
to_build = [tuple(ARGS.scons_args)]
|
|
|
|
all_failed = []
|
|
|
|
for build in to_build:
|
|
args = ()
|
|
# additional arguments come first
|
|
for arg in list(ARGS.scons_args):
|
|
if arg not in build:
|
|
args += (arg,)
|
|
args += build
|
|
|
|
run_build(args)
|
|
failed = run_tests(args)
|
|
|
|
if failed:
|
|
print('FAILED:', *(':'.join(f) for f in failed))
|
|
if not ARGS.keep_going:
|
|
sys.exit(1)
|
|
else:
|
|
all_failed.extend([','.join(build), ':'.join(f)]
|
|
for f in failed)
|
|
else:
|
|
print('Success')
|
|
|
|
if ARGS.clean:
|
|
shutil.rmtree('build')
|
|
if '--ninja' in args:
|
|
os.remove('build.ninja')
|
|
os.remove('.ninja_deps')
|
|
os.remove('.ninja_log')
|
|
|
|
if all_failed:
|
|
if len(to_build) > 1:
|
|
print()
|
|
print('FAILED:', *(':'.join(f) for f in all_failed))
|
|
sys.exit(1)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
sys.exit(0)
|