From 99c1fcdd10c8bb9734c70c07abd16135eb882974 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 21 May 2019 15:24:28 +0530 Subject: [PATCH] Enables logging. --- .../slither_format/format_constable_states.py | 9 +- .../format_constant_function.py | 9 +- .../format_external_function.py | 7 +- .../format_naming_convention.py | 57 +- utils/slither_format/format_pragma.py | 11 +- utils/slither_format/format_solc_version.py | 9 +- utils/slither_format/slither_format.py | 37 +- .../tests/test_constable_states.py | 64 +- .../tests/test_constant_function.py | 56 +- .../tests/test_data/naming_convention.sol | 2 +- .../tests/test_detector_combinations.py | 34 +- .../tests/test_external_function.py | 70 +-- .../tests/test_naming_convention.py | 572 +++++++++--------- utils/slither_format/tests/test_pragma.py | 52 +- .../slither_format/tests/test_solc_version.py | 96 +-- .../tests/test_unused_state_vars.py | 24 +- 16 files changed, 562 insertions(+), 547 deletions(-) diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/format_constable_states.py index fd3f8245f..0cf93b967 100644 --- a/utils/slither_format/format_constable_states.py +++ b/utils/slither_format/format_constable_states.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatConstableStates: @@ -21,5 +26,5 @@ class FormatConstableStates: "new_string" : new_str_of_interest }) else: - print("Error: State variable not found?!") + logger.error(red("State variable not found?!")) sys.exit(-1) diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index a737f8b1f..a4435e9ae 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatConstantFunction: @@ -30,5 +35,5 @@ class FormatConstantFunction: "new_string" : replace_text }) else: - print("Error: No view/pure/constant specifier exists. Regex failed to remove specifier!") + logger.error(red("No view/pure/constant specifier exists. Regex failed to remove specifier!")) sys.exit(-1) diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 36bf9f29e..5fffb9879 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatExternalFunction: diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 324deb165..1fffbb2c2 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -1,8 +1,13 @@ -import re, sys +import re, sys, logging from slither.core.expressions.identifier import Identifier from slither.core.cfg.node import Node from slither.slithir.operations import NewContract from slither.slithir.operations import Member +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatNamingConvention: @@ -44,7 +49,7 @@ class FormatNamingConvention: FormatNamingConvention.create_patch_modifier_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) FormatNamingConvention.create_patch_modifier_uses(slither, patches, name, contract_name, in_file) else: - print("Unknown naming convention! " + _target) + logger.error(red("Unknown naming convention! " + _target)) sys.exit(-1) @staticmethod @@ -67,9 +72,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find contract?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Contract : " + name) + logger.error(red("Could not find contract?!")) sys.exit(-1) @staticmethod @@ -130,9 +133,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find new object?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Contract : " + name) + logger.error(red("Could not find new object?!")) sys.exit(-1) else: @@ -161,9 +162,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find modifier?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Modifier: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find modifier?!")) sys.exit(-1) @staticmethod @@ -190,9 +189,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find modifier name?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Modifier: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find modifier name?!")) sys.exit(-1) @staticmethod @@ -217,9 +214,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find function?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Function: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find function?!")) sys.exit(-1) @staticmethod @@ -281,9 +276,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find event?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Event: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find event?!")) sys.exit(-1) @staticmethod @@ -333,9 +326,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find parameter declaration?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Parameter: " + name + " of Function: " + function_name + " in Contract : " + contract_name) + logger.error(red("Could not find parameter declaration?!")) sys.exit(-1) @staticmethod @@ -367,9 +358,9 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find parameter use?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Parameter: " + name + " of Function: " + function_name + " in Contract : " + contract_name) + logger.error(red("Could not find parameter use?!")) + sys.exit(-1) + # Process function parameters passed to modifiers for modifier in function._expression_modifiers: for arg in modifier.arguments: @@ -391,9 +382,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find parameter use in modifier?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Parameter: " + name + " of Function: " + function_name + " in Contract : " + contract_name) + logger.error(red("Could not find parameter use in modifier?!")) sys.exit(-1) @staticmethod @@ -473,9 +462,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find enum?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Enum: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find enum?!")) sys.exit(-1) @staticmethod @@ -542,8 +529,7 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find new object?!") - print("Enum: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find new object?!")) sys.exit(-1) # To-do: Check any other place/way where enum type is used @@ -567,8 +553,7 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find struct?!") - print("Struct: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find struct?!")) sys.exit(-1) @staticmethod diff --git a/utils/slither_format/format_pragma.py b/utils/slither_format/format_pragma.py index fc8fd2db7..29cc72285 100644 --- a/utils/slither_format/format_pragma.py +++ b/utils/slither_format/format_pragma.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatPragma: @@ -28,7 +33,7 @@ class FormatPragma: for version in used_solc_versions: replace_solc_versions.append(FormatPragma.determine_solc_version_replacement(version)) if not all(version == replace_solc_versions[0] for version in replace_solc_versions): - print("Multiple incompatible versions!") + logger.error(red("Multiple incompatible versions!")) sys.exit(-1) else: return replace_solc_versions[0] @@ -44,7 +49,7 @@ class FormatPragma: elif minor_version == '5': return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' else: - print("Unknown version!") + logger.error(red("Unknown version!")) sys.exit(-1) elif len(versions) == 2: version_left = versions[0] diff --git a/utils/slither_format/format_solc_version.py b/utils/slither_format/format_solc_version.py index de1fb2109..ae35d33b1 100644 --- a/utils/slither_format/format_solc_version.py +++ b/utils/slither_format/format_solc_version.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatSolcVersion: @@ -30,7 +35,7 @@ class FormatSolcVersion: elif minor_version == '5': return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' else: - print("Unknown version!") + logger.error(red("Unknown version!")) sys.exit(-1) elif len(versions) == 2: version_left = versions[0] diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index df68e0e33..eb7e3cfe1 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -1,5 +1,6 @@ -import sys, re +import sys, re, logging from collections import defaultdict +from slither.utils.colors import red, yellow, set_colorization_enabled from slither.detectors.variables.unused_state_variables import UnusedStateVars from slither.detectors.attributes.incorrect_solc import IncorrectSolc from slither.detectors.attributes.constant_pragma import ConstantPragma @@ -19,6 +20,10 @@ from slither_format.format_external_function import FormatExternalFunction from slither_format.format_constable_states import FormatConstableStates from slither_format.format_constant_function import FormatConstantFunction +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) + all_detectors = { 'unused-state': UnusedStateVars, 'solc-version': IncorrectSolc, @@ -68,12 +73,12 @@ def sort_and_flag_overlapping_patches(patches): def is_overlap_patch(args, patch): if 'overlaps' in patch: if args.verbose_test: - print("Overlapping patch won't be applied!") - print("xDetector: " + patch['detector']) - print("xOld string: " + patch['old_string'].replace("\n","")) - print("xNew string: " + patch['new_string'].replace("\n","")) - print("xLocation start: " + str(patch['start'])) - print("xLocation end: " + str(patch['end'])) + logger.info("Overlapping patch won't be applied!") + logger.info("xDetector: " + patch['detector']) + logger.info("xOld string: " + patch['old_string'].replace("\n","")) + logger.info("xNew string: " + patch['new_string'].replace("\n","")) + logger.info("xLocation start: " + str(patch['start'])) + logger.info("xLocation end: " + str(patch['end'])) return True return False @@ -100,19 +105,19 @@ def apply_patches(slither, patches): out_file.close() def print_patches(number_of_slither_results, patches): - print("Number of Slither results: " + str(number_of_slither_results)) + logger.info("Number of Slither results: " + str(number_of_slither_results)) number_of_patches = 0 for file in patches: number_of_patches += len(patches[file]) - print("Number of patches: " + str(number_of_patches)) + logger.info("Number of patches: " + str(number_of_patches)) for file in patches: - print("Patch file: " + file) + logger.info("Patch file: " + file) for patch in patches[file]: - print("Detector: " + patch['detector']) - print("Old string: " + patch['old_string'].replace("\n","")) - print("New string: " + patch['new_string'].replace("\n","")) - print("Location start: " + str(patch['start'])) - print("Location end: " + str(patch['end'])) + logger.info("Detector: " + patch['detector']) + logger.info("Old string: " + patch['old_string'].replace("\n","")) + logger.info("New string: " + patch['new_string'].replace("\n","")) + logger.info("Location start: " + str(patch['start'])) + logger.info("Location end: " + str(patch['end'])) def print_patches_json(number_of_slither_results, patches): print('{',end='') @@ -175,7 +180,7 @@ def apply_detector_results(slither, patches, detector_results): elif result['check'] == 'constant-function': FormatConstantFunction.format(slither, patches, result['elements']) else: - print("Not Supported Yet.") + logger.error(red("Not Supported Yet.")) sys.exit(-1) def get_number_of_slither_results (detector_results): diff --git a/utils/slither_format/tests/test_constable_states.py b/utils/slither_format/tests/test_constable_states.py index 6921485de..ade821b76 100644 --- a/utils/slither_format/tests/test_constable_states.py +++ b/utils/slither_format/tests/test_constable_states.py @@ -19,39 +19,39 @@ class TestConstableState(unittest.TestCase): p.wait() def test_constable_states(self): - outFD = open(self.testFilePath+".out","r") - outFD_lines = outFD.readlines() - for i in range(len(outFD_lines)): - outFD_lines[i] = outFD_lines[i].strip() + errFD = open(self.testFilePath+".err","r") + errFD_lines = errFD.readlines() + for i in range(len(errFD_lines)): + errFD_lines[i] = errFD_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD_lines[0].rstrip(),"Number of Slither results: 6") - self.assertEqual(outFD_lines[1].rstrip(),"Number of patches: 6") - self.assertEqual(outFD_lines.count("Detector: constable-states"), 6) - self.assertEqual(outFD_lines.count("Old string: address public myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) - self.assertEqual(outFD_lines.count("New string: address public constant myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) - self.assertEqual(outFD_lines.count("Location start: 132"), 1) - self.assertEqual(outFD_lines.count("Location end: 208"), 1) - self.assertEqual(outFD_lines.count("Old string: uint public test = 5"), 1) - self.assertEqual(outFD_lines.count("New string: uint public constant test = 5"), 1) - self.assertEqual(outFD_lines.count("Location start: 237"), 1) - self.assertEqual(outFD_lines.count("Location end: 257"), 1) - self.assertEqual(outFD_lines.count("Old string: string text2 = \"xyz\""), 1) - self.assertEqual(outFD_lines.count("New string: string constant text2 = \"xyz\""), 1) - self.assertEqual(outFD_lines.count("Location start: 333"), 1) - self.assertEqual(outFD_lines.count("Location end: 353"), 1) - self.assertEqual(outFD_lines.count("Old string: address public mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) - self.assertEqual(outFD_lines.count("New string: address public constant mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) - self.assertEqual(outFD_lines.count("Location start: 496"), 1) - self.assertEqual(outFD_lines.count("Location end: 572"), 1) - self.assertEqual(outFD_lines.count("Old string: bytes32 should_be_constant = sha256('abc')"), 1) - self.assertEqual(outFD_lines.count("New string: bytes32 constant should_be_constant = sha256('abc')"), 1) - self.assertEqual(outFD_lines.count("Location start: 793"), 1) - self.assertEqual(outFD_lines.count("Location end: 835"), 1) - self.assertEqual(outFD_lines.count("Old string: uint should_be_constant_2 = A + 1"), 1) - self.assertEqual(outFD_lines.count("New string: uint constant should_be_constant_2 = A + 1"), 1) - self.assertEqual(outFD_lines.count("Location start: 841"), 1) - self.assertEqual(outFD_lines.count("Location end: 874"), 1) - outFD.close() + self.assertEqual(errFD_lines[0].rstrip(),"INFO:Slither.Format:Number of Slither results: 6") + self.assertEqual(errFD_lines[1].rstrip(),"INFO:Slither.Format:Number of patches: 6") + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Detector: constable-states"), 6) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: address public myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: address public constant myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 132"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 208"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: uint public test = 5"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: uint public constant test = 5"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 237"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 257"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: string text2 = \"xyz\""), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: string constant text2 = \"xyz\""), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 333"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 353"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: address public mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: address public constant mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 496"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 572"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: bytes32 should_be_constant = sha256('abc')"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: bytes32 constant should_be_constant = sha256('abc')"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 793"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 835"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: uint should_be_constant_2 = A + 1"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: uint constant should_be_constant_2 = A + 1"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 841"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 874"), 1) + errFD.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_constant_function.py b/utils/slither_format/tests/test_constant_function.py index 8fe337726..9458545e6 100644 --- a/utils/slither_format/tests/test_constant_function.py +++ b/utils/slither_format/tests/test_constant_function.py @@ -29,37 +29,37 @@ class TestConstantFunctions(unittest.TestCase): p2.wait() def test_constant_function(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 3") - self.assertEqual(outFD1_lines[1],"Number of patches: 3") - self.assertEqual(outFD1_lines.count("Detector: constant-function"), 3) - self.assertEqual(outFD1_lines.count("Old string: view"), 2) - self.assertEqual(outFD1_lines.count("Old string: constant"), 1) - self.assertEqual(outFD1_lines.count("New string:"), 3) - self.assertEqual(outFD1_lines.count("Location start: 77"), 1) - self.assertEqual(outFD1_lines.count("Location end: 81"), 1) - self.assertEqual(outFD1_lines.count("Location start: 149"), 1) - self.assertEqual(outFD1_lines.count("Location end: 157"), 1) - self.assertEqual(outFD1_lines.count("Location start: 360"), 1) - self.assertEqual(outFD1_lines.count("Location end: 364"), 1) - outFD1.close() + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 3") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 3") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: constant-function"), 3) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: view"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: constant"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string:"), 3) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 77"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 81"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 149"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 157"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 360"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 364"), 1) + errFD1.close() - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD2_lines[1],"Number of patches: 1") - self.assertEqual(outFD2_lines.count("Old string: view"), 1) - self.assertEqual(outFD2_lines.count("New string:"), 1) - self.assertEqual(outFD2_lines.count("Location start: 221"), 1) - self.assertEqual(outFD2_lines.count("Location end: 225"), 1) - outFD2.close() + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: view"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string:"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 221"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 225"), 1) + errFD2.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_data/naming_convention.sol b/utils/slither_format/tests/test_data/naming_convention.sol index 422788344..3420da1f1 100644 --- a/utils/slither_format/tests/test_data/naming_convention.sol +++ b/utils/slither_format/tests/test_data/naming_convention.sol @@ -1,4 +1,4 @@ -//pragma solidity ^0.4.24; +pragma solidity ^0.4.24; contract naming { diff --git a/utils/slither_format/tests/test_detector_combinations.py b/utils/slither_format/tests/test_detector_combinations.py index a521fec9a..c70f7e6b7 100644 --- a/utils/slither_format/tests/test_detector_combinations.py +++ b/utils/slither_format/tests/test_detector_combinations.py @@ -19,23 +19,23 @@ class TestDetectorCombinations(unittest.TestCase): p1.wait() def test_detector_combinations(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - outFD1.close() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + errFD1.close() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines.count("Number of Slither results: 12"), 1) - self.assertEqual(outFD1_lines.count("Number of patches: 19"), 1) - self.assertEqual(outFD1_lines.count("Overlapping patch won't be applied!"), 2) - self.assertEqual(outFD1_lines.count("xDetector: unused-state"), 1) - self.assertEqual(outFD1_lines.count("xDetector: constable-states"), 1) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (state variable declaration)"), 2) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (state variable uses)"), 3) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (parameter declaration)"), 4) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (parameter uses)"), 6) - self.assertEqual(outFD1_lines.count("Detector: external-function"), 2) - self.assertEqual(outFD1_lines.count("Detector: constant-function"), 1) - self.assertEqual(outFD1_lines.count("Detector: solc-version"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Number of Slither results: 12"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Number of patches: 19"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Overlapping patch won't be applied!"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: unused-state"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: constable-states"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable declaration)"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable uses)"), 3) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter declaration)"), 4) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter uses)"), 6) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: external-function"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: constant-function"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_external_function.py b/utils/slither_format/tests/test_external_function.py index 32ccdedef..1f3136114 100644 --- a/utils/slither_format/tests/test_external_function.py +++ b/utils/slither_format/tests/test_external_function.py @@ -29,44 +29,44 @@ class TestExternalFunctions(unittest.TestCase): p2.wait() def test_external_function(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 9") - self.assertEqual(outFD1_lines[1],"Number of patches: 8") - self.assertEqual(outFD1_lines.count("Detector: external-function"), 8) - self.assertEqual(outFD1_lines.count("Old string: public"), 6) - self.assertEqual(outFD1_lines.count("New string: external"), 6) - self.assertEqual(outFD1_lines.count("Location start: 384"), 1) - self.assertEqual(outFD1_lines.count("Location end: 390"), 1) - self.assertEqual(outFD1_lines.count("Location start: 562"), 1) - self.assertEqual(outFD1_lines.count("Location end: 568"), 1) - self.assertEqual(outFD1_lines.count("Location start: 642"), 1) - self.assertEqual(outFD1_lines.count("Location end: 648"), 1) - self.assertEqual(outFD1_lines.count("Location start: 685"), 1) - self.assertEqual(outFD1_lines.count("Location end: 691"), 1) - self.assertEqual(outFD1_lines.count("Location start: 1022"), 1) - self.assertEqual(outFD1_lines.count("Location end: 1028"), 1) - self.assertEqual(outFD1_lines.count("Location start: 1305"), 1) - self.assertEqual(outFD1_lines.count("Location end: 1311"), 1) - self.assertEqual(outFD1_lines.count("Old string:"), 2) - self.assertEqual(outFD1_lines.count("New string: external"), 2) - self.assertEqual(outFD1_lines.count("Location start: 524"), 1) - self.assertEqual(outFD1_lines.count("Location end: 524"), 1) - self.assertEqual(outFD1_lines.count("Location start: 1142"), 1) - self.assertEqual(outFD1_lines.count("Location end: 1142"), 1) - outFD1.close() + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 9") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 8") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: external-function"), 8) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: public"), 6) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 6) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 384"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 390"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 562"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 568"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 642"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 648"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 685"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 691"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1022"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1028"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1305"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1311"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string:"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 524"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 524"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1142"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1142"), 1) + errFD1.close() - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertFalse(os.path.isfile(self.testFilePath2+".format"),"Patched .format file _is_ created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 0") - self.assertEqual(outFD2_lines[1],"Number of patches: 0") - outFD2.close() + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 0") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 0") + errFD2.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index 178676dca..310b53a0b 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -96,314 +96,314 @@ class TestNamingConvention(unittest.TestCase): p8.wait() def test_naming_convention_contract(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - outFD1.close() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + errFD1.close() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD1_lines[1],"Number of patches: 10") - self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract definition)"), 2) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract state variable)"), 2) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract function variable)"), 5) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract new object)"), 1) - self.assertEqual(outFD1_lines.count("Old string: contract one"), 1) - self.assertEqual(outFD1_lines.count("New string: contract One"), 1) - self.assertEqual(outFD1_lines.count("Location start: 53"), 1) - self.assertEqual(outFD1_lines.count("Location end: 65"), 1) - self.assertEqual(outFD1_lines.count("Old string: three k"), 1) - self.assertEqual(outFD1_lines.count("New string: Three k"), 1) - self.assertEqual(outFD1_lines.count("Location start: 117"), 1) - self.assertEqual(outFD1_lines.count("Location end: 124"), 1) - self.assertEqual(outFD1_lines.count("Old string: three l"), 1) - self.assertEqual(outFD1_lines.count("New string: Three l"), 1) - self.assertEqual(outFD1_lines.count("Location start: 206"), 1) - self.assertEqual(outFD1_lines.count("Location end: 213"), 1) - self.assertEqual(outFD1_lines.count("Old string: one m"), 1) - self.assertEqual(outFD1_lines.count("New string: One m"), 1) - self.assertEqual(outFD1_lines.count("Location start: 343"), 1) - self.assertEqual(outFD1_lines.count("Location end: 348"), 1) - self.assertEqual(outFD1_lines.count("Old string: one n"), 1) - self.assertEqual(outFD1_lines.count("New string: One n"), 1) - self.assertEqual(outFD1_lines.count("Location start: 423"), 1) - self.assertEqual(outFD1_lines.count("Location end: 428"), 1) - self.assertEqual(outFD1_lines.count("Old string: contract three"), 1) - self.assertEqual(outFD1_lines.count("New string: contract Three"), 1) - self.assertEqual(outFD1_lines.count("Location start: 498"), 1) - self.assertEqual(outFD1_lines.count("Location end: 512"), 1) - self.assertEqual(outFD1_lines.count("Old string: one"), 1) - self.assertEqual(outFD1_lines.count("New string: One"), 1) - self.assertEqual(outFD1_lines.count("Location start: 646"), 1) - self.assertEqual(outFD1_lines.count("Location end: 649"), 1) - self.assertEqual(outFD1_lines.count("Old string: one r = new one()"), 1) - self.assertEqual(outFD1_lines.count("New string: One r = new one()"), 1) - self.assertEqual(outFD1_lines.count("Location start: 773"), 1) - self.assertEqual(outFD1_lines.count("Location end: 790"), 1) - self.assertEqual(outFD1_lines.count("Old string: one q"), 1) - self.assertEqual(outFD1_lines.count("New string: One q"), 1) - self.assertEqual(outFD1_lines.count("Location start: 871"), 1) - self.assertEqual(outFD1_lines.count("Location end: 876"), 1) - self.assertEqual(outFD1_lines.count("Old string: new one()"), 1) - self.assertEqual(outFD1_lines.count("New string: new One()"), 1) - self.assertEqual(outFD1_lines.count("Location start: 781"), 1) - self.assertEqual(outFD1_lines.count("Location end: 788"), 1) + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 10") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract definition)"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract state variable)"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract function variable)"), 5) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract new object)"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: contract one"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: contract One"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 53"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 65"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: three k"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: Three k"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 117"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 124"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: three l"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: Three l"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 206"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 213"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one m"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One m"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 343"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 348"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one n"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One n"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 423"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 428"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: contract three"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: contract Three"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 498"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 512"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 646"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 649"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one r = new one()"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One r = new one()"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 773"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 790"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one q"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One q"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 871"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 876"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: new one()"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: new One()"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 781"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 788"), 1) def test_naming_convention_modifier(self): - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - outFD2.close() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + errFD2.close() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD2_lines[1],"Number of patches: 5") - self.assertEqual(outFD2_lines.count("Detector: naming-convention (modifier definition)"), 2) - self.assertEqual(outFD2_lines.count("Detector: naming-convention (modifier uses)"), 3) - self.assertEqual(outFD2_lines.count("Old string: modifier One"), 1) - self.assertEqual(outFD2_lines.count("New string: modifier one"), 1) - self.assertEqual(outFD2_lines.count("Location start: 215"), 1) - self.assertEqual(outFD2_lines.count("Location end: 227"), 1) - self.assertEqual(outFD2_lines.count("Old string: () One"), 1) - self.assertEqual(outFD2_lines.count("New string: () one"), 1) - self.assertEqual(outFD2_lines.count("Location start: 288"), 1) - self.assertEqual(outFD2_lines.count("Location end: 295"), 1) - self.assertEqual(outFD2_lines.count("Old string: modifier Two"), 1) - self.assertEqual(outFD2_lines.count("New string: modifier two"), 1) - self.assertEqual(outFD2_lines.count("Location start: 423"), 1) - self.assertEqual(outFD2_lines.count("Location end: 435"), 1) - self.assertEqual(outFD2_lines.count("Old string: () one Two returns"), 2) - self.assertEqual(outFD2_lines.count("New string: () one two returns"), 2) - self.assertEqual(outFD2_lines.count("Location start: 503"), 1) - self.assertEqual(outFD2_lines.count("Location end: 522"), 1) - self.assertEqual(outFD2_lines.count("Location start: 718"), 1) - self.assertEqual(outFD2_lines.count("Location end: 737"), 1) + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 5") + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: naming-convention (modifier definition)"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: naming-convention (modifier uses)"), 3) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: modifier One"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: modifier one"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 215"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 227"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: () One"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: () one"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 288"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 295"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: modifier Two"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: modifier two"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 423"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 435"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: () one Two returns"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: () one two returns"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 503"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 522"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 718"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 737"), 1) def test_naming_convention_structure(self): - outFD3 = open(self.testFilePath3+".out","r") - outFD3_lines = outFD3.readlines() - outFD3.close() - for i in range(len(outFD3_lines)): - outFD3_lines[i] = outFD3_lines[i].strip() + errFD3 = open(self.testFilePath3+".err","r") + errFD3_lines = errFD3.readlines() + errFD3.close() + for i in range(len(errFD3_lines)): + errFD3_lines[i] = errFD3_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath3+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD3_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD3_lines[1],"Number of patches: 8") - self.assertEqual(outFD3_lines.count("Detector: naming-convention (struct definition)"), 2) - self.assertEqual(outFD3_lines.count("Detector: naming-convention (struct use)"), 6) - self.assertEqual(outFD3_lines.count("Old string: struct s { uint i; }"), 2) - self.assertEqual(outFD3_lines.count("New string: struct S { uint i; }"), 2) - self.assertEqual(outFD3_lines.count("Location start: 108"), 1) - self.assertEqual(outFD3_lines.count("Location end: 134"), 1) - self.assertEqual(outFD3_lines.count("Location start: 434"), 1) - self.assertEqual(outFD3_lines.count("Location end: 460"), 1) - self.assertEqual(outFD3_lines.count("Old string: s s1"), 2) - self.assertEqual(outFD3_lines.count("New string: S s1"), 2) - self.assertEqual(outFD3_lines.count("Location start: 171"), 1) - self.assertEqual(outFD3_lines.count("Location end: 175"), 1) - self.assertEqual(outFD3_lines.count("Location start: 497"), 1) - self.assertEqual(outFD3_lines.count("Location end: 501"), 1) - self.assertEqual(outFD3_lines.count("Old string: s sA"), 2) - self.assertEqual(outFD3_lines.count("New string: S sA"), 2) - self.assertEqual(outFD3_lines.count("Location start: 570"), 1) - self.assertEqual(outFD3_lines.count("Location end: 574"), 1) - self.assertEqual(outFD3_lines.count("Location start: 715"), 1) - self.assertEqual(outFD3_lines.count("Location end: 719"), 1) - self.assertEqual(outFD3_lines.count("Old string: s"), 2) - self.assertEqual(outFD3_lines.count("New string: S"), 2) - self.assertEqual(outFD3_lines.count("Location start: 585"), 1) - self.assertEqual(outFD3_lines.count("Location end: 586"), 1) - self.assertEqual(outFD3_lines.count("Location start: 730"), 1) - self.assertEqual(outFD3_lines.count("Location end: 731"), 1) + self.assertEqual(errFD3_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD3_lines[1],"INFO:Slither.Format:Number of patches: 8") + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Detector: naming-convention (struct definition)"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Detector: naming-convention (struct use)"), 6) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: struct s { uint i; }"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: struct S { uint i; }"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 108"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 134"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 434"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 460"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: s s1"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: S s1"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 171"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 175"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 497"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 501"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: s sA"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: S sA"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 570"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 574"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 715"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 719"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: s"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: S"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 585"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 586"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 730"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 731"), 1) def test_naming_convention_enum(self): - outFD4 = open(self.testFilePath4+".out","r") - outFD4_lines = outFD4.readlines() - outFD4.close() - for i in range(len(outFD4_lines)): - outFD4_lines[i] = outFD4_lines[i].strip() + errFD4 = open(self.testFilePath4+".err","r") + errFD4_lines = errFD4.readlines() + errFD4.close() + for i in range(len(errFD4_lines)): + errFD4_lines[i] = errFD4_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath4+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD4_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD4_lines[1],"Number of patches: 11") - self.assertEqual(outFD4_lines.count("Detector: naming-convention (enum definition)"), 2) - self.assertEqual(outFD4_lines.count("Detector: naming-convention (enum use)"), 9) - self.assertEqual(outFD4_lines.count("Old string: enum e {ONE, TWO}"), 2) - self.assertEqual(outFD4_lines.count("New string: enum E {ONE, TWO}"), 2) - self.assertEqual(outFD4_lines.count("Location start: 73"), 1) - self.assertEqual(outFD4_lines.count("Location end: 90"), 1) - self.assertEqual(outFD4_lines.count("Location start: 426"), 1) - self.assertEqual(outFD4_lines.count("Location end: 443"), 1) - self.assertEqual(outFD4_lines.count("Old string: e e1"), 2) - self.assertEqual(outFD4_lines.count("New string: E e1"), 2) - self.assertEqual(outFD4_lines.count("Location start: 125"), 1) - self.assertEqual(outFD4_lines.count("Location end: 129"), 1) - self.assertEqual(outFD4_lines.count("Location start: 478"), 1) - self.assertEqual(outFD4_lines.count("Location end: 482"), 1) - self.assertEqual(outFD4_lines.count("Old string: e eA"), 2) - self.assertEqual(outFD4_lines.count("New string: E eA"), 2) - self.assertEqual(outFD4_lines.count("Location start: 549"), 1) - self.assertEqual(outFD4_lines.count("Location end: 553"), 1) - self.assertEqual(outFD4_lines.count("Location start: 690"), 1) - self.assertEqual(outFD4_lines.count("Location end: 694"), 1) - self.assertEqual(outFD4_lines.count("Old string: e e2 = eA"), 2) - self.assertEqual(outFD4_lines.count("New string: E e2 = eA"), 2) - self.assertEqual(outFD4_lines.count("Location start: 573"), 1) - self.assertEqual(outFD4_lines.count("Location end: 582"), 1) - self.assertEqual(outFD4_lines.count("Location start: 714"), 1) - self.assertEqual(outFD4_lines.count("Location end: 723"), 1) - self.assertEqual(outFD4_lines.count("Old string: e.ONE"), 1) - self.assertEqual(outFD4_lines.count("New string: E.ONE"), 1) - self.assertEqual(outFD4_lines.count("Location start: 186"), 1) - self.assertEqual(outFD4_lines.count("Location end: 192"), 1) - self.assertEqual(outFD4_lines.count("Old string: e"), 2) - self.assertEqual(outFD4_lines.count("New string: E"), 2) - self.assertEqual(outFD4_lines.count("Location start: 564"), 1) - self.assertEqual(outFD4_lines.count("Location end: 565"), 1) - self.assertEqual(outFD4_lines.count("Location start: 705"), 1) - self.assertEqual(outFD4_lines.count("Location end: 706"), 1) + self.assertEqual(errFD4_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD4_lines[1],"INFO:Slither.Format:Number of patches: 11") + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Detector: naming-convention (enum definition)"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Detector: naming-convention (enum use)"), 9) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: enum e {ONE, TWO}"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: enum E {ONE, TWO}"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 73"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 90"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 426"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 443"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e e1"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E e1"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 125"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 129"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 478"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 482"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e eA"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E eA"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 549"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 553"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 690"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 694"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e e2 = eA"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E e2 = eA"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 573"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 582"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 714"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 723"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e.ONE"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E.ONE"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 186"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 192"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 564"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 565"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 705"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 706"), 1) def test_naming_convention_event(self): - outFD5 = open(self.testFilePath5+".out","r") - outFD5_lines = outFD5.readlines() - outFD5.close() - for i in range(len(outFD5_lines)): - outFD5_lines[i] = outFD5_lines[i].strip() + errFD5 = open(self.testFilePath5+".err","r") + errFD5_lines = errFD5.readlines() + errFD5.close() + for i in range(len(errFD5_lines)): + errFD5_lines[i] = errFD5_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath5+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD5_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD5_lines[1],"Number of patches: 5") - self.assertEqual(outFD5_lines.count("Detector: naming-convention (event definition)"), 2) - self.assertEqual(outFD5_lines.count("Detector: naming-convention (event calls)"), 3) - self.assertEqual(outFD5_lines.count("Old string: event e(uint);"), 2) - self.assertEqual(outFD5_lines.count("New string: event E(uint);"), 2) - self.assertEqual(outFD5_lines.count("Location start: 75"), 1) - self.assertEqual(outFD5_lines.count("Location end: 89"), 1) - self.assertEqual(outFD5_lines.count("Location start: 148"), 1) - self.assertEqual(outFD5_lines.count("Location end: 152"), 1) - self.assertEqual(outFD5_lines.count("Old string: e(i)"), 3) - self.assertEqual(outFD5_lines.count("New string: E(i)"), 3) - self.assertEqual(outFD5_lines.count("Location start: 148"), 1) - self.assertEqual(outFD5_lines.count("Location end: 152"), 1) - self.assertEqual(outFD5_lines.count("Location start: 438"), 1) - self.assertEqual(outFD5_lines.count("Location end: 442"), 1) - self.assertEqual(outFD5_lines.count("Location start: 550"), 1) - self.assertEqual(outFD5_lines.count("Location end: 554"), 1) + self.assertEqual(errFD5_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD5_lines[1],"INFO:Slither.Format:Number of patches: 5") + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Detector: naming-convention (event definition)"), 2) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Detector: naming-convention (event calls)"), 3) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Old string: event e(uint);"), 2) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:New string: event E(uint);"), 2) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 75"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 89"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 148"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 152"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Old string: e(i)"), 3) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:New string: E(i)"), 3) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 148"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 152"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 438"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 442"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 550"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 554"), 1) def test_naming_convention_function(self): - outFD6 = open(self.testFilePath6+".out","r") - outFD6_lines = outFD6.readlines() - outFD6.close() - for i in range(len(outFD6_lines)): - outFD6_lines[i] = outFD6_lines[i].strip() + errFD6 = open(self.testFilePath6+".err","r") + errFD6_lines = errFD6.readlines() + errFD6.close() + for i in range(len(errFD6_lines)): + errFD6_lines[i] = errFD6_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath6+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD6_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD6_lines[1],"Number of patches: 4") - self.assertEqual(outFD6_lines.count("Detector: naming-convention (function definition)"), 2) - self.assertEqual(outFD6_lines.count("Detector: naming-convention (function calls)"), 2) - self.assertEqual(outFD6_lines.count("Old string: function Foo"), 1) - self.assertEqual(outFD6_lines.count("New string: function foo"), 1) - self.assertEqual(outFD6_lines.count("Location start: 76"), 1) - self.assertEqual(outFD6_lines.count("Location end: 88"), 1) - self.assertEqual(outFD6_lines.count("Old string: function Foobar"), 1) - self.assertEqual(outFD6_lines.count("New string: function foobar"), 1) - self.assertEqual(outFD6_lines.count("Location start: 189"), 1) - self.assertEqual(outFD6_lines.count("Location end: 204"), 1) - self.assertEqual(outFD6_lines.count("Old string: Foobar(10)"), 1) - self.assertEqual(outFD6_lines.count("New string: foobar(10)"), 1) - self.assertEqual(outFD6_lines.count("Location start: 136"), 1) - self.assertEqual(outFD6_lines.count("Location end: 146"), 1) - self.assertEqual(outFD6_lines.count("Old string: a.Foobar(10)"), 1) - self.assertEqual(outFD6_lines.count("New string: a.foobar(10)"), 1) - self.assertEqual(outFD6_lines.count("Location start: 516"), 1) - self.assertEqual(outFD6_lines.count("Location end: 528"), 1) + self.assertEqual(errFD6_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD6_lines[1],"INFO:Slither.Format:Number of patches: 4") + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Detector: naming-convention (function definition)"), 2) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Detector: naming-convention (function calls)"), 2) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: function Foo"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: function foo"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 76"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 88"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: function Foobar"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: function foobar"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 189"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 204"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: Foobar(10)"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: foobar(10)"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 136"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 146"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: a.Foobar(10)"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: a.foobar(10)"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 516"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 528"), 1) def test_naming_convention_parameter(self): - outFD7 = open(self.testFilePath7+".out","r") - outFD7_lines = outFD7.readlines() - outFD7.close() - for i in range(len(outFD7_lines)): - outFD7_lines[i] = outFD7_lines[i].strip() + errFD7 = open(self.testFilePath7+".err","r") + errFD7_lines = errFD7.readlines() + errFD7.close() + for i in range(len(errFD7_lines)): + errFD7_lines[i] = errFD7_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath7+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD7_lines[0],"Number of Slither results: 6") - self.assertEqual(outFD7_lines[1],"Number of patches: 12") - self.assertEqual(outFD7_lines.count("Detector: naming-convention (parameter declaration)"), 6) - self.assertEqual(outFD7_lines.count("Detector: naming-convention (parameter uses)"), 6) - self.assertEqual(outFD7_lines.count("Old string: uint Count"), 3) - self.assertEqual(outFD7_lines.count("New string: uint _Count"), 3) - self.assertEqual(outFD7_lines.count("Location start: 91"), 1) - self.assertEqual(outFD7_lines.count("Location end: 101"), 1) - self.assertEqual(outFD7_lines.count("Location start: 215"), 1) - self.assertEqual(outFD7_lines.count("Location end: 225"), 1) - self.assertEqual(outFD7_lines.count("Old string: Count"), 3) - self.assertEqual(outFD7_lines.count("New string: _Count"), 3) - self.assertEqual(outFD7_lines.count("Location start: 148"), 1) - self.assertEqual(outFD7_lines.count("Location end: 153"), 1) - self.assertEqual(outFD7_lines.count("Location start: 308"), 1) - self.assertEqual(outFD7_lines.count("Location end: 313"), 1) - self.assertEqual(outFD7_lines.count("Location start: 489"), 1) - self.assertEqual(outFD7_lines.count("Location end: 499"), 1) - self.assertEqual(outFD7_lines.count("Location start: 580"), 1) - self.assertEqual(outFD7_lines.count("Location end: 585"), 1) - self.assertEqual(outFD7_lines.count("Old string: Count)"), 1) - self.assertEqual(outFD7_lines.count("New string: _Count)"), 1) - self.assertEqual(outFD7_lines.count("Location start: 506"), 1) - self.assertEqual(outFD7_lines.count("Location end: 512"), 1) - self.assertEqual(outFD7_lines.count("Old string: uint Number"), 1) - self.assertEqual(outFD7_lines.count("New string: uint _Number"), 1) - self.assertEqual(outFD7_lines.count("Location start: 227"), 1) - self.assertEqual(outFD7_lines.count("Location end: 238"), 1) - self.assertEqual(outFD7_lines.count("Old string: Number"), 1) - self.assertEqual(outFD7_lines.count("New string: _Number"), 1) - self.assertEqual(outFD7_lines.count("Location start: 314"), 1) - self.assertEqual(outFD7_lines.count("Location end: 320"), 1) - self.assertEqual(outFD7_lines.count("Old string: address _to"), 1) - self.assertEqual(outFD7_lines.count("New string: address _To"), 1) - self.assertEqual(outFD7_lines.count("Location start: 708"), 1) - self.assertEqual(outFD7_lines.count("Location end: 719"), 1) - self.assertEqual(outFD7_lines.count("Old string: address _from"), 1) - self.assertEqual(outFD7_lines.count("New string: address _From"), 1) - self.assertEqual(outFD7_lines.count("Location start: 721"), 1) - self.assertEqual(outFD7_lines.count("Location end: 734"), 1) - self.assertEqual(outFD7_lines.count("Old string: _to"), 1) - self.assertEqual(outFD7_lines.count("New string: _To"), 1) - self.assertEqual(outFD7_lines.count("Location start: 811"), 1) - self.assertEqual(outFD7_lines.count("Location end: 814"), 1) - self.assertEqual(outFD7_lines.count("Old string: _from"), 1, "Index variables of writes are not captured by node._expression_vars_read of Slither") - self.assertEqual(outFD7_lines.count("New string: _From"), 1) + self.assertEqual(errFD7_lines[0],"INFO:Slither.Format:Number of Slither results: 6") + self.assertEqual(errFD7_lines[1],"INFO:Slither.Format:Number of patches: 12") + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter declaration)"), 6) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter uses)"), 6) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: uint Count"), 3) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: uint _Count"), 3) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 91"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 101"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 215"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 225"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: Count"), 3) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _Count"), 3) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 148"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 153"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 308"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 313"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 489"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 499"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 580"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 585"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: Count)"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _Count)"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 506"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 512"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: uint Number"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: uint _Number"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 227"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 238"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: Number"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _Number"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 314"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 320"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: address _to"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: address _To"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 708"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 719"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: address _from"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: address _From"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 721"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 734"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: _to"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _To"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 811"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 814"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: _from"), 1, "Index variables of writes are not captured by node._expression_vars_read of Slither") + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _From"), 1) def test_naming_convention_state_variable(self): - outFD8 = open(self.testFilePath8+".out","r") - outFD8_lines = outFD8.readlines() - outFD8.close() - for i in range(len(outFD8_lines)): - outFD8_lines[i] = outFD8_lines[i].strip() + errFD8 = open(self.testFilePath8+".err","r") + errFD8_lines = errFD8.readlines() + errFD8.close() + for i in range(len(errFD8_lines)): + errFD8_lines[i] = errFD8_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath8+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD8_lines[0],"Number of Slither results: 3") - self.assertEqual(outFD8_lines[1],"Number of patches: 9") - self.assertEqual(outFD8_lines.count("Detector: naming-convention (state variable declaration)"), 3) - self.assertEqual(outFD8_lines.count("Detector: naming-convention (state variable uses)"), 6) - self.assertEqual(outFD8_lines.count("Old string: number"), 3) - self.assertEqual(outFD8_lines.count("New string: NUMBER"), 3) - self.assertEqual(outFD8_lines.count("Location start: 469"), 1) - self.assertEqual(outFD8_lines.count("Location end: 475"), 1) - self.assertEqual(outFD8_lines.count("Location start: 716"), 1) - self.assertEqual(outFD8_lines.count("Location end: 722"), 1) - self.assertEqual(outFD8_lines.count("Location start: 850"), 1) - self.assertEqual(outFD8_lines.count("Location end: 856"), 1) - self.assertEqual(outFD8_lines.count("Old string: Count"), 3) - self.assertEqual(outFD8_lines.count("New string: count"), 3) - self.assertEqual(outFD8_lines.count("Location start: 547"), 1) - self.assertEqual(outFD8_lines.count("Location end: 552"), 1) - self.assertEqual(outFD8_lines.count("Location start: 725"), 1) - self.assertEqual(outFD8_lines.count("Location end: 730"), 1) - self.assertEqual(outFD8_lines.count("Location start: 745"), 1) - self.assertEqual(outFD8_lines.count("Location end: 750"), 1) - self.assertEqual(outFD8_lines.count("Old string: Maxnum"), 3) - self.assertEqual(outFD8_lines.count("New string: maxnum"), 3) - self.assertEqual(outFD8_lines.count("Location start: 634"), 1) - self.assertEqual(outFD8_lines.count("Location end: 640"), 1) - self.assertEqual(outFD8_lines.count("Location start: 733"), 1) - self.assertEqual(outFD8_lines.count("Location end: 739"), 1) - self.assertEqual(outFD8_lines.count("Location start: 859"), 1) - self.assertEqual(outFD8_lines.count("Location end: 865"), 1) + self.assertEqual(errFD8_lines[0],"INFO:Slither.Format:Number of Slither results: 3") + self.assertEqual(errFD8_lines[1],"INFO:Slither.Format:Number of patches: 9") + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable declaration)"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable uses)"), 6) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Old string: number"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:New string: NUMBER"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 469"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 475"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 716"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 722"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 850"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 856"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Old string: Count"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:New string: count"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 547"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 552"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 725"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 730"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 745"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 750"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Old string: Maxnum"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:New string: maxnum"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 634"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 640"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 733"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 739"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 859"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 865"), 1) if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_pragma.py b/utils/slither_format/tests/test_pragma.py index ea9ec60b4..70e0b7194 100644 --- a/utils/slither_format/tests/test_pragma.py +++ b/utils/slither_format/tests/test_pragma.py @@ -37,35 +37,35 @@ class TestPragma(unittest.TestCase): p2.wait() def test_pragma(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD1_lines[1],"Number of patches: 2") - self.assertEqual(outFD1_lines.count("Detector: pragma"), 2) - self.assertEqual(outFD1_lines.count("Old string: pragma solidity ^0.4.23;"), 1) - self.assertEqual(outFD1_lines.count("Old string: pragma solidity ^0.4.24;"), 1) - self.assertEqual(outFD1_lines.count("New string: pragma solidity 0.4.25;"), 2) - self.assertEqual(outFD1_lines.count("Location start: 0"), 2) - self.assertEqual(outFD1_lines.count("Location end: 24"), 2) - outFD1.close() + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 2") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: pragma"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.4.23;"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.4.24;"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: pragma solidity 0.4.25;"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 0"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 24"), 2) + errFD1.close() - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD2_lines[1],"Number of patches: 2") - self.assertEqual(outFD2_lines.count("Detector: pragma"), 2) - self.assertEqual(outFD2_lines.count("Old string: pragma solidity ^0.5.4;"), 1) - self.assertEqual(outFD2_lines.count("Old string: pragma solidity ^0.5.2;"), 1) - self.assertEqual(outFD2_lines.count("New string: pragma solidity 0.5.3;"), 2) - self.assertEqual(outFD2_lines.count("Location start: 0"), 2) - self.assertEqual(outFD2_lines.count("Location end: 23"), 2) - outFD2.close() + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 2") + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: pragma"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.5.4;"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.5.2;"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: pragma solidity 0.5.3;"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 0"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 23"), 2) + errFD2.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_solc_version.py b/utils/slither_format/tests/test_solc_version.py index 16a9ea34a..45b51d95c 100644 --- a/utils/slither_format/tests/test_solc_version.py +++ b/utils/slither_format/tests/test_solc_version.py @@ -54,61 +54,61 @@ class TestSolcVersion(unittest.TestCase): p4.wait() def test_solc_version(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD1_lines[1],"Number of patches: 1") - self.assertEqual(outFD1_lines.count("Detector: solc-version"), 1) - self.assertEqual(outFD1_lines.count("Old string: pragma solidity ^0.4.23;"), 1) - self.assertEqual(outFD1_lines.count("New string: pragma solidity 0.4.25;"), 1) - self.assertEqual(outFD1_lines.count("Location start: 63"), 1) - self.assertEqual(outFD1_lines.count("Location end: 87"), 1) - outFD1.close() + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.4.23;"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: pragma solidity 0.4.25;"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 63"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 87"), 1) + errFD1.close() - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD2_lines[1],"Number of patches: 1") - self.assertEqual(outFD2_lines.count("Detector: solc-version"), 1) - self.assertEqual(outFD2_lines.count("Old string: pragma solidity >=0.4.0 <0.6.0;"), 1) - self.assertEqual(outFD2_lines.count("New string: pragma solidity 0.5.3;"), 1) - self.assertEqual(outFD2_lines.count("Location start: 63"), 1) - self.assertEqual(outFD2_lines.count("Location end: 94"), 1) - outFD2.close() + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: pragma solidity >=0.4.0 <0.6.0;"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: pragma solidity 0.5.3;"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 63"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 94"), 1) + errFD2.close() - outFD3 = open(self.testFilePath3+".out","r") - outFD3_lines = outFD3.readlines() - for i in range(len(outFD3_lines)): - outFD3_lines[i] = outFD3_lines[i].strip() + errFD3 = open(self.testFilePath3+".err","r") + errFD3_lines = errFD3.readlines() + for i in range(len(errFD3_lines)): + errFD3_lines[i] = errFD3_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath3+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD3_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD3_lines[1],"Number of patches: 1") - self.assertEqual(outFD3_lines.count("Detector: solc-version"), 1) - self.assertEqual(outFD3_lines.count("Old string: pragma solidity >=0.4.0 <0.4.25;"), 1) - self.assertEqual(outFD3_lines.count("New string: pragma solidity 0.4.25;"), 1) - self.assertEqual(outFD3_lines.count("Location start: 63"), 1) - self.assertEqual(outFD3_lines.count("Location end: 95"), 1) - outFD3.close() + self.assertEqual(errFD3_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD3_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: pragma solidity >=0.4.0 <0.4.25;"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: pragma solidity 0.4.25;"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 63"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 95"), 1) + errFD3.close() - outFD4 = open(self.testFilePath4+".out","r") - outFD4_lines = outFD4.readlines() - for i in range(len(outFD4_lines)): - outFD4_lines[i] = outFD4_lines[i].strip() + errFD4 = open(self.testFilePath4+".err","r") + errFD4_lines = errFD4.readlines() + for i in range(len(errFD4_lines)): + errFD4_lines[i] = errFD4_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath4+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD4_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD4_lines[1],"Number of patches: 1") - self.assertEqual(outFD4_lines.count("Detector: solc-version"), 1) - self.assertEqual(outFD4_lines.count("Old string: pragma solidity ^0.5.1;"), 1) - self.assertEqual(outFD4_lines.count("New string: pragma solidity 0.5.3;"), 1) - self.assertEqual(outFD4_lines.count("Location start: 63"), 1) - self.assertEqual(outFD4_lines.count("Location end: 86"), 1) - outFD4.close() + self.assertEqual(errFD4_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD4_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.5.1;"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: pragma solidity 0.5.3;"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 63"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 86"), 1) + errFD4.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_unused_state_vars.py b/utils/slither_format/tests/test_unused_state_vars.py index d290fc38a..c5ec2011e 100644 --- a/utils/slither_format/tests/test_unused_state_vars.py +++ b/utils/slither_format/tests/test_unused_state_vars.py @@ -19,19 +19,19 @@ class TestUnusedStateVars(unittest.TestCase): p.wait() def test_unused_state_vars(self): - outFD = open(self.testFilePath+".out","r") - outFD_lines = outFD.readlines() - for i in range(len(outFD_lines)): - outFD_lines[i] = outFD_lines[i].strip() + errFD = open(self.testFilePath+".err","r") + errFD_lines = errFD.readlines() + for i in range(len(errFD_lines)): + errFD_lines[i] = errFD_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD_lines[0].rstrip(),"Number of Slither results: 1") - self.assertEqual(outFD_lines[1].rstrip(),"Number of patches: 1") - self.assertEqual(outFD_lines.count("Detector: unused-state"), 1) - self.assertEqual(outFD_lines.count("Old string: address unused ;"), 1) - self.assertEqual(outFD_lines.count("New string:"), 1) - self.assertEqual(outFD_lines.count("Location start: 44"), 1) - self.assertEqual(outFD_lines.count("Location end: 63"), 1) - outFD.close() + self.assertEqual(errFD_lines[0].rstrip(),"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD_lines[1].rstrip(),"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Detector: unused-state"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: address unused ;"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string:"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 44"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 63"), 1) + errFD.close() if __name__ == '__main__': unittest.main()