def testArgIsNormalFunction(self):
     def h():
         yield None
     try:
         always_comb(h)
     except AlwaysCombError, e:
         self.assertEqual(e.kind, _error.ArgType)

 def testArgHasNoArgs(self):
     def h(n):
         return n
     try:
         always_comb(h)
     except AlwaysCombError, e:
         self.assertEqual(e.kind, _error.NrOfArgs)

 def testArgIsFunction(self):
     h = 5
     try:
         always_comb(h)
     except AlwaysCombError as e:
         self.assertEqual(e.kind, _error.ArgType)
     else:
         self.fail()

    def testInfer6(self):
        a, b, c, d = [Signal(0) for i in range(4)]

        def h():
            c.next = a
            x.next = c
        with raises_kind(AlwaysCombError, _error.SignalAsInout % set('c')):
            g = always_comb(h).gen

 def testInfer9(self):
     a, b, c, d = [Signal(0) for i in range(4)]
     def h():
         c.next[a-1] = x[b-1]
     g = always_comb(h).gen
     i = g.gi_frame.f_locals['self']
     expected = Set(['a', 'b', 'x'])
     self.assertEqual(i.inputs, expected)

    def testInfer5(self):
        a, b, c, d = [Signal(0) for i in range(4)]

        def h():
            c.next += 1
            a += 1
        with raises_kind(AlwaysCombError, _error.SignalAsInout % "c"):
            g = always_comb(h).gen

    def testInfer7(self):
        a, b, c, d = [Signal(0) for i in range(4)]

        def h():
            c.next[a:0] = x[b:0]
        g = always_comb(h).gen
        i = g.gi_frame.f_locals['self']
        expected = set(['a', 'b', 'x'])
        assert i.inputs == expected

 def testInfer6(self):
     a, b, c, d = [Signal(0) for i in range(4)]
     def h():
         c.next = a
         x.next = c
     try:
         g = always_comb(h).gen
     except AlwaysCombError, e:
         self.assertEqual(e.kind, _error.SignalAsInout)

 def testInfer1(self):
     a, b, c, d = [Signal(0) for i in range(4)]
     u = 1
     def h():
         c.next = a
         v = u
     g = always_comb(h).gen
     i = g.gi_frame.f_locals['self']
     expected = Set(['a'])
     self.assertEqual(i.inputs, expected)

 def testInfer10(self):
     a, b, c, d = [Signal(0) for i in range(4)]
     def f(x, y, z):
         return 0
     def h():
         c.next = f(a, 2*b, d*x)
     g = always_comb(h).gen
     i = g.gi_frame.f_locals['self']
     expected = Set(['a', 'b', 'd', 'x'])
     self.assertEqual(i.inputs, expected)

 def testInfer8(self):
     a, b, c, d = [Signal(0) for i in range(4)]
     u = 1
     def h():
         v = 2
         c.next[8:1+a+v] = x[4:b*3+u]
     g = always_comb(h).gen
     i = g.gi_frame.f_locals['self']
     expected = Set(['a', 'b', 'x'])
     self.assertEqual(i.inputs, expected)

    def testInfer3(self):
        a, b, c, d = [Signal(0) for i in range(4)]
        u = 1

        def h():
            c.next = a + x + u
            a = 1
        g = always_comb(h).gen
        i = g.gi_frame.f_locals['self']
        expected = set(['x'])
        assert i.inputs == expected

 def testInfer5(self):
     a, b, c, d = [Signal(0) for i in range(4)]
     def h():
         c.next += 1
         a += 1
     try:
         g = always_comb(h).gen
     except AlwaysCombError as e:
         self.assertEqual(e.kind, _error.SignalAsInout % "c")
     else:
         self.fail()

    def testEmbeddedFunction(self):
        a, b, c, d = [Signal(0) for i in range(4)]
        u = 1

        def h():
            def g():
                e = b
                return e
            c.next = x
            g = a
        with raises_kind(AlwaysCombError, _error.EmbeddedFunction):
            g = always_comb(h)

 def testEmbeddedFunction(self):
     a, b, c, d = [Signal(0) for i in range(4)]
     u = 1
     def h():
         def g():
             e = b
             return e
         c.next = x
         g = a
     try:
         g = always_comb(h)
     except AlwaysCombError, e:
         self.assertEqual(e.kind, _error.EmbeddedFunction)

    def bench(self, function):

        clk = Signal(0)
        a = Signal(0)
        b = Signal(0)
        c = Signal(0)
        d = Signal(0)
        z = Signal(0)
        vectors = [intbv(j) for i in range(32) for j in range(16)]
        random.shuffle(vectors)

        
        def combFunc():
            if __debug__:
                f = x
            x.next = function(a, b, c, d)

        comb = always_comb(combFunc)

        def clkGen():
            while 1:
                yield delay(10)
                clk.next ^= 1

        def logic():
            while 1:
                z.next = function(a, b, c, d)
                yield a, b, c, d

        def stimulus():
            for v in vectors:
                a.next = v[0]
                b.next = v[1]
                c.next = v[2]
                d.next = v[3]
                yield clk.posedge
                yield clk.negedge
                self.assertEqual(x, z)
            raise StopSimulation, "always_comb simulation test"

        return instances()

 def testArgIsFunction(self):
     h = 5
     with raises_kind(AlwaysCombError, _error.ArgType):
         always_comb(h)

 def testArgIsNormalFunction(self):
     def h():
         yield None
     with raises_kind(AlwaysCombError, _error.ArgType):
         always_comb(h)

 def testArgHasNoArgs(self):
     def h(n):
         return n
     with raises_kind(AlwaysCombError, _error.NrOfArgs):
         always_comb(h)