def test_neg_set_ioclass_cache_mode(pyocf_ctx, cm, cls): """ Test whether it is possible to add ioclass with invaild cache mode :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device(cache_device, cache_mode=cm, cache_line_size=cls) # Set invalid cache mode and check if failed for i in RandomGenerator(DefaultRanges.INT): if i in list(CacheMode) + [CACHE_MODE_NONE]: continue with pytest.raises(OcfError, match="Error adding partition to cache"): cache.configure_partition(part_id=1, name="unclassified", max_size=100, priority=1, cache_mode=i) print(f"\n{i}")
def test_neg_set_nhit_promotion_policy_param_threshold(pyocf_ctx, cm, cls): """ Test whether it is possible to set invalid promotion policy param INSERTION_THRESHOLD for nhit promotion policy :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device( cache_device, cache_mode=cm, cache_line_size=cls, promotion_policy=PromotionPolicy.NHIT, ) # Set to invalid promotion policy insertion threshold and check if failed for i in RandomGenerator(DefaultRanges.UINT32): if i in ConfValidValues.promotion_nhit_insertion_threshold_range: continue with pytest.raises(OcfError, match="Error setting promotion policy parameter"): cache.set_promotion_policy_param(PromotionPolicy.NHIT, NhitParams.INSERTION_THRESHOLD, i) print(f"\n{i}")
def test_neg_set_acp_param_value(pyocf_ctx, cm, cls, param): """ Test whether it is possible to set invalid value to any of acp cleaning policy params :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :param param: acp parameter to fuzz :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device(cache_device, cache_mode=cm, cache_line_size=cls) cache.set_cleaning_policy(CleaningPolicy.ACP) # Set to invalid acp param value and check if failed valid_range = get_acp_param_valid_rage(param) for i in RandomGenerator(DefaultRanges.UINT32): if i in valid_range: continue with pytest.raises(OcfError, match="Error setting cleaning policy param"): cache.set_cleaning_policy_param(CleaningPolicy.ACP, param, i) print(f"\n{i}")
def test_neg_set_nhit_promotion_policy_param(pyocf_ctx, cm, cls): """ Test whether it is possible to set invalid promotion policy param id for nhit promotion policy :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device( cache_device, cache_mode=cm, cache_line_size=cls, promotion_policy=PromotionPolicy.NHIT, ) # Set invalid promotion policy param id and check if failed for i in RandomGenerator(DefaultRanges.UINT8): if i in [item.value for item in NhitParams]: continue with pytest.raises(OcfError, match="Error setting promotion policy parameter"): cache.set_promotion_policy_param(PromotionPolicy.NHIT, i, 1) print(f"\n{i}")
def test_neg_cache_set_seq_cut_off_threshold(pyocf_ctx, cm, cls): """ Test whether it is possible to change cache seq cut-off threshold to invalid value :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device(cache_device, cache_mode=cm, cache_line_size=cls) # Create 2 core devices core_device1 = Volume(S.from_MiB(10)) core1 = Core.using_device(core_device1, name="core1") core_device2 = Volume(S.from_MiB(10)) core2 = Core.using_device(core_device2, name="core2") # Add cores cache.add_core(core1) cache.add_core(core2) # Change cache seq cut off policy to invalid one and check if failed for i in RandomGenerator(DefaultRanges.UINT32): if i in ConfValidValues.seq_cutoff_threshold_rage: continue with pytest.raises( OcfError, match="Error setting cache seq cut off policy threshold"): cache.set_seq_cut_off_threshold(i) print(f"\n{i}")
def test_neg_core_set_seq_cut_off_policy(pyocf_ctx, cm, cls): """ Test whether it is possible to change core seq cut-off policy to invalid value :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device(cache_device, cache_mode=cm, cache_line_size=cls) # Create core device core_device = Volume(S.from_MiB(10)) core = Core.using_device(core_device) # Add core cache.add_core(core) # Change core seq cut off policy to invalid one and check if failed for i in RandomGenerator(DefaultRanges.UINT32): if i in [item.value for item in SeqCutOffPolicy]: continue with pytest.raises(OcfError, match="Error setting core seq cut off policy"): core.set_seq_cut_off_policy(i) print(f"\n{i}")
def test_neg_change_cache_mode(pyocf_ctx, cm, cls): """ Test whether it is possible to change cache mode to invalid value. :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device(cache_device, cache_mode=cm, cache_line_size=cls) # Change cache mode to invalid one and check if failed for i in RandomGenerator(DefaultRanges.UINT32): if i in [item.value for item in CacheMode]: continue with pytest.raises(OcfError, match="Error changing cache mode"): cache.change_cache_mode(i)
def test_neg_set_promotion_policy(pyocf_ctx, cm, cls): """ Test whether it is possible to set invalid param for promotion policy :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device(cache_device, cache_mode=cm, cache_line_size=cls) # Change to invalid promotion policy and check if failed for i in RandomGenerator(DefaultRanges.UINT32): if i in [item.value for item in PromotionPolicy]: continue with pytest.raises(OcfError, match="Error setting promotion policy"): cache.set_promotion_policy(i)
def test_neg_set_acp_param(pyocf_ctx, cm, cls): """ Test whether it is possible to set invalid param for acp cleaning policy :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device(cache_device, cache_mode=cm, cache_line_size=cls) # Change invalid acp param and check if failed for i in RandomGenerator(DefaultRanges.UINT32): if i in [item.value for item in AcpParams]: continue with pytest.raises(OcfError, match="Error setting cleaning policy param"): cache.set_cleaning_policy_param(CleaningPolicy.ALRU, i, 1)
def test_neg_attach_cls(pyocf_ctx, cm, cls): """ Test whether it is possible to change cache line size to invalid value while attaching cache device :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache(owner=cache_device.owner, cache_mode=cm, cache_line_size=cls) cache.start_cache() # Check whether it is possible to attach cache device with invalid cache line size for i in RandomGenerator(DefaultRanges.UINT64): if i in [item.value for item in CacheLineSize]: continue with pytest.raises(OcfError, match="Attaching cache device failed"): cache.attach_device(cache_device, cache_line_size=i)
def test_neg_set_cleaning_policy(pyocf_ctx, cm, cls): """ Test whether it is possible to change cleaning policy to invalid value :param pyocf_ctx: basic pyocf context fixture :param cm: cache mode we start with :param cls: cache line size we start with :return: """ # Start cache device cache_device = Volume(S.from_MiB(30)) cache = Cache.start_on_device(cache_device, cache_mode=cm, cache_line_size=cls) # Set cleaning policy to invalid one and check if failed for i in RandomGenerator(DefaultRanges.UINT32): if i in [item.value for item in CleaningPolicy]: continue with pytest.raises(OcfError, match="Error changing cleaning policy"): cache.set_cleaning_policy(i) print(f"\n{i}")
Test whether it is impossible to start cache with invalid metadata layout value. :param pyocf_ctx: basic pyocf context fixture :param c_uint32_randomize: metadata layout enum value to start cache with :param cm: cache mode value to start cache with :param cls: cache line size value to start cache with """ with pytest.raises(OcfError, match="OCF_ERR_INVAL"): try_start_cache(metadata_layout=not_metadata_layout_randomize, cache_mode=cm, cache_line_size=cls) @pytest.mark.security @pytest.mark.parametrize("cls", CacheLineSize) @pytest.mark.parametrize('max_wb_queue_size', RandomGenerator(DefaultRanges.UINT32, 10)) def test_fuzzy_start_max_queue_size(pyocf_ctx, max_wb_queue_size, c_uint32_randomize, cls): """ Test whether it is impossible to start cache with invalid dependence between max queue size and queue unblock size. :param pyocf_ctx: basic pyocf context fixture :param max_wb_queue_size: max queue size value to start cache with :param c_uint32_randomize: queue unblock size value to start cache with :param cls: cache line size value to start cache with """ if c_uint32_randomize > max_wb_queue_size: with pytest.raises(OcfError, match="OCF_ERR_INVAL"): try_start_cache(max_queue_size=max_wb_queue_size, queue_unblock_size=c_uint32_randomize, cache_mode=CacheMode.WB,
sys.path.append(os.path.join(os.path.dirname(__file__), os.path.pardir)) def enum_min(enum): return list(enum)[0].value def enum_max(enum): return list(enum)[-1].value def enum_range(enum): return Range(enum_min(enum), enum_max(enum)) @pytest.fixture(params=RandomGenerator(DefaultRanges.UINT16)) def c_uint16_randomize(request): return request.param @pytest.fixture(params=RandomGenerator(DefaultRanges.UINT32)) def c_uint32_randomize(request): return request.param @pytest.fixture(params=RandomGenerator(DefaultRanges.UINT64)) def c_uint64_randomize(request): return request.param @pytest.fixture(params=RandomGenerator(DefaultRanges.INT))