def test_process_conditional_reset(self): parser = BaseParser("") # test reset self.assertTrue(parser.ProcessConditional("!IF FALSE")) parser.ResetParserState() self.assertTrue(parser.InActiveCode()) self.assertEqual(len(parser.ConditionalStack), 0)
def test_replace_macro_using_dollarsign(self): parser = BaseParser("") parser.SetInputVars({ "name": "sean" }) line = "Hello $(name)!" self.assertEqual(parser.ReplaceVariables(line), "Hello sean!")
def test_write_lines(self): parser = BaseParser("") parser.Lines = ["hello"] root_path = tempfile.mkdtemp() file_path = os.path.join(root_path, "lines.txt") parser.WriteLinesToFile(file_path) self.assertTrue(os.path.exists(file_path))
def test_process_conditional_variables(self): parser = BaseParser("") # check variables with self.assertRaises(RuntimeError): parser.ProcessConditional("!ifdef") with self.assertRaises(RuntimeError): parser.ProcessConditional("!ifndef")
def test_process_conditional_non_numerical(self): parser = BaseParser("") # check non numerical values with self.assertRaises(ValueError): parser.ProcessConditional("!IF ROCKETSHIP > 50") with self.assertRaises(ValueError): parser.ProcessConditional("!if 50 < ROCKETSHIPS")
def test_process_garbage_input(self): parser = BaseParser("") # make sure we fail the garbage input conditional_count = len(parser.ConditionalStack) self.assertFalse(parser.ProcessConditional("GARBAGE INPUT")) # make sure our count didn't change self.assertEqual(len(parser.ConditionalStack), conditional_count)
def test_replace_macro_without_resolution(self): parser = BaseParser("") parser.SetInputVars({ "name": "sean" }) line = "!if $(Unknown_Token)!" self.assertEqual(parser.ReplaceVariables(line), "!if 0!")
def test_emulator_conditional_not_or(self): ''' Makes sure we can use the not with other operators ''' parser = BaseParser("") self.assertTrue(parser.EvaluateConditional('!if FALSE NOT OR FALSE')) self.assertFalse(parser.EvaluateConditional('!if TRUE NOT OR FALSE')) self.assertFalse(parser.EvaluateConditional('!if FALSE NOT OR TRUE')) self.assertFalse(parser.EvaluateConditional('!if TRUE NOT OR TRUE'))
def test_emulator_conditional_parens_order(self): ''' Makes sure the parenthesis affect the order of expressions ''' parser = BaseParser("") self.assertFalse( parser.EvaluateConditional('!if TRUE OR FALSE AND FALSE')) self.assertTrue( parser.EvaluateConditional('!if TRUE OR (FALSE AND FALSE)')) parser.ResetParserState()
def test_process_bad_endif(self): parser = BaseParser("") # check to make sure we can't do a malformed endif with self.assertRaises(RuntimeError): self.assertTrue(parser.ProcessConditional("!endif test")) # try to pop the empty stack with self.assertRaises(IndexError): self.assertTrue(parser.ProcessConditional("!endif"))
def test_replace_macro_local_var_priority(self): parser = BaseParser("") parser.SetInputVars({ "name": "sean" }) parser.LocalVars["name"] = "fred" line = "Hello $(name)!" self.assertEqual(parser.ReplaceVariables(line), "Hello fred!")
def test_replace_macro_elseif(self): parser = BaseParser("") parser.SetInputVars({"name": "matt"}) line = "!elseif $(name)" self.assertEqual(parser.ReplaceVariables(line), "!elseif matt") line = "!ELSEIF $(Invalid_Token)" self.assertEqual(parser.ReplaceVariables(line), "!ELSEIF 0")
def test_process_extra_tokens(self): parser = BaseParser("") # make sure we can't do 5 tokens with self.assertRaises(RuntimeError): parser.ProcessConditional("!if 3 == 6 ==") # make sure we can't do three tokens with self.assertRaises(RuntimeError): parser.ProcessConditional("!if 3 ==")
def test_emulator_conditional_or_double_in(self): parser = BaseParser("") parser.SetInputVars({"ARCH": "X64"}) self.assertTrue(parser.ProcessConditional( '!if "IA32" in $(ARCH) || "X64" in $(ARCH)')) self.assertTrue(parser.InActiveCode()) parser.ResetParserState() parser.SetInputVars({"ARCH": "IA32"}) self.assertTrue(parser.ProcessConditional( '!if "IA32" in $(ARCH) || "X64" in $(ARCH)')) self.assertTrue(parser.InActiveCode()) parser.ResetParserState()
def test_conditional_ifndef(self): parser = BaseParser("") # simple confirmation of expected behavior # don't need to test VariableReplacement # that is done in the tests replace methods self.assertTrue(parser.InActiveCode()) parser.ProcessConditional("!ifndef 0") self.assertTrue(parser.InActiveCode()) parser.PopConditional() self.assertTrue(parser.InActiveCode()) parser.ProcessConditional("!ifndef blahblah") self.assertFalse(parser.InActiveCode()) parser.PopConditional()
def test_process_conditional_not_equals_true_false(self): parser = BaseParser("") # check != with true and false self.assertTrue(parser.ProcessConditional("!IF RACECAR != RACECAR")) self.assertFalse(parser.InActiveCode()) self.assertTrue(parser.ProcessConditional("!EnDiF")) self.assertTrue(parser.ProcessConditional("!IF false != FALSE")) self.assertFalse(parser.InActiveCode()) self.assertTrue(parser.ProcessConditional("!EnDiF"))
def test_emulator_conditional_not_it_all(self): ''' Makes sure the parenthesis affect the order of expressions ''' parser = BaseParser("") self.assertTrue(parser.EvaluateConditional('!if NOT FALSE OR FALSE')) self.assertFalse(parser.EvaluateConditional('!if NOT TRUE OR FALSE')) # check to make sure it works with parenthesis self.assertFalse(parser.EvaluateConditional('!if NOT(TRUE)')) self.assertTrue(parser.EvaluateConditional('!if NOT(FALSE)')) # make sure it works with the bang symbol self.assertFalse(parser.EvaluateConditional('!if !(TRUE)')) self.assertTrue(parser.EvaluateConditional('!if !(FALSE)')) parser.ResetParserState()
def test_process_and_operation_conditional(self): parser = BaseParser("") self.assertFalse(parser.EvaluateConditional('!if TRUE AND FALSE')) self.assertFalse(parser.EvaluateConditional('!if FALSE AND TRUE')) self.assertTrue(parser.EvaluateConditional('!if TRUE AND TRUE')) self.assertTrue(parser.EvaluateConditional('!if TRUE && TRUE')) self.assertFalse(parser.EvaluateConditional('!if FALSE AND FALSE')) self.assertFalse(parser.EvaluateConditional('!if FALSE && FALSE'))
def test_emulator_conditional_not_in(self): parser = BaseParser("") parser.SetInputVars({"TOOL_CHAIN_TAG": "VS2019"}) self.assertTrue( parser.ProcessConditional('!if "XCODE5" not in $(TOOL_CHAIN_TAG)')) self.assertTrue(parser.InActiveCode()) parser.ResetParserState()
def test_replace_local_variables(self): parser = BaseParser("") variables = { "FIFTY": 50, "TEST": "TEST", "LOWER NUMBER": 40, "HEX": "0x20", "BOOLEAN": "TRUE", "BOOLEAN FALSE": "FALSE", } parser.LocalVars = variables # check to make sure we don't modify if we don't have variables no_var = "this has no variables" no_var_result = parser.ReplaceVariables(no_var) self.assertEqual(no_var_result, no_var) # make sure we don't fail when we have unknown variables na_var = "unknown var $(UNKNOWN)" na_var_after = "unknown var $(UNKNOWN)" na_var_result = parser.ReplaceVariables(na_var) self.assertEqual(na_var_result, na_var_after) # make sure we're good for all the variables variable_str = "var $(%s)" for variable_key in variables: line = variable_str % variable_key result = parser.ReplaceVariables(line) val = "var " + str(variables[variable_key]) self.assertEqual(result, val)
def test_process_or_operation_conditional(self): parser = BaseParser("") self.assertTrue(parser.EvaluateConditional('!IF TRUE OR FALSE')) self.assertTrue(parser.EvaluateConditional('!if FALSE OR TRUE')) self.assertTrue(parser.EvaluateConditional('!if FALSE || TRUE')) self.assertTrue(parser.EvaluateConditional('!if TRUE OR TRUE')) self.assertFalse(parser.EvaluateConditional('!if FALSE OR FALSE')) self.assertFalse(parser.EvaluateConditional('!if FALSE || FALSE'))
def test_replace_macro_ifndef(self): parser = BaseParser("") parser.SetInputVars({"name": "sean"}) line = "!IfNDef name" self.assertEqual(parser.ReplaceVariables(line), "!IfNDef sean") line = "!ifndef Invalid_Token" self.assertEqual(parser.ReplaceVariables(line), "!ifndef 0") line = "!IFnDEF name" self.assertEqual(parser.ReplaceVariables(line), "!IFnDEF sean")
def test_replace_macro_ifdef_dollarsign(self): parser = BaseParser("") parser.SetInputVars({"name": "sean"}) line = "!ifdef $(name)" self.assertEqual(parser.ReplaceVariables(line), "!ifdef sean") line = "!ifdef $(Invalid_Token)" self.assertEqual(parser.ReplaceVariables(line), "!ifdef 0") line = "!IFDEF $(name)" self.assertEqual(parser.ReplaceVariables(line), "!IFDEF sean")
def test_replace_boolean_constants(self): parser = BaseParser("") parser.SetInputVars({ "true": "True", "false": "False", "b_true": True, "b_false": False }) line = "$(true)" self.assertEqual(parser.ReplaceVariables(line), "TRUE") line = "$(false)" self.assertEqual(parser.ReplaceVariables(line), "FALSE") line = "$(b_true)" self.assertEqual(parser.ReplaceVariables(line), "TRUE") line = "$(b_false)" self.assertEqual(parser.ReplaceVariables(line), "FALSE")
def test_is_guid(self): guid1 = "= { 0xD3B36F2C, 0xD551, 0x11D4, {0x9A, 0x46, 0x0, 0x90, 0x27, 0x3F, 0xC1,0xD }}" parser = BaseParser("") self.assertTrue(parser.IsGuidString(guid1)) guid2 = "= { 0xD3B36F2C, 0xD551, 0x11D4, {0x9A, 0x46, 0x0, 0x90, 0x27, 0x3F, 0xC1,0xD }" self.assertFalse(parser.IsGuidString(guid2)) guid3 = "= { 0xD3B36F2C, 0xD551, 0x11D4, {0x9A, 0x0, 0x90, 0x27, 0x3F, 0xC1,0xD }}" self.assertFalse(parser.IsGuidString(guid3)) # guid4 = "= { 0xD3B36F, 0xD551, 0x11D4, {0x9A, 0x46, 0x0, 0x90, 0x27, 0x3F, 0xC1,0xD }}" # TODO make sure we are checking length? # self.assertFalse(parser.IsGuidString(guid4)) guid5 = " { 0xD3B36F2C, 0xD551, 0x11D4, {0x9A, 0x46, 0x0, 0x90, 0x27, 0x3F, 0xC1,0xD }}" self.assertFalse(parser.IsGuidString(guid5))
def test_parse_guid(self): guid1 = "{ 0xD3B36F2C, 0xD551, 0x11D4, {0x9A, 0x46, 0x0, 0x90, 0x27, 0x3F, 0xC1,0xD }}" guid1_answer = "D3B36F2C-D551-11D4-9A46-0090273FC10D" parser = BaseParser("") guid1_result = parser.ParseGuid(guid1) self.assertEqual(guid1_answer, guid1_result) # try a bad guid and make sure it fails since it's missing an element guid2 = "{ 0xD3B36F2C, 0xD551, 0x11D4, { 0x9A, 0x46, 0x00, 0x90, 0x27, 0x3F, 0xC1 }}" with self.assertRaises(RuntimeError): parser.ParseGuid(guid2) # check one that's too long guid3 = "{ 0xD3B36FbadC, 0xD551, 0x11D4, { 0x9A, 0x46, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}" with self.assertRaises(RuntimeError): parser.ParseGuid(guid3) # check one that's too short guid4 = "{ 0x3, 0x1, 0x4, { 0xA, 0x6, 0x0, 0x9, 0x2, 0xF, 0x1, 0xD }}" guid4_answer = "00000003-0001-0004-0A06-0009020F010D" guid4_result = parser.ParseGuid(guid4) self.assertEqual(guid4_result, guid4_answer)
def test_process_conditional_true_cannot_be_greater_than_hex(self): parser = BaseParser("") # check != with true and false with self.assertRaises(ValueError): parser.ProcessConditional("!IF 0x7 >= TRUE")
def test_find_path(self): # we're using write lines to make sure everything wo parser = BaseParser("") parser.Lines = ["hello"] package_paths = ["Common/Test", "SM_MAGIC"] root_path = tempfile.mkdtemp() target_filedir = os.path.join(root_path, "BuildPkg") parser.TargetFilePath = target_filedir parser.SetPackagePaths(package_paths) parser.SetBaseAbsPath(root_path) os.makedirs(target_filedir) index = 0 root_file = "root.txt" target_file = "target.txt" for package in package_paths: pack_path = os.path.join(root_path, package) os.makedirs(pack_path) parser.WriteLinesToFile(os.path.join(pack_path, f"package_{index}.txt")) index += 1 root_filepath = os.path.join(root_path, root_file) target_filepath = os.path.join(target_filedir, target_file) parser.WriteLinesToFile(root_filepath) parser.WriteLinesToFile(target_filepath) root_found = parser.FindPath(root_file) self.assertEqual(root_found, root_filepath) target_found = parser.FindPath(target_file) self.assertEqual(target_found, target_filepath) # check package relative packages for index in range(len(package_paths)): file_name = f"package_{index}.txt" pp_found = parser.FindPath(file_name) self.assertTrue(os.path.exists(pp_found)) # invalid files invalid_filename = "YOU_WONT_FIND_ME.txt" invalid_file = os.path.join(root_path, invalid_filename) invalid_result = parser.FindPath(invalid_filename) self.assertEqual(invalid_file, invalid_result)
def test_process_conditional_invalid_operators(self): parser = BaseParser("") # check weird operators with self.assertRaises(RuntimeError): self.assertTrue(parser.ProcessConditional("!IF 50 <> 50"))
def test_process_else(self): parser = BaseParser("") # check to make sure we can't do a malformed endif self.assertTrue(parser.ProcessConditional("!if TRUE")) self.assertTrue(parser.ProcessConditional("!else")) self.assertFalse(parser.InActiveCode())