def test_coverpoint_weight(self): @vsc.covergroup class cg(object): def __init__(self): self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t())) self.cp1 = vsc.coverpoint(self.a, bins={ "a": vsc.bin_array([], 1, 2, 4, 8), }, options=dict(weight=1)) self.cp2 = vsc.coverpoint( self.b, bins={"b": vsc.bin_array([], 1, 2, 4, 8)}, options=dict(weight=0)) cg_i = cg() cg_i.sample(1, 1) cg_i.sample(2, 2) cg_i.sample(4, 1) cg_i.sample(8, 2) vsc.report_coverage(details=True) report = vsc.get_coverage_report_model() self.assertEqual(report.covergroups[0].covergroups[0].coverage, 100.0) self.assertEqual( report.covergroups[0].covergroups[0].coverpoints[0].coverage, 100.0) self.assertEqual( report.covergroups[0].covergroups[0].coverpoints[1].coverage, 50.0)
def test_sample_nonvsc_object_local_lambda(self): class my_e(IntEnum): A = auto() B = auto() class my_c: def __init__(self): self.a = 5 self.b = my_e.A @vsc.covergroup class my_cg(object): def __init__(self, input): super().__init__() # self.cp1 = vsc.coverpoint(lambda : input.a, # bins=dict( # a=vsc.bin_array([], [1, 15]) # )) self.cp2 = vsc.coverpoint(lambda: input.b, cp_t=vsc.enum_t(my_e)) inst = my_c() cg = my_cg(inst) inst.b = my_e.A cg.sample() inst.b = my_e.B cg.sample() vsc.report_coverage(details=True) self.assertEquals(cg.cp2.get_coverage(), 100)
def test_covergroup_atleast(self): @vsc.covergroup class cg(object): def __init__(self): self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t())) self.options.at_least = 2 self.cp1 = vsc.coverpoint(self.a, bins={ "a": vsc.bin_array([], 1, 2, 4, 8), }) self.cp2 = vsc.coverpoint( self.b, bins={"b": vsc.bin_array([], 1, 2, 4, 8)}) cg_i = cg() cg_i.sample(1, 1) cg_i.sample(1, 2) cg_i.sample(2, 4) cg_i.sample(2, 8) vsc.report_coverage(details=True) report = vsc.get_coverage_report_model() self.assertEqual( report.covergroups[0].covergroups[0].coverpoints[0].coverage, 50.0) self.assertEqual( report.covergroups[0].covergroups[0].coverpoints[1].coverage, 0.0)
def test_sample_vsc_object_with_sample(self): @vsc.randobj class my_c: def __init__(self): self.a = vsc.uint32_t(i=0) self.b = vsc.uint32_t(i=0) @vsc.covergroup class my_cg(object): def __init__(self): super().__init__() self.with_sample(dict(input=my_c())) self.cp1 = vsc.coverpoint( self.input.a, bins=dict(a=vsc.bin_array([], [1, 15]))) self.cp2 = vsc.coverpoint( self.input.b, bins=dict(b=vsc.bin_array([], [1, 15]))) inst = my_c() cg = my_cg() inst.a = 1 inst.b = 1 cg.sample(inst) inst.a = 2 inst.b = 2 cg.sample(inst) vsc.report_coverage(details=True) report = vsc.get_coverage_report_model() self.assertEqual(len(report.covergroups), 1) self.assertEqual(len(report.covergroups[0].coverpoints), 2) self.assertEqual(report.covergroups[0].coverpoints[0].coverage, 13.33) self.assertEqual(report.covergroups[0].coverpoints[1].coverage, 13.33)
def test_enum_lambda(self): class my_e(IntEnum): A = auto() B = auto() @vsc.covergroup class my_covergroup(object): def __init__(self, a, b): # Need to use lambda for non-reference values super().__init__() self.cp1 = vsc.coverpoint( a, options=dict(auto_bin_max=64), bins=dict(a=vsc.bin_array([], [1, 15]))) self.cp2 = vsc.coverpoint(b, cp_t=vsc.enum_t(my_e)) a = 1 b = my_e.A cg = my_covergroup(lambda: a, lambda: b) cg.sample() cg.dump() vsc.report_coverage(details=True)
def test_smoke(self): @vsc.covergroup class my_cg(object): def __init__(self): self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t())) self.a_cp = vsc.coverpoint(self.a, bins={"a": bin_array(4, [1, 15])}) my_cg_1 = my_cg() my_cg_2 = my_cg() for i in range(8): my_cg_1.sample(i, 0) for i in range(16): my_cg_2.sample(i, 0) report = vsc.get_coverage_report_model() self.assertEqual(1, len(report.covergroups)) self.assertEqual(2, len(report.covergroups[0].covergroups)) self.assertEqual(1, len(report.covergroups[0].covergroups[0].coverpoints)) self.assertEqual(1, len(report.covergroups[0].covergroups[1].coverpoints)) vsc.report_coverage(details=True)
def test_smoke(self): import vsc @vsc.randobj class ignore_bins_test(object): def __init__(self): self.a = vsc.rand_int32_t() self.value = vsc.rand_bit_t(32) @vsc.covergroup class val_cg(object): def __init__(self): self.instr = None self.cp_val = vsc.coverpoint( lambda: self.instr.value[7:5], cp_t=vsc.bit_t(3), ignore_bins=dict(invalid_value=vsc.bin(0b101, 0b110))) self.cp_a = vsc.coverpoint( lambda: self.instr.a, cp_t=vsc.bit_t(32), ignore_bins=dict(invalid_a=vsc.bin(5, 3, 100, 124, 1110))) test_obj = ignore_bins_test() val_cg_i = val_cg() for i in range(5): test_obj.randomize() print("a = {}, value = {}".format(test_obj.a, test_obj.value)) val_cg_i.instr = test_obj val_cg_i.sample() vsc.report_coverage(details=True)
def test_cov_2(self): @vsc.randobj class my_item_c(object): def __init__(self): self.a = vsc.rand_bit_t(8) self.b = vsc.rand_bit_t(8) @vsc.constraint def ab_c(self): self.a != 0 self.a <= self.b self.b in vsc.rangelist(1,2,4,8) @vsc.covergroup class my_cg(object): def __init__(self): # Define the parameters accepted by the sample function self.with_sample({ 'a' : vsc.bit_t(8), 'b' : vsc.bit_t(8) }) self.a_cp = vsc.coverpoint( self.a, bins={ # Create 4 bins across the space 0..255 'a_bins': vsc.bin_array([4], [0,255]) }) self.b_cp = vsc.coverpoint(self.b, bins={ # Create one bin for each value (1,2,4,8) 'b_bins': vsc.bin_array([], 1, 2, 4, 8) }) self.ab_cross = vsc.cross([self.a_cp, self.b_cp]) it = my_item_c() it.a = 4 it.b = 1 my_cg_i = my_cg() my_cg_i.sample(it.a, it.b) it.b = 2 my_cg_i.sample(it.a, it.b) self.assertEqual(my_cg_i.a_cp.get_coverage(), 25.0) self.assertEqual(my_cg_i.b_cp.get_coverage(), 50.0) self.assertEqual(my_cg_i.ab_cross.get_coverage(), 12.5) report_coverage(details=True) print("coverage: %f %f" % (my_cg_i.a_cp.get_coverage(), my_cg_i.b_cp.get_coverage()))
def test_ignore_left_trim(self): import vsc @vsc.randobj class ignore_bins_test(object): def __init__(self): self.a = vsc.rand_int32_t() self.value = vsc.rand_bit_t(32) @vsc.covergroup class val_cg(object): def __init__(self): self.with_sample(dict(a=vsc.uint8_t())) self.cp_val = vsc.coverpoint( self.a, bins=dict(rng_1=vsc.bin_array([4], [1, 3], [4, 6], [7, 9], [10, 12])), ignore_bins=dict(invalid_value=vsc.bin(4))) test_obj = ignore_bins_test() val_cg_i = val_cg() # Note: bins are partitioned *after* removing excluded bins. This means # that 11 values are partitioned into 4 bins. # [1,2] # [3,5] # [6,7] # [8..12] val_cg_i.sample(2) val_cg_i.sample(5) val_cg_i.sample(6) val_cg_i.sample(12) vsc.report_coverage(details=True) cvg_m = vsc.get_coverage_report_model() self.assertEqual(len(cvg_m.covergroups), 1) self.assertEqual(len(cvg_m.covergroups[0].coverpoints), 1) self.assertEqual(len(cvg_m.covergroups[0].coverpoints[0].bins), 4) self.assertEqual(len(cvg_m.covergroups[0].coverpoints[0].ignore_bins), 1) self.assertEqual(cvg_m.covergroups[0].coverpoints[0].bins[0].count, 1) self.assertEqual(cvg_m.covergroups[0].coverpoints[0].bins[1].count, 1) self.assertEqual(cvg_m.covergroups[0].coverpoints[0].bins[2].count, 1) self.assertEqual(cvg_m.covergroups[0].coverpoints[0].bins[3].count, 1) self.assertEqual( cvg_m.covergroups[0].coverpoints[0].ignore_bins[0].count, 0) val_cg_i.sample(4) cvg_m = vsc.get_coverage_report_model() self.assertEqual( cvg_m.covergroups[0].coverpoints[0].ignore_bins[0].count, 1)
def test_covergroup_setname_init(self): @vsc.covergroup class cg_t(object): def __init__(self, name): self.with_sample(dict(a=vsc.uint8_t())) self.set_name(name) self.cp = vsc.coverpoint(self.a) cg1 = cg_t("cg1") cg2 = cg_t("cg2") vsc.report_coverage() report = vsc.get_coverage_report_model() self.assertEqual(len(report.covergroups), 1) self.assertEqual(len(report.covergroups[0].covergroups), 2) self.assertEqual(report.covergroups[0].covergroups[0].name, "cg1") self.assertEqual(report.covergroups[0].covergroups[1].name, "cg2")
def test_smoke(self): class my_r(RandIF): """Defines operations to be implemented by a random generator""" def __init__(self): super().__init__() def randint(self, low: int, high: int) -> int: return low def sample(self, s, k): return random.sample(s, k) @vsc.randobj class cls(object): def __init__(self): self.a = vsc.rand_uint32_t() self.b = vsc.rand_uint32_t() @vsc.covergroup class cvg(object): def __init__(self): self.with_sample(dict(a=vsc.uint32_t(), b=vsc.uint32_t())) self.a_cp = vsc.coverpoint( self.a, bins=dict(a1=vsc.bin_array([], 1, 2, 4, 8))) self.b_cp = vsc.coverpoint( self.b, bins=dict(b1=vsc.bin_array([], 1, 2, 4, 8))) c = cls() cg = cvg() c.a = 1 c.b = 1 cg.sample(c.a, c.b) r = my_r() bin = cg.a_cp.get_model().select_unhit_bin(r) rng = cg.a_cp.get_model().get_bin_range(bin) print("bin=" + str(bin) + " rng=" + str(rng)) print(ModelPrettyPrinter().print(rng)) vsc.report_coverage()
def test_object_sample_2(self): import vsc @vsc.randobj class BranchInstr: def __init__(self): self.type = vsc.rand_bit_t(1) self.disp = vsc.rand_bit_t(19) @vsc.constraint def short_offset_cnstr(self): self.disp <= 4096 def __str__(self): return (f"type = {self.type}, displacement = {self.disp}") @vsc.covergroup class BranchInstr_cg: def __init__(self): self.with_sample(item=BranchInstr()) self.type = vsc.coverpoint(self.item.type) self.disp_cp = vsc.coverpoint( self.item.disp, bins={"small_pos": vsc.bin_array([4], [0, 4096])}) branchInstr = BranchInstr() branchInstr_cg = BranchInstr_cg() for i in range(32): branchInstr.randomize() branchInstr_cg.sample(branchInstr) print(branchInstr) rpt = vsc.get_coverage_report_model() self.assertEqual(len(rpt.covergroups[0].coverpoints), 2) self.assertEqual(len(rpt.covergroups[0].coverpoints[0].bins), 2) self.assertEqual(len(rpt.covergroups[0].coverpoints[1].bins), 4) vsc.report_coverage(details=True)
def test_array_wildcard_bin_3(self): import vsc @vsc.covergroup class cg(object): def __init__(self): self.with_sample(dict(a=vsc.bit_t(8))) self.cp_a = vsc.coverpoint( lambda: self.a[7:0], bins=dict(a=vsc.wildcard_bin_array([], "0b1011011x", "0b0x101010"), b=vsc.wildcard_bin_array([], "0b1011011x", "0b0x10x01x"))) obj1 = cg() model = vsc.get_coverage_report_model() self.assertEqual(len(model.covergroups), 1) self.assertEqual(len(model.covergroups[0].coverpoints), 1) self.assertEqual(len(model.covergroups[0].coverpoints[0].bins), 14) vsc.report_coverage(details=True)
def test_cross_sampling(self): @vsc.covergroup class my_cg(object): def __init__(self, a, b): super().__init__() self.cp1 = vsc.coverpoint( a, bins={"a": vsc.bin_array([], [1, 10])}) self.cp2 = vsc.coverpoint( b, bins={"b": vsc.bin_array([], [1, 10])}) self.cp1X2 = vsc.cross([self.cp1, self.cp2]) a = 6 b = 8 cg = my_cg(lambda: a, lambda: b) for i in range(50): cg.sample() vsc.report_coverage(details=True) # vsc.report_coverage(details=False) print("Coverage: " + str(cg.get_coverage()))
def test_bin_names_int_enum(self): class my_e_1(IntEnum): A = auto() B = auto() class my_e_2(IntEnum): C = auto() D = auto() @vsc.covergroup class my_cg(object): def __init__(self, v1, v2): self.cp1 = vsc.coverpoint(v1, cp_t=vsc.enum_t(my_e_1)) self.cp2 = vsc.coverpoint(v2, cp_t=vsc.enum_t(my_e_2)) self.cp1X2 = vsc.cross([self.cp1, self.cp2]) for i in range(16): # A=random.rand(2) # B=random.rand(2) # C=random.rand(2) # D=random.rand(2) v1 = my_e_1.A v2 = my_e_2.C cg = my_cg(lambda: v1, lambda: v2) cg.sample() v1 = my_e_1.B v2 = my_e_2.D cg.sample() vsc.report_coverage(details=True) report = vsc.get_coverage_report_model() self.assertEqual(len(report.covergroups), 1) self.assertEqual(len(report.covergroups[0].coverpoints), 2) self.assertEqual(len(report.covergroups[0].crosses), 1) self.assertEqual(report.covergroups[0].coverpoints[0].coverage, 100) self.assertEqual(report.covergroups[0].coverpoints[1].coverage, 100) self.assertEqual(report.covergroups[0].crosses[0].coverage, 50)
def test_coverpoint_atleast_option(self): @vsc.covergroup class cg(object): def __init__(self): self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t())) self.options.at_least = 2 self.cp1 = vsc.coverpoint(self.a, bins={ "a": vsc.bin_array([], 1, 2, 4, 8), }) self.cp2 = vsc.coverpoint( self.b, bins={"b": vsc.bin_array([], 1, 2, 4, 8)}) cg_i = cg() cg_i.sample(1, 1) cg_i.sample(1, 2) cg_i.sample(2, 4) cg_i.sample(2, 8) vsc.report_coverage(details=True)
def test_single_type_two_inst(self): @vsc.covergroup class my_cg(object): def __init__(self): self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t())) self.a_cp = vsc.coverpoint(self.a, bins={"a": bin_array([], [0, 15])}) my_cg_1 = my_cg() my_cg_2 = my_cg() for i in range(16): my_cg_1.sample(i, 0) vsc.report_coverage() report = vsc.get_coverage_report_model() self.assertEqual(1, len(report.covergroups)) self.assertEqual(2, len(report.covergroups[0].covergroups)) self.assertEqual(100, report.covergroups[0].coverage) self.assertEqual(100, report.covergroups[0].covergroups[0].coverage) self.assertEqual(0, report.covergroups[0].covergroups[1].coverage)
def test_enum_bins_autobin_exclude(self): import vsc class my_e(IntEnum): A = auto() B = auto() C = auto() D = auto() E = auto() F = auto() G = auto() H = auto() @vsc.randobj class ignore_bins_test(object): def __init__(self): self.v = vsc.rand_enum_t(my_e) @vsc.covergroup class val_cg(object): def __init__(self): self.with_sample(dict(v=vsc.enum_t(my_e))) self.cp_v = vsc.coverpoint(self.v, ignore_bins=dict( ignore_1=vsc.bin(my_e.D), ignore_2=vsc.bin(my_e.H))) test_obj = ignore_bins_test() val_cg_i = val_cg() # Sample all non-excluded values for v in (my_e.A, my_e.B, my_e.C, my_e.E, my_e.F, my_e.G): val_cg_i.sample(v) vsc.report_coverage(details=True) coverage_model = vsc.get_coverage_report_model() self.assertEqual(len(coverage_model.covergroups), 1) self.assertEqual(len(coverage_model.covergroups[0].coverpoints), 1) self.assertEqual( len(coverage_model.covergroups[0].coverpoints[0].bins), 6) self.assertEqual( len(coverage_model.covergroups[0].coverpoints[0].ignore_bins), 2) self.assertEqual( coverage_model.covergroups[0].coverpoints[0].ignore_bins[0].count, 0) self.assertEqual( coverage_model.covergroups[0].coverpoints[0].ignore_bins[1].count, 0) val_cg_i.sample(my_e.D) coverage_model = vsc.get_coverage_report_model() self.assertEqual( coverage_model.covergroups[0].coverpoints[0].ignore_bins[0].count, 1) self.assertEqual( coverage_model.covergroups[0].coverpoints[0].ignore_bins[1].count, 0) val_cg_i.sample(my_e.H) coverage_model = vsc.get_coverage_report_model() self.assertEqual( coverage_model.covergroups[0].coverpoints[0].ignore_bins[0].count, 1) self.assertEqual( coverage_model.covergroups[0].coverpoints[0].ignore_bins[1].count, 1)