Cast to int instead of using .integer

Signed-off-by: Alex Forencich <alex@alexforencich.com>

src/axis/tb/taxi_axis_async_fifo_adapter/test_taxi_axis_async_fifo_adapter.py

@@ -564,7 +564,7 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
         cycles = 0
         while cycles < 100:
             cycles += 1
-            if not tb.source.idle() or dut.s_axis.tvalid.value.integer or dut.m_axis.tvalid.value.integer or dut.m_status_depth.value.integer:
+            if not tb.source.idle() or int(dut.s_axis.tvalid.value) or int(dut.m_axis.tvalid.value) or int(dut.m_status_depth.value):
                 cycles = 0
             await RisingEdge(dut.m_clk)
 

src/axis/tb/taxi_axis_fifo/test_taxi_axis_fifo.py

@@ -350,7 +350,7 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
         cycles = 0
         while cycles < 100:
             cycles += 1
-            if not tb.source.idle() or dut.s_axis.tvalid.value.integer or dut.m_axis.tvalid.value.integer or dut.status_depth.value.integer:
+            if not tb.source.idle() or int(dut.s_axis.tvalid.value) or int(dut.m_axis.tvalid.value) or int(dut.status_depth.value):
                 cycles = 0
             await RisingEdge(dut.clk)
 

src/eth/tb/baser.py

@@ -681,7 +681,7 @@ class BaseRSerdesSink:
                 self.gbx_seq = (self.gbx_seq + 1) % self.gbx_seq_len
 
                 if self.gbx_sync is not None:
-                    if self.gbx_sync.value.integer:
+                    if int(self.gbx_sync.value):
                         self.gbx_seq = 0
 
                 self.gbx_bit_cnt = max(self.gbx_bit_cnt - self.gbx_out_bits, 0)
@@ -701,7 +701,7 @@ class BaseRSerdesSink:
                     self.gbx_sync.value = 1
 
             if self.data_valid is not None:
-                if not self.data_valid.value.integer:
+                if not int(self.data_valid.value):
                     # stall
                     if self.gbx_seq_len and not sync_bad:
                         sync_bad = True
@@ -710,8 +710,8 @@ class BaseRSerdesSink:
 
             sync_bad = False
 
-            data_in = self.data.value.integer
+            data_in = int(self.data.value)
-            hdr_in = self.hdr.value.integer
+            hdr_in = int(self.hdr.value)
 
             if self.reverse:
                 # bit reverse

src/eth/tb/taxi_axis_gmii_tx/test_taxi_axis_gmii_tx.py

@@ -194,7 +194,7 @@ async def run_test_underrun(dut, ifg=12, enable_gen=None, mii_sel=False):
     for k in range(200 if mii_sel else 100):
         while True:
             await RisingEdge(dut.clk)
-            if dut.clk_enable.value.integer:
+            if int(dut.clk_enable.value):
                 break
 
     tb.source.pause = True
@@ -202,7 +202,7 @@ async def run_test_underrun(dut, ifg=12, enable_gen=None, mii_sel=False):
     for k in range(10):
         while True:
             await RisingEdge(dut.clk)
-            if dut.clk_enable.value.integer:
+            if int(dut.clk_enable.value):
                 break
 
     tb.source.pause = False

src/eth/tb/taxi_eth_mac_10g/test_taxi_eth_mac_10g.py

@@ -470,7 +470,7 @@ async def run_test_lfc(dut, ifg=12):
 
     dut.tx_lfc_req.value = 0
 
-    while not dut.rx_lfc_req.value.integer:
+    while not int(dut.rx_lfc_req.value):
         await RisingEdge(dut.tx_clk)
 
     for k in range(200):

src/eth/tb/taxi_eth_mac_10g_fifo/test_taxi_eth_mac_10g_fifo.py

@@ -96,7 +96,7 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12):
     await tb.reset()
 
     tb.log.info("Wait for PTP CDC lock")
-    while not dut.uut.rx_ptp_locked.value.integer:
+    while not int(dut.uut.rx_ptp_locked.value):
         await RisingEdge(dut.rx_clk)
     for k in range(1000):
         await RisingEdge(dut.rx_clk)
@@ -148,7 +148,7 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12):
     await tb.reset()
 
     tb.log.info("Wait for PTP CDC lock")
-    while not dut.uut.tx_ptp_locked.value.integer:
+    while not int(dut.uut.tx_ptp_locked.value):
         await RisingEdge(dut.tx_clk)
     for k in range(1000):
         await RisingEdge(dut.tx_clk)
@@ -201,7 +201,7 @@ async def run_test_tx_alignment(dut, payload_data=None, ifg=12):
     await tb.reset()
 
     tb.log.info("Wait for PTP CDC lock")
-    while not dut.uut.tx_ptp_locked.value.integer:
+    while not int(dut.uut.tx_ptp_locked.value):
         await RisingEdge(dut.tx_clk)
     for k in range(1000):
         await RisingEdge(dut.tx_clk)

src/eth/tb/taxi_eth_mac_1g/test_taxi_eth_mac_1g.py

@@ -292,7 +292,7 @@ async def run_test_tx_underrun(dut, ifg=12, enable_gen=None, mii_sel=False):
     for k in range(200 if mii_sel else 100):
         while True:
             await RisingEdge(dut.tx_clk)
-            if dut.tx_clk_enable.value.integer:
+            if int(dut.tx_clk_enable.value):
                 break
 
     tb.axis_source.pause = True
@@ -300,7 +300,7 @@ async def run_test_tx_underrun(dut, ifg=12, enable_gen=None, mii_sel=False):
     for k in range(10):
         while True:
             await RisingEdge(dut.tx_clk)
-            if dut.tx_clk_enable.value.integer:
+            if int(dut.tx_clk_enable.value):
                 break
 
     tb.axis_source.pause = False
@@ -539,7 +539,7 @@ async def run_test_lfc(dut, ifg=12, enable_gen=None, mii_sel=True):
 
     dut.tx_lfc_req.value = 0
 
-    while not dut.rx_lfc_req.value.integer:
+    while not int(dut.rx_lfc_req.value):
         await RisingEdge(dut.tx_clk)
 
     for k in range(1000):

src/eth/tb/taxi_eth_mac_1g_gmii/test_taxi_eth_mac_1g_gmii.py

@@ -406,7 +406,7 @@ async def run_test_lfc(dut, ifg=12, speed=1000e6):
 
     dut.tx_lfc_req.value = 0
 
-    while not dut.rx_lfc_req.value.integer:
+    while not int(dut.rx_lfc_req.value):
         await RisingEdge(dut.tx_clk)
 
     for k in range(1000):

src/eth/tb/taxi_eth_mac_1g_rgmii/test_taxi_eth_mac_1g_rgmii.py

@@ -254,7 +254,7 @@ async def run_test_tx_underrun(dut, ifg=12, speed=1000e6):
     for k in range(200 if speed != 1000e6 else 100):
         while True:
             await RisingEdge(dut.tx_clk)
-            if dut.uut.mac_gmii_tx_clk_en.value.integer:
+            if int(dut.uut.mac_gmii_tx_clk_en.value):
                 break
 
     tb.axis_source.pause = True
@@ -262,7 +262,7 @@ async def run_test_tx_underrun(dut, ifg=12, speed=1000e6):
     for k in range(10):
         while True:
             await RisingEdge(dut.tx_clk)
-            if dut.uut.mac_gmii_tx_clk_en.value.integer:
+            if int(dut.uut.mac_gmii_tx_clk_en.value):
                 break
 
     tb.axis_source.pause = False
@@ -409,7 +409,7 @@ async def run_test_lfc(dut, ifg=12, speed=1000e6):
 
     dut.tx_lfc_req.value = 0
 
-    while not dut.rx_lfc_req.value.integer:
+    while not int(dut.rx_lfc_req.value):
         await RisingEdge(dut.tx_clk)
 
     for k in range(1000):

src/eth/tb/taxi_eth_mac_25g_us/test_taxi_eth_mac_25g_us.py

@@ -684,7 +684,7 @@ async def run_test_lfc(dut, port=0, ifg=12):
 
     dut.tx_lfc_req.value = 0
 
-    while not dut.rx_lfc_req.value.integer:
+    while not int(dut.rx_lfc_req.value):
         await RisingEdge(dut.xcvr_ctrl_clk)
 
     for k in range(200):

src/eth/tb/taxi_eth_mac_mii/test_taxi_eth_mac_mii.py

@@ -370,7 +370,7 @@ async def run_test_lfc(dut, ifg=12, speed=1000e6):
 
     dut.tx_lfc_req.value = 0
 
-    while not dut.rx_lfc_req.value.integer:
+    while not int(dut.rx_lfc_req.value):
         await RisingEdge(dut.tx_clk)
 
     for k in range(1000):

src/eth/tb/taxi_eth_mac_phy_10g/test_taxi_eth_mac_phy_10g.py

@@ -599,7 +599,7 @@ async def run_test_lfc(dut, gbx_cfg=None, ifg=12):
 
     dut.tx_lfc_req.value = 0
 
-    while not dut.rx_lfc_req.value.integer:
+    while not int(dut.rx_lfc_req.value):
         await RisingEdge(dut.tx_clk)
 
     for k in range(200):

src/eth/tb/taxi_eth_mac_phy_10g_fifo/test_taxi_eth_mac_phy_10g_fifo.py

@@ -138,11 +138,11 @@ async def run_test_rx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None
     await tb.reset()
 
     tb.log.info("Wait for block lock")
-    while not dut.rx_block_lock.value.integer:
+    while not int(dut.rx_block_lock.value):
         await RisingEdge(dut.rx_clk)
 
     tb.log.info("Wait for PTP CDC lock")
-    while not dut.uut.rx_ptp_locked.value.integer:
+    while not int(dut.uut.rx_ptp_locked.value):
         await RisingEdge(dut.rx_clk)
     for k in range(1000):
         await RisingEdge(dut.rx_clk)
@@ -205,7 +205,7 @@ async def run_test_tx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None
     await tb.reset()
 
     tb.log.info("Wait for PTP CDC lock")
-    while not dut.uut.tx_ptp_locked.value.integer:
+    while not int(dut.uut.tx_ptp_locked.value):
         await RisingEdge(dut.tx_clk)
     for k in range(1000):
         await RisingEdge(dut.tx_clk)
@@ -269,7 +269,7 @@ async def run_test_tx_alignment(dut, gbx_cfg=None, payload_data=None, ifg=12):
     await tb.reset()
 
     tb.log.info("Wait for PTP CDC lock")
-    while not dut.uut.tx_ptp_locked.value.integer:
+    while not int(dut.uut.tx_ptp_locked.value):
         await RisingEdge(dut.tx_clk)
     for k in range(1000):
         await RisingEdge(dut.tx_clk)
@@ -362,10 +362,10 @@ async def run_test_rx_frame_sync(dut, gbx_cfg=None):
     await tb.reset()
 
     tb.log.info("Wait for block lock")
-    while not dut.rx_block_lock.value.integer:
+    while not int(dut.rx_block_lock.value):
         await RisingEdge(dut.rx_clk)
 
-    assert dut.rx_block_lock.value.integer
+    assert int(dut.rx_block_lock.value)
 
     tb.log.info("Change offset")
     tb.serdes_source.bit_offset = 33
@@ -374,20 +374,20 @@ async def run_test_rx_frame_sync(dut, gbx_cfg=None):
         await RisingEdge(dut.rx_clk)
 
     tb.log.info("Check for lock lost")
-    assert not dut.rx_block_lock.value.integer
+    assert not int(dut.rx_block_lock.value)
-    assert dut.rx_high_ber.value.integer
+    assert int(dut.rx_high_ber.value)
 
     for k in range(800):
         await RisingEdge(dut.rx_clk)
 
     tb.log.info("Check for block lock")
-    assert dut.rx_block_lock.value.integer
+    assert int(dut.rx_block_lock.value)
 
     for k in range(300):
         await RisingEdge(dut.rx_clk)
 
     tb.log.info("Check for high BER deassert")
-    assert not dut.rx_high_ber.value.integer
+    assert not int(dut.rx_high_ber.value)
 
     await RisingEdge(dut.rx_clk)
     await RisingEdge(dut.rx_clk)

src/eth/tb/taxi_mac_ctrl_rx/test_taxi_mac_ctrl_rx.py

@@ -95,11 +95,11 @@ class TB:
         rx_frame = await self.mcf_sink.recv()
 
         data = bytearray()
-        data.extend(rx_frame.eth_dst.integer.to_bytes(6, 'big'))
+        data.extend(int(rx_frame.eth_dst).to_bytes(6, 'big'))
-        data.extend(rx_frame.eth_src.integer.to_bytes(6, 'big'))
+        data.extend(int(rx_frame.eth_src).to_bytes(6, 'big'))
-        data.extend(rx_frame.eth_type.integer.to_bytes(2, 'big'))
+        data.extend(int(rx_frame.eth_type).to_bytes(2, 'big'))
-        data.extend(rx_frame.opcode.integer.to_bytes(2, 'big'))
+        data.extend(int(rx_frame.opcode).to_bytes(2, 'big'))
-        data.extend(rx_frame.params.integer.to_bytes(44, 'little'))
+        data.extend(int(rx_frame.params).to_bytes(44, 'little'))
 
         return Ether(data)
 

src/eth/tb/taxi_mac_pause_ctrl_tx/test_taxi_mac_pause_ctrl_tx.py

@@ -81,11 +81,11 @@ class TB:
         rx_frame = await self.mcf_sink.recv()
 
         data = bytearray()
-        data.extend(rx_frame.eth_dst.integer.to_bytes(6, 'big'))
+        data.extend(int(rx_frame.eth_dst).to_bytes(6, 'big'))
-        data.extend(rx_frame.eth_src.integer.to_bytes(6, 'big'))
+        data.extend(int(rx_frame.eth_src).to_bytes(6, 'big'))
-        data.extend(rx_frame.eth_type.integer.to_bytes(2, 'big'))
+        data.extend(int(rx_frame.eth_type).to_bytes(2, 'big'))
-        data.extend(rx_frame.opcode.integer.to_bytes(2, 'big'))
+        data.extend(int(rx_frame.opcode).to_bytes(2, 'big'))
-        data.extend(rx_frame.params.integer.to_bytes(44, 'little'))
+        data.extend(int(rx_frame.params).to_bytes(44, 'little'))
 
         return Ether(data)
 

src/lfsr/tb/taxi_lfsr/test_taxi_lfsr.py

@@ -70,7 +70,7 @@ async def run_test_crc(dut, ref_crc):
     dut.data_in.value = int.from_bytes(block, 'little')
     await Timer(10, 'ns')
 
-    val = ~dut.state_out.value.integer & state_mask
+    val = ~int(dut.state_out.value) & state_mask
     ref = ref_crc(block)
 
     tb.log.info("CRC: 0x%x (ref: 0x%x)", val, ref)

src/lfsr/tb/taxi_lfsr_crc/test_taxi_lfsr_crc.py

@@ -83,7 +83,7 @@ async def run_test_crc(dut, ref_crc):
     dut.data_in_valid.value = 0
 
     await RisingEdge(dut.clk)
-    val = dut.crc_out.value.integer
+    val = int(dut.crc_out.value)
     ref = ref_crc(block)
 
     tb.log.info("CRC: 0x%x (ref: 0x%x)", val, ref)
@@ -101,7 +101,7 @@ async def run_test_crc(dut, ref_crc):
     dut.data_in_valid.value = 0
 
     await RisingEdge(dut.clk)
-    val = dut.crc_out.value.integer
+    val = int(dut.crc_out.value)
     ref = ref_crc(block)
 
     tb.log.info("CRC: 0x%x (ref: 0x%x)", val, ref)

src/lfsr/tb/taxi_lfsr_descramble/test_taxi_lfsr_descramble.py

@@ -129,7 +129,7 @@ async def run_test_descramble(dut, ref_scramble, ref_descramble):
         dut.data_in_valid.value = 1
         await RisingEdge(dut.clk)
 
-        val = dut.data_out.value.integer
+        val = int(dut.data_out.value)
 
         if not first:
             ref = int.from_bytes(bytes(next(ref_iter)), 'little')

src/lfsr/tb/taxi_lfsr_prbs_check/test_taxi_lfsr_prbs_check.py

@@ -96,7 +96,7 @@ async def run_test_prbs(dut, ref_prbs):
         dut.data_in.value = int.from_bytes(bytes(next(gen)), 'big')
         dut.data_in_valid.value = 1
 
-        val = dut.data_out.value.integer
+        val = int(dut.data_out.value)
 
         tb.log.info("Error value: 0x%x", val)
 
@@ -130,7 +130,7 @@ async def run_test_prbs(dut, ref_prbs):
         dut.data_in.value = val
         dut.data_in_valid.value = 1
 
-        val = dut.data_out.value.integer
+        val = int(dut.data_out.value)
 
         tb.log.info("Error value: 0x%x", val)
 

src/lfsr/tb/taxi_lfsr_prbs_gen/test_taxi_lfsr_prbs_gen.py

@@ -85,7 +85,7 @@ async def run_test_prbs(dut, ref_prbs):
 
     for i in range(512):
         ref = int.from_bytes(bytes(next(gen)), 'big')
-        val = dut.data_out.value.integer
+        val = int(dut.data_out.value)
 
         tb.log.info("PRBS: 0x%x (ref: 0x%x)", val, ref)
 
@@ -141,7 +141,7 @@ async def run_test_scramble(dut, ref_scramble):
 
     for i in range(512):
         ref = int.from_bytes(bytes(next(scr_iter)), 'little')
-        val = dut.data_out.value.integer
+        val = int(dut.data_out.value)
 
         tb.log.info("PRBS: 0x%x (ref: 0x%x)", val, ref)
 

src/lfsr/tb/taxi_lfsr_scramble/test_taxi_lfsr_scramble.py

@@ -112,7 +112,7 @@ async def run_test_scramble(dut, ref_scramble):
         dut.data_in_valid.value = 1
         await RisingEdge(dut.clk)
 
-        val = dut.data_out.value.integer
+        val = int(dut.data_out.value)
 
         if not first:
             ref = int.from_bytes(bytes(next(scr_iter)), 'little')

src/lss/tb/taxi_i2c_master/test_taxi_i2c_master.py

@@ -87,11 +87,11 @@ class TB:
         return (await self.data_sink.recv()).tdata
 
     async def i2c_wait(self):
-        if self.dut.busy.value.integer:
+        if int(self.dut.busy.value):
             await FallingEdge(self.dut.busy)
 
     async def i2c_wait_bus_idle(self):
-        if self.dut.bus_active.value.integer:
+        if int(self.dut.bus_active.value):
             await FallingEdge(self.dut.bus_active)
 
 

src/lss/tb/taxi_i2c_single_reg/test_taxi_i2c_single_reg.py

@@ -58,7 +58,7 @@ async def run_test_write(dut):
     await tb.i2c_master.write(0x70, b'\x11\xAA')
     await tb.i2c_master.send_stop()
 
-    assert dut.data_out.value.integer == 0xAA
+    assert int(dut.data_out.value) == 0xAA
 
     await RisingEdge(dut.clk)
     await RisingEdge(dut.clk)
@@ -79,7 +79,7 @@ async def run_test_null_write(dut):
     await tb.i2c_master.write(0x70, b'')
     await tb.i2c_master.send_stop()
 
-    assert dut.data_out.value.integer == 0xAA
+    assert int(dut.data_out.value) == 0xAA
 
     await RisingEdge(dut.clk)
     await RisingEdge(dut.clk)
@@ -123,7 +123,7 @@ async def run_test_nack(dut):
     await tb.i2c_master.write(0x55, b'\x00\x04'+b'\xde\xad\xbe\xef')
     await tb.i2c_master.send_stop()
 
-    assert dut.data_out.value.integer == 0xAA
+    assert int(dut.data_out.value) == 0xAA
 
     # assert missed ack
 

src/ptp/tb/ptp_td.py

@@ -455,7 +455,7 @@ class PtpTdSink(Reset):
         while True:
             await clock_edge_event
 
-            sdi_sample = self.data.value.integer
+            sdi_sample = int(self.data.value)
 
             # increment fns portion
             self.ts_fns += ((self.period_ns << 32) + self.period_fns)

src/ptp/tb/taxi_ptp_clock/test_taxi_ptp_clock.py

@@ -61,14 +61,14 @@ class TB:
         await RisingEdge(self.dut.clk)
 
     def get_output_ts_tod_ns(self):
-        ts = self.dut.output_ts_tod.value.integer
+        ts = int(self.dut.output_ts_tod.value)
         return Decimal(ts >> 48).scaleb(9) + (Decimal(ts & 0xffffffffffff) / Decimal(2**16))
 
     def get_output_ts_tod_s(self):
         return self.get_output_ts_tod_ns().scaleb(-9)
 
     def get_output_ts_rel_ns(self):
-        ts = self.dut.output_ts_rel.value.integer
+        ts = int(self.dut.output_ts_rel.value)
         return Decimal(ts) / Decimal(2**16)
 
     def get_output_ts_rel_s(self):
@@ -137,10 +137,10 @@ async def run_load_timestamps(dut):
 
     await RisingEdge(dut.clk)
 
-    assert dut.output_ts_tod.value.integer == 12345678
+    assert int(dut.output_ts_tod.value) == 12345678
-    assert dut.output_ts_tod_step.value.integer == 1
+    assert int(dut.output_ts_tod_step.value) == 1
-    assert dut.output_ts_rel.value.integer == 12345678
+    assert int(dut.output_ts_rel.value) == 12345678
-    assert dut.output_ts_rel_step.value.integer == 1
+    assert int(dut.output_ts_rel_step.value) == 1
 
     await RisingEdge(dut.clk)
 
@@ -207,7 +207,7 @@ async def run_seconds_increment(dut):
     for k in range(3000):
         await RisingEdge(dut.clk)
 
-        if dut.output_pps.value.integer:
+        if int(dut.output_pps.value):
             saw_pps = True
             tb.log.info("Got PPS with sink ToD TS %s", tb.get_output_ts_tod_ns())
             assert (tb.get_output_ts_tod_s() - 1) < 6.4e-9

src/ptp/tb/taxi_ptp_clock_cdc/test_taxi_ptp_clock_cdc.py

@@ -105,14 +105,14 @@ class TB:
             self.dut.output_clk.value = 0
 
     def get_input_ts_ns(self):
-        ts = self.dut.input_ts.value.integer
+        ts = int(self.dut.input_ts.value)
         if len(self.dut.input_ts) == 64:
             return ts/2**16*1e-9
         else:
             return (ts >> 48) + ((ts & 0xffffffffffff)/2**16*1e-9)
 
     def get_output_ts_ns(self):
-        ts = self.dut.output_ts.value.integer
+        ts = int(self.dut.output_ts.value)
         if len(self.dut.output_ts) == 64:
             return ts/2**16*1e-9
         else:
@@ -177,7 +177,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -194,7 +194,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -211,7 +211,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -228,7 +228,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -245,7 +245,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -277,7 +277,7 @@ async def run_test(dut):
         for i in range(200):
             await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -309,7 +309,7 @@ async def run_test(dut):
         for i in range(20):
             await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -326,7 +326,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -343,7 +343,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -360,7 +360,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     # diffs = await tb.measure_ts_diff()
     # tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -392,7 +392,7 @@ async def run_test(dut):
     #     for i in range(20):
     #         await RisingEdge(dut.input_clk)
 
-    # assert tb.dut.locked.value.integer
+    # assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -409,7 +409,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")
@@ -426,7 +426,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.input_clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference: {mean(diffs)*1e9} ns (stdev: {stdev(diffs)*1e9})")

src/ptp/tb/taxi_ptp_td_leaf/test_taxi_ptp_td_leaf.py

@@ -99,11 +99,11 @@ class TB:
         self.clock_period = period
 
     def get_output_ts_tod_ns(self):
-        ts = self.dut.output_ts_tod.value.integer
+        ts = int(self.dut.output_ts_tod.value)
         return Decimal(ts >> 48).scaleb(9) + (Decimal(ts & 0xffffffffffff) / Decimal(2**16))
 
     def get_output_ts_rel_ns(self):
-        ts = self.dut.output_ts_rel.value.integer
+        ts = int(self.dut.output_ts_rel.value)
         return Decimal(ts) / Decimal(2**16)
 
     async def _run_clock(self):
@@ -198,7 +198,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -217,7 +217,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -236,7 +236,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -255,7 +255,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -274,7 +274,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -308,7 +308,7 @@ async def run_test(dut):
         for i in range(200):
             await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -342,7 +342,7 @@ async def run_test(dut):
         for i in range(20):
             await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -361,7 +361,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -380,7 +380,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -399,7 +399,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -433,7 +433,7 @@ async def run_test(dut):
         for i in range(20):
             await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -452,7 +452,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")
@@ -471,7 +471,7 @@ async def run_test(dut):
     for i in range(100000):
         await RisingEdge(dut.clk)
 
-    assert tb.dut.locked.value.integer
+    assert int(tb.dut.locked.value)
 
     rel_diffs, tod_diffs = await tb.measure_ts_diff()
     tb.log.info(f"Difference (rel): {mean(rel_diffs)} ns (stdev: {stdev(rel_diffs)})")

src/ptp/tb/taxi_ptp_td_phc/test_taxi_ptp_td_phc.py

@@ -362,7 +362,7 @@ async def run_seconds_increment(dut):
     for k in range(3000):
         await RisingEdge(dut.clk)
 
-        if dut.output_pps.value.integer:
+        if int(dut.output_pps.value):
             saw_pps = True
             tb.log.info("Got PPS with sink ToD TS %s", tb.ptp_td_sink.get_ts_tod_ns())
             assert (tb.ptp_td_sink.get_ts_tod_s() - 1) < 6.4e-9