def test_ft_watermark_telemetry_interval():
"""
Author : Phani kumar R ([email protected])
"""
result = 0
st.banner('ft_sf_wm_telemetry_interval')
if not sfapi.config_snapshot_interval(
vars.D1, snap="telemetry",
interval_val=sf_data.telemetry_interval):
st.error("Failed to configure watermark telemetry interval")
result += 1
match = [{'telemetryinterval': sf_data.telemetry_interval}]
if not sfapi.verify(vars.D1, 'telemetry_interval', verify_list=match):
st.error(
"Failed to verify the configured watermark telemetry interval value"
)
result += 1
if not sfapi.config_snapshot_interval(
vars.D1,
snap="telemetry",
interval_val=sf_data.default_telemetry_interval):
st.error("Failed to configure default watermark telemetry interval")
result += 1
match = [{'telemetryinterval': sf_data.default_telemetry_interval}]
if not sfapi.verify(vars.D1, 'telemetry_interval', verify_list=match):
st.error(
"Failed to verify the default watermark telemetry interval value")
result += 1
if not result:
st.report_pass("snapshot_telemetry_interval_config_and_reset",
"successful")
else:
st.report_fail("snapshot_telemetry_interval_config_and_reset",
"failed")
def test_ft_sf_verify_cpu_counters():
"""
Author : prudviraj k ([email protected]) and phani kumar ravula([email protected])
"""
result = 0
if not sfapi.config_snapshot_interval(
vars.D1, snap="interval", interval_val=sf_data.snapshot_interval):
st.error("Failed to configure snapshot interval")
result += 1
match = [{'snapshotinterval': sf_data.snapshot_interval}]
if not sfapi.verify(vars.D1, 'snapshot_interval', verify_list=match):
st.error("Failed to verify the configured snapshot interval")
result += 1
st.log("sflow configuration")
sflow.enable_disable_config(vars.D1,
interface=False,
interface_name=None,
action="enable")
sflow.config_attributes(vars.D1,
sample_rate=sf_data.sflow_sample_rate,
interface_name=vars.D1T1P1)
sf_tg_traffic_start_stop(sf_data.unicast, True)
st.log(
"waiting for two snapshot interval times to get the counter values reflect correctly"
)
st.wait(2 * sf_data.snapshot_interval)
st.banner(
'TC name:::: ft_sf_verify_cpu_counter_value_using_counter_DB ::::')
st.banner('#### cpu_counters using CLI ####')
match = [{'CPU:3': sf_data.initial_counter_value}]
if sfapi.verify(vars.D1,
'queue_user_watermark_cpu',
verify_list=match,
port_alias="CPU"):
st.error("Failed to verify the cpu counter value using CLI")
result += 1
st.banner('#### cpu_counters using counter DB ####')
match = [{
'SAI_QUEUE_STAT_SHARED_WATERMARK_BYTES':
sf_data.initial_counter_value
}]
if sfapi.verify(vars.D1,
column_name="COUNTERS_QUEUE_NAME_MAP",
interface_name='CPU',
queue_value=3,
table_name="COUNTERS",
verify_list=match):
st.error("Failed to verify the cpu counter value using counter DB")
result += 1
sf_collecting_debug_logs_when_test_fails()
if result:
st.report_fail("snapshot_tc_verify", "cpu", "failed")
else:
st.report_pass("snapshot_tc_verify", "cpu", "successful")
def test_ft_sf_periodic_verify_using_counter_DB():
"""
Author : prudviraj k ([email protected]) and phani kumar ravula([email protected])
"""
result = 0
if not sfapi.config_snapshot_interval(
vars.D1, snap="interval", interval_val=sf_data.snapshot_interval):
st.error("Failed to configure snapshot interval")
result += 1
match = [{'snapshotinterval': sf_data.snapshot_interval}]
if not sfapi.verify(vars.D1, 'snapshot_interval', verify_list=match):
st.error("Failed to verify the configured snapshot interval")
result += 1
#sf_tg_traffic_start_stop(sf_data.periodic, True)
st.wait(2 * sf_data.snapshot_interval)
st.banner(
'####verification_of_queue_unicast_periodic_update_using_counter_DB####'
)
st.banner('TC name:::: ft_sf_verify_time_stamp_using_counter_DB::::')
counters = sfapi.show(vars.D1,
column_name="COUNTERS_QUEUE_NAME_MAP",
interface_name=vars.D1T1P4,
queue_value=0,
table_name="COUNTERS")
Timestamp_40 = counters[0]['SAI_QUEUE_STAT_TIMESTAMP']
Time_40 = Timestamp_40.split('.')
st.log("Collecting Time stamp when traffic rate is 40..... :{}".format(
Time_40[1]))
st.wait(sf_data.snapshot_interval)
counters = sfapi.show(vars.D1,
column_name="COUNTERS_QUEUE_NAME_MAP",
interface_name=vars.D1T1P4,
queue_value=0,
table_name="COUNTERS")
Timestamp_100 = counters[0]['SAI_QUEUE_STAT_TIMESTAMP']
Time_100 = Timestamp_100.split('.')
st.log("Collecting Time stamp when traffic rate is 100 ..... :{}".format(
Time_100[1]))
Timestamp_diff = datetime.strptime(
Time_100[1], sf_data.FMT) - datetime.strptime(Time_40[1], sf_data.FMT)
st.log("Time stamp difference in Seconds is :{}".format(
Timestamp_diff.seconds))
if (Timestamp_diff.seconds) < (sf_data.snapshot_interval):
st.error("Time stamp interval is not increementing correctly")
result += 1
if not result:
st.report_pass("snapshot_tc_verify", "Time stamp interval",
"successful")
else:
sf_collecting_debug_logs_when_test_fails()
st.report_fail("snapshot_tc_verify", "Time stamp interval", "failed")
"""
def test_ft_snapshot_interval():
"""
Author : Phani kumar R ([email protected])
"""
st.banner(
'ft_sf_snapshot_interval, ft_sf_verify_default_snapshot_interval')
result1 = result2 = 0
if not sfapi.config_snapshot_interval(
vars.D1, snap="interval", interval_val=sf_data.snapshot_interval):
st.error("Failed to configure snapshot interval")
result1 += 1
match = [{'snapshotinterval': sf_data.snapshot_interval}]
if not sfapi.verify(vars.D1, 'snapshot_interval', verify_list=match):
st.error("Failed to verify the configured snapshot interval")
result1 += 1
st.report_tc_fail("ft_sf_snapshot_interval",
"snapshot_interval_config", "failed")
else:
st.report_tc_pass("ft_sf_snapshot_interval",
"snapshot_interval_config", "successful")
if not sfapi.config_snapshot_interval(vars.D1,
snap="clear_snaphot_interval"):
st.error("Failed to clear the snapshot interval")
result2 += 1
match = [{'snapshotinterval': sf_data.default_snapshot_interval}]
if not sfapi.verify(vars.D1, 'snapshot_interval', verify_list=match):
st.error(
"Failed to reset the snapshot interval to default value after clear"
)
result2 += 1
st.report_tc_fail("ft_sf_verify_default_snapshot_interval",
"snapshot_verify_default_interval", "failed")
else:
st.report_tc_pass("ft_sf_verify_default_snapshot_interval",
"snapshot_verify_default_interval", "successful")
if not (result1 or result2):
st.report_pass("snapshot_interval_config_and_reset", "successful")
else:
st.report_fail("snapshot_interval_config_and_reset", "failed")
def test_ft_sf_verify_buffer_pool_counters():
"""
Author : prudviraj k ([email protected]) and phani kumar ravula([email protected])
"""
result = 0
per_result = 0
sf_data.platform_name_summary = get_platform_summary(vars.D1)
sf_data.platform_name = sf_data.platform_name_summary["platform"]
sf_data.platform_hwsku = sf_data.platform_name_summary["hwsku"]
path = "/usr/share/sonic/device/{}/{}/{}".format(sf_data.platform_name,
sf_data.platform_hwsku,
sf_data.device_j2_file)
convert_json = "sonic-cfggen -d -t " "{} > {}".format(
path, sf_data.config_file)
sfapi.load_json_config(vars.D1, convert_json, sf_data.config_file)
reboot_api.config_save_reload(vars.D1)
st.log("To make sure after reload DUT is fully operational")
st.wait(sf_data.reload_interval)
if not sfapi.config_snapshot_interval(
vars.D1, snap="interval", interval_val=sf_data.snapshot_interval):
st.error("Failed to configure snapshot interval")
result += 1
match = [{'snapshotinterval': sf_data.snapshot_interval}]
if not sfapi.verify(vars.D1, 'snapshot_interval', verify_list=match):
st.error("Failed to verify the configured snapshot interval")
result += 1
sf_tg_traffic_start_stop(sf_data.unicast, True)
st.log(
"waiting for two snapshot interval times to get the counter values reflect correctly"
)
st.wait(2 * sf_data.snapshot_interval)
st.banner('#### buffer_Pool_for_user_watermark####')
st.banner('TC name :::: ft_sf_buffer_pool_using_uwm ::::')
match = {'pool': 'ingress_lossless_pool'}
value = {'bytes': sf_data.initial_counter_value}
if sfapi.verify_buffer_pool(vars.D1,
'buffer_pool_watermark',
verify_list=match,
key=value):
st.error(
"Failed to verify the buffer pool counters for user watermark")
result += 1
st.report_tc_fail("ft_sf_buffer_pool_using_uwm", "snapshot_tc_verify",
"buffer_pool_for_user_watermark", "failed")
else:
st.report_tc_pass("ft_sf_buffer_pool_using_uwm", "snapshot_tc_verify",
"buffer_pool_for_user_watermark", "successful")
st.banner('TC name :::: ft_sf_buffer_pool_using_persistent_wm ::::')
st.banner('#### buffer_pool_for_persistent_watermark using percentage####')
match = {'pool': 'egress_lossless_pool'}
value = {'percent': sf_data.initial_counter_value}
if sfapi.verify_buffer_pool(vars.D1,
'buffer_pool_persistent-watermark',
verify_list=match,
key=value,
percent=sf_data.percentage[0]):
st.error(
"Failed to verify the buffer pool counters for persistent watermark"
)
result += 1
per_result += 1
st.banner('#### buffer_pool_for_persistent_watermark using CLI####')
match = {'pool': 'egress_lossless_pool'}
value = {'bytes': sf_data.initial_counter_value}
if sfapi.verify_buffer_pool(vars.D1,
'buffer_pool_persistent-watermark',
verify_list=match,
key=value):
st.error(
"Failed to verify the buffer pool counters for persistent watermark"
)
result += 1
per_result += 1
if per_result:
st.report_tc_fail("ft_sf_buffer_pool_using_persistent_wm",
"snapshot_tc_verify",
"buffer_pool_for_persistent_watermark", "failed")
else:
st.report_tc_pass("ft_sf_buffer_pool_using_persistent_wm",
"snapshot_tc_verify",
"buffer_pool_for_persistent_watermark", "successful")
st.banner('#### buffer_pool_using_counter_DB ####')
st.banner('TC name :::: ft_sf_buffer_pool_using_counter_DB ::::')
match = [{
'SAI_BUFFER_POOL_STAT_WATERMARK_BYTES':
sf_data.initial_counter_value
}]
if sfapi.verify(vars.D1,
'buffer_pool_counters_DB',
oid_type='ingress_lossless_pool',
verify_list=match):
st.error(
"Failed to verify the ingress lossless buffer pool counter using counter DB value"
)
result += 1
st.report_tc_fail("ft_sf_buffer_pool_using_counter_DB",
"snapshot_tc_verify", "ingress lossless buffer pool",
"failed")
else:
st.report_tc_pass("ft_sf_buffer_pool_using_counter_DB",
"snapshot_tc_verify", "ingress lossless buffer pool",
"successful")
sf_tg_traffic_start_stop(sf_data.unicast, False)
st.log(
"waiting for two snapshot interval times to get the counter values reflect correctly"
)
st.wait(2 * sf_data.snapshot_interval)
st.banner('#### clear_buffer_Pool_for_user_watermark####')
st.banner('TC name :::: ft_sf_buffer_pool_clear_using_uwm ::::')
if not sfapi.config_snapshot_interval(vars.D1,
snap="clear_buffer-pool watermark"):
st.error("Failed to clear buffer-pool watermark")
st.log(
"After clear buffer_pool checking the stats with 10 cells tolerance")
counters = sfapi.get(vars.D1,
'buffer_pool_watermark',
get_value='bytes',
match={'pool': 'ingress_lossless_pool'})
if counters > sf_data.buffer_pool_tolerance:
st.error("Failed to clear the buffer pool counters for user watermark")
result += 1
st.report_tc_fail("ft_sf_buffer_pool_clear_using_uwm",
"snapshot_tc_verify",
"buffer_pool_clear_for_user_watermark", "failed")
else:
st.report_tc_pass("ft_sf_buffer_pool_clear_using_uwm",
"snapshot_tc_verify",
"buffer_pool_clear_for_user_watermark", "successful")
st.banner('#### clear_buffer_pool_for_persistent_watermark ####')
st.banner('TC name :::: ft_sf_buffer_pool_clear_using_persistent_wm ::::')
if not sfapi.config_snapshot_interval(
vars.D1, snap="clear_buffer-pool persistent-watermark"):
st.error("Failed to clear_buffer-pool persistent-watermark")
st.log(
"After clear buffer_pool checking the stats with 10 cells tolerance")
counters = sfapi.get(vars.D1,
'buffer_pool_watermark',
get_value='bytes',
match={'pool': 'egress_lossless_pool'})
if counters > sf_data.buffer_pool_tolerance:
st.error(
"Failed to clear the buffer pool counters for persistent watermark"
)
result += 1
st.report_tc_fail("ft_sf_buffer_pool_clear_using_persistent_wm",
"snapshot_tc_verify",
"buffer_pool_clear_for_persistent_watermark",
"failed")
else:
st.report_tc_pass("ft_sf_buffer_pool_clear_using_persistent_wm",
"snapshot_tc_verify",
"buffer_pool_clear_for_persistent_watermark",
"successful")
if not result:
st.report_pass("snapshot_tc_verify", "buffer pool", "successful")
else:
sf_collecting_debug_logs_when_test_fails()
st.report_fail("snapshot_tc_verify", "buffer pool", "failed")
def test_ft_sf_all_buffer_stats_using_multicast_traffic():
"""
Author : prudviraj k ([email protected]) and phani kumar ravula([email protected])
"""
result = 0
if not sfapi.config_snapshot_interval(
vars.D1, snap="interval", interval_val=sf_data.snapshot_interval):
st.error("Failed to configure snapshot interval")
result += 1
match = [{'snapshotinterval': sf_data.snapshot_interval}]
if not sfapi.verify(vars.D1, 'snapshot_interval', verify_list=match):
st.error("Failed to verify the configured snapshot interval")
result += 1
if sfapi.multicast_queue_start_value(vars.D1,
'queue_user_watermark_multicast',
port_alias=vars.D1T1P4):
match = [{'mc8': sf_data.initial_counter_value}]
else:
match = [{'mc10': sf_data.initial_counter_value}]
sf_tg_traffic_start_stop(sf_data.multicast, True)
st.wait(2 * sf_data.snapshot_interval)
st.banner('#### queue_multicast_for_user_watermark ####')
st.banner('TC name:::: ft_sf_queue_multicast_using_uwm ::::')
if sfapi.verify(vars.D1,
'queue_user_watermark_multicast',
verify_list=match,
port_alias=vars.D1T1P4):
st.error(
"Failed to verify the queue_user_watermark_multicast counter value"
)
result += 1
st.report_tc_fail("ft_sf_queue_multicast_using_uwm",
"snapshot_tc_verify",
"queue_multicast_for_user_watermark", "failed")
else:
st.report_tc_pass("ft_sf_queue_multicast_using_uwm",
"snapshot_tc_verify",
"queue_multicast_for_user_watermark", "successful")
st.banner('#### queue_multicast_for_persistent_watermark ####')
st.banner('TC name :::: ft_sf_queue_multicast_using_persistent_wm ::::')
if sfapi.verify(vars.D1,
'queue_persistent_watermark_multicast',
verify_list=match,
port_alias=vars.D1T1P4):
st.error(
"Failed to verify the queue_persistent_watermark_unicast counter value"
)
result += 1
st.report_tc_fail("ft_sf_queue_multicast_using_persistent_wm",
"snapshot_tc_verify",
"queue_multicast_for_persistent_watermark", "failed")
else:
st.report_tc_pass("ft_sf_queue_multicast_using_persistent_wm",
"snapshot_tc_verify",
"queue_multicast_for_persistent_watermark",
"successful")
sf_tg_traffic_start_stop(sf_data.multicast, False)
st.wait(2 * sf_data.snapshot_interval)
st.banner('#### clear_queue_multicast_for_user_watermark ####')
st.banner('TC name :::: ft_sf_queue_multicast_clear_using_uwm ::::')
if not sfapi.config_snapshot_interval(vars.D1,
snap="clear_snapshot_counters",
group=sf_data.group[1],
table=sf_data.table[0],
counter_type=sf_data.PG[3]):
st.error(
"Failed to execute the command clear {} snapshot counters".format(
sf_data.PG[3]))
result += 1
if not sfapi.verify(vars.D1,
'queue_user_watermark_multicast',
verify_list=match,
port_alias=vars.D1T1P4):
st.error("Failed to clear the snapshot counters")
result += 1
st.report_tc_fail(
"ft_sf_queue_multicast_clear_using_uwm", "snapshot_clear_verify",
"clearing the multicast queue counters for user watermark",
"failed")
else:
st.report_tc_pass(
"ft_sf_queue_multicast_clear_using_uwm", "snapshot_clear_verify",
"clearing the multicast queue counters for user watermark",
"successful")
st.banner('#### clear_queue_multicast_for_persistent_watermark ####')
st.banner(
'TC name :::: ft_sf_queue_multicast_clear_using_persistent_wm ::::')
if not sfapi.config_snapshot_interval(vars.D1,
snap="clear_snapshot_counters",
group=sf_data.group[1],
table=sf_data.table[1],
counter_type=sf_data.PG[3]):
st.error(
"Failed to execute the command clear {} snapshot counters".format(
sf_data.PG[3]))
result += 1
if not sfapi.verify(vars.D1,
'queue_persistent_watermark_multicast',
verify_list=match,
port_alias=vars.D1T1P4):
st.error("Failed to clear the snapshot counters")
result += 1
st.report_tc_fail(
"ft_sf_queue_multicast_clear_using_persistent_wm",
"snapshot_clear_verify",
"clearing the multicast queue counters for persistent watermark",
"failed")
else:
st.report_tc_pass(
"ft_sf_queue_multicast_clear_using_persistent_wm",
"snapshot_clear_verify",
"clearing the multicast queue counters for persistent watermark",
"successful")
if not result:
st.report_pass("snapshot_all_buffer_counters", "multicast",
"successful")
else:
sf_collecting_debug_logs_when_test_fails()
st.report_fail("snapshot_all_buffer_counters", "multicast", "failed")
def test_ft_sf_all_buffer_stats_using_unicast_traffic():
"""
Author : prudviraj k ([email protected]) and phani kumar ravula([email protected])
"""
result = 0
per_result = 0
clr_result = 0
if not sfapi.config_snapshot_interval(
vars.D1, snap="interval", interval_val=sf_data.snapshot_interval):
st.error("Failed to configure snapshot interval")
result += 1
match = [{'snapshotinterval': sf_data.snapshot_interval}]
if not sfapi.verify(vars.D1, 'snapshot_interval', verify_list=match):
st.error("Failed to verify the configured snapshot interval")
result += 1
st.log("configuring the QOS maps")
if not cos_api.config_dot1p_to_tc_map(vars.D1, sf_data.obj_name[0],
sf_data.dot1p_to_tc_map_dict):
st.error("Failed to configure qos map of type dot1p to tc")
if not cos_api.config_tc_to_pg_map(vars.D1, sf_data.obj_name[1],
sf_data.tc_to_pg_map_dict):
st.error("Failed to configure qos map of type tc to pg")
if not cos_api.verify_qos_map_table(
vars.D1, 'dot1p_to_tc_map', sf_data.obj_name[0], {
'0': '0',
'1': '1',
'2': '2',
'3': '3',
'4': '4',
'5': '5',
'6': '6',
'7': '7'
}):
st.error("Failed to verify configured dot1p to tc map values")
result += 1
if not cos_api.verify_qos_map_table(
vars.D1, 'tc_to_pg_map', sf_data.obj_name[1], {
'0': '7',
'1': '7',
'2': '7',
'3': '7',
'4': '7',
'5': '7',
'6': '7',
'7': '7'
}):
st.error("Failed to verify configured tc to pg map values")
result += 1
if not cos_api.config_port_qos_map_all(vars.D1, sf_data.dot1p_tc_bind_map):
st.error(
"Failed to bind the configured qos map of type dot1p to tc on interface"
)
if not cos_api.config_port_qos_map_all(vars.D1, sf_data.tc_pg_bind_map):
st.error(
"Failed to bind the configured qos map of type tc to pg on interface"
)
sf_tg_traffic_start_stop(sf_data.unicast, True)
st.wait(2 * sf_data.snapshot_interval)
st.banner('#### PG_shared_for_user_watermark####')
st.banner('TC name :::: ft_sf_pg_shared_using_uwm ::::')
match = [{'pg7': sf_data.initial_counter_value}]
if sfapi.verify(vars.D1,
'user_watermark_PG_shared',
verify_list=match,
port_alias=vars.D1T1P1):
st.error("Failed to verify the user_watermark_PG_shared counter value")
result += 1
st.report_tc_fail("ft_sf_pg_shared_using_uwm", "snapshot_tc_verify",
"PG_shared_for_user_watermark", "failed")
else:
st.report_tc_pass("ft_sf_pg_shared_using_uwm", "snapshot_tc_verify",
"PG_shared_for_user_watermark", "successful")
st.banner('####verification_of_PG_shared_using_counter_DB####')
st.banner('TC name :::: ft_sf_pg_shared_using_Counter_DB ::::')
match = [{
'SAI_INGRESS_PRIORITY_GROUP_STAT_SHARED_WATERMARK_BYTES':
sf_data.initial_counter_value
}]
if sfapi.verify(vars.D1,
column_name="COUNTERS_PG_NAME_MAP",
interface_name=vars.D1T1P1,
queue_value=7,
table_name="COUNTERS",
verify_list=match):
st.error(
"Failed to verify the user_watermark_PG_shared counter DB value")
result += 1
st.report_tc_fail("ft_sf_pg_shared_using_Counter_DB",
"snapshot_tc_counter_DB_verify", "PG_shared",
"failed")
else:
st.report_tc_pass("ft_sf_pg_shared_using_Counter_DB",
"snapshot_tc_counter_DB_verify", "PG_shared",
"successful")
st.banner('TC name:::: ft_sf_queue_unicast_using_uwm ::::')
match = [{'uc0': sf_data.initial_counter_value}]
st.banner(
'#### queue_unicast_for_user_watermark using percentage values####')
if sfapi.verify(vars.D1,
'queue_user_watermark_unicast',
verify_list=match,
port_alias=vars.D1T1P4,
percentage=sf_data.percentage[0]):
st.error(
"Failed to verify the queue_user_watermark_unicast counter value using percentage"
)
result += 1
per_result += 1
st.banner('#### queue_unicast_for_user_watermark using CLI####')
if sfapi.verify(vars.D1,
'queue_user_watermark_unicast',
verify_list=match,
port_alias=vars.D1T1P4):
st.error(
"Failed to verify the queue_user_watermark_unicast counter value")
result += 1
per_result += 1
if per_result:
st.report_tc_fail("ft_sf_queue_unicast_using_uwm",
"snapshot_tc_verify",
"queue_unicast_for_user_watermark", "failed")
else:
st.report_tc_pass("ft_sf_queue_unicast_using_uwm",
"snapshot_tc_verify",
"queue_unicast_for_user_watermark", "successful")
st.banner(
'####verification_of_queue_unicast_for_user_watermark_using_counter_DB####'
)
st.banner('TC name:::: ft_sf_queue_unicast_using_Counter_DB ::::')
match = [{
'SAI_QUEUE_STAT_SHARED_WATERMARK_BYTES':
sf_data.initial_counter_value
}]
if sfapi.verify(vars.D1,
column_name="COUNTERS_QUEUE_NAME_MAP",
interface_name=vars.D1T1P4,
queue_value=0,
table_name="COUNTERS",
verify_list=match):
st.error(
"Failed to verify the queue_user_watermark_unicast counter DB value"
)
result += 1
st.report_tc_fail("ft_sf_queue_unicast_using_Counter_DB",
"snapshot_tc_counter_DB_verify", "queue_unicast",
"failed")
else:
st.report_tc_pass("ft_sf_queue_unicast_using_Counter_DB",
"snapshot_tc_counter_DB_verify", "queue_unicast",
"successful")
st.banner('#### PG_shared_for_persistent_watermark####')
st.banner('TC name :::: ft_sf_pg_shared_using_persistent_wm ::::')
match = [{'pg7': sf_data.initial_counter_value}]
if sfapi.verify(vars.D1,
'persistent_PG_shared',
verify_list=match,
port_alias=vars.D1T1P2):
st.error(
"Failed to verify the persistent_watermark_PG_shared counter value"
)
result += 1
st.report_tc_fail("ft_sf_pg_shared_using_persistent_wm",
"snapshot_tc_verify",
"PG_shared_for_persistent_watermark", "failed")
else:
st.report_tc_pass("ft_sf_pg_shared_using_persistent_wm",
"snapshot_tc_verify",
"PG_shared_for_persistent_watermark", "successful")
st.banner('#### queue_unicast_for_persistent_watermark ####')
st.banner('TC name :::: ft_sf_queue_unicast_using_persistent_wm ::::')
match = [{'uc0': sf_data.initial_counter_value}]
if sfapi.verify(vars.D1,
'queue_persistent_watermark_unicast',
verify_list=match,
port_alias=vars.D1T1P4):
st.error(
"Failed to verify the queue_persistent_watermark_unicast counter value"
)
result += 1
st.report_tc_fail("ft_sf_queue_unicast_using_persistent_wm",
"snapshot_tc_verify",
"queue_unicast_for_persistent_watermark", "failed")
else:
st.report_tc_pass("ft_sf_queue_unicast_using_persistent_wm",
"snapshot_tc_verify",
"queue_unicast_for_persistent_watermark",
"successful")
sf_tg_traffic_start_stop(sf_data.unicast, False)
st.wait(2 * sf_data.snapshot_interval)
st.banner('#### clear_PG_shared_for_user_watermark####')
st.banner('TC name :::: ft_sf_pg_shared_clear_using_uwm ::::')
if not sfapi.config_snapshot_interval(vars.D1,
snap="clear_snapshot_counters",
group=sf_data.group[0],
table=sf_data.table[0],
counter_type=sf_data.PG[0]):
st.error(
"Failed to execute the command clear {} snapshot counters".format(
sf_data.group[0]))
result += 1
match = [{'pg0': sf_data.initial_counter_value}]
if not sfapi.verify(vars.D1,
'user_watermark_PG_shared',
verify_list=match,
port_alias=vars.D1T1P1):
st.error("Failed to clear the snapshot counters")
result += 1
st.report_tc_fail(
"ft_sf_pg_shared_clear_using_uwm", "snapshot_clear_verify",
"clearing the PG shared counters for user_watermark", "failed")
else:
st.report_tc_pass(
"ft_sf_pg_shared_clear_using_uwm", "snapshot_clear_verify",
"clearing the PG shared counters for user watermark", "successful")
st.banner('TC name :::: ft_sf_queue_unicast_clear_using_uwm ::::')
if not sfapi.config_snapshot_interval(vars.D1,
snap="clear_snapshot_counters",
group=sf_data.group[1],
table=sf_data.table[0],
counter_type=sf_data.PG[2]):
st.error(
"Failed to execute the command clear {} snapshot counters".format(
sf_data.group[0]))
result += 1
match = [{'uc0': sf_data.initial_counter_value}]
st.banner(
'#### clear_queue_unicast_percentage_Values_for_user_watermark ####')
if not sfapi.verify(vars.D1,
'queue_user_watermark_unicast',
verify_list=match,
port_alias=vars.D1T1P4,
percentage=sf_data.percentage[1]):
st.error("Failed to clear percentage snapshot counters")
result += 1
clr_result += 1
st.banner('#### clear_queue_unicast_for_user_watermark using CLI####')
if not sfapi.verify(vars.D1,
'queue_user_watermark_unicast',
verify_list=match,
port_alias=vars.D1T1P4):
st.error("Failed to clear the snapshot counters")
result += 1
clr_result += 1
if clr_result:
st.report_tc_fail(
"ft_sf_queue_unicast_clear_using_uwm", "snapshot_clear_verify",
"clearing the unicast queue counters for user watermark", "failed")
else:
st.report_tc_pass(
"ft_sf_queue_unicast_clear_using_uwm", "snapshot_clear_verify",
"clearing the unicast queue counters for user watermark",
"successful")
st.banner('#### clear_PG_shared_for_persistent_watermark ####')
st.banner('TC name :::: ft_sf_pg_shared_clear_using_persistent_wm ::::')
if not sfapi.config_snapshot_interval(vars.D1,
snap="clear_snapshot_counters",
group=sf_data.group[0],
table=sf_data.table[1],
counter_type=sf_data.PG[0]):
st.error(
"Failed to execute the command clear {} snapshot counters".format(
sf_data.group[0]))
result += 1
match = [{'pg0': sf_data.initial_counter_value}]
if not sfapi.verify(vars.D1,
'persistent_PG_shared',
verify_list=match,
port_alias=vars.D1T1P2):
st.error("Failed to clear the snapshot counters")
result += 1
st.report_tc_fail(
"ft_sf_pg_shared_clear_using_persistent_wm",
"snapshot_clear_verify",
"clearing the PG shared counters for persistent watermark",
"failed")
else:
st.report_tc_pass(
"ft_sf_pg_shared_clear_using_persistent_wm",
"snapshot_clear_verify",
"clearing the PG shared counters for persistent watermark",
"successful")
st.banner('#### clear_queue_unicast_for_persistent_watermark ####')
st.banner(
'TC name :::: ft_sf_queue_unicast_clear_using_persistent_wm ::::')
if not sfapi.config_snapshot_interval(vars.D1,
snap="clear_snapshot_counters",
group=sf_data.group[1],
table=sf_data.table[1],
counter_type=sf_data.PG[2]):
st.error(
"Failed to execute the command clear {} snapshot counters".format(
sf_data.group[0]))
result += 1
match = [{'uc0': sf_data.initial_counter_value}]
if not sfapi.verify(vars.D1,
'queue_persistent_watermark_unicast',
verify_list=match,
port_alias=vars.D1T1P4):
st.error("Failed to clear the snapshot counters")
result += 1
st.report_tc_fail(
"ft_sf_queue_unicast_clear_using_persistent_wm",
"snapshot_clear_verify",
"clearing the unicast queue counters for persistent watermark",
"failed")
else:
st.report_tc_pass(
"ft_sf_queue_unicast_clear_using_persistent_wm",
"snapshot_clear_verify",
"clearing the unicast queue counters for persistent watermark",
"successful")
clear_qos_map_config()
if not result:
st.report_pass("snapshot_all_buffer_counters", "unicast", "successful")
else:
sf_collecting_debug_logs_when_test_fails()
st.report_fail("snapshot_all_buffer_counters", "unicast", "failed")