separate more integration tests

2 files changed, 143 insertions, 143 deletions

diff --git a/tests/integration/tests.py b/tests/integration/tests.py
index ac7da3e..7dcfbf4 100644
--- a/tests/integration/tests.py
+++ b/tests/integration/tests.py
@@ -235,5 +235,148 @@ class TestEncodedText(unittest.TestCase):
         self.assertEqual(len(p.commands), 2)
         self.assertEqual(len(p.commands[0]["lines"]), 41)
 
+class TestScript(unittest.TestCase):
+    """for testing parse_script_engine_script_at and script parsing in
+    general. Script should be a class."""
+    #def test_parse_script_engine_script_at(self):
+    #    pass # or raise NotImplementedError, bryan_message
+
+    def test_find_all_text_pointers_in_script_engine_script(self):
+        address = 0x197637 # 0x197634
+        script = parse_script_engine_script_at(address, debug=False)
+        bank = calculate_bank(address)
+        r = find_all_text_pointers_in_script_engine_script(script, bank=bank, debug=False)
+        results = list(r)
+        self.assertIn(0x197661, results)
+
+class TestByteParams(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        load_rom()
+        cls.address = 10
+        cls.sbp = SingleByteParam(address=cls.address)
+
+    @classmethod
+    def tearDownClass(cls):
+        del cls.sbp
+
+    def test__init__(self):
+        self.assertEqual(self.sbp.size, 1)
+        self.assertEqual(self.sbp.address, self.address)
+
+    def test_parse(self):
+        self.sbp.parse()
+        self.assertEqual(str(self.sbp.byte), str(45))
+
+    def test_to_asm(self):
+        self.assertEqual(self.sbp.to_asm(), "$2d")
+        self.sbp.should_be_decimal = True
+        self.assertEqual(self.sbp.to_asm(), str(45))
+
+    # HexByte and DollarSignByte are the same now
+    def test_HexByte_to_asm(self):
+        h = HexByte(address=10)
+        a = h.to_asm()
+        self.assertEqual(a, "$2d")
+
+    def test_DollarSignByte_to_asm(self):
+        d = DollarSignByte(address=10)
+        a = d.to_asm()
+        self.assertEqual(a, "$2d")
+
+    def test_ItemLabelByte_to_asm(self):
+        i = ItemLabelByte(address=433)
+        self.assertEqual(i.byte, 54)
+        self.assertEqual(i.to_asm(), "COIN_CASE")
+        self.assertEqual(ItemLabelByte(address=10).to_asm(), "$2d")
+
+    def test_DecimalParam_to_asm(self):
+        d = DecimalParam(address=10)
+        x = d.to_asm()
+        self.assertEqual(x, str(0x2d))
+
+class TestMultiByteParam(unittest.TestCase):
+    def setup_for(self, somecls, byte_size=2, address=443, **kwargs):
+        self.cls = somecls(address=address, size=byte_size, **kwargs)
+        self.assertEqual(self.cls.address, address)
+        self.assertEqual(self.cls.bytes, rom_interval(address, byte_size, strings=False))
+        self.assertEqual(self.cls.size, byte_size)
+
+    def test_two_byte_param(self):
+        self.setup_for(MultiByteParam, byte_size=2)
+        self.assertEqual(self.cls.to_asm(), "$f0c0")
+
+    def test_three_byte_param(self):
+        self.setup_for(MultiByteParam, byte_size=3)
+
+    def test_PointerLabelParam_no_bank(self):
+        self.setup_for(PointerLabelParam, bank=None)
+        # assuming no label at this location..
+        self.assertEqual(self.cls.to_asm(), "$f0c0")
+        global all_labels
+        # hm.. maybe all_labels should be using a class?
+        all_labels = [{"label": "poop", "address": 0xf0c0,
+                       "offset": 0xf0c0, "bank": 0,
+                       "line_number": 2
+                     }]
+        self.assertEqual(self.cls.to_asm(), "poop")
+
+class TestPostParsing: #(unittest.TestCase):
+    """tests that must be run after parsing all maps"""
+    def test_signpost_counts(self):
+        self.assertEqual(len(map_names[1][1]["signposts"]), 0)
+        self.assertEqual(len(map_names[1][2]["signposts"]), 2)
+        self.assertEqual(len(map_names[10][5]["signposts"]), 7)
+
+    def test_warp_counts(self):
+        self.assertEqual(map_names[10][5]["warp_count"], 9)
+        self.assertEqual(map_names[18][5]["warp_count"], 3)
+        self.assertEqual(map_names[15][1]["warp_count"], 2)
+
+    def test_map_sizes(self):
+        self.assertEqual(map_names[15][1]["height"], 18)
+        self.assertEqual(map_names[15][1]["width"], 10)
+        self.assertEqual(map_names[7][1]["height"], 4)
+        self.assertEqual(map_names[7][1]["width"], 4)
+
+    def test_map_connection_counts(self):
+        self.assertEqual(map_names[7][1]["connections"], 0)
+        self.assertEqual(map_names[10][1]["connections"], 12)
+        self.assertEqual(map_names[10][2]["connections"], 12)
+        self.assertEqual(map_names[11][1]["connections"], 9) # or 13?
+
+    def test_second_map_header_address(self):
+        self.assertEqual(map_names[11][1]["second_map_header_address"], 0x9509c)
+        self.assertEqual(map_names[1][5]["second_map_header_address"], 0x95bd0)
+
+    def test_event_address(self):
+        self.assertEqual(map_names[17][5]["event_address"], 0x194d67)
+        self.assertEqual(map_names[23][3]["event_address"], 0x1a9ec9)
+
+    def test_people_event_counts(self):
+        self.assertEqual(len(map_names[23][3]["people_events"]), 4)
+        self.assertEqual(len(map_names[10][3]["people_events"]), 9)
+
+class TestMapParsing(unittest.TestCase):
+    def test_parse_all_map_headers(self):
+        global parse_map_header_at, old_parse_map_header_at, counter
+        counter = 0
+        for k in map_names.keys():
+            if "offset" not in map_names[k].keys():
+                map_names[k]["offset"] = 0
+        temp = parse_map_header_at
+        temp2 = old_parse_map_header_at
+        def parse_map_header_at(address, map_group=None, map_id=None, debug=False):
+            global counter
+            counter += 1
+            return {}
+        old_parse_map_header_at = parse_map_header_at
+        parse_all_map_headers(debug=False)
+        # parse_all_map_headers is currently doing it 2x
+        # because of the new/old map header parsing routines
+        self.assertEqual(counter, 388 * 2)
+        parse_map_header_at = temp
+        old_parse_map_header_at = temp2
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/tests.py b/tests/tests.py
index 193e49b..bed8213 100644
--- a/tests/tests.py
+++ b/tests/tests.py
@@ -542,27 +542,6 @@ class TestAsmList(unittest.TestCase):
         self.assertNotIn("No newline at end of file", diff)
         self.assertIn("+"+asm[1], diff)
 
-class TestMapParsing(unittest.TestCase):
-    def test_parse_all_map_headers(self):
-        global parse_map_header_at, old_parse_map_header_at, counter
-        counter = 0
-        for k in map_names.keys():
-            if "offset" not in map_names[k].keys():
-                map_names[k]["offset"] = 0
-        temp = parse_map_header_at
-        temp2 = old_parse_map_header_at
-        def parse_map_header_at(address, map_group=None, map_id=None, debug=False):
-            global counter
-            counter += 1
-            return {}
-        old_parse_map_header_at = parse_map_header_at
-        parse_all_map_headers(debug=False)
-        # parse_all_map_headers is currently doing it 2x
-        # because of the new/old map header parsing routines
-        self.assertEqual(counter, 388 * 2)
-        parse_map_header_at = temp
-        old_parse_map_header_at = temp2
-
 class TestTextScript(unittest.TestCase):
     """for testing 'in-script' commands, etc."""
     #def test_to_asm(self):
@@ -579,20 +558,6 @@ class TestEncodedText(unittest.TestCase):
     def test_parse_text_from_bytes(self): pass
     def test_parse_text_at(self): pass
 
-class TestScript(unittest.TestCase):
-    """for testing parse_script_engine_script_at and script parsing in
-    general. Script should be a class."""
-    #def test_parse_script_engine_script_at(self):
-    #    pass # or raise NotImplementedError, bryan_message
-
-    def test_find_all_text_pointers_in_script_engine_script(self):
-        address = 0x197637 # 0x197634
-        script = parse_script_engine_script_at(address, debug=False)
-        bank = calculate_bank(address)
-        r = find_all_text_pointers_in_script_engine_script(script, bank=bank, debug=False)
-        results = list(r)
-        self.assertIn(0x197661, results)
-
 class TestLabel(unittest.TestCase):
     def test_label_making(self):
         line_number = 2
@@ -609,114 +574,6 @@ class TestLabel(unittest.TestCase):
         self.assertEqual(l.name, label_name)
         self.assertEqual(l.address, address)
 
-class TestByteParams(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        load_rom()
-        cls.address = 10
-        cls.sbp = SingleByteParam(address=cls.address)
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.sbp
-
-    def test__init__(self):
-        self.assertEqual(self.sbp.size, 1)
-        self.assertEqual(self.sbp.address, self.address)
-
-    def test_parse(self):
-        self.sbp.parse()
-        self.assertEqual(str(self.sbp.byte), str(45))
-
-    def test_to_asm(self):
-        self.assertEqual(self.sbp.to_asm(), "$2d")
-        self.sbp.should_be_decimal = True
-        self.assertEqual(self.sbp.to_asm(), str(45))
-
-    # HexByte and DollarSignByte are the same now
-    def test_HexByte_to_asm(self):
-        h = HexByte(address=10)
-        a = h.to_asm()
-        self.assertEqual(a, "$2d")
-
-    def test_DollarSignByte_to_asm(self):
-        d = DollarSignByte(address=10)
-        a = d.to_asm()
-        self.assertEqual(a, "$2d")
-
-    def test_ItemLabelByte_to_asm(self):
-        i = ItemLabelByte(address=433)
-        self.assertEqual(i.byte, 54)
-        self.assertEqual(i.to_asm(), "COIN_CASE")
-        self.assertEqual(ItemLabelByte(address=10).to_asm(), "$2d")
-
-    def test_DecimalParam_to_asm(self):
-        d = DecimalParam(address=10)
-        x = d.to_asm()
-        self.assertEqual(x, str(0x2d))
-
-class TestMultiByteParam(unittest.TestCase):
-    def setup_for(self, somecls, byte_size=2, address=443, **kwargs):
-        self.cls = somecls(address=address, size=byte_size, **kwargs)
-        self.assertEqual(self.cls.address, address)
-        self.assertEqual(self.cls.bytes, rom_interval(address, byte_size, strings=False))
-        self.assertEqual(self.cls.size, byte_size)
-
-    def test_two_byte_param(self):
-        self.setup_for(MultiByteParam, byte_size=2)
-        self.assertEqual(self.cls.to_asm(), "$f0c0")
-
-    def test_three_byte_param(self):
-        self.setup_for(MultiByteParam, byte_size=3)
-
-    def test_PointerLabelParam_no_bank(self):
-        self.setup_for(PointerLabelParam, bank=None)
-        # assuming no label at this location..
-        self.assertEqual(self.cls.to_asm(), "$f0c0")
-        global all_labels
-        # hm.. maybe all_labels should be using a class?
-        all_labels = [{"label": "poop", "address": 0xf0c0,
-                       "offset": 0xf0c0, "bank": 0,
-                       "line_number": 2
-                     }]
-        self.assertEqual(self.cls.to_asm(), "poop")
-
-class TestPostParsing: #(unittest.TestCase):
-    """tests that must be run after parsing all maps"""
-    def test_signpost_counts(self):
-        self.assertEqual(len(map_names[1][1]["signposts"]), 0)
-        self.assertEqual(len(map_names[1][2]["signposts"]), 2)
-        self.assertEqual(len(map_names[10][5]["signposts"]), 7)
-
-    def test_warp_counts(self):
-        self.assertEqual(map_names[10][5]["warp_count"], 9)
-        self.assertEqual(map_names[18][5]["warp_count"], 3)
-        self.assertEqual(map_names[15][1]["warp_count"], 2)
-
-    def test_map_sizes(self):
-        self.assertEqual(map_names[15][1]["height"], 18)
-        self.assertEqual(map_names[15][1]["width"], 10)
-        self.assertEqual(map_names[7][1]["height"], 4)
-        self.assertEqual(map_names[7][1]["width"], 4)
-
-    def test_map_connection_counts(self):
-        self.assertEqual(map_names[7][1]["connections"], 0)
-        self.assertEqual(map_names[10][1]["connections"], 12)
-        self.assertEqual(map_names[10][2]["connections"], 12)
-        self.assertEqual(map_names[11][1]["connections"], 9) # or 13?
-
-    def test_second_map_header_address(self):
-        self.assertEqual(map_names[11][1]["second_map_header_address"], 0x9509c)
-        self.assertEqual(map_names[1][5]["second_map_header_address"], 0x95bd0)
-
-    def test_event_address(self):
-        self.assertEqual(map_names[17][5]["event_address"], 0x194d67)
-        self.assertEqual(map_names[23][3]["event_address"], 0x1a9ec9)
-
-    def test_people_event_counts(self):
-        self.assertEqual(len(map_names[23][3]["people_events"]), 4)
-        self.assertEqual(len(map_names[10][3]["people_events"]), 9)
-
 # run the unit tests when this file is executed directly
 if __name__ == "__main__":
     unittest.main()