From 90071bfb97e030733c35db1b83ad866286d9d3cb Mon Sep 17 00:00:00 2001 From: Thom Wiggers Date: Mon, 18 Feb 2019 13:04:59 +0100 Subject: [PATCH] Flake8ify python files --- test/helpers.py | 18 ++++++++++++------ test/pqclean.py | 8 ++++++-- test/test_compile_lib.py | 9 ++++++--- test/test_functest.py | 13 ++++++++++--- test/test_license.py | 8 ++++++-- test/test_metadata.py | 31 +++++++++++++++++++------------ test/test_symbol_namespace.py | 17 +++++++++++------ 7 files changed, 70 insertions(+), 34 deletions(-) diff --git a/test/helpers.py b/test/helpers.py index 32432917..0ad50da9 100644 --- a/test/helpers.py +++ b/test/helpers.py @@ -1,13 +1,19 @@ import subprocess -def run_subprocess(command, working_dir, expected_returncode = 0): - """Helper function to run a shell command and report success/failure depending on the exit status of the shell command.""" - # Note we need to capture stdout/stderr from the subprocess, then print it, which nose/unittest will then capture and buffer appropriately + +def run_subprocess(command, working_dir, expected_returncode=0): + """ + Helper function to run a shell command and report success/failure + depending on the exit status of the shell command. + """ + # Note we need to capture stdout/stderr from the subprocess, + # then print it, which nose/unittest will then capture and + # buffer appropriately result = subprocess.run( command, - stdout = subprocess.PIPE, - stderr = subprocess.STDOUT, - cwd = working_dir + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + cwd=working_dir ) print(result.stdout.decode('utf-8')) assert(result.returncode == expected_returncode) diff --git a/test/pqclean.py b/test/pqclean.py index 7a5d69c2..6a0e9e3a 100644 --- a/test/pqclean.py +++ b/test/pqclean.py @@ -1,6 +1,7 @@ import os import yaml + class Scheme: def __init__(self): self.type = None @@ -58,6 +59,7 @@ class Scheme: print("Can't open {}: {}".format(metafile, e)) return None + class Implementation: def __init__(self, scheme, name): @@ -83,22 +85,24 @@ class Implementation: implementations.append(Implementation(scheme, d)) return implementations + class KEM(Scheme): def __init__(self, name: str): self.type = 'kem' - self.name = name; + self.name = name self.implementations = Implementation.all_implementations(self) @staticmethod def all_kems() -> list: return Scheme.all_schemes_of_type('kem') + class Signature(Scheme): def __init__(self, name: str): self.type = 'sign' - self.name = name; + self.name = name self.implementations = Implementation.all_implementations(self) @staticmethod diff --git a/test/test_compile_lib.py b/test/test_compile_lib.py index d53df8cb..98ea8596 100644 --- a/test/test_compile_lib.py +++ b/test/test_compile_lib.py @@ -1,18 +1,21 @@ """ -Checks that the archive library can be successfully built for every scheme/implementation. +Checks that the archive library can be successfully built for every +scheme/implementation. """ -import os import pqclean import helpers + def test_compile_lib(): for scheme in pqclean.Scheme.all_schemes(): for implementation in scheme.implementations: yield check_compile_lib, scheme.name, implementation.name + def check_compile_lib(scheme_name, implementation_name): - implementation = pqclean.Implementation.by_name(scheme_name, implementation_name) + implementation = pqclean.Implementation.by_name( + scheme_name, implementation_name) helpers.run_subprocess( ['make', 'clean'], implementation.path() diff --git a/test/test_functest.py b/test/test_functest.py index b40ad2c9..b26651ff 100644 --- a/test/test_functest.py +++ b/test/test_functest.py @@ -1,20 +1,27 @@ """ -Checks that the functional test program (functest) can be successfully built and executed for every scheme/implementation. +Checks that the functional test program (functest) can be successfully built +and executed for every scheme/implementation. """ import os import pqclean import helpers + def test_functest(): for scheme in pqclean.Scheme.all_schemes(): for implementation in scheme.implementations: yield check_functest, scheme.name, implementation.name + def check_functest(scheme_name, implementation_name): - implementation = pqclean.Implementation.by_name(scheme_name, implementation_name) + implementation = pqclean.Implementation.by_name( + scheme_name, implementation_name) helpers.run_subprocess( - ['make', 'TYPE=' + implementation.scheme.type, 'SCHEME=' + scheme_name, 'IMPLEMENTATION=' + implementation_name], + ['make', + 'TYPE={}'.format(implementation.scheme.type), + 'SCHEME={}'.format(scheme_name), + 'IMPLEMENTATION={}'.format(implementation_name)], os.path.join('..', 'test') ) helpers.run_subprocess( diff --git a/test/test_license.py b/test/test_license.py index 707f170d..e6c6069a 100644 --- a/test/test_license.py +++ b/test/test_license.py @@ -1,17 +1,21 @@ """ -Checks that a LICENSE or LICENSE.txt file is present for every implementation of the specified scheme. +Checks that a LICENSE or LICENSE.txt file is present for every +implementation of the specified scheme. """ import os import pqclean + def test_license(): for scheme in pqclean.Scheme.all_schemes(): for implementation in scheme.implementations: yield check_license, scheme.name, implementation.name + def check_license(scheme_name, implementation_name): - implementation = pqclean.Implementation.by_name(scheme_name, implementation_name) + implementation = pqclean.Implementation.by_name( + scheme_name, implementation_name) p1 = os.path.join(implementation.path(), 'LICENSE') p2 = os.path.join(implementation.path(), 'LICENSE.txt') assert(os.path.isfile(p1) or os.path.isfile(p2)) diff --git a/test/test_metadata.py b/test/test_metadata.py index 1faf8a73..308e2af8 100644 --- a/test/test_metadata.py +++ b/test/test_metadata.py @@ -4,15 +4,14 @@ Verify the metadata specified in the META.yml files. import copy import itertools -import os import pqclean -import yaml -import unittest + def test_metadata(): for scheme in pqclean.Scheme.all_schemes(): yield check_metadata, scheme.name + def check_metadata(scheme_name): scheme = pqclean.Scheme.by_name(scheme_name) metadata = scheme.metadata() @@ -22,17 +21,22 @@ def check_metadata(scheme_name): if scheme.type == 'kem': specification = itertools.chain(specification, KEM_FIELDS.items()) elif scheme.type == 'sign': - specification = itertools.chain(specification, SIGNATURE_FIELDS.items()) + specification = itertools.chain(specification, + SIGNATURE_FIELDS.items()) else: assert(False) check_spec(copy.deepcopy(metadata), specification) - implementation_names_in_yaml = set(i['name'] for i in metadata['implementations']) + implementation_names_in_yaml = set( + i['name'] for i in metadata['implementations']) implementations_on_disk = set(i.name for i in scheme.implementations) if implementation_names_in_yaml != implementations_on_disk: - raise AssertionError("Implementations in YAML file {} and implementations on disk {} do not match" - .format(implementation_names_in_yaml, implementations_on_disk)) + raise AssertionError("Implementations in YAML file {} and " + "implementations on disk {} do not match" + .format(implementation_names_in_yaml, + implementations_on_disk)) + EXPECTED_FIELDS = { 'name': {'type': str}, @@ -62,6 +66,7 @@ SIGNATURE_FIELDS = { 'length-signature': {'type': int, 'min': 1}, } + def check_spec(metadata, spec): for field, props in spec: if field not in metadata: @@ -75,7 +80,8 @@ def check_spec(metadata, spec): # Done checking all specified fields, check if we have extras for field, value in metadata.items(): - raise AssertionError("Unexpected item '{}' with value '{}'".format(field, value)) + raise AssertionError( + "Unexpected item '{}' with value '{}'".format(field, value)) def check_element(field, element, props): @@ -96,19 +102,20 @@ def check_element(field, element, props): if 'min' in props: if element < props['min']: raise ValueError("Value of field '{}' is lower than minimum " - "value {}".format(field, props['min'])) + "value {}".format(field, props['min'])) if 'max' in props: if element > props['max']: raise ValueError("Value of field '{}' is larger than maximum" - " value {}".format(field, metafile, props['max'])) + " value {}" + .format(field, props['max'])) if type_ == str: if 'length' in props: actual_len = len(element) if actual_len != props['length']: raise ValueError("Value of field '{}' should be length {}" - " but was length {}" - .format(field, props['length'], actual_len)) + " but was length {}" + .format(field, props['length'], actual_len)) if type_ == list: # recursively check the elements for el in element: diff --git a/test/test_symbol_namespace.py b/test/test_symbol_namespace.py index 33386b5f..1e83231f 100644 --- a/test/test_symbol_namespace.py +++ b/test/test_symbol_namespace.py @@ -1,28 +1,32 @@ """ -Checks that the all exported symbols are properly namespaced, i.e., all start with "PQCLEAN_SCHEMENAME_". +Checks that the all exported symbols are properly namespaced, i.e., all +start with "PQCLEAN_SCHEMENAME_". """ -import os import pqclean import helpers import sys import unittest + def test_symbol_namespace(): - if sys.platform not in ['linux', 'darwin']: raise unittest.SkipTest() + if sys.platform not in ['linux', 'darwin']: + raise unittest.SkipTest() for scheme in pqclean.Scheme.all_schemes(): for implementation in scheme.implementations: yield check_symbol_namespace, scheme.name, implementation.name + def check_symbol_namespace(scheme_name, implementation_name): - implementation = pqclean.Implementation.by_name(scheme_name, implementation_name) + implementation = pqclean.Implementation.by_name( + scheme_name, implementation_name) helpers.run_subprocess( ['make'], implementation.path() ) out = helpers.run_subprocess( ['nm', '-g', 'lib{}_{}.a'.format(scheme_name, implementation_name)], - implementation.path() + implementation.path() ) lines = out.strip().split("\n") @@ -36,7 +40,8 @@ def check_symbol_namespace(scheme_name, implementation_name): for symbolstr in symbols: *_, symtype, symbol = symbolstr.split() if symtype in 'TR': - if not symbol.startswith(namespace) and not symbol.startswith('_' + namespace): + if (not symbol.startswith(namespace) and + not symbol.startswith('_' + namespace)): non_namespaced.append(symbol) if non_namespaced: