nmigen/test/test_hdl_ast.py

   1 import warnings
   2 from enum import Enum
   3
   4 from ..hdl.ast import *
   5 from .utils import *
   6
   7
   8 class UnsignedEnum(Enum):
   9     FOO = 1
  10     BAR = 2
  11     BAZ = 3
  12
  13
  14 class SignedEnum(Enum):
  15     FOO = -1
  16     BAR =  0
  17     BAZ = +1
  18
  19
  20 class StringEnum(Enum):
  21     FOO = "a"
  22     BAR = "b"
  23
  24
  25 class ShapeTestCase(FHDLTestCase):
  26     def test_make(self):
  27         s1 = Shape()
  28         self.assertEqual(s1.width, 1)
  29         self.assertEqual(s1.signed, False)
  30         s2 = Shape(signed=True)
  31         self.assertEqual(s2.width, 1)
  32         self.assertEqual(s2.signed, True)
  33         s3 = Shape(3, True)
  34         self.assertEqual(s3.width, 3)
  35         self.assertEqual(s3.signed, True)
  36
  37     def test_make_wrong(self):
  38         with self.assertRaises(TypeError,
  39                 msg="Width must be a non-negative integer, not -1"):
  40             Shape(-1)
  41
  42     def test_tuple(self):
  43         width, signed = Shape()
  44         self.assertEqual(width, 1)
  45         self.assertEqual(signed, False)
  46
  47     def test_unsigned(self):
  48         s1 = unsigned(2)
  49         self.assertIsInstance(s1, Shape)
  50         self.assertEqual(s1.width, 2)
  51         self.assertEqual(s1.signed, False)
  52
  53     def test_signed(self):
  54         s1 = signed(2)
  55         self.assertIsInstance(s1, Shape)
  56         self.assertEqual(s1.width, 2)
  57         self.assertEqual(s1.signed, True)
  58
  59     def test_cast_shape(self):
  60         s1 = Shape.cast(unsigned(1))
  61         self.assertEqual(s1.width, 1)
  62         self.assertEqual(s1.signed, False)
  63         s2 = Shape.cast(signed(3))
  64         self.assertEqual(s2.width, 3)
  65         self.assertEqual(s2.signed, True)
  66
  67     def test_cast_int(self):
  68         s1 = Shape.cast(2)
  69         self.assertEqual(s1.width, 2)
  70         self.assertEqual(s1.signed, False)
  71
  72     def test_cast_int_wrong(self):
  73         with self.assertRaises(TypeError,
  74                 msg="Width must be a non-negative integer, not -1"):
  75             Shape.cast(-1)
  76
  77     def test_cast_tuple(self):
  78         with warnings.catch_warnings():
  79             warnings.filterwarnings(action="ignore", category=DeprecationWarning)
  80             s1 = Shape.cast((1, True))
  81             self.assertEqual(s1.width, 1)
  82             self.assertEqual(s1.signed, True)
  83
  84     def test_cast_tuple_wrong(self):
  85         with warnings.catch_warnings():
  86             warnings.filterwarnings(action="ignore", category=DeprecationWarning)
  87             with self.assertRaises(TypeError,
  88                     msg="Width must be a non-negative integer, not -1"):
  89                 Shape.cast((-1, True))
  90
  91     def test_cast_range(self):
  92         s1 = Shape.cast(range(0, 8))
  93         self.assertEqual(s1.width, 3)
  94         self.assertEqual(s1.signed, False)
  95         s2 = Shape.cast(range(0, 9))
  96         self.assertEqual(s2.width, 4)
  97         self.assertEqual(s2.signed, False)
  98         s3 = Shape.cast(range(-7, 8))
  99         self.assertEqual(s3.width, 4)
 100         self.assertEqual(s3.signed, True)
 101         s4 = Shape.cast(range(0, 1))
 102         self.assertEqual(s4.width, 1)
 103         self.assertEqual(s4.signed, False)
 104         s5 = Shape.cast(range(-1, 0))
 105         self.assertEqual(s5.width, 1)
 106         self.assertEqual(s5.signed, True)
 107         s6 = Shape.cast(range(0, 0))
 108         self.assertEqual(s6.width, 0)
 109         self.assertEqual(s6.signed, False)
 110         s7 = Shape.cast(range(-1, -1))
 111         self.assertEqual(s7.width, 0)
 112         self.assertEqual(s7.signed, True)
 113
 114     def test_cast_enum(self):
 115         s1 = Shape.cast(UnsignedEnum)
 116         self.assertEqual(s1.width, 2)
 117         self.assertEqual(s1.signed, False)
 118         s2 = Shape.cast(SignedEnum)
 119         self.assertEqual(s2.width, 2)
 120         self.assertEqual(s2.signed, True)
 121
 122     def test_cast_enum_bad(self):
 123         with self.assertRaises(TypeError,
 124                 msg="Only enumerations with integer values can be used as value shapes"):
 125             Shape.cast(StringEnum)
 126
 127     def test_cast_bad(self):
 128         with self.assertRaises(TypeError,
 129                 msg="Object 'foo' cannot be used as value shape"):
 130             Shape.cast("foo")
 131
 132
 133 class ValueTestCase(FHDLTestCase):
 134     def test_cast(self):
 135         self.assertIsInstance(Value.cast(0), Const)
 136         self.assertIsInstance(Value.cast(True), Const)
 137         c = Const(0)
 138         self.assertIs(Value.cast(c), c)
 139         with self.assertRaises(TypeError,
 140                 msg="Object 'str' cannot be converted to an nMigen value"):
 141             Value.cast("str")
 142
 143     def test_cast_enum(self):
 144         e1 = Value.cast(UnsignedEnum.FOO)
 145         self.assertIsInstance(e1, Const)
 146         self.assertEqual(e1.shape(), unsigned(2))
 147         e2 = Value.cast(SignedEnum.FOO)
 148         self.assertIsInstance(e2, Const)
 149         self.assertEqual(e2.shape(), signed(2))
 150
 151     def test_cast_enum_wrong(self):
 152         with self.assertRaises(TypeError,
 153                 msg="Only enumerations with integer values can be used as value shapes"):
 154             Value.cast(StringEnum.FOO)
 155
 156     def test_bool(self):
 157         with self.assertRaises(TypeError,
 158                 msg="Attempted to convert nMigen value to boolean"):
 159             if Const(0):
 160                 pass
 161
 162     def test_len(self):
 163         self.assertEqual(len(Const(10)), 4)
 164
 165     def test_getitem_int(self):
 166         s1 = Const(10)[0]
 167         self.assertIsInstance(s1, Slice)
 168         self.assertEqual(s1.start, 0)
 169         self.assertEqual(s1.stop, 1)
 170         s2 = Const(10)[-1]
 171         self.assertIsInstance(s2, Slice)
 172         self.assertEqual(s2.start, 3)
 173         self.assertEqual(s2.stop, 4)
 174         with self.assertRaises(IndexError,
 175                 msg="Cannot index 5 bits into 4-bit value"):
 176             Const(10)[5]
 177
 178     def test_getitem_slice(self):
 179         s1 = Const(10)[1:3]
 180         self.assertIsInstance(s1, Slice)
 181         self.assertEqual(s1.start, 1)
 182         self.assertEqual(s1.stop, 3)
 183         s2 = Const(10)[1:-2]
 184         self.assertIsInstance(s2, Slice)
 185         self.assertEqual(s2.start, 1)
 186         self.assertEqual(s2.stop, 2)
 187         s3 = Const(31)[::2]
 188         self.assertIsInstance(s3, Cat)
 189         self.assertIsInstance(s3.parts[0], Slice)
 190         self.assertEqual(s3.parts[0].start, 0)
 191         self.assertEqual(s3.parts[0].stop, 1)
 192         self.assertIsInstance(s3.parts[1], Slice)
 193         self.assertEqual(s3.parts[1].start, 2)
 194         self.assertEqual(s3.parts[1].stop, 3)
 195         self.assertIsInstance(s3.parts[2], Slice)
 196         self.assertEqual(s3.parts[2].start, 4)
 197         self.assertEqual(s3.parts[2].stop, 5)
 198
 199     def test_getitem_wrong(self):
 200         with self.assertRaises(TypeError,
 201                 msg="Cannot index value with 'str'"):
 202             Const(31)["str"]
 203
 204
 205 class ConstTestCase(FHDLTestCase):
 206     def test_shape(self):
 207         self.assertEqual(Const(0).shape(),   unsigned(1))
 208         self.assertIsInstance(Const(0).shape(), Shape)
 209         self.assertEqual(Const(1).shape(),   unsigned(1))
 210         self.assertEqual(Const(10).shape(),  unsigned(4))
 211         self.assertEqual(Const(-10).shape(), signed(5))
 212
 213         self.assertEqual(Const(1, 4).shape(),          unsigned(4))
 214         self.assertEqual(Const(-1, 4).shape(),         signed(4))
 215         self.assertEqual(Const(1, signed(4)).shape(),  signed(4))
 216         self.assertEqual(Const(0, unsigned(0)).shape(), unsigned(0))
 217
 218     def test_shape_wrong(self):
 219         with self.assertRaises(TypeError,
 220                 msg="Width must be a non-negative integer, not -1"):
 221             Const(1, -1)
 222
 223     def test_normalization(self):
 224         self.assertEqual(Const(0b10110, signed(5)).value, -10)
 225
 226     def test_value(self):
 227         self.assertEqual(Const(10).value, 10)
 228
 229     def test_repr(self):
 230         self.assertEqual(repr(Const(10)),  "(const 4'd10)")
 231         self.assertEqual(repr(Const(-10)), "(const 5'sd-10)")
 232
 233     def test_hash(self):
 234         with self.assertRaises(TypeError):
 235             hash(Const(0))
 236
 237
 238 class OperatorTestCase(FHDLTestCase):
 239     def test_bool(self):
 240         v = Const(0, 4).bool()
 241         self.assertEqual(repr(v), "(b (const 4'd0))")
 242         self.assertEqual(v.shape(), unsigned(1))
 243
 244     def test_invert(self):
 245         v = ~Const(0, 4)
 246         self.assertEqual(repr(v), "(~ (const 4'd0))")
 247         self.assertEqual(v.shape(), unsigned(4))
 248
 249     def test_neg(self):
 250         v1 = -Const(0, unsigned(4))
 251         self.assertEqual(repr(v1), "(- (const 4'd0))")
 252         self.assertEqual(v1.shape(), signed(5))
 253         v2 = -Const(0, signed(4))
 254         self.assertEqual(repr(v2), "(- (const 4'sd0))")
 255         self.assertEqual(v2.shape(), signed(4))
 256
 257     def test_add(self):
 258         v1 = Const(0, unsigned(4)) + Const(0, unsigned(6))
 259         self.assertEqual(repr(v1), "(+ (const 4'd0) (const 6'd0))")
 260         self.assertEqual(v1.shape(), unsigned(7))
 261         v2 = Const(0, signed(4)) + Const(0, signed(6))
 262         self.assertEqual(v2.shape(), signed(7))
 263         v3 = Const(0, signed(4)) + Const(0, unsigned(4))
 264         self.assertEqual(v3.shape(), signed(6))
 265         v4 = Const(0, unsigned(4)) + Const(0, signed(4))
 266         self.assertEqual(v4.shape(), signed(6))
 267         v5 = 10 + Const(0, 4)
 268         self.assertEqual(v5.shape(), unsigned(5))
 269
 270     def test_sub(self):
 271         v1 = Const(0, unsigned(4)) - Const(0, unsigned(6))
 272         self.assertEqual(repr(v1), "(- (const 4'd0) (const 6'd0))")
 273         self.assertEqual(v1.shape(), unsigned(7))
 274         v2 = Const(0, signed(4)) - Const(0, signed(6))
 275         self.assertEqual(v2.shape(), signed(7))
 276         v3 = Const(0, signed(4)) - Const(0, unsigned(4))
 277         self.assertEqual(v3.shape(), signed(6))
 278         v4 = Const(0, unsigned(4)) - Const(0, signed(4))
 279         self.assertEqual(v4.shape(), signed(6))
 280         v5 = 10 - Const(0, 4)
 281         self.assertEqual(v5.shape(), unsigned(5))
 282
 283     def test_mul(self):
 284         v1 = Const(0, unsigned(4)) * Const(0, unsigned(6))
 285         self.assertEqual(repr(v1), "(* (const 4'd0) (const 6'd0))")
 286         self.assertEqual(v1.shape(), unsigned(10))
 287         v2 = Const(0, signed(4)) * Const(0, signed(6))
 288         self.assertEqual(v2.shape(), signed(10))
 289         v3 = Const(0, signed(4)) * Const(0, unsigned(4))
 290         self.assertEqual(v3.shape(), signed(8))
 291         v5 = 10 * Const(0, 4)
 292         self.assertEqual(v5.shape(), unsigned(8))
 293
 294     def test_mod(self):
 295         v1 = Const(0, unsigned(4)) % Const(0, unsigned(6))
 296         self.assertEqual(repr(v1), "(% (const 4'd0) (const 6'd0))")
 297         self.assertEqual(v1.shape(), unsigned(4))
 298         v3 = Const(0, signed(4)) % Const(0, unsigned(4))
 299         self.assertEqual(v3.shape(), signed(4))
 300         v5 = 10 % Const(0, 4)
 301         self.assertEqual(v5.shape(), unsigned(4))
 302
 303     def test_mod_wrong(self):
 304         with self.assertRaises(NotImplementedError,
 305                 msg="Division by a signed value is not supported"):
 306             Const(0, signed(4)) % Const(0, signed(6))
 307
 308     def test_floordiv(self):
 309         v1 = Const(0, unsigned(4)) // Const(0, unsigned(6))
 310         self.assertEqual(repr(v1), "(// (const 4'd0) (const 6'd0))")
 311         self.assertEqual(v1.shape(), unsigned(4))
 312         v3 = Const(0, signed(4)) // Const(0, unsigned(4))
 313         self.assertEqual(v3.shape(), signed(4))
 314         v5 = 10 // Const(0, 4)
 315         self.assertEqual(v5.shape(), unsigned(4))
 316
 317     def test_floordiv_wrong(self):
 318         with self.assertRaises(NotImplementedError,
 319                 msg="Division by a signed value is not supported"):
 320             Const(0, signed(4)) // Const(0, signed(6))
 321
 322     def test_and(self):
 323         v1 = Const(0, unsigned(4)) & Const(0, unsigned(6))
 324         self.assertEqual(repr(v1), "(& (const 4'd0) (const 6'd0))")
 325         self.assertEqual(v1.shape(), unsigned(6))
 326         v2 = Const(0, signed(4)) & Const(0, signed(6))
 327         self.assertEqual(v2.shape(), signed(6))
 328         v3 = Const(0, signed(4)) & Const(0, unsigned(4))
 329         self.assertEqual(v3.shape(), signed(5))
 330         v4 = Const(0, unsigned(4)) & Const(0, signed(4))
 331         self.assertEqual(v4.shape(), signed(5))
 332         v5 = 10 & Const(0, 4)
 333         self.assertEqual(v5.shape(), unsigned(4))
 334
 335     def test_or(self):
 336         v1 = Const(0, unsigned(4)) | Const(0, unsigned(6))
 337         self.assertEqual(repr(v1), "(| (const 4'd0) (const 6'd0))")
 338         self.assertEqual(v1.shape(), unsigned(6))
 339         v2 = Const(0, signed(4)) | Const(0, signed(6))
 340         self.assertEqual(v2.shape(), signed(6))
 341         v3 = Const(0, signed(4)) | Const(0, unsigned(4))
 342         self.assertEqual(v3.shape(), signed(5))
 343         v4 = Const(0, unsigned(4)) | Const(0, signed(4))
 344         self.assertEqual(v4.shape(), signed(5))
 345         v5 = 10 | Const(0, 4)
 346         self.assertEqual(v5.shape(), unsigned(4))
 347
 348     def test_xor(self):
 349         v1 = Const(0, unsigned(4)) ^ Const(0, unsigned(6))
 350         self.assertEqual(repr(v1), "(^ (const 4'd0) (const 6'd0))")
 351         self.assertEqual(v1.shape(), unsigned(6))
 352         v2 = Const(0, signed(4)) ^ Const(0, signed(6))
 353         self.assertEqual(v2.shape(), signed(6))
 354         v3 = Const(0, signed(4)) ^ Const(0, unsigned(4))
 355         self.assertEqual(v3.shape(), signed(5))
 356         v4 = Const(0, unsigned(4)) ^ Const(0, signed(4))
 357         self.assertEqual(v4.shape(), signed(5))
 358         v5 = 10 ^ Const(0, 4)
 359         self.assertEqual(v5.shape(), unsigned(4))
 360
 361     def test_shl(self):
 362         v1 = Const(1, 4) << Const(4)
 363         self.assertEqual(repr(v1), "(<< (const 4'd1) (const 3'd4))")
 364         self.assertEqual(v1.shape(), unsigned(11))
 365         v2 = Const(1, 4) << Const(-3)
 366         self.assertEqual(v2.shape(), unsigned(7))
 367
 368     def test_shr(self):
 369         v1 = Const(1, 4) >> Const(4)
 370         self.assertEqual(repr(v1), "(>> (const 4'd1) (const 3'd4))")
 371         self.assertEqual(v1.shape(), unsigned(4))
 372         v2 = Const(1, 4) >> Const(-3)
 373         self.assertEqual(v2.shape(), unsigned(8))
 374
 375     def test_lt(self):
 376         v = Const(0, 4) < Const(0, 6)
 377         self.assertEqual(repr(v), "(< (const 4'd0) (const 6'd0))")
 378         self.assertEqual(v.shape(), unsigned(1))
 379
 380     def test_le(self):
 381         v = Const(0, 4) <= Const(0, 6)
 382         self.assertEqual(repr(v), "(<= (const 4'd0) (const 6'd0))")
 383         self.assertEqual(v.shape(), unsigned(1))
 384
 385     def test_gt(self):
 386         v = Const(0, 4) > Const(0, 6)
 387         self.assertEqual(repr(v), "(> (const 4'd0) (const 6'd0))")
 388         self.assertEqual(v.shape(), unsigned(1))
 389
 390     def test_ge(self):
 391         v = Const(0, 4) >= Const(0, 6)
 392         self.assertEqual(repr(v), "(>= (const 4'd0) (const 6'd0))")
 393         self.assertEqual(v.shape(), unsigned(1))
 394
 395     def test_eq(self):
 396         v = Const(0, 4) == Const(0, 6)
 397         self.assertEqual(repr(v), "(== (const 4'd0) (const 6'd0))")
 398         self.assertEqual(v.shape(), unsigned(1))
 399
 400     def test_ne(self):
 401         v = Const(0, 4) != Const(0, 6)
 402         self.assertEqual(repr(v), "(!= (const 4'd0) (const 6'd0))")
 403         self.assertEqual(v.shape(), unsigned(1))
 404
 405     def test_mux(self):
 406         s  = Const(0)
 407         v1 = Mux(s, Const(0, unsigned(4)), Const(0, unsigned(6)))
 408         self.assertEqual(repr(v1), "(m (const 1'd0) (const 4'd0) (const 6'd0))")
 409         self.assertEqual(v1.shape(), unsigned(6))
 410         v2 = Mux(s, Const(0, signed(4)), Const(0, signed(6)))
 411         self.assertEqual(v2.shape(), signed(6))
 412         v3 = Mux(s, Const(0, signed(4)), Const(0, unsigned(4)))
 413         self.assertEqual(v3.shape(), signed(5))
 414         v4 = Mux(s, Const(0, unsigned(4)), Const(0, signed(4)))
 415         self.assertEqual(v4.shape(), signed(5))
 416
 417     def test_mux_wide(self):
 418         s = Const(0b100)
 419         v = Mux(s, Const(0, unsigned(4)), Const(0, unsigned(6)))
 420         self.assertEqual(repr(v), "(m (b (const 3'd4)) (const 4'd0) (const 6'd0))")
 421
 422     def test_mux_bool(self):
 423         v = Mux(True, Const(0), Const(0))
 424         self.assertEqual(repr(v), "(m (const 1'd1) (const 1'd0) (const 1'd0))")
 425
 426     def test_bool(self):
 427         v = Const(0).bool()
 428         self.assertEqual(repr(v), "(b (const 1'd0))")
 429         self.assertEqual(v.shape(), unsigned(1))
 430
 431     def test_any(self):
 432         v = Const(0b101).any()
 433         self.assertEqual(repr(v), "(r| (const 3'd5))")
 434
 435     def test_all(self):
 436         v = Const(0b101).all()
 437         self.assertEqual(repr(v), "(r& (const 3'd5))")
 438
 439     def test_xor(self):
 440         v = Const(0b101).xor()
 441         self.assertEqual(repr(v), "(r^ (const 3'd5))")
 442
 443     def test_matches(self):
 444         s = Signal(4)
 445         self.assertRepr(s.matches(), "(const 1'd0)")
 446         self.assertRepr(s.matches(1), """
 447         (== (sig s) (const 1'd1))
 448         """)
 449         self.assertRepr(s.matches(0, 1), """
 450         (r| (cat (== (sig s) (const 1'd0)) (== (sig s) (const 1'd1))))
 451         """)
 452         self.assertRepr(s.matches("10--"), """
 453         (== (& (sig s) (const 4'd12)) (const 4'd8))
 454         """)
 455
 456     def test_matches_enum(self):
 457         s = Signal(SignedEnum)
 458         self.assertRepr(s.matches(SignedEnum.FOO), """
 459         (== (sig s) (const 1'sd-1))
 460         """)
 461
 462     def test_matches_width_wrong(self):
 463         s = Signal(4)
 464         with self.assertRaises(SyntaxError,
 465                 msg="Match pattern '--' must have the same width as match value (which is 4)"):
 466             s.matches("--")
 467         with self.assertWarns(SyntaxWarning,
 468                 msg="Match pattern '10110' is wider than match value (which has width 4); "
 469                     "comparison will never be true"):
 470             s.matches(0b10110)
 471
 472     def test_matches_bits_wrong(self):
 473         s = Signal(4)
 474         with self.assertRaises(SyntaxError,
 475                 msg="Match pattern 'abc' must consist of 0, 1, and - (don't care) bits"):
 476             s.matches("abc")
 477
 478     def test_matches_pattern_wrong(self):
 479         s = Signal(4)
 480         with self.assertRaises(SyntaxError,
 481                 msg="Match pattern must be an integer, a string, or an enumeration, not 1.0"):
 482             s.matches(1.0)
 483
 484     def test_hash(self):
 485         with self.assertRaises(TypeError):
 486             hash(Const(0) + Const(0))
 487
 488
 489 class SliceTestCase(FHDLTestCase):
 490     def test_shape(self):
 491         s1 = Const(10)[2]
 492         self.assertEqual(s1.shape(), unsigned(1))
 493         self.assertIsInstance(s1.shape(), Shape)
 494         s2 = Const(-10)[0:2]
 495         self.assertEqual(s2.shape(), unsigned(2))
 496
 497     def test_start_end_negative(self):
 498         c  = Const(0, 8)
 499         s1 = Slice(c, 0, -1)
 500         self.assertEqual((s1.start, s1.stop), (0, 7))
 501         s1 = Slice(c, -4, -1)
 502         self.assertEqual((s1.start, s1.stop), (4, 7))
 503
 504     def test_start_end_wrong(self):
 505         with self.assertRaises(TypeError,
 506                 msg="Slice start must be an integer, not 'x'"):
 507             Slice(0, "x", 1)
 508         with self.assertRaises(TypeError,
 509                 msg="Slice stop must be an integer, not 'x'"):
 510             Slice(0, 1, "x")
 511
 512     def test_start_end_out_of_range(self):
 513         c = Const(0, 8)
 514         with self.assertRaises(IndexError,
 515                 msg="Cannot start slice 10 bits into 8-bit value"):
 516             Slice(c, 10, 12)
 517         with self.assertRaises(IndexError,
 518                 msg="Cannot stop slice 12 bits into 8-bit value"):
 519             Slice(c, 0, 12)
 520         with self.assertRaises(IndexError,
 521                 msg="Slice start 4 must be less than slice stop 2"):
 522             Slice(c, 4, 2)
 523
 524     def test_repr(self):
 525         s1 = Const(10)[2]
 526         self.assertEqual(repr(s1), "(slice (const 4'd10) 2:3)")
 527
 528
 529 class BitSelectTestCase(FHDLTestCase):
 530     def setUp(self):
 531         self.c = Const(0, 8)
 532         self.s = Signal(range(self.c.width))
 533
 534     def test_shape(self):
 535         s1 = self.c.bit_select(self.s, 2)
 536         self.assertIsInstance(s1, Part)
 537         self.assertEqual(s1.shape(), unsigned(2))
 538         self.assertIsInstance(s1.shape(), Shape)
 539         s2 = self.c.bit_select(self.s, 0)
 540         self.assertIsInstance(s2, Part)
 541         self.assertEqual(s2.shape(), unsigned(0))
 542
 543     def test_stride(self):
 544         s1 = self.c.bit_select(self.s, 2)
 545         self.assertIsInstance(s1, Part)
 546         self.assertEqual(s1.stride, 1)
 547
 548     def test_const(self):
 549         s1 = self.c.bit_select(1, 2)
 550         self.assertIsInstance(s1, Slice)
 551         self.assertRepr(s1, """(slice (const 8'd0) 1:3)""")
 552
 553     def test_width_wrong(self):
 554         with self.assertRaises(TypeError):
 555             self.c.bit_select(self.s, -1)
 556
 557     def test_repr(self):
 558         s = self.c.bit_select(self.s, 2)
 559         self.assertEqual(repr(s), "(part (const 8'd0) (sig s) 2 1)")
 560
 561
 562 class WordSelectTestCase(FHDLTestCase):
 563     def setUp(self):
 564         self.c = Const(0, 8)
 565         self.s = Signal(range(self.c.width))
 566
 567     def test_shape(self):
 568         s1 = self.c.word_select(self.s, 2)
 569         self.assertIsInstance(s1, Part)
 570         self.assertEqual(s1.shape(), unsigned(2))
 571         self.assertIsInstance(s1.shape(), Shape)
 572
 573     def test_stride(self):
 574         s1 = self.c.word_select(self.s, 2)
 575         self.assertIsInstance(s1, Part)
 576         self.assertEqual(s1.stride, 2)
 577
 578     def test_const(self):
 579         s1 = self.c.word_select(1, 2)
 580         self.assertIsInstance(s1, Slice)
 581         self.assertRepr(s1, """(slice (const 8'd0) 2:4)""")
 582
 583     def test_width_wrong(self):
 584         with self.assertRaises(TypeError):
 585             self.c.word_select(self.s, 0)
 586         with self.assertRaises(TypeError):
 587             self.c.word_select(self.s, -1)
 588
 589     def test_repr(self):
 590         s = self.c.word_select(self.s, 2)
 591         self.assertEqual(repr(s), "(part (const 8'd0) (sig s) 2 2)")
 592
 593
 594 class CatTestCase(FHDLTestCase):
 595     def test_shape(self):
 596         c0 = Cat()
 597         self.assertEqual(c0.shape(), unsigned(0))
 598         self.assertIsInstance(c0.shape(), Shape)
 599         c1 = Cat(Const(10))
 600         self.assertEqual(c1.shape(), unsigned(4))
 601         c2 = Cat(Const(10), Const(1))
 602         self.assertEqual(c2.shape(), unsigned(5))
 603         c3 = Cat(Const(10), Const(1), Const(0))
 604         self.assertEqual(c3.shape(), unsigned(6))
 605
 606     def test_repr(self):
 607         c1 = Cat(Const(10), Const(1))
 608         self.assertEqual(repr(c1), "(cat (const 4'd10) (const 1'd1))")
 609
 610
 611 class ReplTestCase(FHDLTestCase):
 612     def test_shape(self):
 613         s1 = Repl(Const(10), 3)
 614         self.assertEqual(s1.shape(), unsigned(12))
 615         self.assertIsInstance(s1.shape(), Shape)
 616         s2 = Repl(Const(10), 0)
 617         self.assertEqual(s2.shape(), unsigned(0))
 618
 619     def test_count_wrong(self):
 620         with self.assertRaises(TypeError):
 621             Repl(Const(10), -1)
 622         with self.assertRaises(TypeError):
 623             Repl(Const(10), "str")
 624
 625     def test_repr(self):
 626         s = Repl(Const(10), 3)
 627         self.assertEqual(repr(s), "(repl (const 4'd10) 3)")
 628
 629
 630 class ArrayTestCase(FHDLTestCase):
 631     def test_acts_like_array(self):
 632         a = Array([1,2,3])
 633         self.assertSequenceEqual(a, [1,2,3])
 634         self.assertEqual(a[1], 2)
 635         a[1] = 4
 636         self.assertSequenceEqual(a, [1,4,3])
 637         del a[1]
 638         self.assertSequenceEqual(a, [1,3])
 639         a.insert(1, 2)
 640         self.assertSequenceEqual(a, [1,2,3])
 641
 642     def test_becomes_immutable(self):
 643         a = Array([1,2,3])
 644         s1 = Signal(range(len(a)))
 645         s2 = Signal(range(len(a)))
 646         v1 = a[s1]
 647         v2 = a[s2]
 648         with self.assertRaisesRegex(ValueError,
 649                 regex=r"^Array can no longer be mutated after it was indexed with a value at "):
 650             a[1] = 2
 651         with self.assertRaisesRegex(ValueError,
 652                 regex=r"^Array can no longer be mutated after it was indexed with a value at "):
 653             del a[1]
 654         with self.assertRaisesRegex(ValueError,
 655                 regex=r"^Array can no longer be mutated after it was indexed with a value at "):
 656             a.insert(1, 2)
 657
 658     def test_repr(self):
 659         a = Array([1,2,3])
 660         self.assertEqual(repr(a), "(array mutable [1, 2, 3])")
 661         s = Signal(range(len(a)))
 662         v = a[s]
 663         self.assertEqual(repr(a), "(array [1, 2, 3])")
 664
 665
 666 class ArrayProxyTestCase(FHDLTestCase):
 667     def test_index_shape(self):
 668         m = Array(Array(x * y for y in range(1, 4)) for x in range(1, 4))
 669         a = Signal(range(3))
 670         b = Signal(range(3))
 671         v = m[a][b]
 672         self.assertEqual(v.shape(), unsigned(4))
 673
 674     def test_attr_shape(self):
 675         from collections import namedtuple
 676         pair = namedtuple("pair", ("p", "n"))
 677         a = Array(pair(i, -i) for i in range(10))
 678         s = Signal(range(len(a)))
 679         v = a[s]
 680         self.assertEqual(v.p.shape(), unsigned(4))
 681         self.assertEqual(v.n.shape(), signed(6))
 682
 683     def test_repr(self):
 684         a = Array([1, 2, 3])
 685         s = Signal(range(3))
 686         v = a[s]
 687         self.assertEqual(repr(v), "(proxy (array [1, 2, 3]) (sig s))")
 688
 689
 690 class SignalTestCase(FHDLTestCase):
 691     def test_shape(self):
 692         s1 = Signal()
 693         self.assertEqual(s1.shape(), unsigned(1))
 694         self.assertIsInstance(s1.shape(), Shape)
 695         s2 = Signal(2)
 696         self.assertEqual(s2.shape(), unsigned(2))
 697         s3 = Signal(unsigned(2))
 698         self.assertEqual(s3.shape(), unsigned(2))
 699         s4 = Signal(signed(2))
 700         self.assertEqual(s4.shape(), signed(2))
 701         s5 = Signal(0)
 702         self.assertEqual(s5.shape(), unsigned(0))
 703         s6 = Signal(range(16))
 704         self.assertEqual(s6.shape(), unsigned(4))
 705         s7 = Signal(range(4, 16))
 706         self.assertEqual(s7.shape(), unsigned(4))
 707         s8 = Signal(range(-4, 16))
 708         self.assertEqual(s8.shape(), signed(5))
 709         s9 = Signal(range(-20, 16))
 710         self.assertEqual(s9.shape(), signed(6))
 711         s10 = Signal(range(0))
 712         self.assertEqual(s10.shape(), unsigned(0))
 713         s11 = Signal(range(1))
 714         self.assertEqual(s11.shape(), unsigned(1))
 715         # deprecated
 716         with warnings.catch_warnings():
 717             warnings.filterwarnings(action="ignore", category=DeprecationWarning)
 718             d6 = Signal(max=16)
 719             self.assertEqual(d6.shape(), unsigned(4))
 720             d7 = Signal(min=4, max=16)
 721             self.assertEqual(d7.shape(), unsigned(4))
 722             d8 = Signal(min=-4, max=16)
 723             self.assertEqual(d8.shape(), signed(5))
 724             d9 = Signal(min=-20, max=16)
 725             self.assertEqual(d9.shape(), signed(6))
 726             d10 = Signal(max=1)
 727             self.assertEqual(d10.shape(), unsigned(0))
 728
 729     def test_shape_wrong(self):
 730         with self.assertRaises(TypeError,
 731                 msg="Width must be a non-negative integer, not -10"):
 732             Signal(-10)
 733
 734     def test_min_max_deprecated(self):
 735         with self.assertWarns(DeprecationWarning,
 736                 msg="instead of `Signal(min=0, max=10)`, use `Signal(range(0, 10))`"):
 737             Signal(max=10)
 738         with warnings.catch_warnings():
 739             warnings.filterwarnings(action="ignore", category=DeprecationWarning)
 740             with self.assertRaises(ValueError,
 741                     msg="Lower bound 10 should be less or equal to higher bound 4"):
 742                 Signal(min=10, max=4)
 743             with self.assertRaises(ValueError,
 744                     msg="Only one of bits/signedness or bounds may be specified"):
 745                 Signal(2, min=10)
 746
 747     def test_name(self):
 748         s1 = Signal()
 749         self.assertEqual(s1.name, "s1")
 750         s2 = Signal(name="sig")
 751         self.assertEqual(s2.name, "sig")
 752
 753     def test_reset(self):
 754         s1 = Signal(4, reset=0b111, reset_less=True)
 755         self.assertEqual(s1.reset, 0b111)
 756         self.assertEqual(s1.reset_less, True)
 757
 758     def test_reset_narrow(self):
 759         with self.assertWarns(SyntaxWarning,
 760                 msg="Reset value 8 requires 4 bits to represent, but the signal only has 3 bits"):
 761             Signal(3, reset=8)
 762         with self.assertWarns(SyntaxWarning,
 763                 msg="Reset value 4 requires 4 bits to represent, but the signal only has 3 bits"):
 764             Signal(signed(3), reset=4)
 765         with self.assertWarns(SyntaxWarning,
 766                 msg="Reset value -5 requires 4 bits to represent, but the signal only has 3 bits"):
 767             Signal(signed(3), reset=-5)
 768
 769     def test_attrs(self):
 770         s1 = Signal()
 771         self.assertEqual(s1.attrs, {})
 772         s2 = Signal(attrs={"no_retiming": True})
 773         self.assertEqual(s2.attrs, {"no_retiming": True})
 774
 775     def test_repr(self):
 776         s1 = Signal()
 777         self.assertEqual(repr(s1), "(sig s1)")
 778
 779     def test_like(self):
 780         s1 = Signal.like(Signal(4))
 781         self.assertEqual(s1.shape(), unsigned(4))
 782         s2 = Signal.like(Signal(range(-15, 1)))
 783         self.assertEqual(s2.shape(), signed(5))
 784         s3 = Signal.like(Signal(4, reset=0b111, reset_less=True))
 785         self.assertEqual(s3.reset, 0b111)
 786         self.assertEqual(s3.reset_less, True)
 787         s4 = Signal.like(Signal(attrs={"no_retiming": True}))
 788         self.assertEqual(s4.attrs, {"no_retiming": True})
 789         s5 = Signal.like(Signal(decoder=str))
 790         self.assertEqual(s5.decoder, str)
 791         s6 = Signal.like(10)
 792         self.assertEqual(s6.shape(), unsigned(4))
 793         s7 = [Signal.like(Signal(4))][0]
 794         self.assertEqual(s7.name, "$like")
 795         s8 = Signal.like(s1, name_suffix="_ff")
 796         self.assertEqual(s8.name, "s1_ff")
 797
 798     def test_decoder(self):
 799         class Color(Enum):
 800             RED  = 1
 801             BLUE = 2
 802         s = Signal(decoder=Color)
 803         self.assertEqual(s.decoder(1), "RED/1")
 804         self.assertEqual(s.decoder(3), "3")
 805
 806     def test_enum(self):
 807         s1 = Signal(UnsignedEnum)
 808         self.assertEqual(s1.shape(), unsigned(2))
 809         s2 = Signal(SignedEnum)
 810         self.assertEqual(s2.shape(), signed(2))
 811         self.assertEqual(s2.decoder(SignedEnum.FOO), "FOO/-1")
 812
 813
 814 class ClockSignalTestCase(FHDLTestCase):
 815     def test_domain(self):
 816         s1 = ClockSignal()
 817         self.assertEqual(s1.domain, "sync")
 818         s2 = ClockSignal("pix")
 819         self.assertEqual(s2.domain, "pix")
 820
 821         with self.assertRaises(TypeError,
 822                 msg="Clock domain name must be a string, not 1"):
 823             ClockSignal(1)
 824
 825     def test_shape(self):
 826         s1 = ClockSignal()
 827         self.assertEqual(s1.shape(), unsigned(1))
 828         self.assertIsInstance(s1.shape(), Shape)
 829
 830     def test_repr(self):
 831         s1 = ClockSignal()
 832         self.assertEqual(repr(s1), "(clk sync)")
 833
 834     def test_wrong_name_comb(self):
 835         with self.assertRaises(ValueError,
 836                 msg="Domain 'comb' does not have a clock"):
 837             ClockSignal("comb")
 838
 839
 840 class ResetSignalTestCase(FHDLTestCase):
 841     def test_domain(self):
 842         s1 = ResetSignal()
 843         self.assertEqual(s1.domain, "sync")
 844         s2 = ResetSignal("pix")
 845         self.assertEqual(s2.domain, "pix")
 846
 847         with self.assertRaises(TypeError,
 848                 msg="Clock domain name must be a string, not 1"):
 849             ResetSignal(1)
 850
 851     def test_shape(self):
 852         s1 = ResetSignal()
 853         self.assertEqual(s1.shape(), unsigned(1))
 854         self.assertIsInstance(s1.shape(), Shape)
 855
 856     def test_repr(self):
 857         s1 = ResetSignal()
 858         self.assertEqual(repr(s1), "(rst sync)")
 859
 860     def test_wrong_name_comb(self):
 861         with self.assertRaises(ValueError,
 862                 msg="Domain 'comb' does not have a reset"):
 863             ResetSignal("comb")
 864
 865
 866 class MockUserValue(UserValue):
 867     def __init__(self, lowered):
 868         super().__init__()
 869         self.lower_count = 0
 870         self.lowered     = lowered
 871
 872     def lower(self):
 873         self.lower_count += 1
 874         return self.lowered
 875
 876
 877 class UserValueTestCase(FHDLTestCase):
 878     def test_shape(self):
 879         uv = MockUserValue(1)
 880         self.assertEqual(uv.shape(), unsigned(1))
 881         self.assertIsInstance(uv.shape(), Shape)
 882         uv.lowered = 2
 883         self.assertEqual(uv.shape(), unsigned(1))
 884         self.assertEqual(uv.lower_count, 1)
 885
 886
 887 class SampleTestCase(FHDLTestCase):
 888     def test_const(self):
 889         s = Sample(1, 1, "sync")
 890         self.assertEqual(s.shape(), unsigned(1))
 891
 892     def test_signal(self):
 893         s1 = Sample(Signal(2), 1, "sync")
 894         self.assertEqual(s1.shape(), unsigned(2))
 895         s2 = Sample(ClockSignal(), 1, "sync")
 896         s3 = Sample(ResetSignal(), 1, "sync")
 897
 898     def test_wrong_value_operator(self):
 899         with self.assertRaises(TypeError,
 900                 "Sampled value must be a signal or a constant, not "
 901                 "(+ (sig $signal) (const 1'd1))"):
 902             Sample(Signal() + 1, 1, "sync")
 903
 904     def test_wrong_clocks_neg(self):
 905         with self.assertRaises(ValueError,
 906                 "Cannot sample a value 1 cycles in the future"):
 907             Sample(Signal(), -1, "sync")
 908
 909     def test_wrong_domain(self):
 910         with self.assertRaises(TypeError,
 911                 "Domain name must be a string or None, not 0"):
 912             Sample(Signal(), 1, 0)
 913
 914
 915 class InitialTestCase(FHDLTestCase):
 916     def test_initial(self):
 917         i = Initial()
 918         self.assertEqual(i.shape(), unsigned(1))