whitespace cleanup

[nmigen-soc.git] / nmigen_soc / test / test_memory.py

diff --git a/nmigen_soc/test/test_memory.py b/nmigen_soc/test/test_memory.py
index 1e61511849197bdf1afdeef764b69b0f48f36c87..040f7774846cfcfcb6b625b1d754e7d4b63222a4 100644 (file)
--- a/nmigen_soc/test/test_memory.py
+++ b/nmigen_soc/test/test_memory.py
@@ -86,7 +86,8 @@ class MemoryMapTestCase(unittest.TestCase):
     def test_add_resource_wrong_address_unaligned(self):
         memory_map = MemoryMap(addr_width=16, data_width=8, alignment=1)
         with self.assertRaisesRegex(ValueError,
-                r"Explicitly specified address 0x1 must be a multiple of 0x2 bytes"):
+                r"Explicitly specified address 0x1 must be "
+                r"a multiple of 0x2 bytes"):
             memory_map.add_resource("a", size=1, addr=1)
 
     def test_add_resource_wrong_size(self):
@@ -104,19 +105,20 @@ class MemoryMapTestCase(unittest.TestCase):
     def test_add_resource_wrong_out_of_bounds(self):
         memory_map = MemoryMap(addr_width=16, data_width=8)
         with self.assertRaisesRegex(ValueError,
-                r"Address range 0x10000\.\.0x10001 out of bounds for memory map spanning "
-                r"range 0x0\.\.0x10000 \(16 address bits\)"):
+                r"Address range 0x10000\.\.0x10001 out of bounds for memory "
+                r"map spanning range 0x0\.\.0x10000 \(16 address bits\)"):
             memory_map.add_resource("a", addr=0x10000, size=1)
         with self.assertRaisesRegex(ValueError,
-                r"Address range 0x0\.\.0x10001 out of bounds for memory map spanning "
-                r"range 0x0\.\.0x10000 \(16 address bits\)"):
+                r"Address range 0x0\.\.0x10001 out of bounds for memory map "
+                r"spanning range 0x0\.\.0x10000 \(16 address bits\)"):
             memory_map.add_resource("a", size=0x10001)
 
     def test_add_resource_wrong_overlap(self):
         memory_map = MemoryMap(addr_width=16, data_width=8)
         memory_map.add_resource("a", size=16)
         with self.assertRaisesRegex(ValueError,
-                r"Address range 0xa\.\.0xb overlaps with resource 'a' at 0x0\.\.0x10"):
+                r"Address range 0xa\.\.0xb overlaps with resource "
+                r"'a' at 0x0\.\.0x10"):
             memory_map.add_resource("b", size=1, addr=10)
 
     def test_add_resource_wrong_twice(self):
@@ -138,19 +140,22 @@ class MemoryMapTestCase(unittest.TestCase):
     def test_add_window(self):
         memory_map = MemoryMap(addr_width=16, data_width=8)
         self.assertEqual(memory_map.add_resource("a", size=1), (0, 1))
-        self.assertEqual(memory_map.add_window(MemoryMap(addr_width=10, data_width=8)),
+        self.assertEqual(memory_map.add_window(MemoryMap(addr_width=10,
+                                                         data_width=8)),
                          (0x400, 0x800, 1))
         self.assertEqual(memory_map.add_resource("b", size=1), (0x800, 0x801))
 
     def test_add_window_sparse(self):
         memory_map = MemoryMap(addr_width=16, data_width=32)
-        self.assertEqual(memory_map.add_window(MemoryMap(addr_width=10, data_width=8),
+        self.assertEqual(memory_map.add_window(MemoryMap(addr_width=10,
+                                                         data_width=8),
                                                sparse=True),
                          (0, 0x400, 1))
 
     def test_add_window_dense(self):
         memory_map = MemoryMap(addr_width=16, data_width=32)
-        self.assertEqual(memory_map.add_window(MemoryMap(addr_width=10, data_width=8),
+        self.assertEqual(memory_map.add_window(MemoryMap(addr_width=10,
+                                                         data_width=8),
                                                sparse=False),
                          (0, 0x100, 4))
 
@@ -163,39 +168,44 @@ class MemoryMapTestCase(unittest.TestCase):
     def test_add_window_wrong_wider(self):
         memory_map = MemoryMap(addr_width=16, data_width=8)
         with self.assertRaisesRegex(ValueError,
-                r"Window has data width 16, and cannot be added to a memory map "
-                r"with data width 8"):
+                r"Window has data width 16, and cannot be added to a memory "
+                r"map with data width 8"):
             memory_map.add_window(MemoryMap(addr_width=10, data_width=16))
 
     def test_add_window_wrong_no_mode(self):
         memory_map = MemoryMap(addr_width=16, data_width=16)
         with self.assertRaisesRegex(ValueError,
-                r"Address translation mode must be explicitly specified when adding "
-                r"a window with data width 8 to a memory map with data width 16"):
+                r"Address translation mode must be explicitly specified "
+                r"when adding a window with data width 8 to a memory map "
+                r"with data width 16"):
             memory_map.add_window(MemoryMap(addr_width=10, data_width=8))
 
     def test_add_window_wrong_ratio(self):
         memory_map = MemoryMap(addr_width=16, data_width=16)
         with self.assertRaisesRegex(ValueError,
-                r"Dense addressing cannot be used because the memory map data width "
-                r"16 is not an integer multiple of window data width 7"):
-            memory_map.add_window(MemoryMap(addr_width=10, data_width=7), sparse=False)
+                r"Dense addressing cannot be used because the memory map "
+                r"data width 16 is not an integer multiple of window data "
+                r"width 7"):
+            memory_map.add_window(MemoryMap(addr_width=10, data_width=7),
+                                            sparse=False)
 
     def test_add_window_wrong_overlap(self):
         memory_map = MemoryMap(addr_width=16, data_width=8)
         memory_map.add_window(MemoryMap(addr_width=10, data_width=8))
         with self.assertRaisesRegex(ValueError,
                 r"Address range 0x200\.\.0x600 overlaps with window "
-                r"<nmigen_soc\.memory\.MemoryMap object at .+?> at 0x0\.\.0x400"):
-            memory_map.add_window(MemoryMap(addr_width=10, data_width=8), addr=0x200)
+                r"<nmigen_soc\.memory\.MemoryMap object at .+?> "
+                r"at 0x0\.\.0x400"):
+            memory_map.add_window(MemoryMap(addr_width=10, data_width=8),
+                                  addr=0x200)
 
     def test_add_window_wrong_twice(self):
         memory_map = MemoryMap(addr_width=16, data_width=8)
         window = MemoryMap(addr_width=10, data_width=8)
         memory_map.add_window(window)
         with self.assertRaisesRegex(ValueError,
-                r"Window <nmigen_soc\.memory\.MemoryMap object at .+?> is already added "
-                r"at address range 0x0\.\.0x400"):
+                r"Window <nmigen_soc\.memory\.MemoryMap object at .+?> is "
+                r"already added at address range 0x0\.\.0x400"):
             memory_map.add_window(window)
 
     def test_iter_windows(self):