tests/test_build_dsl.py

   1 from collections import OrderedDict
   2
   3 from nmigen.build.dsl import *
   4
   5 from .utils import *
   6
   7
   8 class PinsTestCase(FHDLTestCase):
   9     def test_basic(self):
  10         p = Pins("A0 A1 A2")
  11         self.assertEqual(repr(p), "(pins io A0 A1 A2)")
  12         self.assertEqual(len(p.names), 3)
  13         self.assertEqual(p.dir, "io")
  14         self.assertEqual(p.invert, False)
  15         self.assertEqual(list(p), ["A0", "A1", "A2"])
  16
  17     def test_invert(self):
  18         p = PinsN("A0")
  19         self.assertEqual(repr(p), "(pins-n io A0)")
  20         self.assertEqual(p.invert, True)
  21
  22     def test_invert_arg(self):
  23         p = Pins("A0", invert=True)
  24         self.assertEqual(p.invert, True)
  25
  26     def test_conn(self):
  27         p = Pins("0 1 2", conn=("pmod", 0))
  28         self.assertEqual(list(p), ["pmod_0:0", "pmod_0:1", "pmod_0:2"])
  29         p = Pins("0 1 2", conn=("pmod", "a"))
  30         self.assertEqual(list(p), ["pmod_a:0", "pmod_a:1", "pmod_a:2"])
  31
  32     def test_map_names(self):
  33         p = Pins("0 1 2", conn=("pmod", 0))
  34         mapping = {
  35             "pmod_0:0": "A0",
  36             "pmod_0:1": "A1",
  37             "pmod_0:2": "A2",
  38         }
  39         self.assertEqual(p.map_names(mapping, p), ["A0", "A1", "A2"])
  40
  41     def test_map_names_recur(self):
  42         p = Pins("0", conn=("pmod", 0))
  43         mapping = {
  44             "pmod_0:0": "ext_0:1",
  45             "ext_0:1":  "A1",
  46         }
  47         self.assertEqual(p.map_names(mapping, p), ["A1"])
  48
  49     def test_wrong_names(self):
  50         with self.assertRaisesRegex(TypeError,
  51                 r"^Names must be a whitespace-separated string, not \['A0', 'A1', 'A2'\]$"):
  52             p = Pins(["A0", "A1", "A2"])
  53
  54     def test_wrong_dir(self):
  55         with self.assertRaisesRegex(TypeError,
  56                 r"^Direction must be one of \"i\", \"o\", \"oe\", or \"io\", not 'wrong'$"):
  57             p = Pins("A0 A1", dir="wrong")
  58
  59     def test_wrong_conn(self):
  60         with self.assertRaisesRegex(TypeError,
  61                 (r"^Connector must be None or a pair of string \(connector name\) and "
  62                     r"integer\/string \(connector number\), not \('foo', None\)$")):
  63             p = Pins("A0 A1", conn=("foo", None))
  64
  65     def test_wrong_map_names(self):
  66         p = Pins("0 1 2", conn=("pmod", 0))
  67         mapping = {
  68             "pmod_0:0": "A0",
  69         }
  70         with self.assertRaisesRegex(NameError,
  71                 (r"^Resource \(pins io pmod_0:0 pmod_0:1 pmod_0:2\) refers to nonexistent "
  72                     r"connector pin pmod_0:1$")):
  73             p.map_names(mapping, p)
  74
  75     def test_wrong_assert_width(self):
  76         with self.assertRaisesRegex(AssertionError,
  77                 r"^3 names are specified \(0 1 2\), but 4 names are expected$"):
  78             Pins("0 1 2", assert_width=4)
  79
  80
  81 class DiffPairsTestCase(FHDLTestCase):
  82     def test_basic(self):
  83         dp = DiffPairs(p="A0 A1", n="B0 B1")
  84         self.assertEqual(repr(dp), "(diffpairs io (p A0 A1) (n B0 B1))")
  85         self.assertEqual(dp.p.names, ["A0", "A1"])
  86         self.assertEqual(dp.n.names, ["B0", "B1"])
  87         self.assertEqual(dp.dir, "io")
  88         self.assertEqual(list(dp), [("A0", "B0"), ("A1", "B1")])
  89
  90     def test_invert(self):
  91         dp = DiffPairsN(p="A0", n="B0")
  92         self.assertEqual(repr(dp), "(diffpairs-n io (p A0) (n B0))")
  93         self.assertEqual(dp.p.names, ["A0"])
  94         self.assertEqual(dp.n.names, ["B0"])
  95         self.assertEqual(dp.invert, True)
  96
  97     def test_invert_arg(self):
  98         dp = DiffPairs(p="A0", n="B0", invert=True)
  99         self.assertEqual(dp.invert, True)
 100
 101     def test_conn(self):
 102         dp = DiffPairs(p="0 1 2", n="3 4 5", conn=("pmod", 0))
 103         self.assertEqual(list(dp), [
 104             ("pmod_0:0", "pmod_0:3"),
 105             ("pmod_0:1", "pmod_0:4"),
 106             ("pmod_0:2", "pmod_0:5"),
 107         ])
 108
 109     def test_dir(self):
 110         dp = DiffPairs("A0", "B0", dir="o")
 111         self.assertEqual(dp.dir, "o")
 112         self.assertEqual(dp.p.dir, "o")
 113         self.assertEqual(dp.n.dir, "o")
 114
 115     def test_wrong_width(self):
 116         with self.assertRaisesRegex(TypeError,
 117                 (r"^Positive and negative pins must have the same width, but \(pins io A0\) "
 118                     r"and \(pins io B0 B1\) do not$")):
 119             dp = DiffPairs("A0", "B0 B1")
 120
 121     def test_wrong_assert_width(self):
 122         with self.assertRaisesRegex(AssertionError,
 123                 r"^3 names are specified \(0 1 2\), but 4 names are expected$"):
 124             DiffPairs("0 1 2", "3 4 5", assert_width=4)
 125
 126
 127 class AttrsTestCase(FHDLTestCase):
 128     def test_basic(self):
 129         a = Attrs(IO_STANDARD="LVCMOS33", PULLUP=1)
 130         self.assertEqual(a["IO_STANDARD"], "LVCMOS33")
 131         self.assertEqual(repr(a), "(attrs IO_STANDARD='LVCMOS33' PULLUP=1)")
 132
 133     def test_remove(self):
 134         a = Attrs(FOO=None)
 135         self.assertEqual(a["FOO"], None)
 136         self.assertEqual(repr(a), "(attrs !FOO)")
 137
 138     def test_callable(self):
 139         fn = lambda self: "FOO"
 140         a = Attrs(FOO=fn)
 141         self.assertEqual(a["FOO"], fn)
 142         self.assertEqual(repr(a), "(attrs FOO={!r})".format(fn))
 143
 144     def test_wrong_value(self):
 145         with self.assertRaisesRegex(TypeError,
 146                 r"^Value of attribute FOO must be None, int, str, or callable, not 1\.0$"):
 147             a = Attrs(FOO=1.0)
 148
 149
 150 class ClockTestCase(FHDLTestCase):
 151     def test_basic(self):
 152         c = Clock(1_000_000)
 153         self.assertEqual(c.frequency, 1e6)
 154         self.assertEqual(c.period, 1e-6)
 155         self.assertEqual(repr(c), "(clock 1000000.0)")
 156
 157
 158 class SubsignalTestCase(FHDLTestCase):
 159     def test_basic_pins(self):
 160         s = Subsignal("a", Pins("A0"), Attrs(IOSTANDARD="LVCMOS33"))
 161         self.assertEqual(repr(s),
 162             "(subsignal a (pins io A0) (attrs IOSTANDARD='LVCMOS33'))")
 163
 164     def test_basic_diffpairs(self):
 165         s = Subsignal("a", DiffPairs("A0", "B0"))
 166         self.assertEqual(repr(s),
 167             "(subsignal a (diffpairs io (p A0) (n B0)))")
 168
 169     def test_basic_subsignals(self):
 170         s = Subsignal("a",
 171                 Subsignal("b", Pins("A0")),
 172                 Subsignal("c", Pins("A1")))
 173         self.assertEqual(repr(s),
 174             "(subsignal a (subsignal b (pins io A0)) "
 175                          "(subsignal c (pins io A1)))")
 176
 177     def test_attrs(self):
 178         s = Subsignal("a",
 179                 Subsignal("b", Pins("A0")),
 180                 Subsignal("c", Pins("A0"), Attrs(SLEW="FAST")),
 181                 Attrs(IOSTANDARD="LVCMOS33"))
 182         self.assertEqual(s.attrs, {"IOSTANDARD": "LVCMOS33"})
 183         self.assertEqual(s.ios[0].attrs, {})
 184         self.assertEqual(s.ios[1].attrs, {"SLEW": "FAST"})
 185
 186     def test_attrs_many(self):
 187         s = Subsignal("a", Pins("A0"), Attrs(SLEW="FAST"), Attrs(PULLUP="1"))
 188         self.assertEqual(s.attrs, {"SLEW": "FAST", "PULLUP": "1"})
 189
 190     def test_clock(self):
 191         s = Subsignal("a", Pins("A0"), Clock(1e6))
 192         self.assertEqual(s.clock.frequency, 1e6)
 193
 194     def test_wrong_empty_io(self):
 195         with self.assertRaisesRegex(ValueError, r"^Missing I\/O constraints$"):
 196             s = Subsignal("a")
 197
 198     def test_wrong_io(self):
 199         with self.assertRaisesRegex(TypeError,
 200                 (r"^Constraint must be one of Pins, DiffPairs, Subsignal, Attrs, or Clock, "
 201                     r"not 'wrong'$")):
 202             s = Subsignal("a", "wrong")
 203
 204     def test_wrong_pins(self):
 205         with self.assertRaisesRegex(TypeError,
 206                 (r"^Pins and DiffPairs are incompatible with other location or subsignal "
 207                     r"constraints, but \(pins io A1\) appears after \(pins io A0\)$")):
 208             s = Subsignal("a", Pins("A0"), Pins("A1"))
 209
 210     def test_wrong_diffpairs(self):
 211         with self.assertRaisesRegex(TypeError,
 212                 (r"^Pins and DiffPairs are incompatible with other location or subsignal "
 213                     r"constraints, but \(pins io A1\) appears after \(diffpairs io \(p A0\) \(n B0\)\)$")):
 214             s = Subsignal("a", DiffPairs("A0", "B0"), Pins("A1"))
 215
 216     def test_wrong_subsignals(self):
 217         with self.assertRaisesRegex(TypeError,
 218                 (r"^Pins and DiffPairs are incompatible with other location or subsignal "
 219                     r"constraints, but \(pins io B0\) appears after \(subsignal b \(pins io A0\)\)$")):
 220             s = Subsignal("a", Subsignal("b", Pins("A0")), Pins("B0"))
 221
 222     def test_wrong_clock(self):
 223         with self.assertRaisesRegex(TypeError,
 224                 (r"^Clock constraint can only be applied to Pins or DiffPairs, not "
 225                     r"\(subsignal b \(pins io A0\)\)$")):
 226             s = Subsignal("a", Subsignal("b", Pins("A0")), Clock(1e6))
 227
 228     def test_wrong_clock_many(self):
 229         with self.assertRaisesRegex(ValueError,
 230                 r"^Clock constraint can be applied only once$"):
 231             s = Subsignal("a", Pins("A0"), Clock(1e6), Clock(1e7))
 232
 233
 234 class ResourceTestCase(FHDLTestCase):
 235     def test_basic(self):
 236         r = Resource("serial", 0,
 237                 Subsignal("tx", Pins("A0", dir="o")),
 238                 Subsignal("rx", Pins("A1", dir="i")),
 239                 Attrs(IOSTANDARD="LVCMOS33"))
 240         self.assertEqual(repr(r), "(resource serial 0"
 241                                   " (subsignal tx (pins o A0))"
 242                                   " (subsignal rx (pins i A1))"
 243                                   " (attrs IOSTANDARD='LVCMOS33'))")
 244
 245     def test_family(self):
 246         ios = [Subsignal("clk", Pins("A0", dir="o"))]
 247         r1  = Resource.family(0, default_name="spi", ios=ios)
 248         r2  = Resource.family("spi_flash", 0, default_name="spi", ios=ios)
 249         r3  = Resource.family("spi_flash", 0, default_name="spi", ios=ios, name_suffix="4x")
 250         r4  = Resource.family(0, default_name="spi", ios=ios, name_suffix="2x")
 251         self.assertEqual(r1.name, "spi")
 252         self.assertEqual(r1.ios, ios)
 253         self.assertEqual(r2.name, "spi_flash")
 254         self.assertEqual(r2.ios, ios)
 255         self.assertEqual(r3.name, "spi_flash_4x")
 256         self.assertEqual(r3.ios, ios)
 257         self.assertEqual(r4.name, "spi_2x")
 258         self.assertEqual(r4.ios, ios)
 259
 260
 261 class ConnectorTestCase(FHDLTestCase):
 262     def test_string(self):
 263         c = Connector("pmod", 0, "A0 A1 A2 A3 - - A4 A5 A6 A7 - -")
 264         self.assertEqual(c.name, "pmod")
 265         self.assertEqual(c.number, 0)
 266         self.assertEqual(c.mapping, OrderedDict([
 267             ("1", "A0"),
 268             ("2", "A1"),
 269             ("3", "A2"),
 270             ("4", "A3"),
 271             ("7", "A4"),
 272             ("8", "A5"),
 273             ("9", "A6"),
 274             ("10", "A7"),
 275         ]))
 276         self.assertEqual(list(c), [
 277             ("pmod_0:1", "A0"),
 278             ("pmod_0:2", "A1"),
 279             ("pmod_0:3", "A2"),
 280             ("pmod_0:4", "A3"),
 281             ("pmod_0:7", "A4"),
 282             ("pmod_0:8", "A5"),
 283             ("pmod_0:9", "A6"),
 284             ("pmod_0:10", "A7"),
 285         ])
 286         self.assertEqual(repr(c),
 287             "(connector pmod 0 1=>A0 2=>A1 3=>A2 4=>A3 7=>A4 8=>A5 9=>A6 10=>A7)")
 288
 289     def test_dict(self):
 290         c = Connector("ext", 1, {"DP0": "A0", "DP1": "A1"})
 291         self.assertEqual(c.name, "ext")
 292         self.assertEqual(c.number, 1)
 293         self.assertEqual(c.mapping, OrderedDict([
 294             ("DP0", "A0"),
 295             ("DP1", "A1"),
 296         ]))
 297
 298     def test_conn(self):
 299         c = Connector("pmod", 0, "0 1 2 3 - - 4 5 6 7 - -", conn=("expansion", 0))
 300         self.assertEqual(c.mapping, OrderedDict([
 301             ("1", "expansion_0:0"),
 302             ("2", "expansion_0:1"),
 303             ("3", "expansion_0:2"),
 304             ("4", "expansion_0:3"),
 305             ("7", "expansion_0:4"),
 306             ("8", "expansion_0:5"),
 307             ("9", "expansion_0:6"),
 308             ("10", "expansion_0:7"),
 309         ]))
 310
 311     def test_str_name(self):
 312         c = Connector("ext", "A", "0 1 2")
 313         self.assertEqual(c.name, "ext")
 314         self.assertEqual(c.number, "A")
 315
 316     def test_conn_wrong_name(self):
 317         with self.assertRaisesRegex(TypeError,
 318                 (r"^Connector must be None or a pair of string \(connector name\) and "
 319                     r"integer\/string \(connector number\), not \('foo', None\)$")):
 320             Connector("ext", "A", "0 1 2", conn=("foo", None))
 321
 322     def test_wrong_io(self):
 323         with self.assertRaisesRegex(TypeError,
 324                 r"^Connector I\/Os must be a dictionary or a string, not \[\]$"):
 325             Connector("pmod", 0, [])
 326
 327     def test_wrong_dict_key_value(self):
 328         with self.assertRaisesRegex(TypeError,
 329                 r"^Connector pin name must be a string, not 0$"):
 330             Connector("pmod", 0, {0: "A"})
 331         with self.assertRaisesRegex(TypeError,
 332                 r"^Platform pin name must be a string, not 0$"):
 333             Connector("pmod", 0, {"A": 0})