THRIFT-3596 Better conformance to PEP8
This closes #832
diff --git a/test/crossrunner/collect.py b/test/crossrunner/collect.py
index f92b9e2..e91ac0b 100644
--- a/test/crossrunner/collect.py
+++ b/test/crossrunner/collect.py
@@ -40,13 +40,13 @@
# (e.g. "binary" is equivalent to "binary:binary" in tests.json)
#
VALID_JSON_KEYS = [
- 'name', # name of the library, typically a language name
- 'workdir', # work directory where command is executed
- 'command', # test command
- 'extra_args', # args appended to command after other args are appended
- 'remote_args', # args added to the other side of the program
- 'join_args', # whether args should be passed as single concatenated string
- 'env', # additional environmental variable
+ 'name', # name of the library, typically a language name
+ 'workdir', # work directory where command is executed
+ 'command', # test command
+ 'extra_args', # args appended to command after other args are appended
+ 'remote_args', # args added to the other side of the program
+ 'join_args', # whether args should be passed as single concatenated string
+ 'env', # additional environmental variable
]
DEFAULT_DELAY = 1
@@ -54,102 +54,102 @@
def _collect_testlibs(config, server_match, client_match=[None]):
- """Collects server/client configurations from library configurations"""
- def expand_libs(config):
- for lib in config:
- sv = lib.pop('server', None)
- cl = lib.pop('client', None)
- yield lib, sv, cl
+ """Collects server/client configurations from library configurations"""
+ def expand_libs(config):
+ for lib in config:
+ sv = lib.pop('server', None)
+ cl = lib.pop('client', None)
+ yield lib, sv, cl
- def yield_testlibs(base_configs, configs, match):
- for base, conf in zip(base_configs, configs):
- if conf:
- if not match or base['name'] in match:
- platforms = conf.get('platforms') or base.get('platforms')
- if not platforms or platform.system() in platforms:
- yield merge_dict(base, conf)
+ def yield_testlibs(base_configs, configs, match):
+ for base, conf in zip(base_configs, configs):
+ if conf:
+ if not match or base['name'] in match:
+ platforms = conf.get('platforms') or base.get('platforms')
+ if not platforms or platform.system() in platforms:
+ yield merge_dict(base, conf)
- libs, svs, cls = zip(*expand_libs(config))
- servers = list(yield_testlibs(libs, svs, server_match))
- clients = list(yield_testlibs(libs, cls, client_match))
- return servers, clients
+ libs, svs, cls = zip(*expand_libs(config))
+ servers = list(yield_testlibs(libs, svs, server_match))
+ clients = list(yield_testlibs(libs, cls, client_match))
+ return servers, clients
def collect_features(config, match):
- res = list(map(re.compile, match))
- return list(filter(lambda c: any(map(lambda r: r.search(c['name']), res)), config))
+ res = list(map(re.compile, match))
+ return list(filter(lambda c: any(map(lambda r: r.search(c['name']), res)), config))
def _do_collect_tests(servers, clients):
- def intersection(key, o1, o2):
- """intersection of two collections.
- collections are replaced with sets the first time"""
- def cached_set(o, key):
- v = o[key]
- if not isinstance(v, set):
- v = set(v)
- o[key] = v
- return v
- return cached_set(o1, key) & cached_set(o2, key)
+ def intersection(key, o1, o2):
+ """intersection of two collections.
+ collections are replaced with sets the first time"""
+ def cached_set(o, key):
+ v = o[key]
+ if not isinstance(v, set):
+ v = set(v)
+ o[key] = v
+ return v
+ return cached_set(o1, key) & cached_set(o2, key)
- def intersect_with_spec(key, o1, o2):
- # store as set of (spec, impl) tuple
- def cached_set(o):
- def to_spec_impl_tuples(values):
- for v in values:
- spec, _, impl = v.partition(':')
- yield spec, impl or spec
- v = o[key]
- if not isinstance(v, set):
- v = set(to_spec_impl_tuples(set(v)))
- o[key] = v
- return v
- for spec1, impl1 in cached_set(o1):
- for spec2, impl2 in cached_set(o2):
- if spec1 == spec2:
- name = impl1 if impl1 == impl2 else '%s-%s' % (impl1, impl2)
- yield name, impl1, impl2
+ def intersect_with_spec(key, o1, o2):
+ # store as set of (spec, impl) tuple
+ def cached_set(o):
+ def to_spec_impl_tuples(values):
+ for v in values:
+ spec, _, impl = v.partition(':')
+ yield spec, impl or spec
+ v = o[key]
+ if not isinstance(v, set):
+ v = set(to_spec_impl_tuples(set(v)))
+ o[key] = v
+ return v
+ for spec1, impl1 in cached_set(o1):
+ for spec2, impl2 in cached_set(o2):
+ if spec1 == spec2:
+ name = impl1 if impl1 == impl2 else '%s-%s' % (impl1, impl2)
+ yield name, impl1, impl2
- def maybe_max(key, o1, o2, default):
- """maximum of two if present, otherwise defult value"""
- v1 = o1.get(key)
- v2 = o2.get(key)
- return max(v1, v2) if v1 and v2 else v1 or v2 or default
+ def maybe_max(key, o1, o2, default):
+ """maximum of two if present, otherwise defult value"""
+ v1 = o1.get(key)
+ v2 = o2.get(key)
+ return max(v1, v2) if v1 and v2 else v1 or v2 or default
- def filter_with_validkeys(o):
- ret = {}
- for key in VALID_JSON_KEYS:
- if key in o:
- ret[key] = o[key]
- return ret
+ def filter_with_validkeys(o):
+ ret = {}
+ for key in VALID_JSON_KEYS:
+ if key in o:
+ ret[key] = o[key]
+ return ret
- def merge_metadata(o, **ret):
- for key in VALID_JSON_KEYS:
- if key in o:
- ret[key] = o[key]
- return ret
+ def merge_metadata(o, **ret):
+ for key in VALID_JSON_KEYS:
+ if key in o:
+ ret[key] = o[key]
+ return ret
- for sv, cl in product(servers, clients):
- for proto, proto1, proto2 in intersect_with_spec('protocols', sv, cl):
- for trans, trans1, trans2 in intersect_with_spec('transports', sv, cl):
- for sock in intersection('sockets', sv, cl):
- yield {
- 'server': merge_metadata(sv, **{'protocol': proto1, 'transport': trans1}),
- 'client': merge_metadata(cl, **{'protocol': proto2, 'transport': trans2}),
- 'delay': maybe_max('delay', sv, cl, DEFAULT_DELAY),
- 'timeout': maybe_max('timeout', sv, cl, DEFAULT_TIMEOUT),
- 'protocol': proto,
- 'transport': trans,
- 'socket': sock
- }
+ for sv, cl in product(servers, clients):
+ for proto, proto1, proto2 in intersect_with_spec('protocols', sv, cl):
+ for trans, trans1, trans2 in intersect_with_spec('transports', sv, cl):
+ for sock in intersection('sockets', sv, cl):
+ yield {
+ 'server': merge_metadata(sv, **{'protocol': proto1, 'transport': trans1}),
+ 'client': merge_metadata(cl, **{'protocol': proto2, 'transport': trans2}),
+ 'delay': maybe_max('delay', sv, cl, DEFAULT_DELAY),
+ 'timeout': maybe_max('timeout', sv, cl, DEFAULT_TIMEOUT),
+ 'protocol': proto,
+ 'transport': trans,
+ 'socket': sock
+ }
def collect_cross_tests(tests_dict, server_match, client_match):
- sv, cl = _collect_testlibs(tests_dict, server_match, client_match)
- return list(_do_collect_tests(sv, cl))
+ sv, cl = _collect_testlibs(tests_dict, server_match, client_match)
+ return list(_do_collect_tests(sv, cl))
def collect_feature_tests(tests_dict, features_dict, server_match, feature_match):
- sv, _ = _collect_testlibs(tests_dict, server_match)
- ft = collect_features(features_dict, feature_match)
- return list(_do_collect_tests(sv, ft))
+ sv, _ = _collect_testlibs(tests_dict, server_match)
+ ft = collect_features(features_dict, feature_match)
+ return list(_do_collect_tests(sv, ft))
diff --git a/test/crossrunner/compat.py b/test/crossrunner/compat.py
index 6ab9d71..f1ca91b 100644
--- a/test/crossrunner/compat.py
+++ b/test/crossrunner/compat.py
@@ -2,23 +2,23 @@
import sys
if sys.version_info[0] == 2:
- _ENCODE = sys.getfilesystemencoding()
+ _ENCODE = sys.getfilesystemencoding()
- def path_join(*args):
- bin_args = map(lambda a: a.decode(_ENCODE), args)
- return os.path.join(*bin_args).encode(_ENCODE)
+ def path_join(*args):
+ bin_args = map(lambda a: a.decode(_ENCODE), args)
+ return os.path.join(*bin_args).encode(_ENCODE)
- def str_join(s, l):
- bin_args = map(lambda a: a.decode(_ENCODE), l)
- b = s.decode(_ENCODE)
- return b.join(bin_args).encode(_ENCODE)
+ def str_join(s, l):
+ bin_args = map(lambda a: a.decode(_ENCODE), l)
+ b = s.decode(_ENCODE)
+ return b.join(bin_args).encode(_ENCODE)
- logfile_open = open
+ logfile_open = open
else:
- path_join = os.path.join
- str_join = str.join
+ path_join = os.path.join
+ str_join = str.join
- def logfile_open(*args):
- return open(*args, errors='replace')
+ def logfile_open(*args):
+ return open(*args, errors='replace')
diff --git a/test/crossrunner/report.py b/test/crossrunner/report.py
index be7271c..cc5f26f 100644
--- a/test/crossrunner/report.py
+++ b/test/crossrunner/report.py
@@ -39,396 +39,396 @@
def generate_known_failures(testdir, overwrite, save, out):
- def collect_failures(results):
- success_index = 5
- for r in results:
- if not r[success_index]:
- yield TestEntry.get_name(*r)
- try:
- with logfile_open(path_join(testdir, RESULT_JSON), 'r') as fp:
- results = json.load(fp)
- except IOError:
- sys.stderr.write('Unable to load last result. Did you run tests ?\n')
- return False
- fails = collect_failures(results['results'])
- if not overwrite:
- known = load_known_failures(testdir)
- known.extend(fails)
- fails = known
- fails_json = json.dumps(sorted(set(fails)), indent=2, separators=(',', ': '))
- if save:
- with logfile_open(os.path.join(testdir, FAIL_JSON % platform.system()), 'w+') as fp:
- fp.write(fails_json)
- sys.stdout.write('Successfully updated known failures.\n')
- if out:
- sys.stdout.write(fails_json)
- sys.stdout.write('\n')
- return True
+ def collect_failures(results):
+ success_index = 5
+ for r in results:
+ if not r[success_index]:
+ yield TestEntry.get_name(*r)
+ try:
+ with logfile_open(path_join(testdir, RESULT_JSON), 'r') as fp:
+ results = json.load(fp)
+ except IOError:
+ sys.stderr.write('Unable to load last result. Did you run tests ?\n')
+ return False
+ fails = collect_failures(results['results'])
+ if not overwrite:
+ known = load_known_failures(testdir)
+ known.extend(fails)
+ fails = known
+ fails_json = json.dumps(sorted(set(fails)), indent=2, separators=(',', ': '))
+ if save:
+ with logfile_open(os.path.join(testdir, FAIL_JSON % platform.system()), 'w+') as fp:
+ fp.write(fails_json)
+ sys.stdout.write('Successfully updated known failures.\n')
+ if out:
+ sys.stdout.write(fails_json)
+ sys.stdout.write('\n')
+ return True
def load_known_failures(testdir):
- try:
- with logfile_open(path_join(testdir, FAIL_JSON % platform.system()), 'r') as fp:
- return json.load(fp)
- except IOError:
- return []
+ try:
+ with logfile_open(path_join(testdir, FAIL_JSON % platform.system()), 'r') as fp:
+ return json.load(fp)
+ except IOError:
+ return []
class TestReporter(object):
- # Unfortunately, standard library doesn't handle timezone well
- # DATETIME_FORMAT = '%a %b %d %H:%M:%S %Z %Y'
- DATETIME_FORMAT = '%a %b %d %H:%M:%S %Y'
+ # Unfortunately, standard library doesn't handle timezone well
+ # DATETIME_FORMAT = '%a %b %d %H:%M:%S %Z %Y'
+ DATETIME_FORMAT = '%a %b %d %H:%M:%S %Y'
- def __init__(self):
- self._log = multiprocessing.get_logger()
- self._lock = multiprocessing.Lock()
+ def __init__(self):
+ self._log = multiprocessing.get_logger()
+ self._lock = multiprocessing.Lock()
- @classmethod
- def test_logfile(cls, test_name, prog_kind, dir=None):
- relpath = path_join('log', '%s_%s.log' % (test_name, prog_kind))
- return relpath if not dir else os.path.realpath(path_join(dir, relpath))
+ @classmethod
+ def test_logfile(cls, test_name, prog_kind, dir=None):
+ relpath = path_join('log', '%s_%s.log' % (test_name, prog_kind))
+ return relpath if not dir else os.path.realpath(path_join(dir, relpath))
- def _start(self):
- self._start_time = time.time()
+ def _start(self):
+ self._start_time = time.time()
- @property
- def _elapsed(self):
- return time.time() - self._start_time
+ @property
+ def _elapsed(self):
+ return time.time() - self._start_time
- @classmethod
- def _format_date(cls):
- return '%s' % datetime.datetime.now().strftime(cls.DATETIME_FORMAT)
+ @classmethod
+ def _format_date(cls):
+ return '%s' % datetime.datetime.now().strftime(cls.DATETIME_FORMAT)
- def _print_date(self):
- print(self._format_date(), file=self.out)
+ def _print_date(self):
+ print(self._format_date(), file=self.out)
- def _print_bar(self, out=None):
- print(
- '==========================================================================',
- file=(out or self.out))
+ def _print_bar(self, out=None):
+ print(
+ '==========================================================================',
+ file=(out or self.out))
- def _print_exec_time(self):
- print('Test execution took {:.1f} seconds.'.format(self._elapsed), file=self.out)
+ def _print_exec_time(self):
+ print('Test execution took {:.1f} seconds.'.format(self._elapsed), file=self.out)
class ExecReporter(TestReporter):
- def __init__(self, testdir, test, prog):
- super(ExecReporter, self).__init__()
- self._test = test
- self._prog = prog
- self.logpath = self.test_logfile(test.name, prog.kind, testdir)
- self.out = None
-
- def begin(self):
- self._start()
- self._open()
- if self.out and not self.out.closed:
- self._print_header()
- else:
- self._log.debug('Output stream is not available.')
-
- def end(self, returncode):
- self._lock.acquire()
- try:
- if self.out and not self.out.closed:
- self._print_footer(returncode)
- self._close()
+ def __init__(self, testdir, test, prog):
+ super(ExecReporter, self).__init__()
+ self._test = test
+ self._prog = prog
+ self.logpath = self.test_logfile(test.name, prog.kind, testdir)
self.out = None
- else:
- self._log.debug('Output stream is not available.')
- finally:
- self._lock.release()
- def killed(self):
- print(file=self.out)
- print('Server process is successfully killed.', file=self.out)
- self.end(None)
+ def begin(self):
+ self._start()
+ self._open()
+ if self.out and not self.out.closed:
+ self._print_header()
+ else:
+ self._log.debug('Output stream is not available.')
- def died(self):
- print(file=self.out)
- print('*** Server process has died unexpectedly ***', file=self.out)
- self.end(None)
+ def end(self, returncode):
+ self._lock.acquire()
+ try:
+ if self.out and not self.out.closed:
+ self._print_footer(returncode)
+ self._close()
+ self.out = None
+ else:
+ self._log.debug('Output stream is not available.')
+ finally:
+ self._lock.release()
- _init_failure_exprs = {
- 'server': list(map(re.compile, [
- '[Aa]ddress already in use',
- 'Could not bind',
- 'EADDRINUSE',
- ])),
- 'client': list(map(re.compile, [
- '[Cc]onnection refused',
- 'Could not connect to localhost',
- 'ECONNREFUSED',
- 'No such file or directory', # domain socket
- ])),
- }
+ def killed(self):
+ print(file=self.out)
+ print('Server process is successfully killed.', file=self.out)
+ self.end(None)
- def maybe_false_positive(self):
- """Searches through log file for socket bind error.
- Returns True if suspicious expression is found, otherwise False"""
- try:
- if self.out and not self.out.closed:
+ def died(self):
+ print(file=self.out)
+ print('*** Server process has died unexpectedly ***', file=self.out)
+ self.end(None)
+
+ _init_failure_exprs = {
+ 'server': list(map(re.compile, [
+ '[Aa]ddress already in use',
+ 'Could not bind',
+ 'EADDRINUSE',
+ ])),
+ 'client': list(map(re.compile, [
+ '[Cc]onnection refused',
+ 'Could not connect to localhost',
+ 'ECONNREFUSED',
+ 'No such file or directory', # domain socket
+ ])),
+ }
+
+ def maybe_false_positive(self):
+ """Searches through log file for socket bind error.
+ Returns True if suspicious expression is found, otherwise False"""
+ try:
+ if self.out and not self.out.closed:
+ self.out.flush()
+ exprs = self._init_failure_exprs[self._prog.kind]
+
+ def match(line):
+ for expr in exprs:
+ if expr.search(line):
+ return True
+
+ with logfile_open(self.logpath, 'r') as fp:
+ if any(map(match, fp)):
+ return True
+ except (KeyboardInterrupt, SystemExit):
+ raise
+ except Exception as ex:
+ self._log.warn('[%s]: Error while detecting false positive: %s' % (self._test.name, str(ex)))
+ self._log.info(traceback.print_exc())
+ return False
+
+ def _open(self):
+ self.out = logfile_open(self.logpath, 'w+')
+
+ def _close(self):
+ self.out.close()
+
+ def _print_header(self):
+ self._print_date()
+ print('Executing: %s' % str_join(' ', self._prog.command), file=self.out)
+ print('Directory: %s' % self._prog.workdir, file=self.out)
+ print('config:delay: %s' % self._test.delay, file=self.out)
+ print('config:timeout: %s' % self._test.timeout, file=self.out)
+ self._print_bar()
self.out.flush()
- exprs = self._init_failure_exprs[self._prog.kind]
- def match(line):
- for expr in exprs:
- if expr.search(line):
- return True
-
- with logfile_open(self.logpath, 'r') as fp:
- if any(map(match, fp)):
- return True
- except (KeyboardInterrupt, SystemExit):
- raise
- except Exception as ex:
- self._log.warn('[%s]: Error while detecting false positive: %s' % (self._test.name, str(ex)))
- self._log.info(traceback.print_exc())
- return False
-
- def _open(self):
- self.out = logfile_open(self.logpath, 'w+')
-
- def _close(self):
- self.out.close()
-
- def _print_header(self):
- self._print_date()
- print('Executing: %s' % str_join(' ', self._prog.command), file=self.out)
- print('Directory: %s' % self._prog.workdir, file=self.out)
- print('config:delay: %s' % self._test.delay, file=self.out)
- print('config:timeout: %s' % self._test.timeout, file=self.out)
- self._print_bar()
- self.out.flush()
-
- def _print_footer(self, returncode=None):
- self._print_bar()
- if returncode is not None:
- print('Return code: %d' % returncode, file=self.out)
- else:
- print('Process is killed.', file=self.out)
- self._print_exec_time()
- self._print_date()
+ def _print_footer(self, returncode=None):
+ self._print_bar()
+ if returncode is not None:
+ print('Return code: %d' % returncode, file=self.out)
+ else:
+ print('Process is killed.', file=self.out)
+ self._print_exec_time()
+ self._print_date()
class SummaryReporter(TestReporter):
- def __init__(self, basedir, testdir_relative, concurrent=True):
- super(SummaryReporter, self).__init__()
- self._basedir = basedir
- self._testdir_rel = testdir_relative
- self.logdir = path_join(self.testdir, LOG_DIR)
- self.out_path = path_join(self.testdir, RESULT_JSON)
- self.concurrent = concurrent
- self.out = sys.stdout
- self._platform = platform.system()
- self._revision = self._get_revision()
- self._tests = []
- if not os.path.exists(self.logdir):
- os.mkdir(self.logdir)
- self._known_failures = load_known_failures(self.testdir)
- self._unexpected_success = []
- self._flaky_success = []
- self._unexpected_failure = []
- self._expected_failure = []
- self._print_header()
+ def __init__(self, basedir, testdir_relative, concurrent=True):
+ super(SummaryReporter, self).__init__()
+ self._basedir = basedir
+ self._testdir_rel = testdir_relative
+ self.logdir = path_join(self.testdir, LOG_DIR)
+ self.out_path = path_join(self.testdir, RESULT_JSON)
+ self.concurrent = concurrent
+ self.out = sys.stdout
+ self._platform = platform.system()
+ self._revision = self._get_revision()
+ self._tests = []
+ if not os.path.exists(self.logdir):
+ os.mkdir(self.logdir)
+ self._known_failures = load_known_failures(self.testdir)
+ self._unexpected_success = []
+ self._flaky_success = []
+ self._unexpected_failure = []
+ self._expected_failure = []
+ self._print_header()
- @property
- def testdir(self):
- return path_join(self._basedir, self._testdir_rel)
+ @property
+ def testdir(self):
+ return path_join(self._basedir, self._testdir_rel)
- def _result_string(self, test):
- if test.success:
- if test.retry_count == 0:
- return 'success'
- elif test.retry_count == 1:
- return 'flaky(1 retry)'
- else:
- return 'flaky(%d retries)' % test.retry_count
- elif test.expired:
- return 'failure(timeout)'
- else:
- return 'failure(%d)' % test.returncode
-
- def _get_revision(self):
- p = subprocess.Popen(['git', 'rev-parse', '--short', 'HEAD'],
- cwd=self.testdir, stdout=subprocess.PIPE)
- out, _ = p.communicate()
- return out.strip()
-
- def _format_test(self, test, with_result=True):
- name = '%s-%s' % (test.server.name, test.client.name)
- trans = '%s-%s' % (test.transport, test.socket)
- if not with_result:
- return '{:24s}{:13s}{:25s}'.format(name[:23], test.protocol[:12], trans[:24])
- else:
- return '{:24s}{:13s}{:25s}{:s}\n'.format(name[:23], test.protocol[:12], trans[:24], self._result_string(test))
-
- def _print_test_header(self):
- self._print_bar()
- print(
- '{:24s}{:13s}{:25s}{:s}'.format('server-client:', 'protocol:', 'transport:', 'result:'),
- file=self.out)
-
- def _print_header(self):
- self._start()
- print('Apache Thrift - Integration Test Suite', file=self.out)
- self._print_date()
- self._print_test_header()
-
- def _print_unexpected_failure(self):
- if len(self._unexpected_failure) > 0:
- self.out.writelines([
- '*** Following %d failures were unexpected ***:\n' % len(self._unexpected_failure),
- 'If it is introduced by you, please fix it before submitting the code.\n',
- # 'If not, please report at https://issues.apache.org/jira/browse/THRIFT\n',
- ])
- self._print_test_header()
- for i in self._unexpected_failure:
- self.out.write(self._format_test(self._tests[i]))
- self._print_bar()
- else:
- print('No unexpected failures.', file=self.out)
-
- def _print_flaky_success(self):
- if len(self._flaky_success) > 0:
- print(
- 'Following %d tests were expected to cleanly succeed but needed retry:' % len(self._flaky_success),
- file=self.out)
- self._print_test_header()
- for i in self._flaky_success:
- self.out.write(self._format_test(self._tests[i]))
- self._print_bar()
-
- def _print_unexpected_success(self):
- if len(self._unexpected_success) > 0:
- print(
- 'Following %d tests were known to fail but succeeded (maybe flaky):' % len(self._unexpected_success),
- file=self.out)
- self._print_test_header()
- for i in self._unexpected_success:
- self.out.write(self._format_test(self._tests[i]))
- self._print_bar()
-
- def _http_server_command(self, port):
- if sys.version_info[0] < 3:
- return 'python -m SimpleHTTPServer %d' % port
- else:
- return 'python -m http.server %d' % port
-
- def _print_footer(self):
- fail_count = len(self._expected_failure) + len(self._unexpected_failure)
- self._print_bar()
- self._print_unexpected_success()
- self._print_flaky_success()
- self._print_unexpected_failure()
- self._write_html_data()
- self._assemble_log('unexpected failures', self._unexpected_failure)
- self._assemble_log('known failures', self._expected_failure)
- self.out.writelines([
- 'You can browse results at:\n',
- '\tfile://%s/%s\n' % (self.testdir, RESULT_HTML),
- '# If you use Chrome, run:\n',
- '# \tcd %s\n#\t%s\n' % (self._basedir, self._http_server_command(8001)),
- '# then browse:\n',
- '# \thttp://localhost:%d/%s/\n' % (8001, self._testdir_rel),
- 'Full log for each test is here:\n',
- '\ttest/log/client_server_protocol_transport_client.log\n',
- '\ttest/log/client_server_protocol_transport_server.log\n',
- '%d failed of %d tests in total.\n' % (fail_count, len(self._tests)),
- ])
- self._print_exec_time()
- self._print_date()
-
- def _render_result(self, test):
- return [
- test.server.name,
- test.client.name,
- test.protocol,
- test.transport,
- test.socket,
- test.success,
- test.as_expected,
- test.returncode,
- {
- 'server': self.test_logfile(test.name, test.server.kind),
- 'client': self.test_logfile(test.name, test.client.kind),
- },
- ]
-
- def _write_html_data(self):
- """Writes JSON data to be read by result html"""
- results = [self._render_result(r) for r in self._tests]
- with logfile_open(self.out_path, 'w+') as fp:
- fp.write(json.dumps({
- 'date': self._format_date(),
- 'revision': str(self._revision),
- 'platform': self._platform,
- 'duration': '{:.1f}'.format(self._elapsed),
- 'results': results,
- }, indent=2))
-
- def _assemble_log(self, title, indexes):
- if len(indexes) > 0:
- def add_prog_log(fp, test, prog_kind):
- print('*************************** %s message ***************************' % prog_kind,
- file=fp)
- path = self.test_logfile(test.name, prog_kind, self.testdir)
- if os.path.exists(path):
- with logfile_open(path, 'r') as prog_fp:
- print(prog_fp.read(), file=fp)
- filename = title.replace(' ', '_') + '.log'
- with logfile_open(os.path.join(self.logdir, filename), 'w+') as fp:
- for test in map(self._tests.__getitem__, indexes):
- fp.write('TEST: [%s]\n' % test.name)
- add_prog_log(fp, test, test.server.kind)
- add_prog_log(fp, test, test.client.kind)
- fp.write('**********************************************************************\n\n')
- print('%s are logged to %s/%s/%s' % (title.capitalize(), self._testdir_rel, LOG_DIR, filename))
-
- def end(self):
- self._print_footer()
- return len(self._unexpected_failure) == 0
-
- def add_test(self, test_dict):
- test = TestEntry(self.testdir, **test_dict)
- self._lock.acquire()
- try:
- if not self.concurrent:
- self.out.write(self._format_test(test, False))
- self.out.flush()
- self._tests.append(test)
- return len(self._tests) - 1
- finally:
- self._lock.release()
-
- def add_result(self, index, returncode, expired, retry_count):
- self._lock.acquire()
- try:
- failed = returncode is None or returncode != 0
- flaky = not failed and retry_count != 0
- test = self._tests[index]
- known = test.name in self._known_failures
- if failed:
- if known:
- self._log.debug('%s failed as expected' % test.name)
- self._expected_failure.append(index)
+ def _result_string(self, test):
+ if test.success:
+ if test.retry_count == 0:
+ return 'success'
+ elif test.retry_count == 1:
+ return 'flaky(1 retry)'
+ else:
+ return 'flaky(%d retries)' % test.retry_count
+ elif test.expired:
+ return 'failure(timeout)'
else:
- self._log.info('unexpected failure: %s' % test.name)
- self._unexpected_failure.append(index)
- elif flaky and not known:
- self._log.info('unexpected flaky success: %s' % test.name)
- self._flaky_success.append(index)
- elif not flaky and known:
- self._log.info('unexpected success: %s' % test.name)
- self._unexpected_success.append(index)
- test.success = not failed
- test.returncode = returncode
- test.retry_count = retry_count
- test.expired = expired
- test.as_expected = known == failed
- if not self.concurrent:
- self.out.write(self._result_string(test) + '\n')
- else:
- self.out.write(self._format_test(test))
- finally:
- self._lock.release()
+ return 'failure(%d)' % test.returncode
+
+ def _get_revision(self):
+ p = subprocess.Popen(['git', 'rev-parse', '--short', 'HEAD'],
+ cwd=self.testdir, stdout=subprocess.PIPE)
+ out, _ = p.communicate()
+ return out.strip()
+
+ def _format_test(self, test, with_result=True):
+ name = '%s-%s' % (test.server.name, test.client.name)
+ trans = '%s-%s' % (test.transport, test.socket)
+ if not with_result:
+ return '{:24s}{:13s}{:25s}'.format(name[:23], test.protocol[:12], trans[:24])
+ else:
+ return '{:24s}{:13s}{:25s}{:s}\n'.format(name[:23], test.protocol[:12], trans[:24], self._result_string(test))
+
+ def _print_test_header(self):
+ self._print_bar()
+ print(
+ '{:24s}{:13s}{:25s}{:s}'.format('server-client:', 'protocol:', 'transport:', 'result:'),
+ file=self.out)
+
+ def _print_header(self):
+ self._start()
+ print('Apache Thrift - Integration Test Suite', file=self.out)
+ self._print_date()
+ self._print_test_header()
+
+ def _print_unexpected_failure(self):
+ if len(self._unexpected_failure) > 0:
+ self.out.writelines([
+ '*** Following %d failures were unexpected ***:\n' % len(self._unexpected_failure),
+ 'If it is introduced by you, please fix it before submitting the code.\n',
+ # 'If not, please report at https://issues.apache.org/jira/browse/THRIFT\n',
+ ])
+ self._print_test_header()
+ for i in self._unexpected_failure:
+ self.out.write(self._format_test(self._tests[i]))
+ self._print_bar()
+ else:
+ print('No unexpected failures.', file=self.out)
+
+ def _print_flaky_success(self):
+ if len(self._flaky_success) > 0:
+ print(
+ 'Following %d tests were expected to cleanly succeed but needed retry:' % len(self._flaky_success),
+ file=self.out)
+ self._print_test_header()
+ for i in self._flaky_success:
+ self.out.write(self._format_test(self._tests[i]))
+ self._print_bar()
+
+ def _print_unexpected_success(self):
+ if len(self._unexpected_success) > 0:
+ print(
+ 'Following %d tests were known to fail but succeeded (maybe flaky):' % len(self._unexpected_success),
+ file=self.out)
+ self._print_test_header()
+ for i in self._unexpected_success:
+ self.out.write(self._format_test(self._tests[i]))
+ self._print_bar()
+
+ def _http_server_command(self, port):
+ if sys.version_info[0] < 3:
+ return 'python -m SimpleHTTPServer %d' % port
+ else:
+ return 'python -m http.server %d' % port
+
+ def _print_footer(self):
+ fail_count = len(self._expected_failure) + len(self._unexpected_failure)
+ self._print_bar()
+ self._print_unexpected_success()
+ self._print_flaky_success()
+ self._print_unexpected_failure()
+ self._write_html_data()
+ self._assemble_log('unexpected failures', self._unexpected_failure)
+ self._assemble_log('known failures', self._expected_failure)
+ self.out.writelines([
+ 'You can browse results at:\n',
+ '\tfile://%s/%s\n' % (self.testdir, RESULT_HTML),
+ '# If you use Chrome, run:\n',
+ '# \tcd %s\n#\t%s\n' % (self._basedir, self._http_server_command(8001)),
+ '# then browse:\n',
+ '# \thttp://localhost:%d/%s/\n' % (8001, self._testdir_rel),
+ 'Full log for each test is here:\n',
+ '\ttest/log/client_server_protocol_transport_client.log\n',
+ '\ttest/log/client_server_protocol_transport_server.log\n',
+ '%d failed of %d tests in total.\n' % (fail_count, len(self._tests)),
+ ])
+ self._print_exec_time()
+ self._print_date()
+
+ def _render_result(self, test):
+ return [
+ test.server.name,
+ test.client.name,
+ test.protocol,
+ test.transport,
+ test.socket,
+ test.success,
+ test.as_expected,
+ test.returncode,
+ {
+ 'server': self.test_logfile(test.name, test.server.kind),
+ 'client': self.test_logfile(test.name, test.client.kind),
+ },
+ ]
+
+ def _write_html_data(self):
+ """Writes JSON data to be read by result html"""
+ results = [self._render_result(r) for r in self._tests]
+ with logfile_open(self.out_path, 'w+') as fp:
+ fp.write(json.dumps({
+ 'date': self._format_date(),
+ 'revision': str(self._revision),
+ 'platform': self._platform,
+ 'duration': '{:.1f}'.format(self._elapsed),
+ 'results': results,
+ }, indent=2))
+
+ def _assemble_log(self, title, indexes):
+ if len(indexes) > 0:
+ def add_prog_log(fp, test, prog_kind):
+ print('*************************** %s message ***************************' % prog_kind,
+ file=fp)
+ path = self.test_logfile(test.name, prog_kind, self.testdir)
+ if os.path.exists(path):
+ with logfile_open(path, 'r') as prog_fp:
+ print(prog_fp.read(), file=fp)
+ filename = title.replace(' ', '_') + '.log'
+ with logfile_open(os.path.join(self.logdir, filename), 'w+') as fp:
+ for test in map(self._tests.__getitem__, indexes):
+ fp.write('TEST: [%s]\n' % test.name)
+ add_prog_log(fp, test, test.server.kind)
+ add_prog_log(fp, test, test.client.kind)
+ fp.write('**********************************************************************\n\n')
+ print('%s are logged to %s/%s/%s' % (title.capitalize(), self._testdir_rel, LOG_DIR, filename))
+
+ def end(self):
+ self._print_footer()
+ return len(self._unexpected_failure) == 0
+
+ def add_test(self, test_dict):
+ test = TestEntry(self.testdir, **test_dict)
+ self._lock.acquire()
+ try:
+ if not self.concurrent:
+ self.out.write(self._format_test(test, False))
+ self.out.flush()
+ self._tests.append(test)
+ return len(self._tests) - 1
+ finally:
+ self._lock.release()
+
+ def add_result(self, index, returncode, expired, retry_count):
+ self._lock.acquire()
+ try:
+ failed = returncode is None or returncode != 0
+ flaky = not failed and retry_count != 0
+ test = self._tests[index]
+ known = test.name in self._known_failures
+ if failed:
+ if known:
+ self._log.debug('%s failed as expected' % test.name)
+ self._expected_failure.append(index)
+ else:
+ self._log.info('unexpected failure: %s' % test.name)
+ self._unexpected_failure.append(index)
+ elif flaky and not known:
+ self._log.info('unexpected flaky success: %s' % test.name)
+ self._flaky_success.append(index)
+ elif not flaky and known:
+ self._log.info('unexpected success: %s' % test.name)
+ self._unexpected_success.append(index)
+ test.success = not failed
+ test.returncode = returncode
+ test.retry_count = retry_count
+ test.expired = expired
+ test.as_expected = known == failed
+ if not self.concurrent:
+ self.out.write(self._result_string(test) + '\n')
+ else:
+ self.out.write(self._format_test(test))
+ finally:
+ self._lock.release()
diff --git a/test/crossrunner/run.py b/test/crossrunner/run.py
index 68bd928..18c1623 100644
--- a/test/crossrunner/run.py
+++ b/test/crossrunner/run.py
@@ -39,307 +39,307 @@
class ExecutionContext(object):
- def __init__(self, cmd, cwd, env, report):
- self._log = multiprocessing.get_logger()
- self.report = report
- self.cmd = cmd
- self.cwd = cwd
- self.env = env
- self.timer = None
- self.expired = False
- self.killed = False
+ def __init__(self, cmd, cwd, env, report):
+ self._log = multiprocessing.get_logger()
+ self.report = report
+ self.cmd = cmd
+ self.cwd = cwd
+ self.env = env
+ self.timer = None
+ self.expired = False
+ self.killed = False
- def _expire(self):
- self._log.info('Timeout')
- self.expired = True
- self.kill()
+ def _expire(self):
+ self._log.info('Timeout')
+ self.expired = True
+ self.kill()
- def kill(self):
- self._log.debug('Killing process : %d' % self.proc.pid)
- self.killed = True
- if platform.system() != 'Windows':
- try:
- os.killpg(self.proc.pid, signal.SIGKILL)
- except Exception:
- self._log.info('Failed to kill process group', exc_info=sys.exc_info())
- try:
- self.proc.kill()
- except Exception:
- self._log.info('Failed to kill process', exc_info=sys.exc_info())
+ def kill(self):
+ self._log.debug('Killing process : %d' % self.proc.pid)
+ self.killed = True
+ if platform.system() != 'Windows':
+ try:
+ os.killpg(self.proc.pid, signal.SIGKILL)
+ except Exception:
+ self._log.info('Failed to kill process group', exc_info=sys.exc_info())
+ try:
+ self.proc.kill()
+ except Exception:
+ self._log.info('Failed to kill process', exc_info=sys.exc_info())
- def _popen_args(self):
- args = {
- 'cwd': self.cwd,
- 'env': self.env,
- 'stdout': self.report.out,
- 'stderr': subprocess.STDOUT,
- }
- # make sure child processes doesn't remain after killing
- if platform.system() == 'Windows':
- DETACHED_PROCESS = 0x00000008
- args.update(creationflags=DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP)
- else:
- args.update(preexec_fn=os.setsid)
- return args
+ def _popen_args(self):
+ args = {
+ 'cwd': self.cwd,
+ 'env': self.env,
+ 'stdout': self.report.out,
+ 'stderr': subprocess.STDOUT,
+ }
+ # make sure child processes doesn't remain after killing
+ if platform.system() == 'Windows':
+ DETACHED_PROCESS = 0x00000008
+ args.update(creationflags=DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP)
+ else:
+ args.update(preexec_fn=os.setsid)
+ return args
- def start(self, timeout=0):
- joined = str_join(' ', self.cmd)
- self._log.debug('COMMAND: %s', joined)
- self._log.debug('WORKDIR: %s', self.cwd)
- self._log.debug('LOGFILE: %s', self.report.logpath)
- self.report.begin()
- self.proc = subprocess.Popen(self.cmd, **self._popen_args())
- if timeout > 0:
- self.timer = threading.Timer(timeout, self._expire)
- self.timer.start()
- return self._scoped()
+ def start(self, timeout=0):
+ joined = str_join(' ', self.cmd)
+ self._log.debug('COMMAND: %s', joined)
+ self._log.debug('WORKDIR: %s', self.cwd)
+ self._log.debug('LOGFILE: %s', self.report.logpath)
+ self.report.begin()
+ self.proc = subprocess.Popen(self.cmd, **self._popen_args())
+ if timeout > 0:
+ self.timer = threading.Timer(timeout, self._expire)
+ self.timer.start()
+ return self._scoped()
- @contextlib.contextmanager
- def _scoped(self):
- yield self
- self._log.debug('Killing scoped process')
- if self.proc.poll() is None:
- self.kill()
- self.report.killed()
- else:
- self._log.debug('Process died unexpectedly')
- self.report.died()
+ @contextlib.contextmanager
+ def _scoped(self):
+ yield self
+ self._log.debug('Killing scoped process')
+ if self.proc.poll() is None:
+ self.kill()
+ self.report.killed()
+ else:
+ self._log.debug('Process died unexpectedly')
+ self.report.died()
- def wait(self):
- self.proc.communicate()
- if self.timer:
- self.timer.cancel()
- self.report.end(self.returncode)
+ def wait(self):
+ self.proc.communicate()
+ if self.timer:
+ self.timer.cancel()
+ self.report.end(self.returncode)
- @property
- def returncode(self):
- return self.proc.returncode if self.proc else None
+ @property
+ def returncode(self):
+ return self.proc.returncode if self.proc else None
def exec_context(port, logdir, test, prog):
- report = ExecReporter(logdir, test, prog)
- prog.build_command(port)
- return ExecutionContext(prog.command, prog.workdir, prog.env, report)
+ report = ExecReporter(logdir, test, prog)
+ prog.build_command(port)
+ return ExecutionContext(prog.command, prog.workdir, prog.env, report)
def run_test(testdir, logdir, test_dict, max_retry, async=True):
- try:
- logger = multiprocessing.get_logger()
- max_bind_retry = 3
- retry_count = 0
- bind_retry_count = 0
- test = TestEntry(testdir, **test_dict)
- while True:
- if stop.is_set():
- logger.debug('Skipping because shutting down')
- return (retry_count, None)
- logger.debug('Start')
- with PortAllocator.alloc_port_scoped(ports, test.socket) as port:
- logger.debug('Start with port %d' % port)
- sv = exec_context(port, logdir, test, test.server)
- cl = exec_context(port, logdir, test, test.client)
+ try:
+ logger = multiprocessing.get_logger()
+ max_bind_retry = 3
+ retry_count = 0
+ bind_retry_count = 0
+ test = TestEntry(testdir, **test_dict)
+ while True:
+ if stop.is_set():
+ logger.debug('Skipping because shutting down')
+ return (retry_count, None)
+ logger.debug('Start')
+ with PortAllocator.alloc_port_scoped(ports, test.socket) as port:
+ logger.debug('Start with port %d' % port)
+ sv = exec_context(port, logdir, test, test.server)
+ cl = exec_context(port, logdir, test, test.client)
- logger.debug('Starting server')
- with sv.start():
- if test.delay > 0:
- logger.debug('Delaying client for %.2f seconds' % test.delay)
- time.sleep(test.delay)
- connect_retry_count = 0
- max_connect_retry = 10
- connect_retry_wait = 0.5
- while True:
- logger.debug('Starting client')
- cl.start(test.timeout)
- logger.debug('Waiting client')
- cl.wait()
- if not cl.report.maybe_false_positive() or connect_retry_count >= max_connect_retry:
- if connect_retry_count > 0 and connect_retry_count < max_connect_retry:
- logger.warn('[%s]: Connected after %d retry (%.2f sec each)' % (test.server.name, connect_retry_count, connect_retry_wait))
- # Wait for 50ms to see if server does not die at the end.
- time.sleep(0.05)
- break
- logger.debug('Server may not be ready, waiting %.2f second...' % connect_retry_wait)
- time.sleep(connect_retry_wait)
- connect_retry_count += 1
+ logger.debug('Starting server')
+ with sv.start():
+ if test.delay > 0:
+ logger.debug('Delaying client for %.2f seconds' % test.delay)
+ time.sleep(test.delay)
+ connect_retry_count = 0
+ max_connect_retry = 10
+ connect_retry_wait = 0.5
+ while True:
+ logger.debug('Starting client')
+ cl.start(test.timeout)
+ logger.debug('Waiting client')
+ cl.wait()
+ if not cl.report.maybe_false_positive() or connect_retry_count >= max_connect_retry:
+ if connect_retry_count > 0 and connect_retry_count < max_connect_retry:
+ logger.warn('[%s]: Connected after %d retry (%.2f sec each)' % (test.server.name, connect_retry_count, connect_retry_wait))
+ # Wait for 50ms to see if server does not die at the end.
+ time.sleep(0.05)
+ break
+ logger.debug('Server may not be ready, waiting %.2f second...' % connect_retry_wait)
+ time.sleep(connect_retry_wait)
+ connect_retry_count += 1
- if sv.report.maybe_false_positive() and bind_retry_count < max_bind_retry:
- logger.warn('[%s]: Detected socket bind failure, retrying...', test.server.name)
- bind_retry_count += 1
- else:
- if cl.expired:
- result = RESULT_TIMEOUT
- elif not sv.killed and cl.proc.returncode == 0:
- # Server should be alive at the end.
- result = RESULT_ERROR
- else:
- result = cl.proc.returncode
+ if sv.report.maybe_false_positive() and bind_retry_count < max_bind_retry:
+ logger.warn('[%s]: Detected socket bind failure, retrying...', test.server.name)
+ bind_retry_count += 1
+ else:
+ if cl.expired:
+ result = RESULT_TIMEOUT
+ elif not sv.killed and cl.proc.returncode == 0:
+ # Server should be alive at the end.
+ result = RESULT_ERROR
+ else:
+ result = cl.proc.returncode
- if result == 0 or retry_count >= max_retry:
- return (retry_count, result)
- else:
- logger.info('[%s-%s]: test failed, retrying...', test.server.name, test.client.name)
- retry_count += 1
- except (KeyboardInterrupt, SystemExit):
- logger.info('Interrupted execution')
- if not async:
- raise
- stop.set()
- return None
- except:
- if not async:
- raise
- logger.warn('Error executing [%s]', test.name, exc_info=sys.exc_info())
- return (retry_count, RESULT_ERROR)
+ if result == 0 or retry_count >= max_retry:
+ return (retry_count, result)
+ else:
+ logger.info('[%s-%s]: test failed, retrying...', test.server.name, test.client.name)
+ retry_count += 1
+ except (KeyboardInterrupt, SystemExit):
+ logger.info('Interrupted execution')
+ if not async:
+ raise
+ stop.set()
+ return None
+ except:
+ if not async:
+ raise
+ logger.warn('Error executing [%s]', test.name, exc_info=sys.exc_info())
+ return (retry_count, RESULT_ERROR)
class PortAllocator(object):
- def __init__(self):
- self._log = multiprocessing.get_logger()
- self._lock = multiprocessing.Lock()
- self._ports = set()
- self._dom_ports = set()
- self._last_alloc = 0
+ def __init__(self):
+ self._log = multiprocessing.get_logger()
+ self._lock = multiprocessing.Lock()
+ self._ports = set()
+ self._dom_ports = set()
+ self._last_alloc = 0
- def _get_tcp_port(self):
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- sock.bind(('127.0.0.1', 0))
- port = sock.getsockname()[1]
- self._lock.acquire()
- try:
- ok = port not in self._ports
- if ok:
- self._ports.add(port)
- self._last_alloc = time.time()
- finally:
- self._lock.release()
- sock.close()
- return port if ok else self._get_tcp_port()
+ def _get_tcp_port(self):
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ sock.bind(('127.0.0.1', 0))
+ port = sock.getsockname()[1]
+ self._lock.acquire()
+ try:
+ ok = port not in self._ports
+ if ok:
+ self._ports.add(port)
+ self._last_alloc = time.time()
+ finally:
+ self._lock.release()
+ sock.close()
+ return port if ok else self._get_tcp_port()
- def _get_domain_port(self):
- port = random.randint(1024, 65536)
- self._lock.acquire()
- try:
- ok = port not in self._dom_ports
- if ok:
- self._dom_ports.add(port)
- finally:
- self._lock.release()
- return port if ok else self._get_domain_port()
+ def _get_domain_port(self):
+ port = random.randint(1024, 65536)
+ self._lock.acquire()
+ try:
+ ok = port not in self._dom_ports
+ if ok:
+ self._dom_ports.add(port)
+ finally:
+ self._lock.release()
+ return port if ok else self._get_domain_port()
- def alloc_port(self, socket_type):
- if socket_type in ('domain', 'abstract'):
- return self._get_domain_port()
- else:
- return self._get_tcp_port()
+ def alloc_port(self, socket_type):
+ if socket_type in ('domain', 'abstract'):
+ return self._get_domain_port()
+ else:
+ return self._get_tcp_port()
- # static method for inter-process invokation
- @staticmethod
- @contextlib.contextmanager
- def alloc_port_scoped(allocator, socket_type):
- port = allocator.alloc_port(socket_type)
- yield port
- allocator.free_port(socket_type, port)
+ # static method for inter-process invokation
+ @staticmethod
+ @contextlib.contextmanager
+ def alloc_port_scoped(allocator, socket_type):
+ port = allocator.alloc_port(socket_type)
+ yield port
+ allocator.free_port(socket_type, port)
- def free_port(self, socket_type, port):
- self._log.debug('free_port')
- self._lock.acquire()
- try:
- if socket_type == 'domain':
- self._dom_ports.remove(port)
- path = domain_socket_path(port)
- if os.path.exists(path):
- os.remove(path)
- elif socket_type == 'abstract':
- self._dom_ports.remove(port)
- else:
- self._ports.remove(port)
- except IOError:
- self._log.info('Error while freeing port', exc_info=sys.exc_info())
- finally:
- self._lock.release()
+ def free_port(self, socket_type, port):
+ self._log.debug('free_port')
+ self._lock.acquire()
+ try:
+ if socket_type == 'domain':
+ self._dom_ports.remove(port)
+ path = domain_socket_path(port)
+ if os.path.exists(path):
+ os.remove(path)
+ elif socket_type == 'abstract':
+ self._dom_ports.remove(port)
+ else:
+ self._ports.remove(port)
+ except IOError:
+ self._log.info('Error while freeing port', exc_info=sys.exc_info())
+ finally:
+ self._lock.release()
class NonAsyncResult(object):
- def __init__(self, value):
- self._value = value
+ def __init__(self, value):
+ self._value = value
- def get(self, timeout=None):
- return self._value
+ def get(self, timeout=None):
+ return self._value
- def wait(self, timeout=None):
- pass
+ def wait(self, timeout=None):
+ pass
- def ready(self):
- return True
+ def ready(self):
+ return True
- def successful(self):
- return self._value == 0
+ def successful(self):
+ return self._value == 0
class TestDispatcher(object):
- def __init__(self, testdir, basedir, logdir_rel, concurrency):
- self._log = multiprocessing.get_logger()
- self.testdir = testdir
- self._report = SummaryReporter(basedir, logdir_rel, concurrency > 1)
- self.logdir = self._report.testdir
- # seems needed for python 2.x to handle keyboard interrupt
- self._stop = multiprocessing.Event()
- self._async = concurrency > 1
- if not self._async:
- self._pool = None
- global stop
- global ports
- stop = self._stop
- ports = PortAllocator()
- else:
- self._m = multiprocessing.managers.BaseManager()
- self._m.register('ports', PortAllocator)
- self._m.start()
- self._pool = multiprocessing.Pool(concurrency, self._pool_init, (self._m.address,))
- self._log.debug(
- 'TestDispatcher started with %d concurrent jobs' % concurrency)
+ def __init__(self, testdir, basedir, logdir_rel, concurrency):
+ self._log = multiprocessing.get_logger()
+ self.testdir = testdir
+ self._report = SummaryReporter(basedir, logdir_rel, concurrency > 1)
+ self.logdir = self._report.testdir
+ # seems needed for python 2.x to handle keyboard interrupt
+ self._stop = multiprocessing.Event()
+ self._async = concurrency > 1
+ if not self._async:
+ self._pool = None
+ global stop
+ global ports
+ stop = self._stop
+ ports = PortAllocator()
+ else:
+ self._m = multiprocessing.managers.BaseManager()
+ self._m.register('ports', PortAllocator)
+ self._m.start()
+ self._pool = multiprocessing.Pool(concurrency, self._pool_init, (self._m.address,))
+ self._log.debug(
+ 'TestDispatcher started with %d concurrent jobs' % concurrency)
- def _pool_init(self, address):
- global stop
- global m
- global ports
- stop = self._stop
- m = multiprocessing.managers.BaseManager(address)
- m.connect()
- ports = m.ports()
+ def _pool_init(self, address):
+ global stop
+ global m
+ global ports
+ stop = self._stop
+ m = multiprocessing.managers.BaseManager(address)
+ m.connect()
+ ports = m.ports()
- def _dispatch_sync(self, test, cont, max_retry):
- r = run_test(self.testdir, self.logdir, test, max_retry, False)
- cont(r)
- return NonAsyncResult(r)
+ def _dispatch_sync(self, test, cont, max_retry):
+ r = run_test(self.testdir, self.logdir, test, max_retry, False)
+ cont(r)
+ return NonAsyncResult(r)
- def _dispatch_async(self, test, cont, max_retry):
- self._log.debug('_dispatch_async')
- return self._pool.apply_async(func=run_test, args=(self.testdir, self.logdir, test, max_retry), callback=cont)
+ def _dispatch_async(self, test, cont, max_retry):
+ self._log.debug('_dispatch_async')
+ return self._pool.apply_async(func=run_test, args=(self.testdir, self.logdir, test, max_retry), callback=cont)
- def dispatch(self, test, max_retry):
- index = self._report.add_test(test)
+ def dispatch(self, test, max_retry):
+ index = self._report.add_test(test)
- def cont(result):
- if not self._stop.is_set():
- retry_count, returncode = result
- self._log.debug('freeing port')
- self._log.debug('adding result')
- self._report.add_result(index, returncode, returncode == RESULT_TIMEOUT, retry_count)
- self._log.debug('finish continuation')
- fn = self._dispatch_async if self._async else self._dispatch_sync
- return fn(test, cont, max_retry)
+ def cont(result):
+ if not self._stop.is_set():
+ retry_count, returncode = result
+ self._log.debug('freeing port')
+ self._log.debug('adding result')
+ self._report.add_result(index, returncode, returncode == RESULT_TIMEOUT, retry_count)
+ self._log.debug('finish continuation')
+ fn = self._dispatch_async if self._async else self._dispatch_sync
+ return fn(test, cont, max_retry)
- def wait(self):
- if self._async:
- self._pool.close()
- self._pool.join()
- self._m.shutdown()
- return self._report.end()
+ def wait(self):
+ if self._async:
+ self._pool.close()
+ self._pool.join()
+ self._m.shutdown()
+ return self._report.end()
- def terminate(self):
- self._stop.set()
- if self._async:
- self._pool.terminate()
- self._pool.join()
- self._m.shutdown()
+ def terminate(self):
+ self._stop.set()
+ if self._async:
+ self._pool.terminate()
+ self._pool.join()
+ self._m.shutdown()
diff --git a/test/crossrunner/test.py b/test/crossrunner/test.py
index fc90f7f..dcc8a94 100644
--- a/test/crossrunner/test.py
+++ b/test/crossrunner/test.py
@@ -26,118 +26,118 @@
def domain_socket_path(port):
- return '/tmp/ThriftTest.thrift.%d' % port
+ return '/tmp/ThriftTest.thrift.%d' % port
class TestProgram(object):
- def __init__(self, kind, name, protocol, transport, socket, workdir, command, env=None,
- extra_args=[], extra_args2=[], join_args=False, **kwargs):
- self.kind = kind
- self.name = name
- self.protocol = protocol
- self.transport = transport
- self.socket = socket
- self.workdir = workdir
- self.command = None
- self._base_command = self._fix_cmd_path(command)
- if env:
- self.env = copy.copy(os.environ)
- self.env.update(env)
- else:
- self.env = os.environ
- self._extra_args = extra_args
- self._extra_args2 = extra_args2
- self._join_args = join_args
+ def __init__(self, kind, name, protocol, transport, socket, workdir, command, env=None,
+ extra_args=[], extra_args2=[], join_args=False, **kwargs):
+ self.kind = kind
+ self.name = name
+ self.protocol = protocol
+ self.transport = transport
+ self.socket = socket
+ self.workdir = workdir
+ self.command = None
+ self._base_command = self._fix_cmd_path(command)
+ if env:
+ self.env = copy.copy(os.environ)
+ self.env.update(env)
+ else:
+ self.env = os.environ
+ self._extra_args = extra_args
+ self._extra_args2 = extra_args2
+ self._join_args = join_args
- def _fix_cmd_path(self, cmd):
- # if the arg is a file in the current directory, make it path
- def abs_if_exists(arg):
- p = path_join(self.workdir, arg)
- return p if os.path.exists(p) else arg
+ def _fix_cmd_path(self, cmd):
+ # if the arg is a file in the current directory, make it path
+ def abs_if_exists(arg):
+ p = path_join(self.workdir, arg)
+ return p if os.path.exists(p) else arg
- if cmd[0] == 'python':
- cmd[0] = sys.executable
- else:
- cmd[0] = abs_if_exists(cmd[0])
- return cmd
+ if cmd[0] == 'python':
+ cmd[0] = sys.executable
+ else:
+ cmd[0] = abs_if_exists(cmd[0])
+ return cmd
- def _socket_args(self, socket, port):
- return {
- 'ip-ssl': ['--ssl'],
- 'domain': ['--domain-socket=%s' % domain_socket_path(port)],
- 'abstract': ['--abstract-namespace', '--domain-socket=%s' % domain_socket_path(port)],
- }.get(socket, None)
+ def _socket_args(self, socket, port):
+ return {
+ 'ip-ssl': ['--ssl'],
+ 'domain': ['--domain-socket=%s' % domain_socket_path(port)],
+ 'abstract': ['--abstract-namespace', '--domain-socket=%s' % domain_socket_path(port)],
+ }.get(socket, None)
- def build_command(self, port):
- cmd = copy.copy(self._base_command)
- args = copy.copy(self._extra_args2)
- args.append('--protocol=' + self.protocol)
- args.append('--transport=' + self.transport)
- socket_args = self._socket_args(self.socket, port)
- if socket_args:
- args += socket_args
- args.append('--port=%d' % port)
- if self._join_args:
- cmd.append('%s' % " ".join(args))
- else:
- cmd.extend(args)
- if self._extra_args:
- cmd.extend(self._extra_args)
- self.command = cmd
- return self.command
+ def build_command(self, port):
+ cmd = copy.copy(self._base_command)
+ args = copy.copy(self._extra_args2)
+ args.append('--protocol=' + self.protocol)
+ args.append('--transport=' + self.transport)
+ socket_args = self._socket_args(self.socket, port)
+ if socket_args:
+ args += socket_args
+ args.append('--port=%d' % port)
+ if self._join_args:
+ cmd.append('%s' % " ".join(args))
+ else:
+ cmd.extend(args)
+ if self._extra_args:
+ cmd.extend(self._extra_args)
+ self.command = cmd
+ return self.command
class TestEntry(object):
- def __init__(self, testdir, server, client, delay, timeout, **kwargs):
- self.testdir = testdir
- self._log = multiprocessing.get_logger()
- self._config = kwargs
- self.protocol = kwargs['protocol']
- self.transport = kwargs['transport']
- self.socket = kwargs['socket']
- srv_dict = self._fix_workdir(merge_dict(self._config, server))
- cli_dict = self._fix_workdir(merge_dict(self._config, client))
- cli_dict['extra_args2'] = srv_dict.pop('remote_args', [])
- srv_dict['extra_args2'] = cli_dict.pop('remote_args', [])
- self.server = TestProgram('server', **srv_dict)
- self.client = TestProgram('client', **cli_dict)
- self.delay = delay
- self.timeout = timeout
- self._name = None
- # results
- self.success = None
- self.as_expected = None
- self.returncode = None
- self.expired = False
- self.retry_count = 0
+ def __init__(self, testdir, server, client, delay, timeout, **kwargs):
+ self.testdir = testdir
+ self._log = multiprocessing.get_logger()
+ self._config = kwargs
+ self.protocol = kwargs['protocol']
+ self.transport = kwargs['transport']
+ self.socket = kwargs['socket']
+ srv_dict = self._fix_workdir(merge_dict(self._config, server))
+ cli_dict = self._fix_workdir(merge_dict(self._config, client))
+ cli_dict['extra_args2'] = srv_dict.pop('remote_args', [])
+ srv_dict['extra_args2'] = cli_dict.pop('remote_args', [])
+ self.server = TestProgram('server', **srv_dict)
+ self.client = TestProgram('client', **cli_dict)
+ self.delay = delay
+ self.timeout = timeout
+ self._name = None
+ # results
+ self.success = None
+ self.as_expected = None
+ self.returncode = None
+ self.expired = False
+ self.retry_count = 0
- def _fix_workdir(self, config):
- key = 'workdir'
- path = config.get(key, None)
- if not path:
- path = self.testdir
- if os.path.isabs(path):
- path = os.path.realpath(path)
- else:
- path = os.path.realpath(path_join(self.testdir, path))
- config.update({key: path})
- return config
+ def _fix_workdir(self, config):
+ key = 'workdir'
+ path = config.get(key, None)
+ if not path:
+ path = self.testdir
+ if os.path.isabs(path):
+ path = os.path.realpath(path)
+ else:
+ path = os.path.realpath(path_join(self.testdir, path))
+ config.update({key: path})
+ return config
- @classmethod
- def get_name(cls, server, client, proto, trans, sock, *args):
- return '%s-%s_%s_%s-%s' % (server, client, proto, trans, sock)
+ @classmethod
+ def get_name(cls, server, client, proto, trans, sock, *args):
+ return '%s-%s_%s_%s-%s' % (server, client, proto, trans, sock)
- @property
- def name(self):
- if not self._name:
- self._name = self.get_name(
- self.server.name, self.client.name, self.protocol, self.transport, self.socket)
- return self._name
+ @property
+ def name(self):
+ if not self._name:
+ self._name = self.get_name(
+ self.server.name, self.client.name, self.protocol, self.transport, self.socket)
+ return self._name
- @property
- def transport_name(self):
- return '%s-%s' % (self.transport, self.socket)
+ @property
+ def transport_name(self):
+ return '%s-%s' % (self.transport, self.socket)
def test_name(server, client, protocol, transport, socket, **kwargs):
- return TestEntry.get_name(server['name'], client['name'], protocol, transport, socket)
+ return TestEntry.get_name(server['name'], client['name'], protocol, transport, socket)
diff --git a/test/crossrunner/util.py b/test/crossrunner/util.py
index 750ed47..e2d195a 100644
--- a/test/crossrunner/util.py
+++ b/test/crossrunner/util.py
@@ -21,11 +21,11 @@
def merge_dict(base, update):
- """Update dict concatenating list values"""
- res = copy.deepcopy(base)
- for k, v in list(update.items()):
- if k in list(res.keys()) and isinstance(v, list):
- res[k].extend(v)
- else:
- res[k] = v
- return res
+ """Update dict concatenating list values"""
+ res = copy.deepcopy(base)
+ for k, v in list(update.items()):
+ if k in list(res.keys()) and isinstance(v, list):
+ res[k].extend(v)
+ else:
+ res[k] = v
+ return res
diff --git a/test/features/container_limit.py b/test/features/container_limit.py
index 4a7da60..beed0c5 100644
--- a/test/features/container_limit.py
+++ b/test/features/container_limit.py
@@ -10,63 +10,63 @@
# TODO: generate from ThriftTest.thrift
def test_list(proto, value):
- method_name = 'testList'
- ttype = TType.LIST
- etype = TType.I32
- proto.writeMessageBegin(method_name, TMessageType.CALL, 3)
- proto.writeStructBegin(method_name + '_args')
- proto.writeFieldBegin('thing', ttype, 1)
- proto.writeListBegin(etype, len(value))
- for e in value:
- proto.writeI32(e)
- proto.writeListEnd()
- proto.writeFieldEnd()
- proto.writeFieldStop()
- proto.writeStructEnd()
- proto.writeMessageEnd()
- proto.trans.flush()
+ method_name = 'testList'
+ ttype = TType.LIST
+ etype = TType.I32
+ proto.writeMessageBegin(method_name, TMessageType.CALL, 3)
+ proto.writeStructBegin(method_name + '_args')
+ proto.writeFieldBegin('thing', ttype, 1)
+ proto.writeListBegin(etype, len(value))
+ for e in value:
+ proto.writeI32(e)
+ proto.writeListEnd()
+ proto.writeFieldEnd()
+ proto.writeFieldStop()
+ proto.writeStructEnd()
+ proto.writeMessageEnd()
+ proto.trans.flush()
- _, mtype, _ = proto.readMessageBegin()
- assert mtype == TMessageType.REPLY
- proto.readStructBegin()
- _, ftype, fid = proto.readFieldBegin()
- assert fid == 0
- assert ftype == ttype
- etype2, len2 = proto.readListBegin()
- assert etype == etype2
- assert len2 == len(value)
- for i in range(len2):
- v = proto.readI32()
- assert v == value[i]
- proto.readListEnd()
- proto.readFieldEnd()
- _, ftype, _ = proto.readFieldBegin()
- assert ftype == TType.STOP
- proto.readStructEnd()
- proto.readMessageEnd()
+ _, mtype, _ = proto.readMessageBegin()
+ assert mtype == TMessageType.REPLY
+ proto.readStructBegin()
+ _, ftype, fid = proto.readFieldBegin()
+ assert fid == 0
+ assert ftype == ttype
+ etype2, len2 = proto.readListBegin()
+ assert etype == etype2
+ assert len2 == len(value)
+ for i in range(len2):
+ v = proto.readI32()
+ assert v == value[i]
+ proto.readListEnd()
+ proto.readFieldEnd()
+ _, ftype, _ = proto.readFieldBegin()
+ assert ftype == TType.STOP
+ proto.readStructEnd()
+ proto.readMessageEnd()
def main(argv):
- p = argparse.ArgumentParser()
- add_common_args(p)
- p.add_argument('--limit', type=int)
- args = p.parse_args()
- proto = init_protocol(args)
- # TODO: test set and map
- test_list(proto, list(range(args.limit - 1)))
- test_list(proto, list(range(args.limit - 1)))
- print('[OK]: limit - 1')
- test_list(proto, list(range(args.limit)))
- test_list(proto, list(range(args.limit)))
- print('[OK]: just limit')
- try:
- test_list(proto, list(range(args.limit + 1)))
- except:
- print('[OK]: limit + 1')
- else:
- print('[ERROR]: limit + 1')
- assert False
+ p = argparse.ArgumentParser()
+ add_common_args(p)
+ p.add_argument('--limit', type=int)
+ args = p.parse_args()
+ proto = init_protocol(args)
+ # TODO: test set and map
+ test_list(proto, list(range(args.limit - 1)))
+ test_list(proto, list(range(args.limit - 1)))
+ print('[OK]: limit - 1')
+ test_list(proto, list(range(args.limit)))
+ test_list(proto, list(range(args.limit)))
+ print('[OK]: just limit')
+ try:
+ test_list(proto, list(range(args.limit + 1)))
+ except:
+ print('[OK]: limit + 1')
+ else:
+ print('[ERROR]: limit + 1')
+ assert False
if __name__ == '__main__':
- sys.exit(main(sys.argv[1:]))
+ sys.exit(main(sys.argv[1:]))
diff --git a/test/features/local_thrift/__init__.py b/test/features/local_thrift/__init__.py
index 383ee5f..0a0bb0b 100644
--- a/test/features/local_thrift/__init__.py
+++ b/test/features/local_thrift/__init__.py
@@ -5,10 +5,10 @@
ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(SCRIPT_DIR)))
if sys.version_info[0] == 2:
- import glob
- libdir = glob.glob(os.path.join(ROOT_DIR, 'lib', 'py', 'build', 'lib.*'))[0]
- sys.path.insert(0, libdir)
- thrift = __import__('thrift')
+ import glob
+ libdir = glob.glob(os.path.join(ROOT_DIR, 'lib', 'py', 'build', 'lib.*'))[0]
+ sys.path.insert(0, libdir)
+ thrift = __import__('thrift')
else:
- sys.path.insert(0, os.path.join(ROOT_DIR, 'lib', 'py', 'build', 'lib'))
- thrift = __import__('thrift')
+ sys.path.insert(0, os.path.join(ROOT_DIR, 'lib', 'py', 'build', 'lib'))
+ thrift = __import__('thrift')
diff --git a/test/features/string_limit.py b/test/features/string_limit.py
index b4d48ac..3c68b3e 100644
--- a/test/features/string_limit.py
+++ b/test/features/string_limit.py
@@ -10,52 +10,52 @@
# TODO: generate from ThriftTest.thrift
def test_string(proto, value):
- method_name = 'testString'
- ttype = TType.STRING
- proto.writeMessageBegin(method_name, TMessageType.CALL, 3)
- proto.writeStructBegin(method_name + '_args')
- proto.writeFieldBegin('thing', ttype, 1)
- proto.writeString(value)
- proto.writeFieldEnd()
- proto.writeFieldStop()
- proto.writeStructEnd()
- proto.writeMessageEnd()
- proto.trans.flush()
+ method_name = 'testString'
+ ttype = TType.STRING
+ proto.writeMessageBegin(method_name, TMessageType.CALL, 3)
+ proto.writeStructBegin(method_name + '_args')
+ proto.writeFieldBegin('thing', ttype, 1)
+ proto.writeString(value)
+ proto.writeFieldEnd()
+ proto.writeFieldStop()
+ proto.writeStructEnd()
+ proto.writeMessageEnd()
+ proto.trans.flush()
- _, mtype, _ = proto.readMessageBegin()
- assert mtype == TMessageType.REPLY
- proto.readStructBegin()
- _, ftype, fid = proto.readFieldBegin()
- assert fid == 0
- assert ftype == ttype
- result = proto.readString()
- proto.readFieldEnd()
- _, ftype, _ = proto.readFieldBegin()
- assert ftype == TType.STOP
- proto.readStructEnd()
- proto.readMessageEnd()
- assert value == result
+ _, mtype, _ = proto.readMessageBegin()
+ assert mtype == TMessageType.REPLY
+ proto.readStructBegin()
+ _, ftype, fid = proto.readFieldBegin()
+ assert fid == 0
+ assert ftype == ttype
+ result = proto.readString()
+ proto.readFieldEnd()
+ _, ftype, _ = proto.readFieldBegin()
+ assert ftype == TType.STOP
+ proto.readStructEnd()
+ proto.readMessageEnd()
+ assert value == result
def main(argv):
- p = argparse.ArgumentParser()
- add_common_args(p)
- p.add_argument('--limit', type=int)
- args = p.parse_args()
- proto = init_protocol(args)
- test_string(proto, 'a' * (args.limit - 1))
- test_string(proto, 'a' * (args.limit - 1))
- print('[OK]: limit - 1')
- test_string(proto, 'a' * args.limit)
- test_string(proto, 'a' * args.limit)
- print('[OK]: just limit')
- try:
- test_string(proto, 'a' * (args.limit + 1))
- except:
- print('[OK]: limit + 1')
- else:
- print('[ERROR]: limit + 1')
- assert False
+ p = argparse.ArgumentParser()
+ add_common_args(p)
+ p.add_argument('--limit', type=int)
+ args = p.parse_args()
+ proto = init_protocol(args)
+ test_string(proto, 'a' * (args.limit - 1))
+ test_string(proto, 'a' * (args.limit - 1))
+ print('[OK]: limit - 1')
+ test_string(proto, 'a' * args.limit)
+ test_string(proto, 'a' * args.limit)
+ print('[OK]: just limit')
+ try:
+ test_string(proto, 'a' * (args.limit + 1))
+ except:
+ print('[OK]: limit + 1')
+ else:
+ print('[ERROR]: limit + 1')
+ assert False
if __name__ == '__main__':
- main(sys.argv[1:])
+ main(sys.argv[1:])
diff --git a/test/features/theader_binary.py b/test/features/theader_binary.py
index 62a2671..02e010b 100644
--- a/test/features/theader_binary.py
+++ b/test/features/theader_binary.py
@@ -14,57 +14,57 @@
def test_void(proto):
- proto.writeMessageBegin('testVoid', TMessageType.CALL, 3)
- proto.writeStructBegin('testVoid_args')
- proto.writeFieldStop()
- proto.writeStructEnd()
- proto.writeMessageEnd()
- proto.trans.flush()
+ proto.writeMessageBegin('testVoid', TMessageType.CALL, 3)
+ proto.writeStructBegin('testVoid_args')
+ proto.writeFieldStop()
+ proto.writeStructEnd()
+ proto.writeMessageEnd()
+ proto.trans.flush()
- _, mtype, _ = proto.readMessageBegin()
- assert mtype == TMessageType.REPLY
- proto.readStructBegin()
- _, ftype, _ = proto.readFieldBegin()
- assert ftype == TType.STOP
- proto.readStructEnd()
- proto.readMessageEnd()
+ _, mtype, _ = proto.readMessageBegin()
+ assert mtype == TMessageType.REPLY
+ proto.readStructBegin()
+ _, ftype, _ = proto.readFieldBegin()
+ assert ftype == TType.STOP
+ proto.readStructEnd()
+ proto.readMessageEnd()
# THeader stack should accept binary protocol with optionally framed transport
def main(argv):
- p = argparse.ArgumentParser()
- add_common_args(p)
- # Since THeaderTransport acts as framed transport when detected frame, we
- # cannot use --transport=framed as it would result in 2 layered frames.
- p.add_argument('--override-transport')
- p.add_argument('--override-protocol')
- args = p.parse_args()
- assert args.protocol == 'header'
- assert args.transport == 'buffered'
- assert not args.ssl
+ p = argparse.ArgumentParser()
+ add_common_args(p)
+ # Since THeaderTransport acts as framed transport when detected frame, we
+ # cannot use --transport=framed as it would result in 2 layered frames.
+ p.add_argument('--override-transport')
+ p.add_argument('--override-protocol')
+ args = p.parse_args()
+ assert args.protocol == 'header'
+ assert args.transport == 'buffered'
+ assert not args.ssl
- sock = TSocket(args.host, args.port, socket_family=socket.AF_INET)
- if not args.override_transport or args.override_transport == 'buffered':
- trans = TBufferedTransport(sock)
- elif args.override_transport == 'framed':
- print('TFRAMED')
- trans = TFramedTransport(sock)
- else:
- raise ValueError('invalid transport')
- trans.open()
+ sock = TSocket(args.host, args.port, socket_family=socket.AF_INET)
+ if not args.override_transport or args.override_transport == 'buffered':
+ trans = TBufferedTransport(sock)
+ elif args.override_transport == 'framed':
+ print('TFRAMED')
+ trans = TFramedTransport(sock)
+ else:
+ raise ValueError('invalid transport')
+ trans.open()
- if not args.override_protocol or args.override_protocol == 'binary':
- proto = TBinaryProtocol(trans)
- elif args.override_protocol == 'compact':
- proto = TCompactProtocol(trans)
- else:
- raise ValueError('invalid transport')
+ if not args.override_protocol or args.override_protocol == 'binary':
+ proto = TBinaryProtocol(trans)
+ elif args.override_protocol == 'compact':
+ proto = TCompactProtocol(trans)
+ else:
+ raise ValueError('invalid transport')
- test_void(proto)
- test_void(proto)
+ test_void(proto)
+ test_void(proto)
- trans.close()
+ trans.close()
if __name__ == '__main__':
- sys.exit(main(sys.argv[1:]))
+ sys.exit(main(sys.argv[1:]))
diff --git a/test/features/util.py b/test/features/util.py
index e364136..e4997d0 100644
--- a/test/features/util.py
+++ b/test/features/util.py
@@ -11,30 +11,30 @@
def add_common_args(p):
- p.add_argument('--host', default='localhost')
- p.add_argument('--port', type=int, default=9090)
- p.add_argument('--protocol', default='binary')
- p.add_argument('--transport', default='buffered')
- p.add_argument('--ssl', action='store_true')
+ p.add_argument('--host', default='localhost')
+ p.add_argument('--port', type=int, default=9090)
+ p.add_argument('--protocol', default='binary')
+ p.add_argument('--transport', default='buffered')
+ p.add_argument('--ssl', action='store_true')
def parse_common_args(argv):
- p = argparse.ArgumentParser()
- add_common_args(p)
- return p.parse_args(argv)
+ p = argparse.ArgumentParser()
+ add_common_args(p)
+ return p.parse_args(argv)
def init_protocol(args):
- sock = TSocket(args.host, args.port, socket_family=socket.AF_INET)
- sock.setTimeout(500)
- trans = {
- 'buffered': TBufferedTransport,
- 'framed': TFramedTransport,
- 'http': THttpClient,
- }[args.transport](sock)
- trans.open()
- return {
- 'binary': TBinaryProtocol,
- 'compact': TCompactProtocol,
- 'json': TJSONProtocol,
- }[args.protocol](trans)
+ sock = TSocket(args.host, args.port, socket_family=socket.AF_INET)
+ sock.setTimeout(500)
+ trans = {
+ 'buffered': TBufferedTransport,
+ 'framed': TFramedTransport,
+ 'http': THttpClient,
+ }[args.transport](sock)
+ trans.open()
+ return {
+ 'binary': TBinaryProtocol,
+ 'compact': TCompactProtocol,
+ 'json': TJSONProtocol,
+ }[args.protocol](trans)
diff --git a/test/py.tornado/test_suite.py b/test/py.tornado/test_suite.py
index e0bf913..b9ce781 100755
--- a/test/py.tornado/test_suite.py
+++ b/test/py.tornado/test_suite.py
@@ -27,7 +27,7 @@
import unittest
basepath = os.path.abspath(os.path.dirname(__file__))
-sys.path.insert(0, basepath+'/gen-py.tornado')
+sys.path.insert(0, basepath + '/gen-py.tornado')
sys.path.insert(0, glob.glob(os.path.join(basepath, '../../lib/py/build/lib*'))[0])
try:
diff --git a/test/py.twisted/test_suite.py b/test/py.twisted/test_suite.py
index 2c07baa..3a59bb1 100755
--- a/test/py.twisted/test_suite.py
+++ b/test/py.twisted/test_suite.py
@@ -19,7 +19,10 @@
# under the License.
#
-import sys, os, glob, time
+import sys
+import os
+import glob
+import time
basepath = os.path.abspath(os.path.dirname(__file__))
sys.path.insert(0, os.path.join(basepath, 'gen-py.twisted'))
sys.path.insert(0, glob.glob(os.path.join(basepath, '../../lib/py/build/lib.*'))[0])
@@ -35,6 +38,7 @@
from zope.interface import implements
+
class TestHandler:
implements(ThriftTest.Iface)
@@ -100,6 +104,7 @@
def testTypedef(self, thing):
return thing
+
class ThriftTestCase(unittest.TestCase):
@defer.inlineCallbacks
@@ -109,15 +114,15 @@
self.pfactory = TBinaryProtocol.TBinaryProtocolFactory()
self.server = reactor.listenTCP(0,
- TTwisted.ThriftServerFactory(self.processor,
- self.pfactory), interface="127.0.0.1")
+ TTwisted.ThriftServerFactory(self.processor,
+ self.pfactory), interface="127.0.0.1")
self.portNo = self.server.getHost().port
self.txclient = yield ClientCreator(reactor,
- TTwisted.ThriftClientProtocol,
- ThriftTest.Client,
- self.pfactory).connectTCP("127.0.0.1", self.portNo)
+ TTwisted.ThriftClientProtocol,
+ ThriftTest.Client,
+ self.pfactory).connectTCP("127.0.0.1", self.portNo)
self.client = self.txclient.client
@defer.inlineCallbacks
@@ -179,7 +184,7 @@
try:
yield self.client.testException("throw_undeclared")
self.fail("should have thrown exception")
- except Exception: # type is undefined
+ except Exception: # type is undefined
pass
@defer.inlineCallbacks
diff --git a/test/py/FastbinaryTest.py b/test/py/FastbinaryTest.py
index 9d258fd..a8718dc 100755
--- a/test/py/FastbinaryTest.py
+++ b/test/py/FastbinaryTest.py
@@ -41,11 +41,11 @@
class TDevNullTransport(TTransport.TTransportBase):
- def __init__(self):
- pass
+ def __init__(self):
+ pass
- def isOpen(self):
- return True
+ def isOpen(self):
+ return True
ooe1 = OneOfEach()
ooe1.im_true = True
@@ -71,8 +71,8 @@
u"\xc7\x83\xe2\x80\xbc"
if sys.version_info[0] == 2 and os.environ.get('THRIFT_TEST_PY_NO_UTF8STRINGS'):
- ooe1.zomg_unicode = ooe1.zomg_unicode.encode('utf8')
- ooe2.zomg_unicode = ooe2.zomg_unicode.encode('utf8')
+ ooe1.zomg_unicode = ooe1.zomg_unicode.encode('utf8')
+ ooe2.zomg_unicode = ooe2.zomg_unicode.encode('utf8')
hm = HolyMoley(**{"big": [], "contain": set(), "bonks": {}})
hm.big.append(ooe1)
@@ -86,13 +86,13 @@
hm.bonks["nothing"] = []
hm.bonks["something"] = [
- Bonk(**{"type": 1, "message": "Wait."}),
- Bonk(**{"type": 2, "message": "What?"}),
+ Bonk(**{"type": 1, "message": "Wait."}),
+ Bonk(**{"type": 2, "message": "What?"}),
]
hm.bonks["poe"] = [
- Bonk(**{"type": 3, "message": "quoth"}),
- Bonk(**{"type": 4, "message": "the raven"}),
- Bonk(**{"type": 5, "message": "nevermore"}),
+ Bonk(**{"type": 3, "message": "quoth"}),
+ Bonk(**{"type": 4, "message": "the raven"}),
+ Bonk(**{"type": 5, "message": "nevermore"}),
]
rs = RandomStuff()
@@ -112,110 +112,110 @@
def check_write(o):
- trans_fast = TTransport.TMemoryBuffer()
- trans_slow = TTransport.TMemoryBuffer()
- prot_fast = TBinaryProtocol.TBinaryProtocolAccelerated(trans_fast)
- prot_slow = TBinaryProtocol.TBinaryProtocol(trans_slow)
+ trans_fast = TTransport.TMemoryBuffer()
+ trans_slow = TTransport.TMemoryBuffer()
+ prot_fast = TBinaryProtocol.TBinaryProtocolAccelerated(trans_fast)
+ prot_slow = TBinaryProtocol.TBinaryProtocol(trans_slow)
- o.write(prot_fast)
- o.write(prot_slow)
- ORIG = trans_slow.getvalue()
- MINE = trans_fast.getvalue()
- if ORIG != MINE:
- print("mine: %s\norig: %s" % (repr(MINE), repr(ORIG)))
+ o.write(prot_fast)
+ o.write(prot_slow)
+ ORIG = trans_slow.getvalue()
+ MINE = trans_fast.getvalue()
+ if ORIG != MINE:
+ print("mine: %s\norig: %s" % (repr(MINE), repr(ORIG)))
def check_read(o):
- prot = TBinaryProtocol.TBinaryProtocol(TTransport.TMemoryBuffer())
- o.write(prot)
+ prot = TBinaryProtocol.TBinaryProtocol(TTransport.TMemoryBuffer())
+ o.write(prot)
- slow_version_binary = prot.trans.getvalue()
+ slow_version_binary = prot.trans.getvalue()
- prot = TBinaryProtocol.TBinaryProtocolAccelerated(
- TTransport.TMemoryBuffer(slow_version_binary))
- c = o.__class__()
- c.read(prot)
- if c != o:
- print("copy: ")
- pprint(eval(repr(c)))
- print("orig: ")
- pprint(eval(repr(o)))
+ prot = TBinaryProtocol.TBinaryProtocolAccelerated(
+ TTransport.TMemoryBuffer(slow_version_binary))
+ c = o.__class__()
+ c.read(prot)
+ if c != o:
+ print("copy: ")
+ pprint(eval(repr(c)))
+ print("orig: ")
+ pprint(eval(repr(o)))
- prot = TBinaryProtocol.TBinaryProtocolAccelerated(
- TTransport.TBufferedTransport(
- TTransport.TMemoryBuffer(slow_version_binary)))
- c = o.__class__()
- c.read(prot)
- if c != o:
- print("copy: ")
- pprint(eval(repr(c)))
- print("orig: ")
- pprint(eval(repr(o)))
+ prot = TBinaryProtocol.TBinaryProtocolAccelerated(
+ TTransport.TBufferedTransport(
+ TTransport.TMemoryBuffer(slow_version_binary)))
+ c = o.__class__()
+ c.read(prot)
+ if c != o:
+ print("copy: ")
+ pprint(eval(repr(c)))
+ print("orig: ")
+ pprint(eval(repr(o)))
def do_test():
- check_write(hm)
- check_read(HolyMoley())
- no_set = deepcopy(hm)
- no_set.contain = set()
- check_read(no_set)
- check_write(rs)
- check_read(rs)
- check_write(rshuge)
- check_read(rshuge)
- check_write(my_zero)
- check_read(my_zero)
- check_read(Backwards(**{"first_tag2": 4, "second_tag1": 2}))
+ check_write(hm)
+ check_read(HolyMoley())
+ no_set = deepcopy(hm)
+ no_set.contain = set()
+ check_read(no_set)
+ check_write(rs)
+ check_read(rs)
+ check_write(rshuge)
+ check_read(rshuge)
+ check_write(my_zero)
+ check_read(my_zero)
+ check_read(Backwards(**{"first_tag2": 4, "second_tag1": 2}))
- # One case where the serialized form changes, but only superficially.
- o = Backwards(**{"first_tag2": 4, "second_tag1": 2})
- trans_fast = TTransport.TMemoryBuffer()
- trans_slow = TTransport.TMemoryBuffer()
- prot_fast = TBinaryProtocol.TBinaryProtocolAccelerated(trans_fast)
- prot_slow = TBinaryProtocol.TBinaryProtocol(trans_slow)
+ # One case where the serialized form changes, but only superficially.
+ o = Backwards(**{"first_tag2": 4, "second_tag1": 2})
+ trans_fast = TTransport.TMemoryBuffer()
+ trans_slow = TTransport.TMemoryBuffer()
+ prot_fast = TBinaryProtocol.TBinaryProtocolAccelerated(trans_fast)
+ prot_slow = TBinaryProtocol.TBinaryProtocol(trans_slow)
- o.write(prot_fast)
- o.write(prot_slow)
- ORIG = trans_slow.getvalue()
- MINE = trans_fast.getvalue()
- assert id(ORIG) != id(MINE)
+ o.write(prot_fast)
+ o.write(prot_slow)
+ ORIG = trans_slow.getvalue()
+ MINE = trans_fast.getvalue()
+ assert id(ORIG) != id(MINE)
- prot = TBinaryProtocol.TBinaryProtocolAccelerated(TTransport.TMemoryBuffer())
- o.write(prot)
- prot = TBinaryProtocol.TBinaryProtocol(
- TTransport.TMemoryBuffer(prot.trans.getvalue()))
- c = o.__class__()
- c.read(prot)
- if c != o:
- print("copy: ")
- pprint(eval(repr(c)))
- print("orig: ")
- pprint(eval(repr(o)))
+ prot = TBinaryProtocol.TBinaryProtocolAccelerated(TTransport.TMemoryBuffer())
+ o.write(prot)
+ prot = TBinaryProtocol.TBinaryProtocol(
+ TTransport.TMemoryBuffer(prot.trans.getvalue()))
+ c = o.__class__()
+ c.read(prot)
+ if c != o:
+ print("copy: ")
+ pprint(eval(repr(c)))
+ print("orig: ")
+ pprint(eval(repr(o)))
def do_benchmark(iters=5000):
- setup = """
+ setup = """
from __main__ import hm, rs, TDevNullTransport
from thrift.protocol import TBinaryProtocol
trans = TDevNullTransport()
prot = TBinaryProtocol.TBinaryProtocol%s(trans)
"""
- setup_fast = setup % "Accelerated"
- setup_slow = setup % ""
+ setup_fast = setup % "Accelerated"
+ setup_slow = setup % ""
- print("Starting Benchmarks")
+ print("Starting Benchmarks")
- print("HolyMoley Standard = %f" %
- timeit.Timer('hm.write(prot)', setup_slow).timeit(number=iters))
- print("HolyMoley Acceler. = %f" %
- timeit.Timer('hm.write(prot)', setup_fast).timeit(number=iters))
+ print("HolyMoley Standard = %f" %
+ timeit.Timer('hm.write(prot)', setup_slow).timeit(number=iters))
+ print("HolyMoley Acceler. = %f" %
+ timeit.Timer('hm.write(prot)', setup_fast).timeit(number=iters))
- print("FastStruct Standard = %f" %
- timeit.Timer('rs.write(prot)', setup_slow).timeit(number=iters))
- print("FastStruct Acceler. = %f" %
- timeit.Timer('rs.write(prot)', setup_fast).timeit(number=iters))
+ print("FastStruct Standard = %f" %
+ timeit.Timer('rs.write(prot)', setup_slow).timeit(number=iters))
+ print("FastStruct Acceler. = %f" %
+ timeit.Timer('rs.write(prot)', setup_fast).timeit(number=iters))
if __name__ == '__main__':
- do_test()
- do_benchmark()
+ do_test()
+ do_benchmark()
diff --git a/test/py/RunClientServer.py b/test/py/RunClientServer.py
index d5ebd6a..98ead43 100755
--- a/test/py/RunClientServer.py
+++ b/test/py/RunClientServer.py
@@ -37,13 +37,13 @@
DEFAULT_LIBDIR_PY3 = os.path.join(ROOT_DIR, 'lib', 'py', 'build', 'lib')
SCRIPTS = [
- 'FastbinaryTest.py',
- 'TestFrozen.py',
- 'TSimpleJSONProtocolTest.py',
- 'SerializationTest.py',
- 'TestEof.py',
- 'TestSyntax.py',
- 'TestSocket.py',
+ 'FastbinaryTest.py',
+ 'TestFrozen.py',
+ 'TSimpleJSONProtocolTest.py',
+ 'SerializationTest.py',
+ 'TestEof.py',
+ 'TestSyntax.py',
+ 'TestSocket.py',
]
FRAMED = ["TNonblockingServer"]
SKIP_ZLIB = ['TNonblockingServer', 'THttpServer']
@@ -51,20 +51,20 @@
EXTRA_DELAY = dict(TProcessPoolServer=5.5)
PROTOS = [
- 'accel',
- 'binary',
- 'compact',
- 'json',
+ 'accel',
+ 'binary',
+ 'compact',
+ 'json',
]
SERVERS = [
- "TSimpleServer",
- "TThreadedServer",
- "TThreadPoolServer",
- "TProcessPoolServer",
- "TForkingServer",
- "TNonblockingServer",
- "THttpServer",
+ "TSimpleServer",
+ "TThreadedServer",
+ "TThreadPoolServer",
+ "TProcessPoolServer",
+ "TForkingServer",
+ "TNonblockingServer",
+ "THttpServer",
]
@@ -73,246 +73,246 @@
def setup_pypath(libdir, gendir):
- dirs = [libdir, gendir]
- env = copy.deepcopy(os.environ)
- pypath = env.get('PYTHONPATH', None)
- if pypath:
- dirs.append(pypath)
- env['PYTHONPATH'] = ':'.join(dirs)
- if gendir.endswith('gen-py-no_utf8strings'):
- env['THRIFT_TEST_PY_NO_UTF8STRINGS'] = '1'
- return env
+ dirs = [libdir, gendir]
+ env = copy.deepcopy(os.environ)
+ pypath = env.get('PYTHONPATH', None)
+ if pypath:
+ dirs.append(pypath)
+ env['PYTHONPATH'] = ':'.join(dirs)
+ if gendir.endswith('gen-py-no_utf8strings'):
+ env['THRIFT_TEST_PY_NO_UTF8STRINGS'] = '1'
+ return env
def runScriptTest(libdir, genbase, genpydir, script):
- env = setup_pypath(libdir, os.path.join(genbase, genpydir))
- script_args = [sys.executable, relfile(script)]
- print('\nTesting script: %s\n----' % (' '.join(script_args)))
- ret = subprocess.call(script_args, env=env)
- if ret != 0:
- print('*** FAILED ***', file=sys.stderr)
- print('LIBDIR: %s' % libdir, file=sys.stderr)
- print('PY_GEN: %s' % genpydir, file=sys.stderr)
- print('SCRIPT: %s' % script, file=sys.stderr)
- raise Exception("Script subprocess failed, retcode=%d, args: %s" % (ret, ' '.join(script_args)))
+ env = setup_pypath(libdir, os.path.join(genbase, genpydir))
+ script_args = [sys.executable, relfile(script)]
+ print('\nTesting script: %s\n----' % (' '.join(script_args)))
+ ret = subprocess.call(script_args, env=env)
+ if ret != 0:
+ print('*** FAILED ***', file=sys.stderr)
+ print('LIBDIR: %s' % libdir, file=sys.stderr)
+ print('PY_GEN: %s' % genpydir, file=sys.stderr)
+ print('SCRIPT: %s' % script, file=sys.stderr)
+ raise Exception("Script subprocess failed, retcode=%d, args: %s" % (ret, ' '.join(script_args)))
def runServiceTest(libdir, genbase, genpydir, server_class, proto, port, use_zlib, use_ssl, verbose):
- env = setup_pypath(libdir, os.path.join(genbase, genpydir))
- # Build command line arguments
- server_args = [sys.executable, relfile('TestServer.py')]
- cli_args = [sys.executable, relfile('TestClient.py')]
- for which in (server_args, cli_args):
- which.append('--protocol=%s' % proto) # accel, binary, compact or json
- which.append('--port=%d' % port) # default to 9090
- if use_zlib:
- which.append('--zlib')
- if use_ssl:
- which.append('--ssl')
- if verbose == 0:
- which.append('-q')
- if verbose == 2:
- which.append('-v')
- # server-specific option to select server class
- server_args.append(server_class)
- # client-specific cmdline options
- if server_class in FRAMED:
- cli_args.append('--transport=framed')
- else:
- cli_args.append('--transport=buffered')
- if server_class == 'THttpServer':
- cli_args.append('--http=/')
- if verbose > 0:
- print('Testing server %s: %s' % (server_class, ' '.join(server_args)))
- serverproc = subprocess.Popen(server_args, env=env)
-
- def ensureServerAlive():
- if serverproc.poll() is not None:
- print(('FAIL: Server process (%s) failed with retcode %d')
- % (' '.join(server_args), serverproc.returncode))
- raise Exception('Server subprocess %s died, args: %s'
- % (server_class, ' '.join(server_args)))
-
- # Wait for the server to start accepting connections on the given port.
- sock = socket.socket()
- sleep_time = 0.1 # Seconds
- max_attempts = 100
- try:
- attempt = 0
- while sock.connect_ex(('127.0.0.1', port)) != 0:
- attempt += 1
- if attempt >= max_attempts:
- raise Exception("TestServer not ready on port %d after %.2f seconds"
- % (port, sleep_time * attempt))
- ensureServerAlive()
- time.sleep(sleep_time)
- finally:
- sock.close()
-
- try:
+ env = setup_pypath(libdir, os.path.join(genbase, genpydir))
+ # Build command line arguments
+ server_args = [sys.executable, relfile('TestServer.py')]
+ cli_args = [sys.executable, relfile('TestClient.py')]
+ for which in (server_args, cli_args):
+ which.append('--protocol=%s' % proto) # accel, binary, compact or json
+ which.append('--port=%d' % port) # default to 9090
+ if use_zlib:
+ which.append('--zlib')
+ if use_ssl:
+ which.append('--ssl')
+ if verbose == 0:
+ which.append('-q')
+ if verbose == 2:
+ which.append('-v')
+ # server-specific option to select server class
+ server_args.append(server_class)
+ # client-specific cmdline options
+ if server_class in FRAMED:
+ cli_args.append('--transport=framed')
+ else:
+ cli_args.append('--transport=buffered')
+ if server_class == 'THttpServer':
+ cli_args.append('--http=/')
if verbose > 0:
- print('Testing client: %s' % (' '.join(cli_args)))
- ret = subprocess.call(cli_args, env=env)
- if ret != 0:
- print('*** FAILED ***', file=sys.stderr)
- print('LIBDIR: %s' % libdir, file=sys.stderr)
- print('PY_GEN: %s' % genpydir, file=sys.stderr)
- raise Exception("Client subprocess failed, retcode=%d, args: %s" % (ret, ' '.join(cli_args)))
- finally:
- # check that server didn't die
- ensureServerAlive()
- extra_sleep = EXTRA_DELAY.get(server_class, 0)
- if extra_sleep > 0 and verbose > 0:
- print('Giving %s (proto=%s,zlib=%s,ssl=%s) an extra %d seconds for child'
- 'processes to terminate via alarm'
- % (server_class, proto, use_zlib, use_ssl, extra_sleep))
- time.sleep(extra_sleep)
- os.kill(serverproc.pid, signal.SIGKILL)
- serverproc.wait()
+ print('Testing server %s: %s' % (server_class, ' '.join(server_args)))
+ serverproc = subprocess.Popen(server_args, env=env)
+
+ def ensureServerAlive():
+ if serverproc.poll() is not None:
+ print(('FAIL: Server process (%s) failed with retcode %d')
+ % (' '.join(server_args), serverproc.returncode))
+ raise Exception('Server subprocess %s died, args: %s'
+ % (server_class, ' '.join(server_args)))
+
+ # Wait for the server to start accepting connections on the given port.
+ sock = socket.socket()
+ sleep_time = 0.1 # Seconds
+ max_attempts = 100
+ try:
+ attempt = 0
+ while sock.connect_ex(('127.0.0.1', port)) != 0:
+ attempt += 1
+ if attempt >= max_attempts:
+ raise Exception("TestServer not ready on port %d after %.2f seconds"
+ % (port, sleep_time * attempt))
+ ensureServerAlive()
+ time.sleep(sleep_time)
+ finally:
+ sock.close()
+
+ try:
+ if verbose > 0:
+ print('Testing client: %s' % (' '.join(cli_args)))
+ ret = subprocess.call(cli_args, env=env)
+ if ret != 0:
+ print('*** FAILED ***', file=sys.stderr)
+ print('LIBDIR: %s' % libdir, file=sys.stderr)
+ print('PY_GEN: %s' % genpydir, file=sys.stderr)
+ raise Exception("Client subprocess failed, retcode=%d, args: %s" % (ret, ' '.join(cli_args)))
+ finally:
+ # check that server didn't die
+ ensureServerAlive()
+ extra_sleep = EXTRA_DELAY.get(server_class, 0)
+ if extra_sleep > 0 and verbose > 0:
+ print('Giving %s (proto=%s,zlib=%s,ssl=%s) an extra %d seconds for child'
+ 'processes to terminate via alarm'
+ % (server_class, proto, use_zlib, use_ssl, extra_sleep))
+ time.sleep(extra_sleep)
+ os.kill(serverproc.pid, signal.SIGKILL)
+ serverproc.wait()
class TestCases(object):
- def __init__(self, genbase, libdir, port, gendirs, servers, verbose):
- self.genbase = genbase
- self.libdir = libdir
- self.port = port
- self.verbose = verbose
- self.gendirs = gendirs
- self.servers = servers
+ def __init__(self, genbase, libdir, port, gendirs, servers, verbose):
+ self.genbase = genbase
+ self.libdir = libdir
+ self.port = port
+ self.verbose = verbose
+ self.gendirs = gendirs
+ self.servers = servers
- def default_conf(self):
- return {
- 'gendir': self.gendirs[0],
- 'server': self.servers[0],
- 'proto': PROTOS[0],
- 'zlib': False,
- 'ssl': False,
- }
+ def default_conf(self):
+ return {
+ 'gendir': self.gendirs[0],
+ 'server': self.servers[0],
+ 'proto': PROTOS[0],
+ 'zlib': False,
+ 'ssl': False,
+ }
- def run(self, conf, test_count):
- with_zlib = conf['zlib']
- with_ssl = conf['ssl']
- try_server = conf['server']
- try_proto = conf['proto']
- genpydir = conf['gendir']
- # skip any servers that don't work with the Zlib transport
- if with_zlib and try_server in SKIP_ZLIB:
- return False
- # skip any servers that don't work with SSL
- if with_ssl and try_server in SKIP_SSL:
- return False
- if self.verbose > 0:
- print('\nTest run #%d: (includes %s) Server=%s, Proto=%s, zlib=%s, SSL=%s'
- % (test_count, genpydir, try_server, try_proto, with_zlib, with_ssl))
- runServiceTest(self.libdir, self.genbase, genpydir, try_server, try_proto, self.port, with_zlib, with_ssl, self.verbose)
- if self.verbose > 0:
- print('OK: Finished (includes %s) %s / %s proto / zlib=%s / SSL=%s. %d combinations tested.'
- % (genpydir, try_server, try_proto, with_zlib, with_ssl, test_count))
- return True
+ def run(self, conf, test_count):
+ with_zlib = conf['zlib']
+ with_ssl = conf['ssl']
+ try_server = conf['server']
+ try_proto = conf['proto']
+ genpydir = conf['gendir']
+ # skip any servers that don't work with the Zlib transport
+ if with_zlib and try_server in SKIP_ZLIB:
+ return False
+ # skip any servers that don't work with SSL
+ if with_ssl and try_server in SKIP_SSL:
+ return False
+ if self.verbose > 0:
+ print('\nTest run #%d: (includes %s) Server=%s, Proto=%s, zlib=%s, SSL=%s'
+ % (test_count, genpydir, try_server, try_proto, with_zlib, with_ssl))
+ runServiceTest(self.libdir, self.genbase, genpydir, try_server, try_proto, self.port, with_zlib, with_ssl, self.verbose)
+ if self.verbose > 0:
+ print('OK: Finished (includes %s) %s / %s proto / zlib=%s / SSL=%s. %d combinations tested.'
+ % (genpydir, try_server, try_proto, with_zlib, with_ssl, test_count))
+ return True
- def test_feature(self, name, values):
- test_count = 0
- conf = self.default_conf()
- for try_server in values:
- conf[name] = try_server
- if self.run(conf, test_count):
- test_count += 1
- return test_count
+ def test_feature(self, name, values):
+ test_count = 0
+ conf = self.default_conf()
+ for try_server in values:
+ conf[name] = try_server
+ if self.run(conf, test_count):
+ test_count += 1
+ return test_count
- def run_all_tests(self):
- test_count = 0
- for try_server in self.servers:
- for genpydir in self.gendirs:
- for try_proto in PROTOS:
- for with_zlib in (False, True):
- # skip any servers that don't work with the Zlib transport
- if with_zlib and try_server in SKIP_ZLIB:
- continue
- for with_ssl in (False, True):
- # skip any servers that don't work with SSL
- if with_ssl and try_server in SKIP_SSL:
- continue
- test_count += 1
- if self.verbose > 0:
- print('\nTest run #%d: (includes %s) Server=%s, Proto=%s, zlib=%s, SSL=%s'
- % (test_count, genpydir, try_server, try_proto, with_zlib, with_ssl))
- runServiceTest(self.libdir, self.genbase, genpydir, try_server, try_proto, self.port, with_zlib, with_ssl)
- if self.verbose > 0:
- print('OK: Finished (includes %s) %s / %s proto / zlib=%s / SSL=%s. %d combinations tested.'
- % (genpydir, try_server, try_proto, with_zlib, with_ssl, test_count))
- return test_count
+ def run_all_tests(self):
+ test_count = 0
+ for try_server in self.servers:
+ for genpydir in self.gendirs:
+ for try_proto in PROTOS:
+ for with_zlib in (False, True):
+ # skip any servers that don't work with the Zlib transport
+ if with_zlib and try_server in SKIP_ZLIB:
+ continue
+ for with_ssl in (False, True):
+ # skip any servers that don't work with SSL
+ if with_ssl and try_server in SKIP_SSL:
+ continue
+ test_count += 1
+ if self.verbose > 0:
+ print('\nTest run #%d: (includes %s) Server=%s, Proto=%s, zlib=%s, SSL=%s'
+ % (test_count, genpydir, try_server, try_proto, with_zlib, with_ssl))
+ runServiceTest(self.libdir, self.genbase, genpydir, try_server, try_proto, self.port, with_zlib, with_ssl)
+ if self.verbose > 0:
+ print('OK: Finished (includes %s) %s / %s proto / zlib=%s / SSL=%s. %d combinations tested.'
+ % (genpydir, try_server, try_proto, with_zlib, with_ssl, test_count))
+ return test_count
def default_libdir():
- if sys.version_info[0] == 2:
- return glob.glob(DEFAULT_LIBDIR_GLOB)[0]
- else:
- return DEFAULT_LIBDIR_PY3
+ if sys.version_info[0] == 2:
+ return glob.glob(DEFAULT_LIBDIR_GLOB)[0]
+ else:
+ return DEFAULT_LIBDIR_PY3
def main():
- parser = OptionParser()
- parser.add_option('--all', action="store_true", dest='all')
- parser.add_option('--genpydirs', type='string', dest='genpydirs',
- default='default,slots,oldstyle,no_utf8strings,dynamic,dynamicslots',
- help='directory extensions for generated code, used as suffixes for \"gen-py-*\" added sys.path for individual tests')
- parser.add_option("--port", type="int", dest="port", default=9090,
- help="port number for server to listen on")
- parser.add_option('-v', '--verbose', action="store_const",
- dest="verbose", const=2,
- help="verbose output")
- parser.add_option('-q', '--quiet', action="store_const",
- dest="verbose", const=0,
- help="minimal output")
- parser.add_option('-L', '--libdir', dest="libdir", default=default_libdir(),
- help="directory path that contains Thrift Python library")
- parser.add_option('--gen-base', dest="gen_base", default=SCRIPT_DIR,
- help="directory path that contains Thrift Python library")
- parser.set_defaults(verbose=1)
- options, args = parser.parse_args()
+ parser = OptionParser()
+ parser.add_option('--all', action="store_true", dest='all')
+ parser.add_option('--genpydirs', type='string', dest='genpydirs',
+ default='default,slots,oldstyle,no_utf8strings,dynamic,dynamicslots',
+ help='directory extensions for generated code, used as suffixes for \"gen-py-*\" added sys.path for individual tests')
+ parser.add_option("--port", type="int", dest="port", default=9090,
+ help="port number for server to listen on")
+ parser.add_option('-v', '--verbose', action="store_const",
+ dest="verbose", const=2,
+ help="verbose output")
+ parser.add_option('-q', '--quiet', action="store_const",
+ dest="verbose", const=0,
+ help="minimal output")
+ parser.add_option('-L', '--libdir', dest="libdir", default=default_libdir(),
+ help="directory path that contains Thrift Python library")
+ parser.add_option('--gen-base', dest="gen_base", default=SCRIPT_DIR,
+ help="directory path that contains Thrift Python library")
+ parser.set_defaults(verbose=1)
+ options, args = parser.parse_args()
- generated_dirs = []
- for gp_dir in options.genpydirs.split(','):
- generated_dirs.append('gen-py-%s' % (gp_dir))
+ generated_dirs = []
+ for gp_dir in options.genpydirs.split(','):
+ generated_dirs.append('gen-py-%s' % (gp_dir))
- # commandline permits a single class name to be specified to override SERVERS=[...]
- servers = SERVERS
- if len(args) == 1:
- if args[0] in SERVERS:
- servers = args
+ # commandline permits a single class name to be specified to override SERVERS=[...]
+ servers = SERVERS
+ if len(args) == 1:
+ if args[0] in SERVERS:
+ servers = args
+ else:
+ print('Unavailable server type "%s", please choose one of: %s' % (args[0], servers))
+ sys.exit(0)
+
+ tests = TestCases(options.gen_base, options.libdir, options.port, generated_dirs, servers, options.verbose)
+
+ # run tests without a client/server first
+ print('----------------')
+ print(' Executing individual test scripts with various generated code directories')
+ print(' Directories to be tested: ' + ', '.join(generated_dirs))
+ print(' Scripts to be tested: ' + ', '.join(SCRIPTS))
+ print('----------------')
+ for genpydir in generated_dirs:
+ for script in SCRIPTS:
+ runScriptTest(options.libdir, options.gen_base, genpydir, script)
+
+ print('----------------')
+ print(' Executing Client/Server tests with various generated code directories')
+ print(' Servers to be tested: ' + ', '.join(servers))
+ print(' Directories to be tested: ' + ', '.join(generated_dirs))
+ print(' Protocols to be tested: ' + ', '.join(PROTOS))
+ print(' Options to be tested: ZLIB(yes/no), SSL(yes/no)')
+ print('----------------')
+
+ if options.all:
+ tests.run_all_tests()
else:
- print('Unavailable server type "%s", please choose one of: %s' % (args[0], servers))
- sys.exit(0)
-
- tests = TestCases(options.gen_base, options.libdir, options.port, generated_dirs, servers, options.verbose)
-
- # run tests without a client/server first
- print('----------------')
- print(' Executing individual test scripts with various generated code directories')
- print(' Directories to be tested: ' + ', '.join(generated_dirs))
- print(' Scripts to be tested: ' + ', '.join(SCRIPTS))
- print('----------------')
- for genpydir in generated_dirs:
- for script in SCRIPTS:
- runScriptTest(options.libdir, options.gen_base, genpydir, script)
-
- print('----------------')
- print(' Executing Client/Server tests with various generated code directories')
- print(' Servers to be tested: ' + ', '.join(servers))
- print(' Directories to be tested: ' + ', '.join(generated_dirs))
- print(' Protocols to be tested: ' + ', '.join(PROTOS))
- print(' Options to be tested: ZLIB(yes/no), SSL(yes/no)')
- print('----------------')
-
- if options.all:
- tests.run_all_tests()
- else:
- tests.test_feature('gendir', generated_dirs)
- tests.test_feature('server', servers)
- tests.test_feature('proto', PROTOS)
- tests.test_feature('zlib', [False, True])
- tests.test_feature('ssl', [False, True])
+ tests.test_feature('gendir', generated_dirs)
+ tests.test_feature('server', servers)
+ tests.test_feature('proto', PROTOS)
+ tests.test_feature('zlib', [False, True])
+ tests.test_feature('ssl', [False, True])
if __name__ == '__main__':
- sys.exit(main())
+ sys.exit(main())
diff --git a/test/py/SerializationTest.py b/test/py/SerializationTest.py
index d4755cf..65a1495 100755
--- a/test/py/SerializationTest.py
+++ b/test/py/SerializationTest.py
@@ -30,341 +30,342 @@
class AbstractTest(unittest.TestCase):
- def setUp(self):
- self.v1obj = VersioningTestV1(
- begin_in_both=12345,
- old_string='aaa',
- end_in_both=54321,
- )
+ def setUp(self):
+ self.v1obj = VersioningTestV1(
+ begin_in_both=12345,
+ old_string='aaa',
+ end_in_both=54321,
+ )
- self.v2obj = VersioningTestV2(
- begin_in_both=12345,
- newint=1,
- newbyte=2,
- newshort=3,
- newlong=4,
- newdouble=5.0,
- newstruct=Bonk(message="Hello!", type=123),
- newlist=[7,8,9],
- newset=set([42,1,8]),
- newmap={1:2,2:3},
- newstring="Hola!",
- end_in_both=54321,
- )
+ self.v2obj = VersioningTestV2(
+ begin_in_both=12345,
+ newint=1,
+ newbyte=2,
+ newshort=3,
+ newlong=4,
+ newdouble=5.0,
+ newstruct=Bonk(message="Hello!", type=123),
+ newlist=[7, 8, 9],
+ newset=set([42, 1, 8]),
+ newmap={1: 2, 2: 3},
+ newstring="Hola!",
+ end_in_both=54321,
+ )
- self.bools = Bools(im_true=True, im_false=False)
- self.bools_flipped = Bools(im_true=False, im_false=True)
+ self.bools = Bools(im_true=True, im_false=False)
+ self.bools_flipped = Bools(im_true=False, im_false=True)
- self.large_deltas = LargeDeltas (
- b1=self.bools,
- b10=self.bools_flipped,
- b100=self.bools,
- check_true=True,
- b1000=self.bools_flipped,
- check_false=False,
- vertwo2000=VersioningTestV2(newstruct=Bonk(message='World!', type=314)),
- a_set2500=set(['lazy', 'brown', 'cow']),
- vertwo3000=VersioningTestV2(newset=set([2, 3, 5, 7, 11])),
- big_numbers=[2**8, 2**16, 2**31-1, -(2**31-1)]
- )
+ self.large_deltas = LargeDeltas(
+ b1=self.bools,
+ b10=self.bools_flipped,
+ b100=self.bools,
+ check_true=True,
+ b1000=self.bools_flipped,
+ check_false=False,
+ vertwo2000=VersioningTestV2(newstruct=Bonk(message='World!', type=314)),
+ a_set2500=set(['lazy', 'brown', 'cow']),
+ vertwo3000=VersioningTestV2(newset=set([2, 3, 5, 7, 11])),
+ big_numbers=[2**8, 2**16, 2**31 - 1, -(2**31 - 1)]
+ )
- self.compact_struct = CompactProtoTestStruct(
- a_byte = 127,
- a_i16=32000,
- a_i32=1000000000,
- a_i64=0xffffffffff,
- a_double=5.6789,
- a_string="my string",
- true_field=True,
- false_field=False,
- empty_struct_field=Empty(),
- byte_list=[-127, -1, 0, 1, 127],
- i16_list=[-1, 0, 1, 0x7fff],
- i32_list= [-1, 0, 0xff, 0xffff, 0xffffff, 0x7fffffff],
- i64_list=[-1, 0, 0xff, 0xffff, 0xffffff, 0xffffffff, 0xffffffffff, 0xffffffffffff, 0xffffffffffffff, 0x7fffffffffffffff],
- double_list=[0.1, 0.2, 0.3],
- string_list=["first", "second", "third"],
- boolean_list=[True, True, True, False, False, False],
- struct_list=[Empty(), Empty()],
- byte_set=set([-127, -1, 0, 1, 127]),
- i16_set=set([-1, 0, 1, 0x7fff]),
- i32_set=set([1, 2, 3]),
- i64_set=set([-1, 0, 0xff, 0xffff, 0xffffff, 0xffffffff, 0xffffffffff, 0xffffffffffff, 0xffffffffffffff, 0x7fffffffffffffff]),
- double_set=set([0.1, 0.2, 0.3]),
- string_set=set(["first", "second", "third"]),
- boolean_set=set([True, False]),
- #struct_set=set([Empty()]), # unhashable instance
- byte_byte_map={1 : 2},
- i16_byte_map={1 : 1, -1 : 1, 0x7fff : 1},
- i32_byte_map={1 : 1, -1 : 1, 0x7fffffff : 1},
- i64_byte_map={0 : 1, 1 : 1, -1 : 1, 0x7fffffffffffffff : 1},
- double_byte_map={-1.1 : 1, 1.1 : 1},
- string_byte_map={"first" : 1, "second" : 2, "third" : 3, "" : 0},
- boolean_byte_map={True : 1, False: 0},
- byte_i16_map={1 : 1, 2 : -1, 3 : 0x7fff},
- byte_i32_map={1 : 1, 2 : -1, 3 : 0x7fffffff},
- byte_i64_map={1 : 1, 2 : -1, 3 : 0x7fffffffffffffff},
- byte_double_map={1 : 0.1, 2 : -0.1, 3 : 1000000.1},
- byte_string_map={1 : "", 2 : "blah", 3 : "loooooooooooooong string"},
- byte_boolean_map={1 : True, 2 : False},
- #list_byte_map # unhashable
- #set_byte_map={set([1, 2, 3]) : 1, set([0, 1]) : 2, set([]) : 0}, # unhashable
- #map_byte_map # unhashable
- byte_map_map={0 : {}, 1 : {1 : 1}, 2 : {1 : 1, 2 : 2}},
- byte_set_map={0 : set([]), 1 : set([1]), 2 : set([1, 2])},
- byte_list_map={0 : [], 1 : [1], 2 : [1, 2]},
- )
+ self.compact_struct = CompactProtoTestStruct(
+ a_byte=127,
+ a_i16=32000,
+ a_i32=1000000000,
+ a_i64=0xffffffffff,
+ a_double=5.6789,
+ a_string="my string",
+ true_field=True,
+ false_field=False,
+ empty_struct_field=Empty(),
+ byte_list=[-127, -1, 0, 1, 127],
+ i16_list=[-1, 0, 1, 0x7fff],
+ i32_list=[-1, 0, 0xff, 0xffff, 0xffffff, 0x7fffffff],
+ i64_list=[-1, 0, 0xff, 0xffff, 0xffffff, 0xffffffff, 0xffffffffff, 0xffffffffffff, 0xffffffffffffff, 0x7fffffffffffffff],
+ double_list=[0.1, 0.2, 0.3],
+ string_list=["first", "second", "third"],
+ boolean_list=[True, True, True, False, False, False],
+ struct_list=[Empty(), Empty()],
+ byte_set=set([-127, -1, 0, 1, 127]),
+ i16_set=set([-1, 0, 1, 0x7fff]),
+ i32_set=set([1, 2, 3]),
+ i64_set=set([-1, 0, 0xff, 0xffff, 0xffffff, 0xffffffff, 0xffffffffff, 0xffffffffffff, 0xffffffffffffff, 0x7fffffffffffffff]),
+ double_set=set([0.1, 0.2, 0.3]),
+ string_set=set(["first", "second", "third"]),
+ boolean_set=set([True, False]),
+ # struct_set=set([Empty()]), # unhashable instance
+ byte_byte_map={1: 2},
+ i16_byte_map={1: 1, -1: 1, 0x7fff: 1},
+ i32_byte_map={1: 1, -1: 1, 0x7fffffff: 1},
+ i64_byte_map={0: 1, 1: 1, -1: 1, 0x7fffffffffffffff: 1},
+ double_byte_map={-1.1: 1, 1.1: 1},
+ string_byte_map={"first": 1, "second": 2, "third": 3, "": 0},
+ boolean_byte_map={True: 1, False: 0},
+ byte_i16_map={1: 1, 2: -1, 3: 0x7fff},
+ byte_i32_map={1: 1, 2: -1, 3: 0x7fffffff},
+ byte_i64_map={1: 1, 2: -1, 3: 0x7fffffffffffffff},
+ byte_double_map={1: 0.1, 2: -0.1, 3: 1000000.1},
+ byte_string_map={1: "", 2: "blah", 3: "loooooooooooooong string"},
+ byte_boolean_map={1: True, 2: False},
+ # list_byte_map # unhashable
+ # set_byte_map={set([1, 2, 3]) : 1, set([0, 1]) : 2, set([]) : 0}, # unhashable
+ # map_byte_map # unhashable
+ byte_map_map={0: {}, 1: {1: 1}, 2: {1: 1, 2: 2}},
+ byte_set_map={0: set([]), 1: set([1]), 2: set([1, 2])},
+ byte_list_map={0: [], 1: [1], 2: [1, 2]},
+ )
- self.nested_lists_i32x2 = NestedListsI32x2(
- [
- [ 1, 1, 2 ],
- [ 2, 7, 9 ],
- [ 3, 5, 8 ]
- ]
- )
+ self.nested_lists_i32x2 = NestedListsI32x2(
+ [
+ [1, 1, 2],
+ [2, 7, 9],
+ [3, 5, 8]
+ ]
+ )
- self.nested_lists_i32x3 = NestedListsI32x3(
- [
- [
- [ 2, 7, 9 ],
- [ 3, 5, 8 ]
- ],
- [
- [ 1, 1, 2 ],
- [ 1, 4, 9 ]
- ]
- ]
- )
-
- self.nested_mixedx2 = NestedMixedx2( int_set_list=[
- set([1,2,3]),
- set([1,4,9]),
- set([1,2,3,5,8,13,21]),
- set([-1, 0, 1])
- ],
- # note, the sets below are sets of chars, since the strings are iterated
- map_int_strset={ 10:set('abc'), 20:set('def'), 30:set('GHI') },
- map_int_strset_list=[
- { 10:set('abc'), 20:set('def'), 30:set('GHI') },
- { 100:set('lmn'), 200:set('opq'), 300:set('RST') },
- { 1000:set('uvw'), 2000:set('wxy'), 3000:set('XYZ') }
- ]
- )
-
- self.nested_lists_bonk = NestedListsBonk(
- [
- [
- [
- Bonk(message='inner A first', type=1),
- Bonk(message='inner A second', type=1)
- ],
- [
- Bonk(message='inner B first', type=2),
- Bonk(message='inner B second', type=2)
- ]
- ]
- ]
- )
-
- self.list_bonks = ListBonks(
- [
- Bonk(message='inner A', type=1),
- Bonk(message='inner B', type=2),
- Bonk(message='inner C', type=0)
- ]
- )
-
- def _serialize(self, obj):
- trans = TTransport.TMemoryBuffer()
- prot = self.protocol_factory.getProtocol(trans)
- obj.write(prot)
- return trans.getvalue()
-
- def _deserialize(self, objtype, data):
- prot = self.protocol_factory.getProtocol(TTransport.TMemoryBuffer(data))
- ret = objtype()
- ret.read(prot)
- return ret
-
- def testForwards(self):
- obj = self._deserialize(VersioningTestV2, self._serialize(self.v1obj))
- self.assertEquals(obj.begin_in_both, self.v1obj.begin_in_both)
- self.assertEquals(obj.end_in_both, self.v1obj.end_in_both)
-
- def testBackwards(self):
- obj = self._deserialize(VersioningTestV1, self._serialize(self.v2obj))
- self.assertEquals(obj.begin_in_both, self.v2obj.begin_in_both)
- self.assertEquals(obj.end_in_both, self.v2obj.end_in_both)
-
- def testSerializeV1(self):
- obj = self._deserialize(VersioningTestV1, self._serialize(self.v1obj))
- self.assertEquals(obj, self.v1obj)
-
- def testSerializeV2(self):
- obj = self._deserialize(VersioningTestV2, self._serialize(self.v2obj))
- self.assertEquals(obj, self.v2obj)
-
- def testBools(self):
- self.assertNotEquals(self.bools, self.bools_flipped)
- self.assertNotEquals(self.bools, self.v1obj)
- obj = self._deserialize(Bools, self._serialize(self.bools))
- self.assertEquals(obj, self.bools)
- obj = self._deserialize(Bools, self._serialize(self.bools_flipped))
- self.assertEquals(obj, self.bools_flipped)
- rep = repr(self.bools)
- self.assertTrue(len(rep) > 0)
-
- def testLargeDeltas(self):
- # test large field deltas (meaningful in CompactProto only)
- obj = self._deserialize(LargeDeltas, self._serialize(self.large_deltas))
- self.assertEquals(obj, self.large_deltas)
- rep = repr(self.large_deltas)
- self.assertTrue(len(rep) > 0)
-
- def testNestedListsI32x2(self):
- obj = self._deserialize(NestedListsI32x2, self._serialize(self.nested_lists_i32x2))
- self.assertEquals(obj, self.nested_lists_i32x2)
- rep = repr(self.nested_lists_i32x2)
- self.assertTrue(len(rep) > 0)
-
- def testNestedListsI32x3(self):
- obj = self._deserialize(NestedListsI32x3, self._serialize(self.nested_lists_i32x3))
- self.assertEquals(obj, self.nested_lists_i32x3)
- rep = repr(self.nested_lists_i32x3)
- self.assertTrue(len(rep) > 0)
-
- def testNestedMixedx2(self):
- obj = self._deserialize(NestedMixedx2, self._serialize(self.nested_mixedx2))
- self.assertEquals(obj, self.nested_mixedx2)
- rep = repr(self.nested_mixedx2)
- self.assertTrue(len(rep) > 0)
-
- def testNestedListsBonk(self):
- obj = self._deserialize(NestedListsBonk, self._serialize(self.nested_lists_bonk))
- self.assertEquals(obj, self.nested_lists_bonk)
- rep = repr(self.nested_lists_bonk)
- self.assertTrue(len(rep) > 0)
-
- def testListBonks(self):
- obj = self._deserialize(ListBonks, self._serialize(self.list_bonks))
- self.assertEquals(obj, self.list_bonks)
- rep = repr(self.list_bonks)
- self.assertTrue(len(rep) > 0)
-
- def testCompactStruct(self):
- # test large field deltas (meaningful in CompactProto only)
- obj = self._deserialize(CompactProtoTestStruct, self._serialize(self.compact_struct))
- self.assertEquals(obj, self.compact_struct)
- rep = repr(self.compact_struct)
- self.assertTrue(len(rep) > 0)
-
- def testIntegerLimits(self):
- if (sys.version_info[0] == 2 and sys.version_info[1] <= 6):
- print('Skipping testIntegerLimits for Python 2.6')
- return
- bad_values = [CompactProtoTestStruct(a_byte=128), CompactProtoTestStruct(a_byte=-129),
- CompactProtoTestStruct(a_i16=32768), CompactProtoTestStruct(a_i16=-32769),
- CompactProtoTestStruct(a_i32=2147483648), CompactProtoTestStruct(a_i32=-2147483649),
- CompactProtoTestStruct(a_i64=9223372036854775808), CompactProtoTestStruct(a_i64=-9223372036854775809)
+ self.nested_lists_i32x3 = NestedListsI32x3(
+ [
+ [
+ [2, 7, 9],
+ [3, 5, 8]
+ ],
+ [
+ [1, 1, 2],
+ [1, 4, 9]
]
+ ]
+ )
- for value in bad_values:
- self.assertRaises(Exception, self._serialize, value)
+ self.nested_mixedx2 = NestedMixedx2(int_set_list=[
+ set([1, 2, 3]),
+ set([1, 4, 9]),
+ set([1, 2, 3, 5, 8, 13, 21]),
+ set([-1, 0, 1])
+ ],
+ # note, the sets below are sets of chars, since the strings are iterated
+ map_int_strset={10: set('abc'), 20: set('def'), 30: set('GHI')},
+ map_int_strset_list=[
+ {10: set('abc'), 20: set('def'), 30: set('GHI')},
+ {100: set('lmn'), 200: set('opq'), 300: set('RST')},
+ {1000: set('uvw'), 2000: set('wxy'), 3000: set('XYZ')}
+ ]
+ )
+
+ self.nested_lists_bonk = NestedListsBonk(
+ [
+ [
+ [
+ Bonk(message='inner A first', type=1),
+ Bonk(message='inner A second', type=1)
+ ],
+ [
+ Bonk(message='inner B first', type=2),
+ Bonk(message='inner B second', type=2)
+ ]
+ ]
+ ]
+ )
+
+ self.list_bonks = ListBonks(
+ [
+ Bonk(message='inner A', type=1),
+ Bonk(message='inner B', type=2),
+ Bonk(message='inner C', type=0)
+ ]
+ )
+
+ def _serialize(self, obj):
+ trans = TTransport.TMemoryBuffer()
+ prot = self.protocol_factory.getProtocol(trans)
+ obj.write(prot)
+ return trans.getvalue()
+
+ def _deserialize(self, objtype, data):
+ prot = self.protocol_factory.getProtocol(TTransport.TMemoryBuffer(data))
+ ret = objtype()
+ ret.read(prot)
+ return ret
+
+ def testForwards(self):
+ obj = self._deserialize(VersioningTestV2, self._serialize(self.v1obj))
+ self.assertEquals(obj.begin_in_both, self.v1obj.begin_in_both)
+ self.assertEquals(obj.end_in_both, self.v1obj.end_in_both)
+
+ def testBackwards(self):
+ obj = self._deserialize(VersioningTestV1, self._serialize(self.v2obj))
+ self.assertEquals(obj.begin_in_both, self.v2obj.begin_in_both)
+ self.assertEquals(obj.end_in_both, self.v2obj.end_in_both)
+
+ def testSerializeV1(self):
+ obj = self._deserialize(VersioningTestV1, self._serialize(self.v1obj))
+ self.assertEquals(obj, self.v1obj)
+
+ def testSerializeV2(self):
+ obj = self._deserialize(VersioningTestV2, self._serialize(self.v2obj))
+ self.assertEquals(obj, self.v2obj)
+
+ def testBools(self):
+ self.assertNotEquals(self.bools, self.bools_flipped)
+ self.assertNotEquals(self.bools, self.v1obj)
+ obj = self._deserialize(Bools, self._serialize(self.bools))
+ self.assertEquals(obj, self.bools)
+ obj = self._deserialize(Bools, self._serialize(self.bools_flipped))
+ self.assertEquals(obj, self.bools_flipped)
+ rep = repr(self.bools)
+ self.assertTrue(len(rep) > 0)
+
+ def testLargeDeltas(self):
+ # test large field deltas (meaningful in CompactProto only)
+ obj = self._deserialize(LargeDeltas, self._serialize(self.large_deltas))
+ self.assertEquals(obj, self.large_deltas)
+ rep = repr(self.large_deltas)
+ self.assertTrue(len(rep) > 0)
+
+ def testNestedListsI32x2(self):
+ obj = self._deserialize(NestedListsI32x2, self._serialize(self.nested_lists_i32x2))
+ self.assertEquals(obj, self.nested_lists_i32x2)
+ rep = repr(self.nested_lists_i32x2)
+ self.assertTrue(len(rep) > 0)
+
+ def testNestedListsI32x3(self):
+ obj = self._deserialize(NestedListsI32x3, self._serialize(self.nested_lists_i32x3))
+ self.assertEquals(obj, self.nested_lists_i32x3)
+ rep = repr(self.nested_lists_i32x3)
+ self.assertTrue(len(rep) > 0)
+
+ def testNestedMixedx2(self):
+ obj = self._deserialize(NestedMixedx2, self._serialize(self.nested_mixedx2))
+ self.assertEquals(obj, self.nested_mixedx2)
+ rep = repr(self.nested_mixedx2)
+ self.assertTrue(len(rep) > 0)
+
+ def testNestedListsBonk(self):
+ obj = self._deserialize(NestedListsBonk, self._serialize(self.nested_lists_bonk))
+ self.assertEquals(obj, self.nested_lists_bonk)
+ rep = repr(self.nested_lists_bonk)
+ self.assertTrue(len(rep) > 0)
+
+ def testListBonks(self):
+ obj = self._deserialize(ListBonks, self._serialize(self.list_bonks))
+ self.assertEquals(obj, self.list_bonks)
+ rep = repr(self.list_bonks)
+ self.assertTrue(len(rep) > 0)
+
+ def testCompactStruct(self):
+ # test large field deltas (meaningful in CompactProto only)
+ obj = self._deserialize(CompactProtoTestStruct, self._serialize(self.compact_struct))
+ self.assertEquals(obj, self.compact_struct)
+ rep = repr(self.compact_struct)
+ self.assertTrue(len(rep) > 0)
+
+ def testIntegerLimits(self):
+ if (sys.version_info[0] == 2 and sys.version_info[1] <= 6):
+ print('Skipping testIntegerLimits for Python 2.6')
+ return
+ bad_values = [CompactProtoTestStruct(a_byte=128), CompactProtoTestStruct(a_byte=-129),
+ CompactProtoTestStruct(a_i16=32768), CompactProtoTestStruct(a_i16=-32769),
+ CompactProtoTestStruct(a_i32=2147483648), CompactProtoTestStruct(a_i32=-2147483649),
+ CompactProtoTestStruct(a_i64=9223372036854775808), CompactProtoTestStruct(a_i64=-9223372036854775809)
+ ]
+
+ for value in bad_values:
+ self.assertRaises(Exception, self._serialize, value)
class NormalBinaryTest(AbstractTest):
- protocol_factory = TBinaryProtocol.TBinaryProtocolFactory()
+ protocol_factory = TBinaryProtocol.TBinaryProtocolFactory()
class AcceleratedBinaryTest(AbstractTest):
- protocol_factory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory()
+ protocol_factory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory()
class CompactProtocolTest(AbstractTest):
- protocol_factory = TCompactProtocol.TCompactProtocolFactory()
+ protocol_factory = TCompactProtocol.TCompactProtocolFactory()
class JSONProtocolTest(AbstractTest):
- protocol_factory = TJSONProtocol.TJSONProtocolFactory()
+ protocol_factory = TJSONProtocol.TJSONProtocolFactory()
class AcceleratedFramedTest(unittest.TestCase):
- def testSplit(self):
- """Test FramedTransport and BinaryProtocolAccelerated
+ def testSplit(self):
+ """Test FramedTransport and BinaryProtocolAccelerated
- Tests that TBinaryProtocolAccelerated and TFramedTransport
- play nicely together when a read spans a frame"""
+ Tests that TBinaryProtocolAccelerated and TFramedTransport
+ play nicely together when a read spans a frame"""
- protocol_factory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory()
- bigstring = "".join(chr(byte) for byte in range(ord("a"), ord("z")+1))
+ protocol_factory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory()
+ bigstring = "".join(chr(byte) for byte in range(ord("a"), ord("z") + 1))
- databuf = TTransport.TMemoryBuffer()
- prot = protocol_factory.getProtocol(databuf)
- prot.writeI32(42)
- prot.writeString(bigstring)
- prot.writeI16(24)
- data = databuf.getvalue()
- cutpoint = len(data) // 2
- parts = [ data[:cutpoint], data[cutpoint:] ]
+ databuf = TTransport.TMemoryBuffer()
+ prot = protocol_factory.getProtocol(databuf)
+ prot.writeI32(42)
+ prot.writeString(bigstring)
+ prot.writeI16(24)
+ data = databuf.getvalue()
+ cutpoint = len(data) // 2
+ parts = [data[:cutpoint], data[cutpoint:]]
- framed_buffer = TTransport.TMemoryBuffer()
- framed_writer = TTransport.TFramedTransport(framed_buffer)
- for part in parts:
- framed_writer.write(part)
- framed_writer.flush()
- self.assertEquals(len(framed_buffer.getvalue()), len(data) + 8)
+ framed_buffer = TTransport.TMemoryBuffer()
+ framed_writer = TTransport.TFramedTransport(framed_buffer)
+ for part in parts:
+ framed_writer.write(part)
+ framed_writer.flush()
+ self.assertEquals(len(framed_buffer.getvalue()), len(data) + 8)
- # Recreate framed_buffer so we can read from it.
- framed_buffer = TTransport.TMemoryBuffer(framed_buffer.getvalue())
- framed_reader = TTransport.TFramedTransport(framed_buffer)
- prot = protocol_factory.getProtocol(framed_reader)
- self.assertEqual(prot.readI32(), 42)
- self.assertEqual(prot.readString(), bigstring)
- self.assertEqual(prot.readI16(), 24)
+ # Recreate framed_buffer so we can read from it.
+ framed_buffer = TTransport.TMemoryBuffer(framed_buffer.getvalue())
+ framed_reader = TTransport.TFramedTransport(framed_buffer)
+ prot = protocol_factory.getProtocol(framed_reader)
+ self.assertEqual(prot.readI32(), 42)
+ self.assertEqual(prot.readString(), bigstring)
+ self.assertEqual(prot.readI16(), 24)
+
class SerializersTest(unittest.TestCase):
- def testSerializeThenDeserialize(self):
- obj = Xtruct2(i32_thing=1,
- struct_thing=Xtruct(string_thing="foo"))
+ def testSerializeThenDeserialize(self):
+ obj = Xtruct2(i32_thing=1,
+ struct_thing=Xtruct(string_thing="foo"))
- s1 = serialize(obj)
- for i in range(10):
- self.assertEquals(s1, serialize(obj))
- objcopy = Xtruct2()
- deserialize(objcopy, serialize(obj))
- self.assertEquals(obj, objcopy)
+ s1 = serialize(obj)
+ for i in range(10):
+ self.assertEquals(s1, serialize(obj))
+ objcopy = Xtruct2()
+ deserialize(objcopy, serialize(obj))
+ self.assertEquals(obj, objcopy)
- obj = Xtruct(string_thing="bar")
- objcopy = Xtruct()
- deserialize(objcopy, serialize(obj))
- self.assertEquals(obj, objcopy)
+ obj = Xtruct(string_thing="bar")
+ objcopy = Xtruct()
+ deserialize(objcopy, serialize(obj))
+ self.assertEquals(obj, objcopy)
- # test booleans
- obj = Bools(im_true=True, im_false=False)
- objcopy = Bools()
- deserialize(objcopy, serialize(obj))
- self.assertEquals(obj, objcopy)
+ # test booleans
+ obj = Bools(im_true=True, im_false=False)
+ objcopy = Bools()
+ deserialize(objcopy, serialize(obj))
+ self.assertEquals(obj, objcopy)
- # test enums
- for num, name in Numberz._VALUES_TO_NAMES.items():
- obj = Bonk(message='enum Numberz value %d is string %s' % (num, name), type=num)
- objcopy = Bonk()
- deserialize(objcopy, serialize(obj))
- self.assertEquals(obj, objcopy)
+ # test enums
+ for num, name in Numberz._VALUES_TO_NAMES.items():
+ obj = Bonk(message='enum Numberz value %d is string %s' % (num, name), type=num)
+ objcopy = Bonk()
+ deserialize(objcopy, serialize(obj))
+ self.assertEquals(obj, objcopy)
def suite():
- suite = unittest.TestSuite()
- loader = unittest.TestLoader()
+ suite = unittest.TestSuite()
+ loader = unittest.TestLoader()
- suite.addTest(loader.loadTestsFromTestCase(NormalBinaryTest))
- suite.addTest(loader.loadTestsFromTestCase(AcceleratedBinaryTest))
- suite.addTest(loader.loadTestsFromTestCase(CompactProtocolTest))
- suite.addTest(loader.loadTestsFromTestCase(JSONProtocolTest))
- suite.addTest(loader.loadTestsFromTestCase(AcceleratedFramedTest))
- suite.addTest(loader.loadTestsFromTestCase(SerializersTest))
- return suite
+ suite.addTest(loader.loadTestsFromTestCase(NormalBinaryTest))
+ suite.addTest(loader.loadTestsFromTestCase(AcceleratedBinaryTest))
+ suite.addTest(loader.loadTestsFromTestCase(CompactProtocolTest))
+ suite.addTest(loader.loadTestsFromTestCase(JSONProtocolTest))
+ suite.addTest(loader.loadTestsFromTestCase(AcceleratedFramedTest))
+ suite.addTest(loader.loadTestsFromTestCase(SerializersTest))
+ return suite
if __name__ == "__main__":
- unittest.main(defaultTest="suite", testRunner=unittest.TextTestRunner(verbosity=2))
+ unittest.main(defaultTest="suite", testRunner=unittest.TextTestRunner(verbosity=2))
diff --git a/test/py/TSimpleJSONProtocolTest.py b/test/py/TSimpleJSONProtocolTest.py
index 1ed8c15..7298760 100644
--- a/test/py/TSimpleJSONProtocolTest.py
+++ b/test/py/TSimpleJSONProtocolTest.py
@@ -28,81 +28,81 @@
class SimpleJSONProtocolTest(unittest.TestCase):
- protocol_factory = TJSONProtocol.TSimpleJSONProtocolFactory()
+ protocol_factory = TJSONProtocol.TSimpleJSONProtocolFactory()
- def _assertDictEqual(self, a, b, msg=None):
- if hasattr(self, 'assertDictEqual'):
- # assertDictEqual only in Python 2.7. Depends on your machine.
- self.assertDictEqual(a, b, msg)
- return
+ def _assertDictEqual(self, a, b, msg=None):
+ if hasattr(self, 'assertDictEqual'):
+ # assertDictEqual only in Python 2.7. Depends on your machine.
+ self.assertDictEqual(a, b, msg)
+ return
- # Substitute implementation not as good as unittest library's
- self.assertEquals(len(a), len(b), msg)
- for k, v in a.iteritems():
- self.assertTrue(k in b, msg)
- self.assertEquals(b.get(k), v, msg)
+ # Substitute implementation not as good as unittest library's
+ self.assertEquals(len(a), len(b), msg)
+ for k, v in a.iteritems():
+ self.assertTrue(k in b, msg)
+ self.assertEquals(b.get(k), v, msg)
- def _serialize(self, obj):
- trans = TTransport.TMemoryBuffer()
- prot = self.protocol_factory.getProtocol(trans)
- obj.write(prot)
- return trans.getvalue()
+ def _serialize(self, obj):
+ trans = TTransport.TMemoryBuffer()
+ prot = self.protocol_factory.getProtocol(trans)
+ obj.write(prot)
+ return trans.getvalue()
- def _deserialize(self, objtype, data):
- prot = self.protocol_factory.getProtocol(TTransport.TMemoryBuffer(data))
- ret = objtype()
- ret.read(prot)
- return ret
+ def _deserialize(self, objtype, data):
+ prot = self.protocol_factory.getProtocol(TTransport.TMemoryBuffer(data))
+ ret = objtype()
+ ret.read(prot)
+ return ret
- def testWriteOnly(self):
- self.assertRaises(NotImplementedError,
- self._deserialize, VersioningTestV1, b'{}')
+ def testWriteOnly(self):
+ self.assertRaises(NotImplementedError,
+ self._deserialize, VersioningTestV1, b'{}')
- def testSimpleMessage(self):
- v1obj = VersioningTestV1(
- begin_in_both=12345,
- old_string='aaa',
- end_in_both=54321)
- expected = dict(begin_in_both=v1obj.begin_in_both,
- old_string=v1obj.old_string,
- end_in_both=v1obj.end_in_both)
- actual = json.loads(self._serialize(v1obj).decode('ascii'))
+ def testSimpleMessage(self):
+ v1obj = VersioningTestV1(
+ begin_in_both=12345,
+ old_string='aaa',
+ end_in_both=54321)
+ expected = dict(begin_in_both=v1obj.begin_in_both,
+ old_string=v1obj.old_string,
+ end_in_both=v1obj.end_in_both)
+ actual = json.loads(self._serialize(v1obj).decode('ascii'))
- self._assertDictEqual(expected, actual)
+ self._assertDictEqual(expected, actual)
- def testComplicated(self):
- v2obj = VersioningTestV2(
- begin_in_both=12345,
- newint=1,
- newbyte=2,
- newshort=3,
- newlong=4,
- newdouble=5.0,
- newstruct=Bonk(message="Hello!", type=123),
- newlist=[7, 8, 9],
- newset=set([42, 1, 8]),
- newmap={1: 2, 2: 3},
- newstring="Hola!",
- end_in_both=54321)
- expected = dict(begin_in_both=v2obj.begin_in_both,
- newint=v2obj.newint,
- newbyte=v2obj.newbyte,
- newshort=v2obj.newshort,
- newlong=v2obj.newlong,
- newdouble=v2obj.newdouble,
- newstruct=dict(message=v2obj.newstruct.message,
- type=v2obj.newstruct.type),
- newlist=v2obj.newlist,
- newset=list(v2obj.newset),
- newmap=v2obj.newmap,
- newstring=v2obj.newstring,
- end_in_both=v2obj.end_in_both)
+ def testComplicated(self):
+ v2obj = VersioningTestV2(
+ begin_in_both=12345,
+ newint=1,
+ newbyte=2,
+ newshort=3,
+ newlong=4,
+ newdouble=5.0,
+ newstruct=Bonk(message="Hello!", type=123),
+ newlist=[7, 8, 9],
+ newset=set([42, 1, 8]),
+ newmap={1: 2, 2: 3},
+ newstring="Hola!",
+ end_in_both=54321)
+ expected = dict(begin_in_both=v2obj.begin_in_both,
+ newint=v2obj.newint,
+ newbyte=v2obj.newbyte,
+ newshort=v2obj.newshort,
+ newlong=v2obj.newlong,
+ newdouble=v2obj.newdouble,
+ newstruct=dict(message=v2obj.newstruct.message,
+ type=v2obj.newstruct.type),
+ newlist=v2obj.newlist,
+ newset=list(v2obj.newset),
+ newmap=v2obj.newmap,
+ newstring=v2obj.newstring,
+ end_in_both=v2obj.end_in_both)
- # Need to load/dump because map keys get escaped.
- expected = json.loads(json.dumps(expected))
- actual = json.loads(self._serialize(v2obj).decode('ascii'))
- self._assertDictEqual(expected, actual)
+ # Need to load/dump because map keys get escaped.
+ expected = json.loads(json.dumps(expected))
+ actual = json.loads(self._serialize(v2obj).decode('ascii'))
+ self._assertDictEqual(expected, actual)
if __name__ == '__main__':
- unittest.main()
+ unittest.main()
diff --git a/test/py/TestClient.py b/test/py/TestClient.py
index 347329e..bc7650d 100755
--- a/test/py/TestClient.py
+++ b/test/py/TestClient.py
@@ -32,42 +32,42 @@
class AbstractTest(unittest.TestCase):
- def setUp(self):
- if options.http_path:
- self.transport = THttpClient.THttpClient(options.host, port=options.port, path=options.http_path)
- else:
- if options.ssl:
- from thrift.transport import TSSLSocket
- socket = TSSLSocket.TSSLSocket(options.host, options.port, validate=False)
- else:
- socket = TSocket.TSocket(options.host, options.port)
- # frame or buffer depending upon args
- self.transport = TTransport.TBufferedTransport(socket)
- if options.trans == 'framed':
- self.transport = TTransport.TFramedTransport(socket)
- elif options.trans == 'buffered':
- self.transport = TTransport.TBufferedTransport(socket)
- elif options.trans == '':
- raise AssertionError('Unknown --transport option: %s' % options.trans)
- if options.zlib:
- self.transport = TZlibTransport.TZlibTransport(self.transport, 9)
- self.transport.open()
- protocol = self.get_protocol(self.transport)
- self.client = ThriftTest.Client(protocol)
+ def setUp(self):
+ if options.http_path:
+ self.transport = THttpClient.THttpClient(options.host, port=options.port, path=options.http_path)
+ else:
+ if options.ssl:
+ from thrift.transport import TSSLSocket
+ socket = TSSLSocket.TSSLSocket(options.host, options.port, validate=False)
+ else:
+ socket = TSocket.TSocket(options.host, options.port)
+ # frame or buffer depending upon args
+ self.transport = TTransport.TBufferedTransport(socket)
+ if options.trans == 'framed':
+ self.transport = TTransport.TFramedTransport(socket)
+ elif options.trans == 'buffered':
+ self.transport = TTransport.TBufferedTransport(socket)
+ elif options.trans == '':
+ raise AssertionError('Unknown --transport option: %s' % options.trans)
+ if options.zlib:
+ self.transport = TZlibTransport.TZlibTransport(self.transport, 9)
+ self.transport.open()
+ protocol = self.get_protocol(self.transport)
+ self.client = ThriftTest.Client(protocol)
- def tearDown(self):
- self.transport.close()
+ def tearDown(self):
+ self.transport.close()
- def testVoid(self):
- print('testVoid')
- self.client.testVoid()
+ def testVoid(self):
+ print('testVoid')
+ self.client.testVoid()
- def testString(self):
- print('testString')
- self.assertEqual(self.client.testString('Python' * 20), 'Python' * 20)
- self.assertEqual(self.client.testString(''), '')
- s1 = u'\b\t\n/\\\\\r{}:パイソン"'
- s2 = u"""Afrikaans, Alemannisch, Aragonés, العربية, مصرى,
+ def testString(self):
+ print('testString')
+ self.assertEqual(self.client.testString('Python' * 20), 'Python' * 20)
+ self.assertEqual(self.client.testString(''), '')
+ s1 = u'\b\t\n/\\\\\r{}:パイソン"'
+ s2 = u"""Afrikaans, Alemannisch, Aragonés, العربية, مصرى,
Asturianu, Aymar aru, Azərbaycan, Башҡорт, Boarisch, Žemaitėška,
Беларуская, Беларуская (тарашкевіца), Български, Bamanankan,
বাংলা, Brezhoneg, Bosanski, Català, Mìng-dĕ̤ng-ngṳ̄, Нохчийн,
@@ -92,199 +92,199 @@
Türkçe, Татарча/Tatarça, Українська, اردو, Tiếng Việt, Volapük,
Walon, Winaray, 吴语, isiXhosa, ייִדיש, Yorùbá, Zeêuws, 中文,
Bân-lâm-gú, 粵語"""
- if sys.version_info[0] == 2 and os.environ.get('THRIFT_TEST_PY_NO_UTF8STRINGS'):
- s1 = s1.encode('utf8')
- s2 = s2.encode('utf8')
- self.assertEqual(self.client.testString(s1), s1)
- self.assertEqual(self.client.testString(s2), s2)
+ if sys.version_info[0] == 2 and os.environ.get('THRIFT_TEST_PY_NO_UTF8STRINGS'):
+ s1 = s1.encode('utf8')
+ s2 = s2.encode('utf8')
+ self.assertEqual(self.client.testString(s1), s1)
+ self.assertEqual(self.client.testString(s2), s2)
- def testBool(self):
- print('testBool')
- self.assertEqual(self.client.testBool(True), True)
- self.assertEqual(self.client.testBool(False), False)
+ def testBool(self):
+ print('testBool')
+ self.assertEqual(self.client.testBool(True), True)
+ self.assertEqual(self.client.testBool(False), False)
- def testByte(self):
- print('testByte')
- self.assertEqual(self.client.testByte(63), 63)
- self.assertEqual(self.client.testByte(-127), -127)
+ def testByte(self):
+ print('testByte')
+ self.assertEqual(self.client.testByte(63), 63)
+ self.assertEqual(self.client.testByte(-127), -127)
- def testI32(self):
- print('testI32')
- self.assertEqual(self.client.testI32(-1), -1)
- self.assertEqual(self.client.testI32(0), 0)
+ def testI32(self):
+ print('testI32')
+ self.assertEqual(self.client.testI32(-1), -1)
+ self.assertEqual(self.client.testI32(0), 0)
- def testI64(self):
- print('testI64')
- self.assertEqual(self.client.testI64(1), 1)
- self.assertEqual(self.client.testI64(-34359738368), -34359738368)
+ def testI64(self):
+ print('testI64')
+ self.assertEqual(self.client.testI64(1), 1)
+ self.assertEqual(self.client.testI64(-34359738368), -34359738368)
- def testDouble(self):
- print('testDouble')
- self.assertEqual(self.client.testDouble(-5.235098235), -5.235098235)
- self.assertEqual(self.client.testDouble(0), 0)
- self.assertEqual(self.client.testDouble(-1), -1)
- self.assertEqual(self.client.testDouble(-0.000341012439638598279), -0.000341012439638598279)
+ def testDouble(self):
+ print('testDouble')
+ self.assertEqual(self.client.testDouble(-5.235098235), -5.235098235)
+ self.assertEqual(self.client.testDouble(0), 0)
+ self.assertEqual(self.client.testDouble(-1), -1)
+ self.assertEqual(self.client.testDouble(-0.000341012439638598279), -0.000341012439638598279)
- def testBinary(self):
- print('testBinary')
- val = bytearray([i for i in range(0, 256)])
- self.assertEqual(bytearray(self.client.testBinary(bytes(val))), val)
+ def testBinary(self):
+ print('testBinary')
+ val = bytearray([i for i in range(0, 256)])
+ self.assertEqual(bytearray(self.client.testBinary(bytes(val))), val)
- def testStruct(self):
- print('testStruct')
- x = Xtruct()
- x.string_thing = "Zero"
- x.byte_thing = 1
- x.i32_thing = -3
- x.i64_thing = -5
- y = self.client.testStruct(x)
- self.assertEqual(y, x)
+ def testStruct(self):
+ print('testStruct')
+ x = Xtruct()
+ x.string_thing = "Zero"
+ x.byte_thing = 1
+ x.i32_thing = -3
+ x.i64_thing = -5
+ y = self.client.testStruct(x)
+ self.assertEqual(y, x)
- def testNest(self):
- print('testNest')
- inner = Xtruct(string_thing="Zero", byte_thing=1, i32_thing=-3, i64_thing=-5)
- x = Xtruct2(struct_thing=inner, byte_thing=0, i32_thing=0)
- y = self.client.testNest(x)
- self.assertEqual(y, x)
+ def testNest(self):
+ print('testNest')
+ inner = Xtruct(string_thing="Zero", byte_thing=1, i32_thing=-3, i64_thing=-5)
+ x = Xtruct2(struct_thing=inner, byte_thing=0, i32_thing=0)
+ y = self.client.testNest(x)
+ self.assertEqual(y, x)
- def testMap(self):
- print('testMap')
- x = {0: 1, 1: 2, 2: 3, 3: 4, -1: -2}
- y = self.client.testMap(x)
- self.assertEqual(y, x)
+ def testMap(self):
+ print('testMap')
+ x = {0: 1, 1: 2, 2: 3, 3: 4, -1: -2}
+ y = self.client.testMap(x)
+ self.assertEqual(y, x)
- def testSet(self):
- print('testSet')
- x = set([8, 1, 42])
- y = self.client.testSet(x)
- self.assertEqual(y, x)
+ def testSet(self):
+ print('testSet')
+ x = set([8, 1, 42])
+ y = self.client.testSet(x)
+ self.assertEqual(y, x)
- def testList(self):
- print('testList')
- x = [1, 4, 9, -42]
- y = self.client.testList(x)
- self.assertEqual(y, x)
+ def testList(self):
+ print('testList')
+ x = [1, 4, 9, -42]
+ y = self.client.testList(x)
+ self.assertEqual(y, x)
- def testEnum(self):
- print('testEnum')
- x = Numberz.FIVE
- y = self.client.testEnum(x)
- self.assertEqual(y, x)
+ def testEnum(self):
+ print('testEnum')
+ x = Numberz.FIVE
+ y = self.client.testEnum(x)
+ self.assertEqual(y, x)
- def testTypedef(self):
- print('testTypedef')
- x = 0xffffffffffffff # 7 bytes of 0xff
- y = self.client.testTypedef(x)
- self.assertEqual(y, x)
+ def testTypedef(self):
+ print('testTypedef')
+ x = 0xffffffffffffff # 7 bytes of 0xff
+ y = self.client.testTypedef(x)
+ self.assertEqual(y, x)
- def testMapMap(self):
- print('testMapMap')
- x = {
- -4: {-4: -4, -3: -3, -2: -2, -1: -1},
- 4: {4: 4, 3: 3, 2: 2, 1: 1},
- }
- y = self.client.testMapMap(42)
- self.assertEqual(y, x)
+ def testMapMap(self):
+ print('testMapMap')
+ x = {
+ -4: {-4: -4, -3: -3, -2: -2, -1: -1},
+ 4: {4: 4, 3: 3, 2: 2, 1: 1},
+ }
+ y = self.client.testMapMap(42)
+ self.assertEqual(y, x)
- def testMulti(self):
- print('testMulti')
- xpected = Xtruct(string_thing='Hello2', byte_thing=74, i32_thing=0xff00ff, i64_thing=0xffffffffd0d0)
- y = self.client.testMulti(xpected.byte_thing,
- xpected.i32_thing,
- xpected.i64_thing,
- {0: 'abc'},
- Numberz.FIVE,
- 0xf0f0f0)
- self.assertEqual(y, xpected)
+ def testMulti(self):
+ print('testMulti')
+ xpected = Xtruct(string_thing='Hello2', byte_thing=74, i32_thing=0xff00ff, i64_thing=0xffffffffd0d0)
+ y = self.client.testMulti(xpected.byte_thing,
+ xpected.i32_thing,
+ xpected.i64_thing,
+ {0: 'abc'},
+ Numberz.FIVE,
+ 0xf0f0f0)
+ self.assertEqual(y, xpected)
- def testException(self):
- print('testException')
- self.client.testException('Safe')
- try:
- self.client.testException('Xception')
- self.fail("should have gotten exception")
- except Xception as x:
- self.assertEqual(x.errorCode, 1001)
- self.assertEqual(x.message, 'Xception')
- # TODO ensure same behavior for repr within generated python variants
- # ensure exception's repr method works
- # x_repr = repr(x)
- # self.assertEqual(x_repr, 'Xception(errorCode=1001, message=\'Xception\')')
+ def testException(self):
+ print('testException')
+ self.client.testException('Safe')
+ try:
+ self.client.testException('Xception')
+ self.fail("should have gotten exception")
+ except Xception as x:
+ self.assertEqual(x.errorCode, 1001)
+ self.assertEqual(x.message, 'Xception')
+ # TODO ensure same behavior for repr within generated python variants
+ # ensure exception's repr method works
+ # x_repr = repr(x)
+ # self.assertEqual(x_repr, 'Xception(errorCode=1001, message=\'Xception\')')
- try:
- self.client.testException('TException')
- self.fail("should have gotten exception")
- except TException as x:
- pass
+ try:
+ self.client.testException('TException')
+ self.fail("should have gotten exception")
+ except TException as x:
+ pass
- # Should not throw
- self.client.testException('success')
+ # Should not throw
+ self.client.testException('success')
- def testMultiException(self):
- print('testMultiException')
- try:
- self.client.testMultiException('Xception', 'ignore')
- except Xception as ex:
- self.assertEqual(ex.errorCode, 1001)
- self.assertEqual(ex.message, 'This is an Xception')
+ def testMultiException(self):
+ print('testMultiException')
+ try:
+ self.client.testMultiException('Xception', 'ignore')
+ except Xception as ex:
+ self.assertEqual(ex.errorCode, 1001)
+ self.assertEqual(ex.message, 'This is an Xception')
- try:
- self.client.testMultiException('Xception2', 'ignore')
- except Xception2 as ex:
- self.assertEqual(ex.errorCode, 2002)
- self.assertEqual(ex.struct_thing.string_thing, 'This is an Xception2')
+ try:
+ self.client.testMultiException('Xception2', 'ignore')
+ except Xception2 as ex:
+ self.assertEqual(ex.errorCode, 2002)
+ self.assertEqual(ex.struct_thing.string_thing, 'This is an Xception2')
- y = self.client.testMultiException('success', 'foobar')
- self.assertEqual(y.string_thing, 'foobar')
+ y = self.client.testMultiException('success', 'foobar')
+ self.assertEqual(y.string_thing, 'foobar')
- def testOneway(self):
- print('testOneway')
- start = time.time()
- self.client.testOneway(1) # type is int, not float
- end = time.time()
- self.assertTrue(end - start < 3,
- "oneway sleep took %f sec" % (end - start))
+ def testOneway(self):
+ print('testOneway')
+ start = time.time()
+ self.client.testOneway(1) # type is int, not float
+ end = time.time()
+ self.assertTrue(end - start < 3,
+ "oneway sleep took %f sec" % (end - start))
- def testOnewayThenNormal(self):
- print('testOnewayThenNormal')
- self.client.testOneway(1) # type is int, not float
- self.assertEqual(self.client.testString('Python'), 'Python')
+ def testOnewayThenNormal(self):
+ print('testOnewayThenNormal')
+ self.client.testOneway(1) # type is int, not float
+ self.assertEqual(self.client.testString('Python'), 'Python')
class NormalBinaryTest(AbstractTest):
- def get_protocol(self, transport):
- return TBinaryProtocol.TBinaryProtocolFactory().getProtocol(transport)
+ def get_protocol(self, transport):
+ return TBinaryProtocol.TBinaryProtocolFactory().getProtocol(transport)
class CompactTest(AbstractTest):
- def get_protocol(self, transport):
- return TCompactProtocol.TCompactProtocolFactory().getProtocol(transport)
+ def get_protocol(self, transport):
+ return TCompactProtocol.TCompactProtocolFactory().getProtocol(transport)
class JSONTest(AbstractTest):
- def get_protocol(self, transport):
- return TJSONProtocol.TJSONProtocolFactory().getProtocol(transport)
+ def get_protocol(self, transport):
+ return TJSONProtocol.TJSONProtocolFactory().getProtocol(transport)
class AcceleratedBinaryTest(AbstractTest):
- def get_protocol(self, transport):
- return TBinaryProtocol.TBinaryProtocolAcceleratedFactory().getProtocol(transport)
+ def get_protocol(self, transport):
+ return TBinaryProtocol.TBinaryProtocolAcceleratedFactory().getProtocol(transport)
def suite():
- suite = unittest.TestSuite()
- loader = unittest.TestLoader()
- if options.proto == 'binary': # look for --proto on cmdline
- suite.addTest(loader.loadTestsFromTestCase(NormalBinaryTest))
- elif options.proto == 'accel':
- suite.addTest(loader.loadTestsFromTestCase(AcceleratedBinaryTest))
- elif options.proto == 'compact':
- suite.addTest(loader.loadTestsFromTestCase(CompactTest))
- elif options.proto == 'json':
- suite.addTest(loader.loadTestsFromTestCase(JSONTest))
- else:
- raise AssertionError('Unknown protocol given with --protocol: %s' % options.proto)
- return suite
+ suite = unittest.TestSuite()
+ loader = unittest.TestLoader()
+ if options.proto == 'binary': # look for --proto on cmdline
+ suite.addTest(loader.loadTestsFromTestCase(NormalBinaryTest))
+ elif options.proto == 'accel':
+ suite.addTest(loader.loadTestsFromTestCase(AcceleratedBinaryTest))
+ elif options.proto == 'compact':
+ suite.addTest(loader.loadTestsFromTestCase(CompactTest))
+ elif options.proto == 'json':
+ suite.addTest(loader.loadTestsFromTestCase(JSONTest))
+ else:
+ raise AssertionError('Unknown protocol given with --protocol: %s' % options.proto)
+ return suite
class OwnArgsTestProgram(unittest.TestProgram):
@@ -296,50 +296,50 @@
self.createTests()
if __name__ == "__main__":
- parser = OptionParser()
- parser.add_option('--libpydir', type='string', dest='libpydir',
- help='include this directory in sys.path for locating library code')
- parser.add_option('--genpydir', type='string', dest='genpydir',
- help='include this directory in sys.path for locating generated code')
- parser.add_option("--port", type="int", dest="port",
- help="connect to server at port")
- parser.add_option("--host", type="string", dest="host",
- help="connect to server")
- parser.add_option("--zlib", action="store_true", dest="zlib",
- help="use zlib wrapper for compressed transport")
- parser.add_option("--ssl", action="store_true", dest="ssl",
- help="use SSL for encrypted transport")
- parser.add_option("--http", dest="http_path",
- help="Use the HTTP transport with the specified path")
- parser.add_option('-v', '--verbose', action="store_const",
- dest="verbose", const=2,
- help="verbose output")
- parser.add_option('-q', '--quiet', action="store_const",
- dest="verbose", const=0,
- help="minimal output")
- parser.add_option('--protocol', dest="proto", type="string",
- help="protocol to use, one of: accel, binary, compact, json")
- parser.add_option('--transport', dest="trans", type="string",
- help="transport to use, one of: buffered, framed")
- parser.set_defaults(framed=False, http_path=None, verbose=1, host='localhost', port=9090, proto='binary')
- options, args = parser.parse_args()
+ parser = OptionParser()
+ parser.add_option('--libpydir', type='string', dest='libpydir',
+ help='include this directory in sys.path for locating library code')
+ parser.add_option('--genpydir', type='string', dest='genpydir',
+ help='include this directory in sys.path for locating generated code')
+ parser.add_option("--port", type="int", dest="port",
+ help="connect to server at port")
+ parser.add_option("--host", type="string", dest="host",
+ help="connect to server")
+ parser.add_option("--zlib", action="store_true", dest="zlib",
+ help="use zlib wrapper for compressed transport")
+ parser.add_option("--ssl", action="store_true", dest="ssl",
+ help="use SSL for encrypted transport")
+ parser.add_option("--http", dest="http_path",
+ help="Use the HTTP transport with the specified path")
+ parser.add_option('-v', '--verbose', action="store_const",
+ dest="verbose", const=2,
+ help="verbose output")
+ parser.add_option('-q', '--quiet', action="store_const",
+ dest="verbose", const=0,
+ help="minimal output")
+ parser.add_option('--protocol', dest="proto", type="string",
+ help="protocol to use, one of: accel, binary, compact, json")
+ parser.add_option('--transport', dest="trans", type="string",
+ help="transport to use, one of: buffered, framed")
+ parser.set_defaults(framed=False, http_path=None, verbose=1, host='localhost', port=9090, proto='binary')
+ options, args = parser.parse_args()
- if options.genpydir:
- sys.path.insert(0, os.path.join(SCRIPT_DIR, options.genpydir))
- if options.libpydir:
- sys.path.insert(0, glob.glob(options.libpydir)[0])
- else:
- sys.path.insert(0, glob.glob(DEFAULT_LIBDIR_GLOB)[0])
+ if options.genpydir:
+ sys.path.insert(0, os.path.join(SCRIPT_DIR, options.genpydir))
+ if options.libpydir:
+ sys.path.insert(0, glob.glob(options.libpydir)[0])
+ else:
+ sys.path.insert(0, glob.glob(DEFAULT_LIBDIR_GLOB)[0])
- from ThriftTest import ThriftTest
- from ThriftTest.ttypes import Xtruct, Xtruct2, Numberz, Xception, Xception2
- from thrift.Thrift import TException
- from thrift.transport import TTransport
- from thrift.transport import TSocket
- from thrift.transport import THttpClient
- from thrift.transport import TZlibTransport
- from thrift.protocol import TBinaryProtocol
- from thrift.protocol import TCompactProtocol
- from thrift.protocol import TJSONProtocol
+ from ThriftTest import ThriftTest
+ from ThriftTest.ttypes import Xtruct, Xtruct2, Numberz, Xception, Xception2
+ from thrift.Thrift import TException
+ from thrift.transport import TTransport
+ from thrift.transport import TSocket
+ from thrift.transport import THttpClient
+ from thrift.transport import TZlibTransport
+ from thrift.protocol import TBinaryProtocol
+ from thrift.protocol import TCompactProtocol
+ from thrift.protocol import TJSONProtocol
- OwnArgsTestProgram(defaultTest="suite", testRunner=unittest.TextTestRunner(verbosity=1))
+ OwnArgsTestProgram(defaultTest="suite", testRunner=unittest.TextTestRunner(verbosity=1))
diff --git a/test/py/TestEof.py b/test/py/TestEof.py
index 6614638..0239fc6 100755
--- a/test/py/TestEof.py
+++ b/test/py/TestEof.py
@@ -28,99 +28,99 @@
class TestEof(unittest.TestCase):
- def make_data(self, pfactory=None):
- trans = TTransport.TMemoryBuffer()
- if pfactory:
- prot = pfactory.getProtocol(trans)
- else:
- prot = TBinaryProtocol.TBinaryProtocol(trans)
+ def make_data(self, pfactory=None):
+ trans = TTransport.TMemoryBuffer()
+ if pfactory:
+ prot = pfactory.getProtocol(trans)
+ else:
+ prot = TBinaryProtocol.TBinaryProtocol(trans)
- x = Xtruct()
- x.string_thing = "Zero"
- x.byte_thing = 0
+ x = Xtruct()
+ x.string_thing = "Zero"
+ x.byte_thing = 0
- x.write(prot)
+ x.write(prot)
- x = Xtruct()
- x.string_thing = "One"
- x.byte_thing = 1
+ x = Xtruct()
+ x.string_thing = "One"
+ x.byte_thing = 1
- x.write(prot)
+ x.write(prot)
- return trans.getvalue()
+ return trans.getvalue()
- def testTransportReadAll(self):
- """Test that readAll on any type of transport throws an EOFError"""
- trans = TTransport.TMemoryBuffer(self.make_data())
- trans.readAll(1)
+ def testTransportReadAll(self):
+ """Test that readAll on any type of transport throws an EOFError"""
+ trans = TTransport.TMemoryBuffer(self.make_data())
+ trans.readAll(1)
- try:
- trans.readAll(10000)
- except EOFError:
- return
+ try:
+ trans.readAll(10000)
+ except EOFError:
+ return
- self.fail("Should have gotten EOFError")
+ self.fail("Should have gotten EOFError")
- def eofTestHelper(self, pfactory):
- trans = TTransport.TMemoryBuffer(self.make_data(pfactory))
- prot = pfactory.getProtocol(trans)
+ def eofTestHelper(self, pfactory):
+ trans = TTransport.TMemoryBuffer(self.make_data(pfactory))
+ prot = pfactory.getProtocol(trans)
- x = Xtruct()
- x.read(prot)
- self.assertEqual(x.string_thing, "Zero")
- self.assertEqual(x.byte_thing, 0)
-
- x = Xtruct()
- x.read(prot)
- self.assertEqual(x.string_thing, "One")
- self.assertEqual(x.byte_thing, 1)
-
- try:
- x = Xtruct()
- x.read(prot)
- except EOFError:
- return
-
- self.fail("Should have gotten EOFError")
-
- def eofTestHelperStress(self, pfactory):
- """Teest the ability of TBinaryProtocol to deal with the removal of every byte in the file"""
- # TODO: we should make sure this covers more of the code paths
-
- data = self.make_data(pfactory)
- for i in range(0, len(data) + 1):
- trans = TTransport.TMemoryBuffer(data[0:i])
- prot = pfactory.getProtocol(trans)
- try:
x = Xtruct()
x.read(prot)
+ self.assertEqual(x.string_thing, "Zero")
+ self.assertEqual(x.byte_thing, 0)
+
+ x = Xtruct()
x.read(prot)
- x.read(prot)
- except EOFError:
- continue
- self.fail("Should have gotten an EOFError")
+ self.assertEqual(x.string_thing, "One")
+ self.assertEqual(x.byte_thing, 1)
- def testBinaryProtocolEof(self):
- """Test that TBinaryProtocol throws an EOFError when it reaches the end of the stream"""
- self.eofTestHelper(TBinaryProtocol.TBinaryProtocolFactory())
- self.eofTestHelperStress(TBinaryProtocol.TBinaryProtocolFactory())
+ try:
+ x = Xtruct()
+ x.read(prot)
+ except EOFError:
+ return
- def testBinaryProtocolAcceleratedEof(self):
- """Test that TBinaryProtocolAccelerated throws an EOFError when it reaches the end of the stream"""
- self.eofTestHelper(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())
- self.eofTestHelperStress(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())
+ self.fail("Should have gotten EOFError")
- def testCompactProtocolEof(self):
- """Test that TCompactProtocol throws an EOFError when it reaches the end of the stream"""
- self.eofTestHelper(TCompactProtocol.TCompactProtocolFactory())
- self.eofTestHelperStress(TCompactProtocol.TCompactProtocolFactory())
+ def eofTestHelperStress(self, pfactory):
+ """Teest the ability of TBinaryProtocol to deal with the removal of every byte in the file"""
+ # TODO: we should make sure this covers more of the code paths
+
+ data = self.make_data(pfactory)
+ for i in range(0, len(data) + 1):
+ trans = TTransport.TMemoryBuffer(data[0:i])
+ prot = pfactory.getProtocol(trans)
+ try:
+ x = Xtruct()
+ x.read(prot)
+ x.read(prot)
+ x.read(prot)
+ except EOFError:
+ continue
+ self.fail("Should have gotten an EOFError")
+
+ def testBinaryProtocolEof(self):
+ """Test that TBinaryProtocol throws an EOFError when it reaches the end of the stream"""
+ self.eofTestHelper(TBinaryProtocol.TBinaryProtocolFactory())
+ self.eofTestHelperStress(TBinaryProtocol.TBinaryProtocolFactory())
+
+ def testBinaryProtocolAcceleratedEof(self):
+ """Test that TBinaryProtocolAccelerated throws an EOFError when it reaches the end of the stream"""
+ self.eofTestHelper(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())
+ self.eofTestHelperStress(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())
+
+ def testCompactProtocolEof(self):
+ """Test that TCompactProtocol throws an EOFError when it reaches the end of the stream"""
+ self.eofTestHelper(TCompactProtocol.TCompactProtocolFactory())
+ self.eofTestHelperStress(TCompactProtocol.TCompactProtocolFactory())
def suite():
- suite = unittest.TestSuite()
- loader = unittest.TestLoader()
- suite.addTest(loader.loadTestsFromTestCase(TestEof))
- return suite
+ suite = unittest.TestSuite()
+ loader = unittest.TestLoader()
+ suite.addTest(loader.loadTestsFromTestCase(TestEof))
+ return suite
if __name__ == "__main__":
- unittest.main(defaultTest="suite", testRunner=unittest.TextTestRunner(verbosity=2))
+ unittest.main(defaultTest="suite", testRunner=unittest.TextTestRunner(verbosity=2))
diff --git a/test/py/TestFrozen.py b/test/py/TestFrozen.py
index 76750ad..30a6a55 100755
--- a/test/py/TestFrozen.py
+++ b/test/py/TestFrozen.py
@@ -28,89 +28,89 @@
class TestFrozenBase(unittest.TestCase):
- def _roundtrip(self, src, dst):
- otrans = TTransport.TMemoryBuffer()
- optoro = self.protocol(otrans)
- src.write(optoro)
- itrans = TTransport.TMemoryBuffer(otrans.getvalue())
- iproto = self.protocol(itrans)
- return dst.read(iproto) or dst
+ def _roundtrip(self, src, dst):
+ otrans = TTransport.TMemoryBuffer()
+ optoro = self.protocol(otrans)
+ src.write(optoro)
+ itrans = TTransport.TMemoryBuffer(otrans.getvalue())
+ iproto = self.protocol(itrans)
+ return dst.read(iproto) or dst
- def test_dict_is_hashable_only_after_frozen(self):
- d0 = {}
- self.assertFalse(isinstance(d0, collections.Hashable))
- d1 = TFrozenDict(d0)
- self.assertTrue(isinstance(d1, collections.Hashable))
+ def test_dict_is_hashable_only_after_frozen(self):
+ d0 = {}
+ self.assertFalse(isinstance(d0, collections.Hashable))
+ d1 = TFrozenDict(d0)
+ self.assertTrue(isinstance(d1, collections.Hashable))
- def test_struct_with_collection_fields(self):
- pass
+ def test_struct_with_collection_fields(self):
+ pass
- def test_set(self):
- """Test that annotated set field can be serialized and deserialized"""
- x = CompactProtoTestStruct(set_byte_map={
- frozenset([42, 100, -100]): 99,
- frozenset([0]): 100,
- frozenset([]): 0,
- })
- x2 = self._roundtrip(x, CompactProtoTestStruct())
- self.assertEqual(x2.set_byte_map[frozenset([42, 100, -100])], 99)
- self.assertEqual(x2.set_byte_map[frozenset([0])], 100)
- self.assertEqual(x2.set_byte_map[frozenset([])], 0)
+ def test_set(self):
+ """Test that annotated set field can be serialized and deserialized"""
+ x = CompactProtoTestStruct(set_byte_map={
+ frozenset([42, 100, -100]): 99,
+ frozenset([0]): 100,
+ frozenset([]): 0,
+ })
+ x2 = self._roundtrip(x, CompactProtoTestStruct())
+ self.assertEqual(x2.set_byte_map[frozenset([42, 100, -100])], 99)
+ self.assertEqual(x2.set_byte_map[frozenset([0])], 100)
+ self.assertEqual(x2.set_byte_map[frozenset([])], 0)
- def test_map(self):
- """Test that annotated map field can be serialized and deserialized"""
- x = CompactProtoTestStruct(map_byte_map={
- TFrozenDict({42: 42, 100: -100}): 99,
- TFrozenDict({0: 0}): 100,
- TFrozenDict({}): 0,
- })
- x2 = self._roundtrip(x, CompactProtoTestStruct())
- self.assertEqual(x2.map_byte_map[TFrozenDict({42: 42, 100: -100})], 99)
- self.assertEqual(x2.map_byte_map[TFrozenDict({0: 0})], 100)
- self.assertEqual(x2.map_byte_map[TFrozenDict({})], 0)
+ def test_map(self):
+ """Test that annotated map field can be serialized and deserialized"""
+ x = CompactProtoTestStruct(map_byte_map={
+ TFrozenDict({42: 42, 100: -100}): 99,
+ TFrozenDict({0: 0}): 100,
+ TFrozenDict({}): 0,
+ })
+ x2 = self._roundtrip(x, CompactProtoTestStruct())
+ self.assertEqual(x2.map_byte_map[TFrozenDict({42: 42, 100: -100})], 99)
+ self.assertEqual(x2.map_byte_map[TFrozenDict({0: 0})], 100)
+ self.assertEqual(x2.map_byte_map[TFrozenDict({})], 0)
- def test_list(self):
- """Test that annotated list field can be serialized and deserialized"""
- x = CompactProtoTestStruct(list_byte_map={
- (42, 100, -100): 99,
- (0,): 100,
- (): 0,
- })
- x2 = self._roundtrip(x, CompactProtoTestStruct())
- self.assertEqual(x2.list_byte_map[(42, 100, -100)], 99)
- self.assertEqual(x2.list_byte_map[(0,)], 100)
- self.assertEqual(x2.list_byte_map[()], 0)
+ def test_list(self):
+ """Test that annotated list field can be serialized and deserialized"""
+ x = CompactProtoTestStruct(list_byte_map={
+ (42, 100, -100): 99,
+ (0,): 100,
+ (): 0,
+ })
+ x2 = self._roundtrip(x, CompactProtoTestStruct())
+ self.assertEqual(x2.list_byte_map[(42, 100, -100)], 99)
+ self.assertEqual(x2.list_byte_map[(0,)], 100)
+ self.assertEqual(x2.list_byte_map[()], 0)
- def test_empty_struct(self):
- """Test that annotated empty struct can be serialized and deserialized"""
- x = CompactProtoTestStruct(empty_struct_field=Empty())
- x2 = self._roundtrip(x, CompactProtoTestStruct())
- self.assertEqual(x2.empty_struct_field, Empty())
+ def test_empty_struct(self):
+ """Test that annotated empty struct can be serialized and deserialized"""
+ x = CompactProtoTestStruct(empty_struct_field=Empty())
+ x2 = self._roundtrip(x, CompactProtoTestStruct())
+ self.assertEqual(x2.empty_struct_field, Empty())
- def test_struct(self):
- """Test that annotated struct can be serialized and deserialized"""
- x = Wrapper(foo=Empty())
- self.assertEqual(x.foo, Empty())
- x2 = self._roundtrip(x, Wrapper)
- self.assertEqual(x2.foo, Empty())
+ def test_struct(self):
+ """Test that annotated struct can be serialized and deserialized"""
+ x = Wrapper(foo=Empty())
+ self.assertEqual(x.foo, Empty())
+ x2 = self._roundtrip(x, Wrapper)
+ self.assertEqual(x2.foo, Empty())
class TestFrozen(TestFrozenBase):
- def protocol(self, trans):
- return TBinaryProtocol.TBinaryProtocolFactory().getProtocol(trans)
+ def protocol(self, trans):
+ return TBinaryProtocol.TBinaryProtocolFactory().getProtocol(trans)
class TestFrozenAccelerated(TestFrozenBase):
- def protocol(self, trans):
- return TBinaryProtocol.TBinaryProtocolAcceleratedFactory().getProtocol(trans)
+ def protocol(self, trans):
+ return TBinaryProtocol.TBinaryProtocolAcceleratedFactory().getProtocol(trans)
def suite():
- suite = unittest.TestSuite()
- loader = unittest.TestLoader()
- suite.addTest(loader.loadTestsFromTestCase(TestFrozen))
- suite.addTest(loader.loadTestsFromTestCase(TestFrozenAccelerated))
- return suite
+ suite = unittest.TestSuite()
+ loader = unittest.TestLoader()
+ suite.addTest(loader.loadTestsFromTestCase(TestFrozen))
+ suite.addTest(loader.loadTestsFromTestCase(TestFrozenAccelerated))
+ return suite
if __name__ == "__main__":
- unittest.main(defaultTest="suite", testRunner=unittest.TextTestRunner(verbosity=2))
+ unittest.main(defaultTest="suite", testRunner=unittest.TextTestRunner(verbosity=2))
diff --git a/test/py/TestServer.py b/test/py/TestServer.py
index f12a9fe..ef93509 100755
--- a/test/py/TestServer.py
+++ b/test/py/TestServer.py
@@ -32,287 +32,287 @@
class TestHandler(object):
- def testVoid(self):
- if options.verbose > 1:
- logging.info('testVoid()')
+ def testVoid(self):
+ if options.verbose > 1:
+ logging.info('testVoid()')
- def testString(self, str):
- if options.verbose > 1:
- logging.info('testString(%s)' % str)
- return str
+ def testString(self, str):
+ if options.verbose > 1:
+ logging.info('testString(%s)' % str)
+ return str
- def testBool(self, boolean):
- if options.verbose > 1:
- logging.info('testBool(%s)' % str(boolean).lower())
- return boolean
+ def testBool(self, boolean):
+ if options.verbose > 1:
+ logging.info('testBool(%s)' % str(boolean).lower())
+ return boolean
- def testByte(self, byte):
- if options.verbose > 1:
- logging.info('testByte(%d)' % byte)
- return byte
+ def testByte(self, byte):
+ if options.verbose > 1:
+ logging.info('testByte(%d)' % byte)
+ return byte
- def testI16(self, i16):
- if options.verbose > 1:
- logging.info('testI16(%d)' % i16)
- return i16
+ def testI16(self, i16):
+ if options.verbose > 1:
+ logging.info('testI16(%d)' % i16)
+ return i16
- def testI32(self, i32):
- if options.verbose > 1:
- logging.info('testI32(%d)' % i32)
- return i32
+ def testI32(self, i32):
+ if options.verbose > 1:
+ logging.info('testI32(%d)' % i32)
+ return i32
- def testI64(self, i64):
- if options.verbose > 1:
- logging.info('testI64(%d)' % i64)
- return i64
+ def testI64(self, i64):
+ if options.verbose > 1:
+ logging.info('testI64(%d)' % i64)
+ return i64
- def testDouble(self, dub):
- if options.verbose > 1:
- logging.info('testDouble(%f)' % dub)
- return dub
+ def testDouble(self, dub):
+ if options.verbose > 1:
+ logging.info('testDouble(%f)' % dub)
+ return dub
- def testBinary(self, thing):
- if options.verbose > 1:
- logging.info('testBinary()') # TODO: hex output
- return thing
+ def testBinary(self, thing):
+ if options.verbose > 1:
+ logging.info('testBinary()') # TODO: hex output
+ return thing
- def testStruct(self, thing):
- if options.verbose > 1:
- logging.info('testStruct({%s, %s, %s, %s})' % (thing.string_thing, thing.byte_thing, thing.i32_thing, thing.i64_thing))
- return thing
+ def testStruct(self, thing):
+ if options.verbose > 1:
+ logging.info('testStruct({%s, %s, %s, %s})' % (thing.string_thing, thing.byte_thing, thing.i32_thing, thing.i64_thing))
+ return thing
- def testException(self, arg):
- # if options.verbose > 1:
- logging.info('testException(%s)' % arg)
- if arg == 'Xception':
- raise Xception(errorCode=1001, message=arg)
- elif arg == 'TException':
- raise TException(message='This is a TException')
+ def testException(self, arg):
+ # if options.verbose > 1:
+ logging.info('testException(%s)' % arg)
+ if arg == 'Xception':
+ raise Xception(errorCode=1001, message=arg)
+ elif arg == 'TException':
+ raise TException(message='This is a TException')
- def testMultiException(self, arg0, arg1):
- if options.verbose > 1:
- logging.info('testMultiException(%s, %s)' % (arg0, arg1))
- if arg0 == 'Xception':
- raise Xception(errorCode=1001, message='This is an Xception')
- elif arg0 == 'Xception2':
- raise Xception2(
- errorCode=2002,
- struct_thing=Xtruct(string_thing='This is an Xception2'))
- return Xtruct(string_thing=arg1)
+ def testMultiException(self, arg0, arg1):
+ if options.verbose > 1:
+ logging.info('testMultiException(%s, %s)' % (arg0, arg1))
+ if arg0 == 'Xception':
+ raise Xception(errorCode=1001, message='This is an Xception')
+ elif arg0 == 'Xception2':
+ raise Xception2(
+ errorCode=2002,
+ struct_thing=Xtruct(string_thing='This is an Xception2'))
+ return Xtruct(string_thing=arg1)
- def testOneway(self, seconds):
- if options.verbose > 1:
- logging.info('testOneway(%d) => sleeping...' % seconds)
- time.sleep(seconds / 3) # be quick
- if options.verbose > 1:
- logging.info('done sleeping')
+ def testOneway(self, seconds):
+ if options.verbose > 1:
+ logging.info('testOneway(%d) => sleeping...' % seconds)
+ time.sleep(seconds / 3) # be quick
+ if options.verbose > 1:
+ logging.info('done sleeping')
- def testNest(self, thing):
- if options.verbose > 1:
- logging.info('testNest(%s)' % thing)
- return thing
+ def testNest(self, thing):
+ if options.verbose > 1:
+ logging.info('testNest(%s)' % thing)
+ return thing
- def testMap(self, thing):
- if options.verbose > 1:
- logging.info('testMap(%s)' % thing)
- return thing
+ def testMap(self, thing):
+ if options.verbose > 1:
+ logging.info('testMap(%s)' % thing)
+ return thing
- def testStringMap(self, thing):
- if options.verbose > 1:
- logging.info('testStringMap(%s)' % thing)
- return thing
+ def testStringMap(self, thing):
+ if options.verbose > 1:
+ logging.info('testStringMap(%s)' % thing)
+ return thing
- def testSet(self, thing):
- if options.verbose > 1:
- logging.info('testSet(%s)' % thing)
- return thing
+ def testSet(self, thing):
+ if options.verbose > 1:
+ logging.info('testSet(%s)' % thing)
+ return thing
- def testList(self, thing):
- if options.verbose > 1:
- logging.info('testList(%s)' % thing)
- return thing
+ def testList(self, thing):
+ if options.verbose > 1:
+ logging.info('testList(%s)' % thing)
+ return thing
- def testEnum(self, thing):
- if options.verbose > 1:
- logging.info('testEnum(%s)' % thing)
- return thing
+ def testEnum(self, thing):
+ if options.verbose > 1:
+ logging.info('testEnum(%s)' % thing)
+ return thing
- def testTypedef(self, thing):
- if options.verbose > 1:
- logging.info('testTypedef(%s)' % thing)
- return thing
+ def testTypedef(self, thing):
+ if options.verbose > 1:
+ logging.info('testTypedef(%s)' % thing)
+ return thing
- def testMapMap(self, thing):
- if options.verbose > 1:
- logging.info('testMapMap(%s)' % thing)
- return {
- -4: {
- -4: -4,
- -3: -3,
- -2: -2,
- -1: -1,
- },
- 4: {
- 4: 4,
- 3: 3,
- 2: 2,
- 1: 1,
- },
- }
+ def testMapMap(self, thing):
+ if options.verbose > 1:
+ logging.info('testMapMap(%s)' % thing)
+ return {
+ -4: {
+ -4: -4,
+ -3: -3,
+ -2: -2,
+ -1: -1,
+ },
+ 4: {
+ 4: 4,
+ 3: 3,
+ 2: 2,
+ 1: 1,
+ },
+ }
- def testInsanity(self, argument):
- if options.verbose > 1:
- logging.info('testInsanity(%s)' % argument)
- return {
- 1: {
- 2: argument,
- 3: argument,
- },
- 2: {6: Insanity()},
- }
+ def testInsanity(self, argument):
+ if options.verbose > 1:
+ logging.info('testInsanity(%s)' % argument)
+ return {
+ 1: {
+ 2: argument,
+ 3: argument,
+ },
+ 2: {6: Insanity()},
+ }
- def testMulti(self, arg0, arg1, arg2, arg3, arg4, arg5):
- if options.verbose > 1:
- logging.info('testMulti(%s)' % [arg0, arg1, arg2, arg3, arg4, arg5])
- return Xtruct(string_thing='Hello2',
- byte_thing=arg0, i32_thing=arg1, i64_thing=arg2)
+ def testMulti(self, arg0, arg1, arg2, arg3, arg4, arg5):
+ if options.verbose > 1:
+ logging.info('testMulti(%s)' % [arg0, arg1, arg2, arg3, arg4, arg5])
+ return Xtruct(string_thing='Hello2',
+ byte_thing=arg0, i32_thing=arg1, i64_thing=arg2)
def main(options):
- # set up the protocol factory form the --protocol option
- prot_factories = {
- 'binary': TBinaryProtocol.TBinaryProtocolFactory,
- 'accel': TBinaryProtocol.TBinaryProtocolAcceleratedFactory,
- 'compact': TCompactProtocol.TCompactProtocolFactory,
- 'json': TJSONProtocol.TJSONProtocolFactory,
- }
- pfactory_cls = prot_factories.get(options.proto, None)
- if pfactory_cls is None:
- raise AssertionError('Unknown --protocol option: %s' % options.proto)
- pfactory = pfactory_cls()
- try:
- pfactory.string_length_limit = options.string_limit
- pfactory.container_length_limit = options.container_limit
- except:
- # Ignore errors for those protocols that does not support length limit
- pass
+ # set up the protocol factory form the --protocol option
+ prot_factories = {
+ 'binary': TBinaryProtocol.TBinaryProtocolFactory,
+ 'accel': TBinaryProtocol.TBinaryProtocolAcceleratedFactory,
+ 'compact': TCompactProtocol.TCompactProtocolFactory,
+ 'json': TJSONProtocol.TJSONProtocolFactory,
+ }
+ pfactory_cls = prot_factories.get(options.proto, None)
+ if pfactory_cls is None:
+ raise AssertionError('Unknown --protocol option: %s' % options.proto)
+ pfactory = pfactory_cls()
+ try:
+ pfactory.string_length_limit = options.string_limit
+ pfactory.container_length_limit = options.container_limit
+ except:
+ # Ignore errors for those protocols that does not support length limit
+ pass
- # get the server type (TSimpleServer, TNonblockingServer, etc...)
- if len(args) > 1:
- raise AssertionError('Only one server type may be specified, not multiple types.')
- server_type = args[0]
+ # get the server type (TSimpleServer, TNonblockingServer, etc...)
+ if len(args) > 1:
+ raise AssertionError('Only one server type may be specified, not multiple types.')
+ server_type = args[0]
- # Set up the handler and processor objects
- handler = TestHandler()
- processor = ThriftTest.Processor(handler)
+ # Set up the handler and processor objects
+ handler = TestHandler()
+ processor = ThriftTest.Processor(handler)
- # Handle THttpServer as a special case
- if server_type == 'THttpServer':
- server = THttpServer.THttpServer(processor, ('', options.port), pfactory)
+ # Handle THttpServer as a special case
+ if server_type == 'THttpServer':
+ server = THttpServer.THttpServer(processor, ('', options.port), pfactory)
+ server.serve()
+ sys.exit(0)
+
+ # set up server transport and transport factory
+
+ abs_key_path = os.path.join(os.path.dirname(SCRIPT_DIR), 'keys', 'server.pem')
+
+ host = None
+ if options.ssl:
+ from thrift.transport import TSSLSocket
+ transport = TSSLSocket.TSSLServerSocket(host, options.port, certfile=abs_key_path)
+ else:
+ transport = TSocket.TServerSocket(host, options.port)
+ tfactory = TTransport.TBufferedTransportFactory()
+ if options.trans == 'buffered':
+ tfactory = TTransport.TBufferedTransportFactory()
+ elif options.trans == 'framed':
+ tfactory = TTransport.TFramedTransportFactory()
+ elif options.trans == '':
+ raise AssertionError('Unknown --transport option: %s' % options.trans)
+ else:
+ tfactory = TTransport.TBufferedTransportFactory()
+ # if --zlib, then wrap server transport, and use a different transport factory
+ if options.zlib:
+ transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib
+ tfactory = TZlibTransport.TZlibTransportFactory()
+
+ # do server-specific setup here:
+ if server_type == "TNonblockingServer":
+ server = TNonblockingServer.TNonblockingServer(processor, transport, inputProtocolFactory=pfactory)
+ elif server_type == "TProcessPoolServer":
+ import signal
+ from thrift.server import TProcessPoolServer
+ server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory)
+ server.setNumWorkers(5)
+
+ def set_alarm():
+ def clean_shutdown(signum, frame):
+ for worker in server.workers:
+ if options.verbose > 0:
+ logging.info('Terminating worker: %s' % worker)
+ worker.terminate()
+ if options.verbose > 0:
+ logging.info('Requesting server to stop()')
+ try:
+ server.stop()
+ except:
+ pass
+ signal.signal(signal.SIGALRM, clean_shutdown)
+ signal.alarm(4)
+ set_alarm()
+ else:
+ # look up server class dynamically to instantiate server
+ ServerClass = getattr(TServer, server_type)
+ server = ServerClass(processor, transport, tfactory, pfactory)
+ # enter server main loop
server.serve()
- sys.exit(0)
-
- # set up server transport and transport factory
-
- abs_key_path = os.path.join(os.path.dirname(SCRIPT_DIR), 'keys', 'server.pem')
-
- host = None
- if options.ssl:
- from thrift.transport import TSSLSocket
- transport = TSSLSocket.TSSLServerSocket(host, options.port, certfile=abs_key_path)
- else:
- transport = TSocket.TServerSocket(host, options.port)
- tfactory = TTransport.TBufferedTransportFactory()
- if options.trans == 'buffered':
- tfactory = TTransport.TBufferedTransportFactory()
- elif options.trans == 'framed':
- tfactory = TTransport.TFramedTransportFactory()
- elif options.trans == '':
- raise AssertionError('Unknown --transport option: %s' % options.trans)
- else:
- tfactory = TTransport.TBufferedTransportFactory()
- # if --zlib, then wrap server transport, and use a different transport factory
- if options.zlib:
- transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib
- tfactory = TZlibTransport.TZlibTransportFactory()
-
- # do server-specific setup here:
- if server_type == "TNonblockingServer":
- server = TNonblockingServer.TNonblockingServer(processor, transport, inputProtocolFactory=pfactory)
- elif server_type == "TProcessPoolServer":
- import signal
- from thrift.server import TProcessPoolServer
- server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory)
- server.setNumWorkers(5)
-
- def set_alarm():
- def clean_shutdown(signum, frame):
- for worker in server.workers:
- if options.verbose > 0:
- logging.info('Terminating worker: %s' % worker)
- worker.terminate()
- if options.verbose > 0:
- logging.info('Requesting server to stop()')
- try:
- server.stop()
- except:
- pass
- signal.signal(signal.SIGALRM, clean_shutdown)
- signal.alarm(4)
- set_alarm()
- else:
- # look up server class dynamically to instantiate server
- ServerClass = getattr(TServer, server_type)
- server = ServerClass(processor, transport, tfactory, pfactory)
- # enter server main loop
- server.serve()
if __name__ == '__main__':
- parser = OptionParser()
- parser.add_option('--libpydir', type='string', dest='libpydir',
- help='include this directory to sys.path for locating library code')
- parser.add_option('--genpydir', type='string', dest='genpydir',
- default='gen-py',
- help='include this directory to sys.path for locating generated code')
- parser.add_option("--port", type="int", dest="port",
- help="port number for server to listen on")
- parser.add_option("--zlib", action="store_true", dest="zlib",
- help="use zlib wrapper for compressed transport")
- parser.add_option("--ssl", action="store_true", dest="ssl",
- help="use SSL for encrypted transport")
- parser.add_option('-v', '--verbose', action="store_const",
- dest="verbose", const=2,
- help="verbose output")
- parser.add_option('-q', '--quiet', action="store_const",
- dest="verbose", const=0,
- help="minimal output")
- parser.add_option('--protocol', dest="proto", type="string",
- help="protocol to use, one of: accel, binary, compact, json")
- parser.add_option('--transport', dest="trans", type="string",
- help="transport to use, one of: buffered, framed")
- parser.add_option('--container-limit', dest='container_limit', type='int', default=None)
- parser.add_option('--string-limit', dest='string_limit', type='int', default=None)
- parser.set_defaults(port=9090, verbose=1, proto='binary')
- options, args = parser.parse_args()
+ parser = OptionParser()
+ parser.add_option('--libpydir', type='string', dest='libpydir',
+ help='include this directory to sys.path for locating library code')
+ parser.add_option('--genpydir', type='string', dest='genpydir',
+ default='gen-py',
+ help='include this directory to sys.path for locating generated code')
+ parser.add_option("--port", type="int", dest="port",
+ help="port number for server to listen on")
+ parser.add_option("--zlib", action="store_true", dest="zlib",
+ help="use zlib wrapper for compressed transport")
+ parser.add_option("--ssl", action="store_true", dest="ssl",
+ help="use SSL for encrypted transport")
+ parser.add_option('-v', '--verbose', action="store_const",
+ dest="verbose", const=2,
+ help="verbose output")
+ parser.add_option('-q', '--quiet', action="store_const",
+ dest="verbose", const=0,
+ help="minimal output")
+ parser.add_option('--protocol', dest="proto", type="string",
+ help="protocol to use, one of: accel, binary, compact, json")
+ parser.add_option('--transport', dest="trans", type="string",
+ help="transport to use, one of: buffered, framed")
+ parser.add_option('--container-limit', dest='container_limit', type='int', default=None)
+ parser.add_option('--string-limit', dest='string_limit', type='int', default=None)
+ parser.set_defaults(port=9090, verbose=1, proto='binary')
+ options, args = parser.parse_args()
- # Print TServer log to stdout so that the test-runner can redirect it to log files
- logging.basicConfig(level=options.verbose)
+ # Print TServer log to stdout so that the test-runner can redirect it to log files
+ logging.basicConfig(level=options.verbose)
- sys.path.insert(0, os.path.join(SCRIPT_DIR, options.genpydir))
- if options.libpydir:
- sys.path.insert(0, glob.glob(options.libpydir)[0])
- else:
- sys.path.insert(0, glob.glob(DEFAULT_LIBDIR_GLOB)[0])
+ sys.path.insert(0, os.path.join(SCRIPT_DIR, options.genpydir))
+ if options.libpydir:
+ sys.path.insert(0, glob.glob(options.libpydir)[0])
+ else:
+ sys.path.insert(0, glob.glob(DEFAULT_LIBDIR_GLOB)[0])
- from ThriftTest import ThriftTest
- from ThriftTest.ttypes import Xtruct, Xception, Xception2, Insanity
- from thrift.Thrift import TException
- from thrift.transport import TTransport
- from thrift.transport import TSocket
- from thrift.transport import TZlibTransport
- from thrift.protocol import TBinaryProtocol
- from thrift.protocol import TCompactProtocol
- from thrift.protocol import TJSONProtocol
- from thrift.server import TServer, TNonblockingServer, THttpServer
+ from ThriftTest import ThriftTest
+ from ThriftTest.ttypes import Xtruct, Xception, Xception2, Insanity
+ from thrift.Thrift import TException
+ from thrift.transport import TTransport
+ from thrift.transport import TSocket
+ from thrift.transport import TZlibTransport
+ from thrift.protocol import TBinaryProtocol
+ from thrift.protocol import TCompactProtocol
+ from thrift.protocol import TJSONProtocol
+ from thrift.server import TServer, TNonblockingServer, THttpServer
- sys.exit(main(options))
+ sys.exit(main(options))
diff --git a/test/py/TestSocket.py b/test/py/TestSocket.py
index a01be85..9b578cc 100755
--- a/test/py/TestSocket.py
+++ b/test/py/TestSocket.py
@@ -68,10 +68,10 @@
self.assert_(time.time() - starttime < 5.0)
if __name__ == '__main__':
- suite = unittest.TestSuite()
- loader = unittest.TestLoader()
+ suite = unittest.TestSuite()
+ loader = unittest.TestLoader()
- suite.addTest(loader.loadTestsFromTestCase(TimeoutTest))
+ suite.addTest(loader.loadTestsFromTestCase(TimeoutTest))
- testRunner = unittest.TextTestRunner(verbosity=2)
- testRunner.run(suite)
+ testRunner = unittest.TextTestRunner(verbosity=2)
+ testRunner.run(suite)
diff --git a/test/test.py b/test/test.py
index a5bcd9b..42babeb 100755
--- a/test/test.py
+++ b/test/test.py
@@ -46,124 +46,124 @@
def run_cross_tests(server_match, client_match, jobs, skip_known_failures, retry_count):
- logger = multiprocessing.get_logger()
- logger.debug('Collecting tests')
- with open(path_join(TEST_DIR, CONFIG_FILE), 'r') as fp:
- j = json.load(fp)
- tests = crossrunner.collect_cross_tests(j, server_match, client_match)
- if not tests:
- print('No test found that matches the criteria', file=sys.stderr)
- print(' servers: %s' % server_match, file=sys.stderr)
- print(' clients: %s' % client_match, file=sys.stderr)
- return False
- if skip_known_failures:
- logger.debug('Skipping known failures')
- known = crossrunner.load_known_failures(TEST_DIR)
- tests = list(filter(lambda t: crossrunner.test_name(**t) not in known, tests))
+ logger = multiprocessing.get_logger()
+ logger.debug('Collecting tests')
+ with open(path_join(TEST_DIR, CONFIG_FILE), 'r') as fp:
+ j = json.load(fp)
+ tests = crossrunner.collect_cross_tests(j, server_match, client_match)
+ if not tests:
+ print('No test found that matches the criteria', file=sys.stderr)
+ print(' servers: %s' % server_match, file=sys.stderr)
+ print(' clients: %s' % client_match, file=sys.stderr)
+ return False
+ if skip_known_failures:
+ logger.debug('Skipping known failures')
+ known = crossrunner.load_known_failures(TEST_DIR)
+ tests = list(filter(lambda t: crossrunner.test_name(**t) not in known, tests))
- dispatcher = crossrunner.TestDispatcher(TEST_DIR, ROOT_DIR, TEST_DIR_RELATIVE, jobs)
- logger.debug('Executing %d tests' % len(tests))
- try:
- for r in [dispatcher.dispatch(test, retry_count) for test in tests]:
- r.wait()
- logger.debug('Waiting for completion')
- return dispatcher.wait()
- except (KeyboardInterrupt, SystemExit):
- logger.debug('Interrupted, shutting down')
- dispatcher.terminate()
- return False
+ dispatcher = crossrunner.TestDispatcher(TEST_DIR, ROOT_DIR, TEST_DIR_RELATIVE, jobs)
+ logger.debug('Executing %d tests' % len(tests))
+ try:
+ for r in [dispatcher.dispatch(test, retry_count) for test in tests]:
+ r.wait()
+ logger.debug('Waiting for completion')
+ return dispatcher.wait()
+ except (KeyboardInterrupt, SystemExit):
+ logger.debug('Interrupted, shutting down')
+ dispatcher.terminate()
+ return False
def run_feature_tests(server_match, feature_match, jobs, skip_known_failures, retry_count):
- basedir = path_join(ROOT_DIR, FEATURE_DIR_RELATIVE)
- logger = multiprocessing.get_logger()
- logger.debug('Collecting tests')
- with open(path_join(TEST_DIR, CONFIG_FILE), 'r') as fp:
- j = json.load(fp)
- with open(path_join(basedir, CONFIG_FILE), 'r') as fp:
- j2 = json.load(fp)
- tests = crossrunner.collect_feature_tests(j, j2, server_match, feature_match)
- if not tests:
- print('No test found that matches the criteria', file=sys.stderr)
- print(' servers: %s' % server_match, file=sys.stderr)
- print(' features: %s' % feature_match, file=sys.stderr)
- return False
- if skip_known_failures:
- logger.debug('Skipping known failures')
- known = crossrunner.load_known_failures(basedir)
- tests = list(filter(lambda t: crossrunner.test_name(**t) not in known, tests))
+ basedir = path_join(ROOT_DIR, FEATURE_DIR_RELATIVE)
+ logger = multiprocessing.get_logger()
+ logger.debug('Collecting tests')
+ with open(path_join(TEST_DIR, CONFIG_FILE), 'r') as fp:
+ j = json.load(fp)
+ with open(path_join(basedir, CONFIG_FILE), 'r') as fp:
+ j2 = json.load(fp)
+ tests = crossrunner.collect_feature_tests(j, j2, server_match, feature_match)
+ if not tests:
+ print('No test found that matches the criteria', file=sys.stderr)
+ print(' servers: %s' % server_match, file=sys.stderr)
+ print(' features: %s' % feature_match, file=sys.stderr)
+ return False
+ if skip_known_failures:
+ logger.debug('Skipping known failures')
+ known = crossrunner.load_known_failures(basedir)
+ tests = list(filter(lambda t: crossrunner.test_name(**t) not in known, tests))
- dispatcher = crossrunner.TestDispatcher(TEST_DIR, ROOT_DIR, FEATURE_DIR_RELATIVE, jobs)
- logger.debug('Executing %d tests' % len(tests))
- try:
- for r in [dispatcher.dispatch(test, retry_count) for test in tests]:
- r.wait()
- logger.debug('Waiting for completion')
- return dispatcher.wait()
- except (KeyboardInterrupt, SystemExit):
- logger.debug('Interrupted, shutting down')
- dispatcher.terminate()
- return False
+ dispatcher = crossrunner.TestDispatcher(TEST_DIR, ROOT_DIR, FEATURE_DIR_RELATIVE, jobs)
+ logger.debug('Executing %d tests' % len(tests))
+ try:
+ for r in [dispatcher.dispatch(test, retry_count) for test in tests]:
+ r.wait()
+ logger.debug('Waiting for completion')
+ return dispatcher.wait()
+ except (KeyboardInterrupt, SystemExit):
+ logger.debug('Interrupted, shutting down')
+ dispatcher.terminate()
+ return False
def default_concurrenty():
- try:
- return int(os.environ.get('THRIFT_CROSSTEST_CONCURRENCY'))
- except (TypeError, ValueError):
- # Since much time is spent sleeping, use many threads
- return int(multiprocessing.cpu_count() * 1.25) + 1
+ try:
+ return int(os.environ.get('THRIFT_CROSSTEST_CONCURRENCY'))
+ except (TypeError, ValueError):
+ # Since much time is spent sleeping, use many threads
+ return int(multiprocessing.cpu_count() * 1.25) + 1
def main(argv):
- parser = argparse.ArgumentParser()
- parser.add_argument('--server', default='', nargs='*',
- help='list of servers to test')
- parser.add_argument('--client', default='', nargs='*',
- help='list of clients to test')
- parser.add_argument('-F', '--features', nargs='*', default=None,
- help='run server feature tests instead of cross language tests')
- parser.add_argument('-s', '--skip-known-failures', action='store_true', dest='skip_known_failures',
- help='do not execute tests that are known to fail')
- parser.add_argument('-r', '--retry-count', type=int,
- default=0, help='maximum retry on failure')
- parser.add_argument('-j', '--jobs', type=int,
- default=default_concurrenty(),
- help='number of concurrent test executions')
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--server', default='', nargs='*',
+ help='list of servers to test')
+ parser.add_argument('--client', default='', nargs='*',
+ help='list of clients to test')
+ parser.add_argument('-F', '--features', nargs='*', default=None,
+ help='run server feature tests instead of cross language tests')
+ parser.add_argument('-s', '--skip-known-failures', action='store_true', dest='skip_known_failures',
+ help='do not execute tests that are known to fail')
+ parser.add_argument('-r', '--retry-count', type=int,
+ default=0, help='maximum retry on failure')
+ parser.add_argument('-j', '--jobs', type=int,
+ default=default_concurrenty(),
+ help='number of concurrent test executions')
- g = parser.add_argument_group(title='Advanced')
- g.add_argument('-v', '--verbose', action='store_const',
- dest='log_level', const=logging.DEBUG, default=logging.WARNING,
- help='show debug output for test runner')
- g.add_argument('-P', '--print-expected-failures', choices=['merge', 'overwrite'],
- dest='print_failures',
- help="generate expected failures based on last result and print to stdout")
- g.add_argument('-U', '--update-expected-failures', choices=['merge', 'overwrite'],
- dest='update_failures',
- help="generate expected failures based on last result and save to default file location")
- options = parser.parse_args(argv)
+ g = parser.add_argument_group(title='Advanced')
+ g.add_argument('-v', '--verbose', action='store_const',
+ dest='log_level', const=logging.DEBUG, default=logging.WARNING,
+ help='show debug output for test runner')
+ g.add_argument('-P', '--print-expected-failures', choices=['merge', 'overwrite'],
+ dest='print_failures',
+ help="generate expected failures based on last result and print to stdout")
+ g.add_argument('-U', '--update-expected-failures', choices=['merge', 'overwrite'],
+ dest='update_failures',
+ help="generate expected failures based on last result and save to default file location")
+ options = parser.parse_args(argv)
- logger = multiprocessing.log_to_stderr()
- logger.setLevel(options.log_level)
+ logger = multiprocessing.log_to_stderr()
+ logger.setLevel(options.log_level)
- if options.features is not None and options.client:
- print('Cannot specify both --features and --client ', file=sys.stderr)
- return 1
+ if options.features is not None and options.client:
+ print('Cannot specify both --features and --client ', file=sys.stderr)
+ return 1
- # Allow multiple args separated with ',' for backward compatibility
- server_match = list(chain(*[x.split(',') for x in options.server]))
- client_match = list(chain(*[x.split(',') for x in options.client]))
+ # Allow multiple args separated with ',' for backward compatibility
+ server_match = list(chain(*[x.split(',') for x in options.server]))
+ client_match = list(chain(*[x.split(',') for x in options.client]))
- if options.update_failures or options.print_failures:
- dire = path_join(ROOT_DIR, FEATURE_DIR_RELATIVE) if options.features is not None else TEST_DIR
- res = crossrunner.generate_known_failures(
- dire, options.update_failures == 'overwrite',
- options.update_failures, options.print_failures)
- elif options.features is not None:
- features = options.features or ['.*']
- res = run_feature_tests(server_match, features, options.jobs, options.skip_known_failures, options.retry_count)
- else:
- res = run_cross_tests(server_match, client_match, options.jobs, options.skip_known_failures, options.retry_count)
- return 0 if res else 1
+ if options.update_failures or options.print_failures:
+ dire = path_join(ROOT_DIR, FEATURE_DIR_RELATIVE) if options.features is not None else TEST_DIR
+ res = crossrunner.generate_known_failures(
+ dire, options.update_failures == 'overwrite',
+ options.update_failures, options.print_failures)
+ elif options.features is not None:
+ features = options.features or ['.*']
+ res = run_feature_tests(server_match, features, options.jobs, options.skip_known_failures, options.retry_count)
+ else:
+ res = run_cross_tests(server_match, client_match, options.jobs, options.skip_known_failures, options.retry_count)
+ return 0 if res else 1
if __name__ == '__main__':
- sys.exit(main(sys.argv[1:]))
+ sys.exit(main(sys.argv[1:]))