TheDude
/
slither
mirror of https://github.com/crytic/slither
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Enables logging.

Browse Source
pull/238/head
rajeevgopalakrishna 6 years ago
parent fda131811e
commit 99c1fcdd10
16 changed files with 562 additions and 547 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 9
      utils/slither_format/format_constable_states.py
  2. 9
      utils/slither_format/format_constant_function.py
  3. 7
      utils/slither_format/format_external_function.py
  4. 57
      utils/slither_format/format_naming_convention.py
  5. 11
      utils/slither_format/format_pragma.py
  6. 9
      utils/slither_format/format_solc_version.py
  7. 37
      utils/slither_format/slither_format.py
  8. 64
      utils/slither_format/tests/test_constable_states.py
  9. 56
      utils/slither_format/tests/test_constant_function.py
  10. 2
      utils/slither_format/tests/test_data/naming_convention.sol
  11. 34
      utils/slither_format/tests/test_detector_combinations.py
  12. 70
      utils/slither_format/tests/test_external_function.py
  13. 572
      utils/slither_format/tests/test_naming_convention.py
  14. 52
      utils/slither_format/tests/test_pragma.py
  15. 96
      utils/slither_format/tests/test_solc_version.py
  16. 24
      utils/slither_format/tests/test_unused_state_vars.py

9
utils/slither_format/format_constable_states.py
Unescape View File

@ -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)

9
utils/slither_format/format_constant_function.py
Unescape View File

@ -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)

7
utils/slither_format/format_external_function.py
Unescape View File

@ -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:

57
utils/slither_format/format_naming_convention.py
Unescape View File

@ -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

11
utils/slither_format/format_pragma.py
Unescape View File

@ -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]

9
utils/slither_format/format_solc_version.py
Unescape View File

@ -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]

37
utils/slither_format/slither_format.py
Unescape View File

@ -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):

64
utils/slither_format/tests/test_constable_states.py
Unescape View File

@ -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()

56
utils/slither_format/tests/test_constant_function.py
Unescape View File

@ -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()

2
utils/slither_format/tests/test_data/naming_convention.sol
Unescape View File

@ -1,4 +1,4 @@
//pragma solidity ^0.4.24;
pragma solidity ^0.4.24;
contract naming {

34
utils/slither_format/tests/test_detector_combinations.py
Unescape View File

@ -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()

70
utils/slither_format/tests/test_external_function.py
Unescape View File

@ -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()

572
utils/slither_format/tests/test_naming_convention.py
Unescape View File

@ -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()

52
utils/slither_format/tests/test_pragma.py
Unescape View File

@ -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()

96
utils/slither_format/tests/test_solc_version.py
Unescape View File

@ -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()

24
utils/slither_format/tests/test_unused_state_vars.py
Unescape View File

@ -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()

Write Preview
Loading…
Cancel
Save