# RUN: %{python} %s # # END. import os.path import platform import unittest import lit.discovery import lit.LitConfig import lit.Test as Test from lit.TestRunner import ParserKind, IntegratedTestKeywordParser, \ parseIntegratedTestScript class TestIntegratedTestKeywordParser(unittest.TestCase): inputTestCase = None @staticmethod def load_keyword_parser_lit_tests(): """ Create and load the LIT test suite and test objects used by TestIntegratedTestKeywordParser """ # Create the global config object. lit_config = lit.LitConfig.LitConfig(progname='lit', path=[], quiet=False, useValgrind=False, valgrindLeakCheck=False, valgrindArgs=[], noExecute=False, debug=False, isWindows=( platform.system() == 'Windows'), params={}) TestIntegratedTestKeywordParser.litConfig = lit_config # Perform test discovery. test_path = os.path.dirname(os.path.dirname(__file__)) inputs = [os.path.join(test_path, 'Inputs/testrunner-custom-parsers/')] assert os.path.isdir(inputs[0]) tests = lit.discovery.find_tests_for_inputs(lit_config, inputs, False) assert len(tests) == 1 and "there should only be one test" TestIntegratedTestKeywordParser.inputTestCase = tests[0] @staticmethod def make_parsers(): def custom_parse(line_number, line, output): if output is None: output = [] output += [part for part in line.split(' ') if part.strip()] return output return [ IntegratedTestKeywordParser("MY_TAG.", ParserKind.TAG), IntegratedTestKeywordParser("MY_DNE_TAG.", ParserKind.TAG), IntegratedTestKeywordParser("MY_LIST:", ParserKind.LIST), IntegratedTestKeywordParser("MY_BOOL:", ParserKind.BOOLEAN_EXPR), IntegratedTestKeywordParser("MY_INT:", ParserKind.INTEGER), IntegratedTestKeywordParser("MY_RUN:", ParserKind.COMMAND), IntegratedTestKeywordParser("MY_CUSTOM:", ParserKind.CUSTOM, custom_parse), ] @staticmethod def get_parser(parser_list, keyword): for p in parser_list: if p.keyword == keyword: return p assert False and "parser not found" @staticmethod def parse_test(parser_list, allow_result=False): script = parseIntegratedTestScript( TestIntegratedTestKeywordParser.inputTestCase, additional_parsers=parser_list, require_script=False) if isinstance(script, lit.Test.Result): assert allow_result else: assert isinstance(script, list) assert len(script) == 0 return script def test_tags(self): parsers = self.make_parsers() self.parse_test(parsers) tag_parser = self.get_parser(parsers, 'MY_TAG.') dne_tag_parser = self.get_parser(parsers, 'MY_DNE_TAG.') self.assertTrue(tag_parser.getValue()) self.assertFalse(dne_tag_parser.getValue()) def test_lists(self): parsers = self.make_parsers() self.parse_test(parsers) list_parser = self.get_parser(parsers, 'MY_LIST:') self.assertEqual(list_parser.getValue(), ['one', 'two', 'three', 'four']) def test_commands(self): parsers = self.make_parsers() self.parse_test(parsers) cmd_parser = self.get_parser(parsers, 'MY_RUN:') value = cmd_parser.getValue() self.assertEqual(len(value), 2) # there are only two run lines self.assertEqual(value[0].strip(), "%dbg(MY_RUN: at line 4) baz") self.assertEqual(value[1].strip(), "%dbg(MY_RUN: at line 7) foo bar") def test_boolean(self): parsers = self.make_parsers() self.parse_test(parsers) bool_parser = self.get_parser(parsers, 'MY_BOOL:') value = bool_parser.getValue() self.assertEqual(len(value), 2) # there are only two run lines self.assertEqual(value[0].strip(), "a && (b)") self.assertEqual(value[1].strip(), "d") def test_integer(self): parsers = self.make_parsers() self.parse_test(parsers) int_parser = self.get_parser(parsers, 'MY_INT:') value = int_parser.getValue() self.assertEqual(len(value), 2) # there are only two MY_INT: lines self.assertEqual(type(value[0]), int) self.assertEqual(value[0], 4) self.assertEqual(type(value[1]), int) self.assertEqual(value[1], 6) def test_bad_parser_type(self): parsers = self.make_parsers() + ["BAD_PARSER_TYPE"] script = self.parse_test(parsers, allow_result=True) self.assertTrue(isinstance(script, lit.Test.Result)) self.assertEqual(script.code, lit.Test.UNRESOLVED) self.assertEqual('Additional parser must be an instance of ' 'IntegratedTestKeywordParser', script.output) def test_duplicate_keyword(self): parsers = self.make_parsers() + \ [IntegratedTestKeywordParser("KEY:", ParserKind.BOOLEAN_EXPR), IntegratedTestKeywordParser("KEY:", ParserKind.BOOLEAN_EXPR)] script = self.parse_test(parsers, allow_result=True) self.assertTrue(isinstance(script, lit.Test.Result)) self.assertEqual(script.code, lit.Test.UNRESOLVED) self.assertEqual("Parser for keyword 'KEY:' already exists", script.output) def test_boolean_unterminated(self): parsers = self.make_parsers() + \ [IntegratedTestKeywordParser("MY_BOOL_UNTERMINATED:", ParserKind.BOOLEAN_EXPR)] script = self.parse_test(parsers, allow_result=True) self.assertTrue(isinstance(script, lit.Test.Result)) self.assertEqual(script.code, lit.Test.UNRESOLVED) self.assertEqual("Test has unterminated 'MY_BOOL_UNTERMINATED:' lines " "(with '\\')", script.output) def test_custom(self): parsers = self.make_parsers() self.parse_test(parsers) custom_parser = self.get_parser(parsers, 'MY_CUSTOM:') value = custom_parser.getValue() self.assertEqual(value, ['a', 'b', 'c']) def test_bad_keywords(self): def custom_parse(line_number, line, output): return output try: IntegratedTestKeywordParser("TAG_NO_SUFFIX", ParserKind.TAG), self.fail("TAG_NO_SUFFIX failed to raise an exception") except ValueError as e: pass except BaseException as e: self.fail("TAG_NO_SUFFIX raised the wrong exception: %r" % e) try: IntegratedTestKeywordParser("TAG_WITH_COLON:", ParserKind.TAG), self.fail("TAG_WITH_COLON: failed to raise an exception") except ValueError as e: pass except BaseException as e: self.fail("TAG_WITH_COLON: raised the wrong exception: %r" % e) try: IntegratedTestKeywordParser("LIST_WITH_DOT.", ParserKind.LIST), self.fail("LIST_WITH_DOT. failed to raise an exception") except ValueError as e: pass except BaseException as e: self.fail("LIST_WITH_DOT. raised the wrong exception: %r" % e) try: IntegratedTestKeywordParser("CUSTOM_NO_SUFFIX", ParserKind.CUSTOM, custom_parse), self.fail("CUSTOM_NO_SUFFIX failed to raise an exception") except ValueError as e: pass except BaseException as e: self.fail("CUSTOM_NO_SUFFIX raised the wrong exception: %r" % e) # Both '.' and ':' are allowed for CUSTOM keywords. try: IntegratedTestKeywordParser("CUSTOM_WITH_DOT.", ParserKind.CUSTOM, custom_parse), except BaseException as e: self.fail("CUSTOM_WITH_DOT. raised an exception: %r" % e) try: IntegratedTestKeywordParser("CUSTOM_WITH_COLON:", ParserKind.CUSTOM, custom_parse), except BaseException as e: self.fail("CUSTOM_WITH_COLON: raised an exception: %r" % e) try: IntegratedTestKeywordParser("CUSTOM_NO_PARSER:", ParserKind.CUSTOM), self.fail("CUSTOM_NO_PARSER: failed to raise an exception") except ValueError as e: pass except BaseException as e: self.fail("CUSTOM_NO_PARSER: raised the wrong exception: %r" % e) class TestApplySubtitutions(unittest.TestCase): def test_simple(self): script = ["echo %bar"] substitutions = [("%bar", "hello")] result = lit.TestRunner.applySubstitutions(script, substitutions) self.assertEqual(result, ["echo hello"]) def test_multiple_substitutions(self): script = ["echo %bar %baz"] substitutions = [("%bar", "hello"), ("%baz", "world"), ("%useless", "shouldnt expand")] result = lit.TestRunner.applySubstitutions(script, substitutions) self.assertEqual(result, ["echo hello world"]) def test_multiple_script_lines(self): script = ["%cxx %compile_flags -c -o %t.o", "%cxx %link_flags %t.o -o %t.exe"] substitutions = [("%cxx", "clang++"), ("%compile_flags", "-std=c++11 -O3"), ("%link_flags", "-lc++")] result = lit.TestRunner.applySubstitutions(script, substitutions) self.assertEqual(result, ["clang++ -std=c++11 -O3 -c -o %t.o", "clang++ -lc++ %t.o -o %t.exe"]) def test_recursive_substitution_real(self): script = ["%build %s"] substitutions = [("%cxx", "clang++"), ("%compile_flags", "-std=c++11 -O3"), ("%link_flags", "-lc++"), ("%build", "%cxx %compile_flags %link_flags %s -o %t.exe")] result = lit.TestRunner.applySubstitutions(script, substitutions, recursion_limit=3) self.assertEqual(result, ["clang++ -std=c++11 -O3 -lc++ %s -o %t.exe %s"]) def test_recursive_substitution_limit(self): script = ["%rec5"] # Make sure the substitutions are not in an order where the global # substitution would appear to be recursive just because they are # processed in the right order. substitutions = [("%rec1", "STOP"), ("%rec2", "%rec1"), ("%rec3", "%rec2"), ("%rec4", "%rec3"), ("%rec5", "%rec4")] for limit in [5, 6, 7]: result = lit.TestRunner.applySubstitutions(script, substitutions, recursion_limit=limit) self.assertEqual(result, ["STOP"]) def test_recursive_substitution_limit_exceeded(self): script = ["%rec5"] substitutions = [("%rec1", "STOP"), ("%rec2", "%rec1"), ("%rec3", "%rec2"), ("%rec4", "%rec3"), ("%rec5", "%rec4")] for limit in [0, 1, 2, 3, 4]: try: lit.TestRunner.applySubstitutions(script, substitutions, recursion_limit=limit) self.fail("applySubstitutions should have raised an exception") except ValueError: pass def test_recursive_substitution_invalid_value(self): script = ["%rec5"] substitutions = [("%rec1", "STOP"), ("%rec2", "%rec1"), ("%rec3", "%rec2"), ("%rec4", "%rec3"), ("%rec5", "%rec4")] for limit in [-1, -2, -3, "foo"]: try: lit.TestRunner.applySubstitutions(script, substitutions, recursion_limit=limit) self.fail("applySubstitutions should have raised an exception") except AssertionError: pass if __name__ == '__main__': TestIntegratedTestKeywordParser.load_keyword_parser_lit_tests() unittest.main(verbosity=2)