diff --git a/tools/ldgen/test/data/Kconfig b/tools/ldgen/test/data/Kconfig index c813c008c..cb0b364d1 100644 --- a/tools/ldgen/test/data/Kconfig +++ b/tools/ldgen/test/data/Kconfig @@ -1,7 +1,19 @@ menu "Test config" config PERFORMANCE_LEVEL - int "Performance level" + int range 0 3 + prompt "Performance level" + config A + bool + default "y" + + config B + bool + default "n" + + config C + bool + default "y" endmenu diff --git a/tools/ldgen/test/test_fragments.py b/tools/ldgen/test/test_fragments.py index d246a2262..1d2efbe30 100755 --- a/tools/ldgen/test/test_fragments.py +++ b/tools/ldgen/test/test_fragments.py @@ -14,625 +14,725 @@ # See the License for the specific language governing permissions and # limitations under the License. # - -import unittest import sys -from pyparsing import ParseException -from pyparsing import restOfLine +import unittest + +from io import StringIO +from pyparsing import Word, ParseException, ParseFatalException, alphanums try: - import fragments + from fragments import FragmentFile, FRAGMENT_TYPES, Fragment, KeyGrammar + from sdkconfig import SDKConfig except ImportError: sys.path.append('../') - import fragments + from fragments import FragmentFile, FRAGMENT_TYPES, Fragment, KeyGrammar + from sdkconfig import SDKConfig -from sdkconfig import SDKConfig + +class SampleFragment(Fragment): + + grammars = { + "key_1": KeyGrammar(Word(alphanums + "_").setResultsName("value"), 0, None, True), + "key_2": KeyGrammar(Word(alphanums + "_").setResultsName("value"), 0, None, False), + "key_3": KeyGrammar(Word(alphanums + "_").setResultsName("value"), 3, 5, False) + } + + def set_key_value(self, key, parse_results): + if key == "key_1": + self.key_1 = list() + for result in parse_results: + self.key_1.append(result["value"]) + elif key == "key_2": + self.key_2 = list() + for result in parse_results: + self.key_2.append(result["value"]) + + def get_key_grammars(self): + return self.__class__.grammars + + +FRAGMENT_TYPES["test"] = SampleFragment class FragmentTest(unittest.TestCase): - def parse(self, text): - self.parser.ignore("#" + restOfLine) - fragment = self.parser.parseString(text, parseAll=True) - return fragment[0] + def setUp(self): + self.sdkconfig = SDKConfig("data/Kconfig", "data/sdkconfig") + + @staticmethod + def create_fragment_file(contents, name="test_fragment.lf"): + f = StringIO(contents) + f.name = name + return f + + def test_basic(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_1 + value_2 # comments should be ignored + value_3 +# this is a comment as well +key_2: value_a + +# this is the last comment +""") + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + + self.assertEqual(len(fragment_file.fragments[0].key_1), 3) + self.assertEqual(fragment_file.fragments[0].key_1[0], "value_1") + self.assertEqual(fragment_file.fragments[0].key_1[1], "value_2") + self.assertEqual(fragment_file.fragments[0].key_1[2], "value_3") + self.assertEqual(len(fragment_file.fragments[0].key_2), 1) + self.assertEqual(fragment_file.fragments[0].key_2[0], "value_a") + + def test_duplicate_keys(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: value_1 +key_1: value_a +""") + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_empty_key(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: +""") + with self.assertRaises(ParseException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_conditional(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_1 + if A = y: + value_2 + value_3 + if A = n: + value_4 + if B = n: + value_5 +""") + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(fragment_file.fragments[0].key_1[0], "value_1") + self.assertEqual(fragment_file.fragments[0].key_1[1], "value_2") + self.assertEqual(fragment_file.fragments[0].key_1[2], "value_3") + self.assertEqual(fragment_file.fragments[0].key_1[3], "value_5") + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_1 + if B = y: + value_2 + elif C = y: + value_3 + elif A = y: + value_4 + else: + value_5 + value_6 +""") + + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(fragment_file.fragments[0].key_1[0], "value_1") + self.assertEqual(fragment_file.fragments[0].key_1[1], "value_3") + self.assertEqual(fragment_file.fragments[0].key_1[2], "value_6") + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_1 + if A = y: + value_2 + if B = y: + value_3 + else: + value_4 + if C = y: + value_5 + value_6 + value_7 +key_2: + value_a + if B != y: + value_b +""") + + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(fragment_file.fragments[0].key_1[0], "value_1") + self.assertEqual(fragment_file.fragments[0].key_1[1], "value_2") + self.assertEqual(fragment_file.fragments[0].key_1[2], "value_4") + self.assertEqual(fragment_file.fragments[0].key_1[3], "value_5") + self.assertEqual(fragment_file.fragments[0].key_1[4], "value_6") + self.assertEqual(fragment_file.fragments[0].key_1[5], "value_7") + self.assertEqual(fragment_file.fragments[0].key_2[0], "value_a") + self.assertEqual(fragment_file.fragments[0].key_2[1], "value_b") + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + if A = n: + value_2 +""") + + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(len(fragment_file.fragments[0].key_1), 0) + + def test_empty_file(self): + test_fragment = self.create_fragment_file(u""" + + + + +""") + + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(len(fragment_file.fragments), 0) + + def test_setting_indent(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_1 + value_2 + value_3 +""") + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + + self.assertEqual(len(fragment_file.fragments[0].key_1), 3) + self.assertEqual(fragment_file.fragments[0].key_1[0], "value_1") + self.assertEqual(fragment_file.fragments[0].key_1[1], "value_2") + self.assertEqual(fragment_file.fragments[0].key_1[2], "value_3") + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_1 + value_2 # first element dictates indent + value_3 +""") + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_values_num_limit(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_a +key_3: + value_1 + value_2 + value_3 +""") + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_a +key_3: + value_1 + value_2 + value_3 + value_4 +""") + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(len(fragment_file.fragments), 1) + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_a +key_3: + value_1 + value_2 + value_3 + value_4 + value_5 +""") + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(len(fragment_file.fragments), 1) + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_a +key_3: + value_1 + value_2 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_a +key_3: + value_1 + value_2 + value_3 + value_4 + value_5 + value_6 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_unsupported_key(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + value_a +key_4: + value_1 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_empty_fragment(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +""") + + with self.assertRaises(ParseException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_empty_conditional(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + if B = y: + else: + value_1 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + if B = y: + value_1 + else B = y: +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + if B = y: + value_1 + elif B = y: + else: + value_2 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_out_of_order_conditional(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + elif B = y: + value_1 + else: + value_2 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[test:test] +key_1: + else: + value_2 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_required_keys(self): + test_fragment = self.create_fragment_file(u""" +[test:test] +key_2: + value_1 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_multiple_fragments(self): + test_fragment = self.create_fragment_file(u""" +[test:test1] +key_1: + value_1 + +[test:test2] +key_1: + value_2 +""") + + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + + self.assertEqual(len(fragment_file.fragments), 2) + self.assertEqual(fragment_file.fragments[0].key_1[0], "value_1") + self.assertEqual(fragment_file.fragments[1].key_1[0], "value_2") + + def test_whole_conditional_fragment(self): + test_fragment = self.create_fragment_file(u""" +if B = y: + [test:test1] + key_1: + value_1 +else: + [test:test2] + key_1: + value_2 + + if A = y: + [test:test3] + key_1: + value_3 + if C = y: + value_6 + + [test:test4] + key_1: + value_4 + +[test:test5] +key_1: + value_5 +""") + + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(len(fragment_file.fragments), 4) + self.assertEqual(fragment_file.fragments[0].name, "test2") + self.assertEqual(fragment_file.fragments[1].name, "test3") + self.assertEqual(fragment_file.fragments[1].key_1[1], "value_6") + self.assertEqual(fragment_file.fragments[2].name, "test4") + self.assertEqual(fragment_file.fragments[3].name, "test5") + + def test_equivalent_conditional_fragment(self): + test_fragment1 = self.create_fragment_file(u""" +if A = y: + [test:test1] + key_1: + value_1 +else: + [test:test2] + key_1: + value_2 +""") + + fragment_file1 = FragmentFile(test_fragment1, self.sdkconfig) + self.assertEqual(len(fragment_file1.fragments), 1) + self.assertEqual(fragment_file1.fragments[0].key_1[0], "value_1") + + test_fragment2 = self.create_fragment_file(u""" +[test:test1] +key_1: + if A = y: + value_1 + else: + value_2 +""") + + fragment_file2 = FragmentFile(test_fragment2, self.sdkconfig) + self.assertEqual(len(fragment_file2.fragments), 1) + self.assertEqual(fragment_file2.fragments[0].key_1[0], "value_1") class SectionsTest(FragmentTest): - def setUp(self): - self.parser = fragments.Sections.get_fragment_grammar() + def test_basic(self): + test_fragment = self.create_fragment_file(u""" +[sections:test] +entries: + .section1 + .section2 +""") - def test_valid_entries(self): - valid_entries = """ - [sections:test] - entries: - .section1 - .section2 - - # Section 3 should not exist - # section3 - .section4 - - # This is a comment - - .section5 - """ - - sections = self.parse(valid_entries) - - self.assertEqual("test", sections.name) - - entries = sections.entries - - expected = { - ".section1", - ".section2", - ".section4", - ".section5" - } - - self.assertEqual(set(entries), expected) - - def test_blank_entries(self): - blank_entries = """ - [sections:test] - entries: - """ - - with self.assertRaises(ParseException): - self.parse(blank_entries) - - def test_invalid_names(self): - with_spaces = """ - [sections:invalid name 1] - entries: - """ - - begins_with_number = """ - [sections:2invalid_name] - entries: - """ - - with_special_character = """ - [sections:invalid_name~] - entries: - """ - - with self.assertRaises(ParseException): - self.parse(with_spaces) - - with self.assertRaises(ParseException): - self.parse(begins_with_number) - - with self.assertRaises(ParseException): - self.parse(with_special_character) - - def test_non_existent_entries(self): - misspelled_entries_field = """ - [sections:test] - entrie: - .section1 - """ - - missing_entries_field = """ - [sections:test] - """ - - with self.assertRaises(ParseException): - self.parse(misspelled_entries_field) - - with self.assertRaises(ParseException): - self.parse(missing_entries_field) + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(fragment_file.fragments[0].entries, {".section1", ".section2"}) def test_duplicate_entries(self): - duplicate_entries = """ - [sections:test] - entries: - .section1 - .section3 - .section1 - .section1 - .section2 - .section3 - .section1 - """ + test_fragment = self.create_fragment_file(u""" +[sections:test] +entries: + .section1 + .section2 + .section3 + .section2 +""") - sections = self.parse(duplicate_entries) + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(fragment_file.fragments[0].entries, {".section1", ".section2", ".section3"}) - entries = sections.entries + def test_empty_entries(self): + test_fragment = self.create_fragment_file(u""" +[sections:test] +entries: +""") - expected = { - ".section1", - ".section2", - ".section3", - } + with self.assertRaises(ParseException): + FragmentFile(test_fragment, self.sdkconfig) - self.assertEqual(set(entries), expected) + test_fragment = self.create_fragment_file(u""" +[sections:test] +entries: + if B = y: + .section1 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) class SchemeTest(FragmentTest): - def setUp(self): - self.parser = fragments.Scheme.get_fragment_grammar() + def test_basic(self): + test_fragment = self.create_fragment_file(u""" +[scheme:test] +entries: + sections1 -> target1 + sections2 -> target2 +""") - def test_valid_entries(self): - valid_entries = """ - [scheme:test] - entries: - sections1 -> target1 - sections2 -> target2 - """ + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(fragment_file.fragments[0].entries, + {("sections1", "target1"), + ("sections2", "target2")}) - scheme = self.parse(valid_entries) + def test_duplicate_entries(self): + test_fragment = self.create_fragment_file(u""" +[scheme:test] +entries: + sections1 -> target1 + sections2 -> target2 + sections2 -> target2 +""") - entries = scheme.entries + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(fragment_file.fragments[0].entries, + {("sections1", "target1"), + ("sections2", "target2")}) - expected = { - ("sections1", "target1"), - ("sections2", "target2") - } - - self.assertEqual(entries, expected) - - def test_duplicate_same_mapping(self): - duplicate_entries = """ - [scheme:duplicate_same_mapping] - entries: - sections1 -> target1 - sections2 -> target2 - sections1 -> target1 - """ - - scheme = self.parse(duplicate_entries) - - entries = scheme.entries - - expected = { - ("sections1", "target1"), - ("sections2", "target2") - } - - self.assertEqual(len(entries), 2) - self.assertEqual(entries, expected) - - def test_invalid_separator(self): - wrong_character = """ - [scheme:test] - entries: - sections1, target1 - """ - - single_word = """ - [scheme:test] - entries: - sections1 - """ + def test_empty_entries(self): + test_fragment = self.create_fragment_file(u""" +[scheme:test] +entries: +""") with self.assertRaises(ParseException): - self.parse(wrong_character) + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[scheme:test] +entries: + if B = y: + sections1 -> target1 +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_improper_grammar(self): + test_fragment = self.create_fragment_file(u""" +[scheme:test] +entries: + sections1, target1 # improper separator +""") with self.assertRaises(ParseException): - self.parse(single_word) - - def test_blank_entries(self): - blank_entries = """ - [scheme:test] - entries: - """ - - with self.assertRaises(ParseException): - self.parse(blank_entries) - - def test_non_existent_entries(self): - misspelled_entries_field = """ - [scheme:test] - entrie: - section -> target - """ - - missing_entries_field = """ - [scheme:test] - """ - - with self.assertRaises(ParseException): - self.parse(misspelled_entries_field) - - with self.assertRaises(ParseException): - self.parse(missing_entries_field) + FragmentFile(test_fragment, self.sdkconfig) class MappingTest(FragmentTest): - def setUp(self): - self.parser = fragments.Mapping.get_fragment_grammar() + def test_basic(self): + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: lib.a +entries: + obj:symbol (noflash) + obj (noflash) + obj:symbol_2 (noflash) + obj_2 (noflash) + * (noflash) +""") - def parse_expression(self, expression): - parser = SDKConfig.get_expression_grammar() - return parser.parseString(expression, parseAll=True) - - def test_valid_grammar(self): - valid_entries = """ - [mapping] - archive: lib.a - entries: - obj:symbol (noflash) - # Comments should not matter - obj (noflash) - # Nor should whitespace - obj : symbol_2 ( noflash ) - obj_2 ( noflash ) - * (noflash) - """ - - mapping = self.parse(valid_entries) - - self.assertEqual("lib.a", mapping.archive) - self.assertEqual("lib_a", mapping.name) - - entries = mapping.entries - - expected = [("default", { - ("obj", "symbol", "noflash"), + expected = {("obj", "symbol", "noflash"), ("obj", None, "noflash"), ("obj", "symbol_2", "noflash"), ("obj_2", None, "noflash"), - ("*", None, "noflash") - })] + ("*", None, "noflash")} - self.assertEqual(entries, expected) + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(expected, fragment_file.fragments[0].entries) + + def test_archive(self): + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: +entries: + * (default) +""") + + with self.assertRaises(ParseException): + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: + lib1.a + lib2.a +entries: + * (default) +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_empty_entries(self): + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: + lib.a +entries: + if B = y: + * (noflash) # if condition is false, then no 'entries' key value +""") + + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: + lib.a +entries: +""") + + with self.assertRaises(ParseException): + FragmentFile(test_fragment, self.sdkconfig) + + def test_duplicate_entries(self): + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: + lib.a +entries: + obj:symbol (noflash) + obj:symbol (noflash) +""") + + expected = {("obj", "symbol", "noflash")} + + fragment_file = FragmentFile(test_fragment, self.sdkconfig) + self.assertEqual(expected, fragment_file.fragments[0].entries) def test_invalid_grammar(self): - with_fragment_name = """ - [mapping:name] - archive: lib.a - entries: - obj:symbol (noflash) - """ + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: + lib.a +""") - missing_archive = """ - [mapping:name] - entries: - obj:symbol (noflash) - """ + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) - misspelled_archive = """ - [mapping:name] - archi: lib.a - entries: - obj:symbol (noflash) - """ + test_fragment = self.create_fragment_file(u""" +[mapping:test] +entries: + * (default) +""") - missing_entries = """ - [mapping] - archive: lib.a - """ + with self.assertRaises(ParseFatalException): + FragmentFile(test_fragment, self.sdkconfig) - misspelled_entries = """ - [mapping] - archive: lib.a - entrie: - obj:symbol (noflash) - """ - - missing_symbols = """ - [mapping] - archive: lib.a - entries: - obj: (noflash) - """ - - missing_scheme_1 = """ - [mapping] - archive: lib.a - entries: - obj: () - """ - - missing_scheme_2 = """ - [mapping] - archive: lib.a - entries: - obj:symbol - """ - - missing_entity = """ - [mapping] - archive: lib.a - entries: - (noflash) - """ - - wilcard_symbol = """ - [mapping] - archive: lib.a - entries: - obj:* (noflash) - """ - - empty_object_with_symbol = """ - [mapping] - archive: lib.a - entries: - :symbol (noflash) - """ - - wildcard_object_with_symbol = """ - [mapping] - archive: lib.a - entries: - *:symbol (noflash) - """ - - empty_definition = """ - [mapping] - """ + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: lib.a +entries: + obj: (noflash) +""") with self.assertRaises(ParseException): - self.parse(with_fragment_name) + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: lib.a +entries: + obj: () +""") with self.assertRaises(ParseException): - self.parse(missing_archive) + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: lib.a +entries: + obj:symbol +""") with self.assertRaises(ParseException): - self.parse(misspelled_archive) + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: lib.a +entries: + (noflash) +""") with self.assertRaises(ParseException): - self.parse(missing_entries) + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: lib.a +entries: + obj:* (noflash) +""") with self.assertRaises(ParseException): - self.parse(misspelled_entries) + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: lib.a +entries: + :symbol (noflash) +""") with self.assertRaises(ParseException): - self.parse(missing_symbols) + FragmentFile(test_fragment, self.sdkconfig) + + test_fragment = self.create_fragment_file(u""" +[mapping:test] +archive: lib.a +entries: + *:symbol (noflash) +""") with self.assertRaises(ParseException): - self.parse(missing_scheme_1) - - with self.assertRaises(ParseException): - self.parse(missing_scheme_2) - - with self.assertRaises(ParseException): - self.parse(missing_entity) - - with self.assertRaises(ParseException): - self.parse(wilcard_symbol) - - with self.assertRaises(ParseException): - self.parse(empty_object_with_symbol) - - with self.assertRaises(ParseException): - self.parse(wildcard_object_with_symbol) - - with self.assertRaises(ParseException): - self.parse(empty_definition) - - def test_explicit_blank_default_w_others(self): - expl_blnk_w_oth = """ - [mapping] - archive: lib.a - entries: - : CONFIG_A = y - obj_a (noflash) - : default - """ - - mapping = self.parse(expl_blnk_w_oth) - - entries = mapping.entries - - expected = [(entries[0][0], { - ("obj_a", None, "noflash"), - }), - ("default", set())] - - self.assertEqual(entries, expected) - - def test_implicit_blank_default_w_others(self): - impl_blnk_w_oth = """ - [mapping] - archive: lib.a - entries: - : CONFIG_A = y - obj_a (noflash) - """ - - mapping = self.parse(impl_blnk_w_oth) - - entries = mapping.entries - - expected = [(entries[0][0], { - ("obj_a", None, "noflash"), - }), - ("default", set())] - - self.assertEqual(entries, expected) - - def test_explicit_blank_default(self): - expl_blnk_def = """ - [mapping] - archive: lib.a - entries: - : default - """ - mapping = self.parse(expl_blnk_def) - entries = mapping.entries - expected = [("default", set())] - - self.assertEqual(entries, expected) - - def test_implicit_blank_default(self): - impl_blnk_def = """ - [mapping] - archive: lib.a - entries: - : default - """ - mapping = self.parse(impl_blnk_def) - entries = mapping.entries - expected = [("default", set())] - - self.assertEqual(entries, expected) - - def test_multiple_entries(self): - multiple_entries = """ - [mapping] - archive: lib.a - entries: - : CONFIG_A = y - obj_a1 (noflash) - obj_a2 (noflash) - : CONFIG_B = y - obj_b1 (noflash) - obj_b2 (noflash) - obj_b3 (noflash) - : CONFIG_C = y - obj_c1 (noflash) - """ - - mapping = self.parse(multiple_entries) - - entries = mapping.entries - - expected = [(entries[0][0], { - ("obj_a1", None, "noflash"), - ("obj_a2", None, "noflash"), - }), - (entries[1][0], { - ("obj_b1", None, "noflash"), - ("obj_b2", None, "noflash"), - ("obj_b3", None, "noflash"), - }), - (entries[2][0], { - ("obj_c1", None, "noflash"), - }), - ("default", set())] - - self.assertEqual(entries, expected) - - def test_blank_entries(self): - blank_entries = """ - [mapping] - archive: lib.a - entries: - : CONFIG_A = y - obj_a (noflash) - : CONFIG_B = y - : CONFIG_C = y - obj_c (noflash) - : CONFIG_D = y - : CONFIG_E = y - : default - obj (noflash) - """ - - mapping = self.parse(blank_entries) - - entries = mapping.entries - - expected = [(entries[0][0], { - ("obj_a", None, "noflash") - }), - (entries[1][0], set()), - (entries[2][0], { - ("obj_c", None, "noflash") - }), - (entries[3][0], set()), - (entries[4][0], set()), - ("default", { - ("obj", None, "noflash") - })] - - self.assertEqual(entries, expected) - - def test_blank_first_condition(self): - blank_first_condition = """ - [mapping] - archive: lib.a - entries: - obj_a (noflash) - : CONFIG_B = y - obj_b (noflash) - """ - - with self.assertRaises(ParseException): - self.parse(blank_first_condition) - - def test_nonlast_default(self): - nonlast_default_1 = """ - [mapping] - archive: lib.a - entries: - : default - obj_a (noflash) - : CONFIG_A = y - obj_A (noflash) - """ - - nonlast_default_2 = """ - [mapping] - archive: lib.a - entries: - : CONFIG_A = y - obj_A (noflash) - : default - obj_a (noflash) - : CONFIG_B = y - obj_B (noflash) - """ - - nonlast_default_3 = """ - [mapping] - archive: lib.a - entries: - : CONFIG_A = y - obj_A (noflash) - : - obj_a (noflash) - : CONFIG_B = y - obj_B (noflash) - """ - - with self.assertRaises(ParseException): - self.parse(nonlast_default_1) - - with self.assertRaises(ParseException): - self.parse(nonlast_default_2) - - with self.assertRaises(ParseException): - self.parse(nonlast_default_3) - - def test_duplicate_default(self): - duplicate_default_1 = """ - archive: lib.a - entries: - : CONFIG_A = y - obj_A (noflash) - : default - obj_a (noflash) - : CONFIG_B = y - obj_B (noflash) - : default - obj_a (noflash) - """ - - duplicate_default_2 = """ - archive: lib.a - entries: - : CONFIG_A = y - obj_A (noflash) - : CONFIG_B = y - obj_a (noflash) - : default - obj_B (noflash) - : - obj_a (noflash) - """ - - with self.assertRaises(ParseException): - self.parse(duplicate_default_1) - - with self.assertRaises(ParseException): - self.parse(duplicate_default_2) + FragmentFile(test_fragment, self.sdkconfig) if __name__ == "__main__": diff --git a/tools/ldgen/test/test_generation.py b/tools/ldgen/test/test_generation.py index 3a6eed35c..a09701576 100755 --- a/tools/ldgen/test/test_generation.py +++ b/tools/ldgen/test/test_generation.py @@ -29,28 +29,23 @@ from generation import SectionsInfo from generation import TemplateModel from generation import GenerationModel -from fragments import FragmentFileModel -from fragments import Mapping -from fragments import Sections -from fragments import Scheme +from fragments import FragmentFile from sdkconfig import SDKConfig +from io import StringIO class GenerationModelTest(unittest.TestCase): def setUp(self): self.model = GenerationModel() - self.sdkconfig = None self.sections_info = None self.script_model = None - with open("data/Kconfig") as kconfig_file_obj: - with open("data/sdkconfig") as sdkconfig_file_obj: - self.sdkconfig = SDKConfig(kconfig_file_obj, sdkconfig_file_obj) + self.sdkconfig = SDKConfig("data/Kconfig", "data/sdkconfig") with open("data/sample.lf") as fragment_file_obj: - fragment_file = FragmentFileModel(fragment_file_obj) + fragment_file = FragmentFile(fragment_file_obj, self.sdkconfig) self.model.add_fragments_from_file(fragment_file) self.sections_info = SectionsInfo() @@ -61,29 +56,25 @@ class GenerationModelTest(unittest.TestCase): with open("data/template.ld") as template_file_obj: self.script_model = TemplateModel(template_file_obj) - def _add_mapping(self, text): - parser = Mapping.get_fragment_grammar() - fragment = parser.parseString(text, parseAll=True) - self.model.mappings[fragment[0].name] = fragment[0] + @staticmethod + def create_fragment_file(contents, name="test_fragment.lf"): + f = StringIO(contents) + f.name = name + return f - def _add_sections(self, text): - parser = Sections.get_fragment_grammar() - fragment = parser.parseString(text, parseAll=True) - self.model.sections[fragment[0].name] = fragment[0] + def add_fragments(self, text): + fragment_file = self.create_fragment_file(text) + fragment_file = FragmentFile(fragment_file, self.sdkconfig) + self.model.add_fragments_from_file(fragment_file) - def _add_scheme(self, text): - parser = Scheme.get_fragment_grammar() - fragment = parser.parseString(text, parseAll=True) - self.model.schemes[fragment[0].name] = fragment[0] - - def _write(self, expected, actual): - self.script_model.fill(expected, self.sdkconfig) + def write(self, expected, actual): + self.script_model.fill(expected) self.script_model.write(open("expected.ld", "w")) - self.script_model.fill(actual, self.sdkconfig) + self.script_model.fill(actual) self.script_model.write(open("actual.ld", "w")) - def _generate_default_rules(self): + def generate_default_rules(self): rules = dict() # flash_text @@ -100,13 +91,13 @@ class GenerationModelTest(unittest.TestCase): # dram0_data placement_rules = list() - rule = PlacementRule(None, None, None, self.model.sections["data"].entries + self.model.sections["dram"].entries, "dram0_data") + rule = PlacementRule(None, None, None, self.model.sections["data"].entries | self.model.sections["dram"].entries, "dram0_data") placement_rules.append(rule) rules["dram0_data"] = placement_rules # dram0_bss placement_rules = list() - rule = PlacementRule(None, None, None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "dram0_bss") + rule = PlacementRule(None, None, None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "dram0_bss") placement_rules.append(rule) rules["dram0_bss"] = placement_rules @@ -124,7 +115,7 @@ class GenerationModelTest(unittest.TestCase): # rtc_data placement_rules = list() - rule = PlacementRule(None, None, None, self.model.sections["rtc_data"].entries + self.model.sections["rtc_rodata"].entries, "rtc_data") + rule = PlacementRule(None, None, None, self.model.sections["rtc_data"].entries | self.model.sections["rtc_rodata"].entries, "rtc_data") placement_rules.append(rule) rules["rtc_data"] = placement_rules @@ -136,7 +127,7 @@ class GenerationModelTest(unittest.TestCase): return rules - def _compare_rules(self, expected, actual): + def compare_rules(self, expected, actual): self.assertEqual(set(expected.keys()), set(actual.keys())) for (target, rules) in actual.items(): @@ -154,39 +145,38 @@ class GenerationModelTest(unittest.TestCase): for expected_target_rule in expected_target_rules: self.assertTrue(expected_target_rule in actual_target_rules, message + str(expected_target_rule)) - def _get_default(self, target, rules): + def get_default(self, target, rules): return rules[target][0] - def test_rule_generation_blank(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - """ + def test_rule_generation_default(self): + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + * (default) +""" - self._add_mapping(normal) + self.add_fragments(normal) + actual = self.model.generate_rules(self.sections_info) + expected = self.generate_default_rules() - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) - - expected = self._generate_default_rules() - - self.assertEqual(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_1(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - * (noflash) - """ - self._add_mapping(normal) + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + * (noflash) +""" + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) iram0_text_E1 = PlacementRule("libfreertos.a", "*", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E1 = PlacementRule("libfreertos.a", "*", None, self.model.sections["rodata"].entries, "dram0_data") @@ -199,30 +189,30 @@ class GenerationModelTest(unittest.TestCase): expected["iram0_text"].append(iram0_text_E1) expected["dram0_data"].append(dram0_data_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_2(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - timers (rtc) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + timers (rtc) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) rtc_text_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") # Add the exclusions flash_text_default.add_exclusion(rtc_text_E1) @@ -235,31 +225,31 @@ class GenerationModelTest(unittest.TestCase): expected["rtc_data"].append(rtc_data_E1) expected["rtc_bss"].append(rtc_bss_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_3(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - timers (rtc) - * (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + timers (rtc) + * (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) rtc_text_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E1 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E2 = PlacementRule("libfreertos.a", "*", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E2 = PlacementRule("libfreertos.a", "*", None, self.model.sections["rodata"].entries, "dram0_data") @@ -282,39 +272,39 @@ class GenerationModelTest(unittest.TestCase): expected["rtc_data"].append(rtc_data_E1) expected["rtc_bss"].append(rtc_bss_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_4(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine (rtc) - event_groups (noflash) - timers (rtc) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine (rtc) + event_groups (noflash) + timers (rtc) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) rtc_text_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E2 = PlacementRule("libfreertos.a", "event_groups", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E2 = PlacementRule("libfreertos.a", "event_groups", None, self.model.sections["rodata"].entries, "dram0_data") rtc_text_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") # Add the exclusions flash_text_default.add_exclusion(rtc_text_E3) @@ -342,40 +332,40 @@ class GenerationModelTest(unittest.TestCase): expected["rtc_data"].append(rtc_data_E1) expected["rtc_bss"].append(rtc_bss_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_5(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine (rtc) - event_groups (noflash) - timers (rtc) - * (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine (rtc) + event_groups (noflash) + timers (rtc) + * (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) rtc_text_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E2 = PlacementRule("libfreertos.a", "event_groups", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E2 = PlacementRule("libfreertos.a", "event_groups", None, self.model.sections["rodata"].entries, "dram0_data") rtc_text_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E3 = PlacementRule("libfreertos.a", "timers", None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E4 = PlacementRule("libfreertos.a", "*", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E4 = PlacementRule("libfreertos.a", "*", None, self.model.sections["rodata"].entries, "dram0_data") @@ -412,24 +402,24 @@ class GenerationModelTest(unittest.TestCase): expected["rtc_data"].append(rtc_data_E1) expected["rtc_bss"].append(rtc_bss_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_6(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine:prvCheckPendingReadyList (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine:prvCheckPendingReadyList (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) iram0_text_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckPendingReadyList", self.model.sections["text"].entries, "iram0_text") dram0_data_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckPendingReadyList", self.model.sections["rodata"].entries, "dram0_data") @@ -451,26 +441,26 @@ class GenerationModelTest(unittest.TestCase): expected["iram0_text"].append(iram0_text_E1) expected["dram0_data"].append(dram0_data_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_7(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine:prvCheckPendingReadyList (noflash) - croutine:prvCheckDelayedList (noflash) - croutine:xCoRoutineCreate (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine:prvCheckPendingReadyList (noflash) + croutine:prvCheckDelayedList (noflash) + croutine:xCoRoutineCreate (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) iram0_text_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckPendingReadyList", self.model.sections["text"].entries, "iram0_text") dram0_data_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckPendingReadyList", self.model.sections["rodata"].entries, "dram0_data") @@ -510,37 +500,37 @@ class GenerationModelTest(unittest.TestCase): expected["iram0_text"].append(iram0_text_E3) expected["dram0_data"].append(dram0_data_E3) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_8(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine:prvCheckPendingReadyList (noflash) - croutine:prvCheckDelayedList (rtc) - croutine:xCoRoutineCreate (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine:prvCheckPendingReadyList (noflash) + croutine:prvCheckDelayedList (rtc) + croutine:xCoRoutineCreate (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) iram0_text_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckPendingReadyList", self.model.sections["text"].entries, "iram0_text") dram0_data_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckPendingReadyList", self.model.sections["rodata"].entries, "dram0_data") rtc_text_E2 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["text"].entries, "rtc_text") rtc_data_E2 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", - self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") + self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") rtc_bss_E2 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", - self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E3 = PlacementRule("libfreertos.a", "croutine", "xCoRoutineCreate", self.model.sections["text"].entries, "iram0_text") dram0_data_E3 = PlacementRule("libfreertos.a", "croutine", "xCoRoutineCreate", self.model.sections["rodata"].entries, "dram0_data") @@ -583,33 +573,33 @@ class GenerationModelTest(unittest.TestCase): expected["iram0_text"].append(iram0_text_E3) expected["dram0_data"].append(dram0_data_E3) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_9(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine:prvCheckDelayedList (rtc) - croutine (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine:prvCheckDelayedList (rtc) + croutine (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) rtc_text_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["text"].entries, "rtc_text") rtc_data_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", - self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") + self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") rtc_bss_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", - self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E2 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E2 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["rodata"].entries, "dram0_data") @@ -641,34 +631,34 @@ class GenerationModelTest(unittest.TestCase): expected["rtc_data"].append(rtc_data_E1) expected["rtc_bss"].append(rtc_bss_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_10(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine:prvCheckDelayedList (rtc) - * (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine:prvCheckDelayedList (rtc) + * (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - iram0_text_default = self._get_default("iram0_text", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + iram0_text_default = self.get_default("iram0_text", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) rtc_text_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["text"].entries, "rtc_text") rtc_data_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", - self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") + self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") rtc_bss_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", - self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E2 = PlacementRule("libfreertos.a", None, None, self.model.sections["text"].entries, "iram0_text") dram0_data_E2 = PlacementRule("libfreertos.a", None, None, self.model.sections["rodata"].entries, "dram0_data") @@ -704,36 +694,36 @@ class GenerationModelTest(unittest.TestCase): expected["rtc_data"].append(rtc_data_E1) expected["rtc_bss"].append(rtc_bss_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_11(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine:prvCheckDelayedList (noflash) - croutine (rtc) - * (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine:prvCheckDelayedList (noflash) + croutine (rtc) + * (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - iram0_text_default = self._get_default("iram0_text", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + iram0_text_default = self.get_default("iram0_text", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) iram0_text_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["text"].entries, "iram0_text") dram0_data_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["rodata"].entries, "dram0_data") rtc_text_E2 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E2 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E2 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E2 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E2 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E3 = PlacementRule("libfreertos.a", None, None, self.model.sections["text"].entries, "iram0_text") dram0_data_E3 = PlacementRule("libfreertos.a", None, None, self.model.sections["rodata"].entries, "dram0_data") @@ -762,41 +752,41 @@ class GenerationModelTest(unittest.TestCase): expected["iram0_text"].append(iram0_text_E3) expected["dram0_data"].append(dram0_data_E3) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_12(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine:prvCheckDelayedList (rtc) - croutine (noflash) - * (rtc) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine:prvCheckDelayedList (rtc) + croutine (noflash) + * (rtc) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) rtc_text_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["text"].entries, "rtc_text") rtc_data_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", - self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") + self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") rtc_bss_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", - self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E2 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E2 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["rodata"].entries, "dram0_data") rtc_text_E3 = PlacementRule("libfreertos.a", None, None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E3 = PlacementRule("libfreertos.a", None, None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E3 = PlacementRule("libfreertos.a", None, None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E3 = PlacementRule("libfreertos.a", None, None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E3 = PlacementRule("libfreertos.a", None, None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") rtc_data_extra = PlacementRule("libfreertos.a", "croutine", None, [".data.*"], "rtc_data") rtc_bss_extra = PlacementRule("libfreertos.a", "croutine", None, [".bss.*"], "rtc_bss") @@ -832,30 +822,30 @@ class GenerationModelTest(unittest.TestCase): expected["rtc_data"].append(rtc_data_E3) expected["rtc_bss"].append(rtc_bss_E3) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_13(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine:prvCheckDelayedList (noflash) - event_groups:xEventGroupCreate (noflash) - croutine (rtc) - event_groups (rtc) - * (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine:prvCheckDelayedList (noflash) + event_groups:xEventGroupCreate (noflash) + croutine (rtc) + event_groups (rtc) + * (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) iram0_text_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["text"].entries, "iram0_text") dram0_data_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["rodata"].entries, "dram0_data") @@ -864,14 +854,14 @@ class GenerationModelTest(unittest.TestCase): dram0_data_E2 = PlacementRule("libfreertos.a", "event_groups", "xEventGroupCreate", self.model.sections["rodata"].entries, "dram0_data") rtc_text_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") rtc_text_E4 = PlacementRule("libfreertos.a", "event_groups", None, self.model.sections["text"].entries, "rtc_text") rtc_data_E4 = PlacementRule("libfreertos.a", "event_groups", None, - self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") + self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") rtc_bss_E4 = PlacementRule("libfreertos.a", "event_groups", None, - self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E5 = PlacementRule("libfreertos.a", None, None, self.model.sections["text"].entries, "iram0_text") dram0_data_E5 = PlacementRule("libfreertos.a", None, None, self.model.sections["rodata"].entries, "dram0_data") @@ -913,42 +903,42 @@ class GenerationModelTest(unittest.TestCase): expected["iram0_text"].append(iram0_text_E5) expected["dram0_data"].append(dram0_data_E5) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_14(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine:prvCheckDelayedList (noflash) - event_groups:xEventGroupCreate (rtc) - croutine (rtc) - event_groups (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine:prvCheckDelayedList (noflash) + event_groups:xEventGroupCreate (rtc) + croutine (rtc) + event_groups (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) - dram0_data_default = self._get_default("dram0_data", expected) - dram0_bss_default = self._get_default("dram0_bss", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + dram0_data_default = self.get_default("dram0_data", expected) + dram0_bss_default = self.get_default("dram0_bss", expected) iram0_text_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["text"].entries, "iram0_text") dram0_data_E1 = PlacementRule("libfreertos.a", "croutine", "prvCheckDelayedList", self.model.sections["rodata"].entries, "dram0_data") rtc_text_E2 = PlacementRule("libfreertos.a", "event_groups", "xEventGroupCreate", self.model.sections["text"].entries, "rtc_text") rtc_data_E2 = PlacementRule("libfreertos.a", "event_groups", "xEventGroupCreate", - self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") + self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") rtc_bss_E2 = PlacementRule("libfreertos.a", "event_groups", "xEventGroupCreate", - self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") rtc_text_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["text"].entries, "rtc_text") - rtc_data_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries + self.model.sections["rodata"].entries, "rtc_data") - rtc_bss_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries + self.model.sections["common"].entries, "rtc_bss") + rtc_data_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["data"].entries | self.model.sections["rodata"].entries, "rtc_data") + rtc_bss_E3 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["bss"].entries | self.model.sections["common"].entries, "rtc_bss") iram0_text_E4 = PlacementRule("libfreertos.a", "event_groups", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E4 = PlacementRule("libfreertos.a", "event_groups", None, self.model.sections["rodata"].entries, "dram0_data") @@ -993,25 +983,25 @@ class GenerationModelTest(unittest.TestCase): expected["dram0_data"].append(dram0_data_extra) expected["dram0_bss"].append(dram0_bss_extra) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_15(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine (noflash_data) - croutine (noflash_text) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine (noflash_data) + croutine (noflash_text) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) iram0_text_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["rodata"].entries, "dram0_data") @@ -1024,25 +1014,25 @@ class GenerationModelTest(unittest.TestCase): expected["iram0_text"].append(iram0_text_E1) expected["dram0_data"].append(dram0_data_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_nominal_16(self): - normal = """ - [mapping] - archive: libfreertos.a - entries: - croutine (noflash_data) - croutine (noflash) - """ + normal = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine (noflash_data) + croutine (noflash) +""" - self._add_mapping(normal) + self.add_fragments(normal) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) + actual = self.model.generate_rules(self.sections_info) - expected = self._generate_default_rules() + expected = self.generate_default_rules() - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) iram0_text_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["text"].entries, "iram0_text") dram0_data_E1 = PlacementRule("libfreertos.a", "croutine", None, self.model.sections["rodata"].entries, "dram0_data") @@ -1055,60 +1045,58 @@ class GenerationModelTest(unittest.TestCase): expected["iram0_text"].append(iram0_text_E1) expected["dram0_data"].append(dram0_data_E1) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) def test_rule_generation_conflict(self): - conflict_mapping = """ - [mapping] - archive: libfreertos.a - entries: - croutine (conflict) - croutine (noflash) - """ + conflict_mapping = u""" +[mapping:test] +archive: libfreertos.a +entries: + croutine (conflict) + croutine (noflash) - conflict_scheme = """ - [scheme:conflict] - entries: - rodata -> dram0_data - bss -> dram0_data - """ - - self._add_scheme(conflict_scheme) - self._add_mapping(conflict_mapping) +[scheme:conflict] +entries: + rodata -> dram0_data + bss -> dram0_data +""" + self.add_fragments(conflict_mapping) with self.assertRaises(GenerationException): - self.model.generate_rules(self.sdkconfig, self.sections_info) + self.model.generate_rules(self.sections_info) def test_rule_generation_condition(self): - generation_with_condition = """ - [mapping] - archive: lib.a - entries: - : PERFORMANCE_LEVEL = 0 - : PERFORMANCE_LEVEL = 1 - obj1 (noflash) - : PERFORMANCE_LEVEL = 2 - obj1 (noflash) - obj2 (noflash) - : PERFORMANCE_LEVEL = 3 - obj1 (noflash) - obj2 (noflash) - obj3 (noflash) - """ - - self._add_mapping(generation_with_condition) + generation_with_condition = u""" +[mapping:test] +archive: lib.a +entries: + if PERFORMANCE_LEVEL = 1: + obj1 (noflash) + elif PERFORMANCE_LEVEL = 2: + obj1 (noflash) + obj2 (noflash) + elif PERFORMANCE_LEVEL = 3: + obj1 (noflash) + obj2 (noflash) + obj3 (noflash) + else: # PERFORMANCE_LEVEL = 0 + * (default) +""" for perf_level in range(0, 4): self.sdkconfig.config.syms["PERFORMANCE_LEVEL"].set_value(str(perf_level)) - actual = self.model.generate_rules(self.sdkconfig, self.sections_info) - expected = self._generate_default_rules() + self.model.mappings = {} + self.add_fragments(generation_with_condition) - flash_text_default = self._get_default("flash_text", expected) - flash_rodata_default = self._get_default("flash_rodata", expected) + actual = self.model.generate_rules(self.sections_info) + expected = self.generate_default_rules() if perf_level < 4: for append_no in range(1, perf_level + 1): + flash_text_default = self.get_default("flash_text", expected) + flash_rodata_default = self.get_default("flash_rodata", expected) + iram_rule = PlacementRule("lib.a", "obj" + str(append_no), None, self.model.sections["text"].entries, "iram0_text") dram_rule = PlacementRule("lib.a", "obj" + str(append_no), None, self.model.sections["rodata"].entries, "dram0_data") @@ -1118,7 +1106,89 @@ class GenerationModelTest(unittest.TestCase): expected["iram0_text"].append(iram_rule) expected["dram0_data"].append(dram_rule) - self._compare_rules(expected, actual) + self.compare_rules(expected, actual) + + def test_conditional_sections_1(self): + generation_with_condition = u""" +[sections:cond_text_data] +entries: + if PERFORMANCE_LEVEL >= 1: + .text+ + .literal+ + else: + .data+ + +[scheme:cond_noflash] +entries: + if PERFORMANCE_LEVEL >= 1: + cond_text_data -> iram0_text + else: + cond_text_data -> dram0_data + +[mapping:test] +archive: lib.a +entries: + * (cond_noflash) +""" + + self.sdkconfig.config.syms["PERFORMANCE_LEVEL"].set_value("1") + self.add_fragments(generation_with_condition) + + actual = self.model.generate_rules(self.sections_info) + expected = self.generate_default_rules() + + flash_text_default = self.get_default("flash_text", expected) + + iram0_text_E1 = PlacementRule("lib.a", "*", None, self.model.sections["text"].entries, "iram0_text") + + # Add the exclusions + flash_text_default.add_exclusion(iram0_text_E1) + + # Add to the placement rules list + expected["iram0_text"].append(iram0_text_E1) + + self.compare_rules(expected, actual) + + def test_conditional_sections_2(self): + generation_with_condition = u""" +[sections:cond_text_data] +entries: + if PERFORMANCE_LEVEL >= 1: + .text+ + .literal+ + else: + .rodata+ + +[scheme:cond_noflash] +entries: + if PERFORMANCE_LEVEL >= 1: + cond_text_data -> iram0_text + else: + cond_text_data -> dram0_data + +[mapping:test] +archive: lib.a +entries: + * (cond_noflash) +""" + + self.sdkconfig.config.syms["PERFORMANCE_LEVEL"].set_value("0") + self.add_fragments(generation_with_condition) + + actual = self.model.generate_rules(self.sections_info) + expected = self.generate_default_rules() + + flash_rodata_default = self.get_default("flash_rodata", expected) + + dram0_data_E1 = PlacementRule("lib.a", "*", None, self.model.sections["rodata"].entries, "dram0_data") + + # Add the exclusions + flash_rodata_default.add_exclusion(dram0_data_E1) + + # Add to the placement rules list + expected["dram0_data"].append(dram0_data_E1) + + self.compare_rules(expected, actual) if __name__ == "__main__":