autopep8 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 040f7774846cfcfcb6b625b1d754e7d4b63222a4..7f42319f0e8b7a310d690804da8cc27956358b4d 100644 (file)
--- a/nmigen_soc/test/test_memory.py
+++ b/nmigen_soc/test/test_memory.py
@@ -6,33 +6,33 @@ from ..memory import _RangeMap, MemoryMap
 class RangeMapTestCase(unittest.TestCase):
     def test_insert(self):
         range_map = _RangeMap()
-        range_map.insert(range(0,10), "a")
-        range_map.insert(range(20,21), "c")
-        range_map.insert(range(15,16), "b")
-        range_map.insert(range(16,20), "q")
+        range_map.insert(range(0, 10), "a")
+        range_map.insert(range(20, 21), "c")
+        range_map.insert(range(15, 16), "b")
+        range_map.insert(range(16, 20), "q")
         self.assertEqual(range_map._keys, [
-            range(0,10), range(15,16), range(16,20), range(20,21)
+            range(0, 10), range(15, 16), range(16, 20), range(20, 21)
         ])
 
     def test_overlaps(self):
         range_map = _RangeMap()
-        range_map.insert(range(10,20), "a")
-        self.assertEqual(range_map.overlaps(range(5,15)), ["a"])
-        self.assertEqual(range_map.overlaps(range(15,25)), ["a"])
-        self.assertEqual(range_map.overlaps(range(5,25)), ["a"])
-        self.assertEqual(range_map.overlaps(range(0,3)), [])
-        self.assertEqual(range_map.overlaps(range(0,5)), [])
-        self.assertEqual(range_map.overlaps(range(25,30)), [])
+        range_map.insert(range(10, 20), "a")
+        self.assertEqual(range_map.overlaps(range(5, 15)), ["a"])
+        self.assertEqual(range_map.overlaps(range(15, 25)), ["a"])
+        self.assertEqual(range_map.overlaps(range(5, 25)), ["a"])
+        self.assertEqual(range_map.overlaps(range(0, 3)), [])
+        self.assertEqual(range_map.overlaps(range(0, 5)), [])
+        self.assertEqual(range_map.overlaps(range(25, 30)), [])
 
     def test_insert_wrong_overlap(self):
         range_map = _RangeMap()
-        range_map.insert(range(0,10), "a")
+        range_map.insert(range(0, 10), "a")
         with self.assertRaises(AssertionError):
-            range_map.insert(range(5,15), "b")
+            range_map.insert(range(5, 15), "b")
 
     def test_get(self):
         range_map = _RangeMap()
-        range_map.insert(range(5,15), "a")
+        range_map.insert(range(5, 15), "a")
         self.assertEqual(range_map.get(0), None)
         self.assertEqual(range_map.get(5), "a")
         self.assertEqual(range_map.get(10), "a")
@@ -43,17 +43,17 @@ class RangeMapTestCase(unittest.TestCase):
 class MemoryMapTestCase(unittest.TestCase):
     def test_wrong_addr_width(self):
         with self.assertRaisesRegex(ValueError,
-                r"Address width must be a positive integer, not -1"):
+                    r"Address width must be a positive integer, not -1"):
             MemoryMap(addr_width=-1, data_width=8)
 
     def test_wrong_data_width(self):
         with self.assertRaisesRegex(ValueError,
-                r"Data width must be a positive integer, not -1"):
+                    r"Data width must be a positive integer, not -1"):
             MemoryMap(addr_width=16, data_width=-1)
 
     def test_wrong_alignment(self):
         with self.assertRaisesRegex(ValueError,
-                r"Alignment must be a non-negative integer, not -1"):
+                    r"Alignment must be a non-negative integer, not -1"):
             MemoryMap(addr_width=16, data_width=8, alignment=-1)
 
     def test_add_resource(self):
@@ -69,31 +69,35 @@ class MemoryMapTestCase(unittest.TestCase):
     def test_add_resource_explicit_aligned(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_resource("b", size=1, alignment=1), (2, 4))
+        self.assertEqual(
+            memory_map.add_resource(
+                "b", size=1, alignment=1), (2, 4))
         self.assertEqual(memory_map.add_resource("c", size=2), (4, 6))
 
     def test_add_resource_addr(self):
         memory_map = MemoryMap(addr_width=16, data_width=8)
-        self.assertEqual(memory_map.add_resource("a", size=1, addr=10), (10, 11))
+        self.assertEqual(
+            memory_map.add_resource(
+                "a", size=1, addr=10), (10, 11))
         self.assertEqual(memory_map.add_resource("b", size=2), (11, 13))
 
     def test_add_resource_wrong_address(self):
         memory_map = MemoryMap(addr_width=16, data_width=8)
         with self.assertRaisesRegex(ValueError,
-                r"Address must be a non-negative integer, not -1"):
+                    r"Address must be a non-negative integer, not -1"):
             memory_map.add_resource("a", size=1, addr=-1)
 
     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 "
-                r"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):
         memory_map = MemoryMap(addr_width=16, data_width=8)
         with self.assertRaisesRegex(ValueError,
-                r"Size must be a non-negative integer, not -1"):
+                    r"Size must be a non-negative integer, not -1"):
             memory_map.add_resource("a", size=-1)
 
     def test_add_resource_wrong_alignment(self):
@@ -187,7 +191,7 @@ class MemoryMapTestCase(unittest.TestCase):
                 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)
+                                  sparse=False)
 
     def test_add_window_wrong_overlap(self):
         memory_map = MemoryMap(addr_width=16, data_width=8)