diff --git a/gdb-port/tests/run_unittest_main.py b/gdb-port/tests/run_unittest_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..decab90a023e4f8078aa262cc743f66ad39382f0
--- /dev/null
+++ b/gdb-port/tests/run_unittest_main.py
@@ -0,0 +1,3 @@
+import unittest
+
+unittest.main(exit=False)
diff --git a/gdb-port/tests/unit/breakpoints_hammer.py b/gdb-port/tests/unit/breakpoints_hammer.py
index fef2eb9e8786d60c0687dc1b8a59663c025742bf..6d51f9d869f8d1239d88f9f4acc5996be4bf1a1e 100644
--- a/gdb-port/tests/unit/breakpoints_hammer.py
+++ b/gdb-port/tests/unit/breakpoints_hammer.py
@@ -3,9 +3,10 @@ import unittest
class PerformLowlevelParseRetBreakpointCreated(unittest.TestCase):
def test_breakpoint_is_at_ret(self):
+ breakpoint_loc = int(perform_lowlevel_parse_ret.location.lstrip("*"), 16)
arch = gdb.selected_frame().architecture()
- disassembled_ins = arch.disassemble(perform_lowlevel_parse_ret.location)
- ins = disassembled_ins['asm'].split(" ")[0]
+ disassembled_ins = arch.disassemble(breakpoint_loc)
+ ins = disassembled_ins[0]['asm'].split(" ")[0]
self.assertIn(ins, ["ret", "retq"])
@@ -14,9 +15,10 @@ class PerformLowlevelParseRetBreakpointCreated(unittest.TestCase):
class HPackratParseRetBreakpointCreated(unittest.TestCase):
def test_breakpoint_is_at_ret(self):
+ breakpoint_loc = int(h_packrat_parse_ret.location.lstrip("*"), 16)
arch = gdb.selected_frame().architecture()
- disassembled_ins = arch.disassemble(h_packrat_parse_ret.location)
- ins = disassembled_ins['asm'].split(" ")[0]
+ disassembled_ins = arch.disassemble(breakpoint_loc)
+ ins = disassembled_ins[0]['asm'].split(" ")[0]
self.assertIn(ins, ["ret", "retq"])
diff --git a/gdb-port/tests/unit/breakpoints_pdf.py b/gdb-port/tests/unit/breakpoints_pdf.py
index 3c0ecb8bf35a2aa72c9da1d3ab038bc242003cc3..b179e629758eefc0da82e1a74274cb57584fee02 100644
--- a/gdb-port/tests/unit/breakpoints_pdf.py
+++ b/gdb-port/tests/unit/breakpoints_pdf.py
@@ -3,12 +3,12 @@ import unittest
# TODO: This actually tests whether the main script set up the breakpoint properly, move to integration
class InitParserBreakpointCreated(unittest.TestCase):
def test_breakpoint_is_at_ret(self):
+ breakpoint_loc = int(init_parser.location.lstrip("*"), 16)
arch = gdb.selected_frame().architecture()
- disassembled_ins = arch.disassemble(init_parser.location)
- ins = disassembled_ins['asm'].split(" ")[0]
+ disassembled_ins = arch.disassemble(breakpoint_loc)
+ ins = disassembled_ins[0]['asm'].split(" ")[0]
self.assertIn(ins, ["ret", "retq"])
def test_not_pending(self):
self.assertFalse(init_parser.pending)
-
diff --git a/gdb-port/tests/unit/parser-envs-pdf.py b/gdb-port/tests/unit/parser-envs-pdf.py
index 5cb9f60daae8197e49316190dd2f8f28876d66b5..13207bd1bd842d7977023d544a60e6b39dc45ca7 100644
--- a/gdb-port/tests/unit/parser-envs-pdf.py
+++ b/gdb-port/tests/unit/parser-envs-pdf.py
@@ -126,4 +126,4 @@ class TokenEnvCreation(unittest.TestCase):
self.assertIsNotNone(self.parser_env.str_len)
self.assertIsInstance(self.parser_env.str_len, int)
-unittest.main()
+unittest.main(exit=False)
diff --git a/gdb-port/tests/unit/parser_envs_pdf.py b/gdb-port/tests/unit/parser_envs_pdf.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c6b973e2d304a18dbfde0552c7953927fcbdb0f
--- /dev/null
+++ b/gdb-port/tests/unit/parser_envs_pdf.py
@@ -0,0 +1,128 @@
+# These tests use parsers defined in the PDF parser, for expediency
+# There's probably a way to test them in a general manner, but they'd need to be mocked out in process memory
+import unittest
+
+hparser_p_t = gdb.lookup_type("HParser").pointer()
+
+
+class ChoiceEnvCreation(unittest.TestCase):
+ # setup is also done by parser-name-instrumentation.py and parser-type-instrumentation.py
+ def setUp(self):
+ self.parser_obj = top_level_parse.parsers_by_name("eol")[0]
+ self.parser_env = top_level_parse.parser_decombinator.decompose_parser(self.parser_obj,top_level_parse)
+
+ def test_parser_decombine(self):
+ self.assertIsInstance(self.parser_env, ChoiceEnv)
+
+ def test_member_parsers(self):
+ self.assertIsNotNone(self.parser_env.member_parsers)
+ for p in self.parser_env.member_parsers:
+ self.assertIsInstance(p, Parser)
+
+ def test_member_parsers_name(self):
+ for p in self.parser_env.member_parsers:
+ self.assertIsNotNone(p.name)
+
+ def test_member_parsers_size(self):
+ self.assertEqual(len(self.parser_env.member_parsers),3)
+
+
+# Maybe separate tests for h_left, h_middle, etc.?
+class IgnoreSeqEnvCreation(unittest.TestCase):
+ # setup is also done by parser-name-instrumentation.py and parser-type-instrumentation.py
+ def setUp(self):
+ self.parser_obj = top_level_parse.parsers_by_name("name")[0]
+ self.parser_env = top_level_parse.parser_decombinator.decompose_parser(self.parser_obj,top_level_parse)
+
+ def test_parser_decombine(self):
+ self.assertIsInstance(self.parser_env, IgnoreSeqEnv)
+
+ def test_member_parsers(self):
+ self.assertIsNotNone(self.parser_env.member_parsers)
+ for p in self.parser_env.member_parsers:
+ self.assertIsInstance(p, Parser)
+
+ def test_member_parsers_name(self):
+ for p in self.parser_env.member_parsers:
+ self.assertIsNotNone(p.name)
+
+ def test_which(self):
+ self.assertIsNotNone(self.parser_env.which)
+ self.assertIsInstance(self.parser_env.which, int)
+
+ def test_member_parsers_size(self):
+ self.assertEqual(len(self.parser_env.member_parsers),2)
+
+
+class ManyEnvCreation(unittest.TestCase):
+ # setup is also done by parser-name-instrumentation.py and parser-type-instrumentation.py
+ def setUp(self):
+ self.parser_obj = top_level_parse.parsers_by_name("digits")[0]
+ self.parser_env = top_level_parse.parser_decombinator.decompose_parser(self.parser_obj,top_level_parse)
+
+ def test_parser_decombine(self):
+ self.assertIsInstance(self.parser_env, ManyEnv)
+
+ def test_member_parser(self):
+ self.assertIsNotNone(self.parser_env.p)
+ self.assertIsInstance(self.parser_env.p, Parser)
+
+ def test_member_parser_name(self):
+ self.assertIsNotNone(self.parser_env.p.name)
+
+
+# TODO: some parser combinators aren't represented in the H_RULE()s declared
+#class NotEnvCreation(unittest.TestCase):
+ #def setUp(self):
+ # self.parser_obj = top_level_parse.parsers_by_name("")[0]
+ # self.parser_env = top_level_parse.parser_decombinator.decompose_parser(self.parser_obj,top_level_parse)
+
+ #def test_parser_decombine(self):
+ # self.assertIsInstance(self.parser_env, NotEnv)
+
+ #def test_member_parser(self):
+ # Member parser gets extracted from memory
+ # self.assertIsNotNone(self.parser_env.member_parser)
+ # Parser gets named on creation
+ # self.assertIsNotNone(self.parser_env.member_parser.name)
+
+
+class SequenceEnvCreation(unittest.TestCase):
+ # setup is also done by parser-name-instrumentation.py and parser-type-instrumentation.py
+ def setUp(self):
+ self.parser_obj = top_level_parse.parsers_by_name("comment")[0]
+ self.parser_env = top_level_parse.parser_decombinator.decompose_parser(self.parser_obj,top_level_parse)
+
+ def test_parser_decombine(self):
+ self.assertIsInstance(self.parser_env, SequenceEnv)
+
+ def test_member_parsers(self):
+ self.assertIsNotNone(self.parser_env.member_parsers)
+ for p in self.parser_env.member_parsers:
+ self.assertIsInstance(p, Parser)
+
+ def test_member_parsers_name(self):
+ for p in self.parser_env.member_parsers:
+ self.assertIsNotNone(p.name)
+
+ def test_member_parsers_size(self):
+ self.assertEqual(len(self.parser_env.member_parsers),3)
+
+class TokenEnvCreation(unittest.TestCase):
+ def setUp(self):
+ self.parser_obj = top_level_parse.parsers_by_name("null")[0]
+ self.parser_env = top_level_parse.parser_decombinator.decompose_parser(self.parser_obj,top_level_parse)
+ self.token_type = gdb.lookup_type("uint8_t").pointer()
+
+ def test_parser_decombine(self):
+ self.assertIsInstance(self.parser_env, TokenEnv)
+
+ def test_token(self):
+ self.assertIsNotNone(self.parser_env.token)
+ self.assertIsInstance(self.parser_env.token, gdb.Value)
+ self.assertEqual(self.parser_env.token.type, self.token_type) # For gdb.Type objects, == checks for equivalence, and the "is" operator won't work
+
+ def test_str_len(self):
+ self.assertIsNotNone(self.parser_env.str_len)
+ self.assertIsInstance(self.parser_env.str_len, int)
+