def test_bgp_best_path_with_dynamic_import_p0(request):
"""
TC6_FUNC_6:
1.5.6. Verify BGP best path selection algorithm works fine when
routes are imported from ISR to default vrf and vice versa.
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
build_config_from_json(tgen, topo)
if tgen.routers_have_failure():
check_router_status(tgen)
for addr_type in ADDR_TYPES:
step("Redistribute configured static routes into BGP process"
" on R1/R2 and R3")
input_dict_1 = {}
DUT = ["r1", "r2", "r3", "r4"]
VRFS = ["ISR", "ISR", "default", "default"]
AS_NUM = [100, 100, 300, 400]
for dut, vrf, as_num in zip(DUT, VRFS, AS_NUM):
temp = {dut: {"bgp": []}}
input_dict_1.update(temp)
temp[dut]["bgp"].append({
"local_as": as_num,
"vrf": vrf,
"address_family": {
addr_type: {
"unicast": {
"redistribute": [{
"redist_type": "static"
}]
}
}
},
})
result = create_router_bgp(tgen, topo, input_dict_1)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Import from default vrf into vrf ISR on R1 and R2 as below")
input_dict_vrf = {}
DUT = ["r1", "r2"]
VRFS = ["ISR", "ISR"]
AS_NUM = [100, 100]
for dut, vrf, as_num in zip(DUT, VRFS, AS_NUM):
temp = {dut: {"bgp": []}}
input_dict_vrf.update(temp)
temp[dut]["bgp"].append({
"local_as": as_num,
"vrf": vrf,
"address_family": {
addr_type: {
"unicast": {
"import": {
"vrf": "default"
}
}
}
},
})
result = create_router_bgp(tgen, topo, input_dict_vrf)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
input_dict_default = {}
DUT = ["r1", "r2"]
VRFS = ["default", "default"]
AS_NUM = [100, 100]
for dut, vrf, as_num in zip(DUT, VRFS, AS_NUM):
temp = {dut: {"bgp": []}}
input_dict_default.update(temp)
temp[dut]["bgp"].append({
"local_as": as_num,
"vrf": vrf,
"address_family": {
addr_type: {
"unicast": {
"import": {
"vrf": "ISR"
}
}
}
},
})
result = create_router_bgp(tgen, topo, input_dict_default)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Verify ECMP/Next-hop/Imported routes Vs Locally originated "
"routes/eBGP routes vs iBGP routes --already covered in almost"
" all tests")
for addr_type in ADDR_TYPES:
step("Verify Pre-emption")
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type]]
}]
}
}
intf_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"]["interface"]
intf_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"]["interface"]
if addr_type == "ipv6" and "link_local" in PREFERRED_NEXT_HOP:
nh_r3_r1 = get_frr_ipv6_linklocal(tgen, "r3", intf=intf_r3_r1)
nh_r4_r1 = get_frr_ipv6_linklocal(tgen, "r4", intf=intf_r4_r1)
else:
nh_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"][
addr_type].split("/")[0]
nh_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"][
addr_type].split("/")[0]
result = verify_bgp_rib(tgen,
addr_type,
"r1",
input_routes_r3,
next_hop=[nh_r4_r1])
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result)
step("Shutdown interface connected to r1 from r4:")
shutdown_bringup_interface(tgen, "r4", intf_r4_r1, False)
for addr_type in ADDR_TYPES:
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type]]
}]
}
}
intf_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"]["interface"]
intf_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"]["interface"]
if addr_type == "ipv6" and "link_local" in PREFERRED_NEXT_HOP:
nh_r3_r1 = get_frr_ipv6_linklocal(tgen, "r3", intf=intf_r3_r1)
nh_r4_r1 = get_frr_ipv6_linklocal(tgen, "r4", intf=intf_r4_r1)
else:
nh_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"][
addr_type].split("/")[0]
nh_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"][
addr_type].split("/")[0]
step("Verify next-hop is changed")
result = verify_bgp_rib(tgen,
addr_type,
"r1",
input_routes_r3,
next_hop=[nh_r3_r1])
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result)
step("Bringup interface connected to r1 from r4:")
shutdown_bringup_interface(tgen, "r4", intf_r4_r1, True)
for addr_type in ADDR_TYPES:
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type]]
}]
}
}
intf_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"]["interface"]
intf_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"]["interface"]
if addr_type == "ipv6" and "link_local" in PREFERRED_NEXT_HOP:
nh_r3_r1 = get_frr_ipv6_linklocal(tgen, "r3", intf=intf_r3_r1)
nh_r4_r1 = get_frr_ipv6_linklocal(tgen, "r4", intf=intf_r4_r1)
else:
nh_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"][
addr_type].split("/")[0]
nh_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"][
addr_type].split("/")[0]
step("Verify next-hop is not chnaged aftr shutdown:")
result = verify_bgp_rib(tgen,
addr_type,
"r1",
input_routes_r3,
next_hop=[nh_r3_r1])
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result)
step("Active-Standby scenario(as-path prepend and Local pref)")
for addr_type in ADDR_TYPES:
step("Create prefix-list")
input_dict_pf = {
"r1": {
"prefix_lists": {
addr_type: {
"pf_ls_{}".format(addr_type): [{
"seqid":
10,
"network":
NETWORK3_4[addr_type],
"action":
"permit",
}]
}
}
}
}
result = create_prefix_lists(tgen, input_dict_pf)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Create route-map to match prefix-list and set localpref 500")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_PATH1_{}".format(addr_type): [{
"action": "permit",
"seq_id": 10,
"match": {
addr_type: {
"prefix_lists": "pf_ls_{}".format(addr_type)
}
},
"set": {
"locPrf": 500
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Create route-map to match prefix-list and set localpref 600")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_PATH2_{}".format(addr_type): [{
"action": "permit",
"seq_id": 20,
"match": {
addr_type: {
"prefix_lists": "pf_ls_{}".format(addr_type)
}
},
"set": {
"locPrf": 600
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
input_dict_rma = {
"r1": {
"bgp": [{
"local_as": "100",
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r3": {
"dest_link": {
"r1-link1": {
"route_maps": [{
"name":
"rmap_PATH1_{}".format(
addr_type),
"direction":
"in",
}]
}
}
},
"r4": {
"dest_link": {
"r1-link1": {
"route_maps": [{
"name":
"rmap_PATH2_{}".format(
addr_type),
"direction":
"in",
}]
}
}
},
}
}
}
},
}]
}
}
result = create_router_bgp(tgen, topo, input_dict_rma)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
dut = "r1"
attribute = "locPrf"
for addr_type in ADDR_TYPES:
step("Verify bestpath is installed as per highest localpref")
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type], NETWORK3_4[addr_type]]
}]
}
}
result = verify_best_path_as_per_bgp_attribute(tgen, addr_type, dut,
input_routes_r3,
attribute)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Create route-map to match prefix-list and set localpref 700")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_PATH1_{}".format(addr_type): [{
"action": "permit",
"seq_id": 10,
"match": {
addr_type: {
"prefix_lists": "pf_ls_{}".format(addr_type)
}
},
"set": {
"locPrf": 700
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Verify bestpath is changed as per highest localpref")
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type], NETWORK3_4[addr_type]]
}]
}
}
result = verify_best_path_as_per_bgp_attribute(tgen, addr_type, dut,
input_routes_r3,
attribute)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Create route-map to match prefix-list and set as-path prepend")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_PATH2_{}".format(addr_type): [{
"action": "permit",
"seq_id": 20,
"match": {
addr_type: {
"prefix_lists": "pf_ls_{}".format(addr_type)
}
},
"set": {
"localpref": 700,
"path": {
"as_num": "111",
"as_action": "prepend"
},
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
attribute = "path"
for addr_type in ADDR_TYPES:
step("Verify bestpath is changed as per shortest as-path")
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type], NETWORK3_4[addr_type]]
}]
}
}
result = verify_best_path_as_per_bgp_attribute(tgen, addr_type, dut,
input_routes_r3,
attribute)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
write_test_footer(tc_name)
def test_origin_attribute(request):
"""
Test origin attribute and verify best path is
installed as per IGP>EGP>INCOMPLETE rule
"""
tgen = get_topogen()
# Don't run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
# test case name
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
reset_config_on_routers(tgen)
# Api call to advertise networks
input_dict = {
"r4": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"advertise_networks": [
{"network": "200.50.2.0/32"},
{"network": "200.60.2.0/32"},
]
}
},
"ipv6": {
"unicast": {
"advertise_networks": [
{"network": "200:50:2::/128"},
{"network": "200:60:2::/128"},
]
}
},
}
}
},
"r2": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r1": {"dest_link": {"r2": {"next_hop_self": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r1": {"dest_link": {"r2": {"next_hop_self": True}}}
}
}
},
}
}
},
"r3": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r1": {"dest_link": {"r3": {"next_hop_self": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r1": {"dest_link": {"r3": {"next_hop_self": True}}}
}
}
},
}
}
},
"r5": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"redistribute": [
{"redist_type": "static"},
{"redist_type": "connected"},
]
}
},
"ipv6": {
"unicast": {
"redistribute": [
{"redist_type": "static"},
{"redist_type": "connected"},
]
}
},
}
}
},
}
result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Api call to create static routes
input_dict_3 = {
"r5": {
"static_routes": [
{"network": "200.50.2.0/32", "next_hop": "Null0"},
{"network": "200.60.2.0/32", "next_hop": "Null0"},
{"network": "200:50:2::/128", "next_hop": "Null0"},
{"network": "200:60:2::/128", "next_hop": "Null0"},
]
}
}
result = create_static_routes(tgen, input_dict_3)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Verifying best path
dut = "r1"
attribute = "origin"
for addr_type in ADDR_TYPES:
result = verify_best_path_as_per_bgp_attribute(
tgen, addr_type, dut, {"r4": input_dict["r4"]}, attribute
)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
write_test_footer(tc_name)
def test_med_attribute(request):
" Verifying MED attribute functionality"
tgen = get_topogen()
# Don't run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
# test case name
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
reset_config_on_routers(tgen)
# Api call to advertise networks
input_dict = {
"r4": {
"bgp":{
"address_family": {
"ipv4": {
"unicast": {
"advertise_networks": [
{
"network": "200.50.2.0/32"
},
{
"network": "200.60.2.0/32"
}
]
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
# Api call to advertise networks
# Configure next-hop-self to bgp neighbor
# Create Prefix list
input_dict_3 = {
"r2": {
"prefix_lists": {
"ipv4": {
"pf_ls_r2": [{
"seqid": 10,
"network": "200.0.0.0/8",
"le": "32",
"action": "permit"
}]
}
}
},
"r3": {
"prefix_lists": {
"ipv4": {
"pf_ls_r3": [{
"seqid": 10,
"network": "200.0.0.0/8",
"le": "32",
"action": "permit"
}]
}
}
}
}
result = create_prefix_lists(tgen, input_dict_3)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
# Create route map
input_dict_3 = {
"r2": {
"route_maps": {
"RMAP_MED_R2": [{
"action": "permit",
"match": {
"ipv4": {
"prefix_lists": "pf_ls_r2"
}
},
"set": {
"med": 100
}
}]
}
},
"r3": {
"route_maps": {
"RMAP_MED_R3": [{
"action": "permit",
"match": {
"ipv4": {
"prefix_lists": "pf_ls_r3"
}
},
"set": {
"med": 10
}
}]
}
}
}
result = create_route_maps(tgen, input_dict_3)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
# Configure neighbor for route map
input_dict_4 = {
"r5": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"advertise_networks": [
{
"network": "200.50.2.0/32"
},
{
"network": "200.60.2.0/32"
}
]
}
}
}
}
},
"r2": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r4": {
"dest_link": {
"r2-link1": {
"route_maps": [
{"name": "RMAP_MED_R2",
"direction": "in"}
]
}
}
},
"r1": {
"dest_link": {
"r2": {"next_hop_self": True}
}
}
}
}
}
}
}
},
"r3": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r3": {"next_hop_self": True}
}
},
"r5": {
"dest_link": {
"r3": {
"route_maps": [
{"name": "RMAP_MED_R3",
"direction": "in"}
]
}
}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
# Verifying best path
dut = "r1"
attribute = "med"
result = verify_best_path_as_per_bgp_attribute(tgen, "ipv4", dut,
input_dict, attribute)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
logger.info("Testcase %s :Passed \n", tc_name)
def test_weight_attribute(request):
"""
Test configure/modify weight attribute and
verify best path is installed as per highest weight
"""
tgen = get_topogen()
# Don't run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
# test case name
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
reset_config_on_routers(tgen)
# Api call to advertise networks
input_dict = {
"r7": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"advertise_networks": [
{"network": "200.50.2.0/32"},
{"network": "200.60.2.0/32"},
]
}
},
"ipv6": {
"unicast": {
"advertise_networks": [
{"network": "200:50:2::/128"},
{"network": "200:60:2::/128"},
]
}
},
}
}
},
"r2": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r1": {"dest_link": {"r2": {"next_hop_self": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r1": {"dest_link": {"r2": {"next_hop_self": True}}}
}
}
},
}
}
},
"r3": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r1": {"dest_link": {"r3": {"next_hop_self": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r1": {"dest_link": {"r3": {"next_hop_self": True}}}
}
}
},
}
}
},
}
result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Create Prefix list
input_dict_2 = {
"r1": {
"prefix_lists": {
"ipv4": {
"pf_ls_1_ipv4": [
{
"seqid": 10,
"network": "200.0.0.0/8",
"le": "32",
"action": "permit",
}
]
},
"ipv6": {
"pf_ls_1_ipv6": [
{
"seqid": 10,
"network": "200::/8",
"le": "128",
"action": "permit",
}
]
},
}
}
}
result = create_prefix_lists(tgen, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Create route map
input_dict_3 = {
"r1": {
"route_maps": {
"RMAP_WEIGHT": [
{
"action": "permit",
"seq_id": "5",
"match": {"ipv4": {"prefix_lists": "pf_ls_1_ipv4"}},
"set": {"weight": 500},
},
{
"action": "permit",
"seq_id": "10",
"match": {"ipv6": {"prefix_lists": "pf_ls_1_ipv6"}},
"set": {"weight": 500},
},
]
}
}
}
result = create_route_maps(tgen, input_dict_3)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Configure neighbor for route map
input_dict_4 = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r2": {
"dest_link": {
"r1": {
"route_maps": [
{
"name": "RMAP_WEIGHT",
"direction": "in",
}
]
}
}
}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r2": {
"dest_link": {
"r1": {
"route_maps": [
{
"name": "RMAP_WEIGHT",
"direction": "in",
}
]
}
}
}
}
}
},
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Verifying best path
dut = "r1"
attribute = "weight"
for addr_type in ADDR_TYPES:
result = verify_best_path_as_per_bgp_attribute(
tgen, addr_type, dut, {"r7": input_dict["r7"]}, attribute
)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
# Modify route map
input_dict_3 = {
"r1": {
"route_maps": {
"RMAP_WEIGHT": [
{
"action": "permit",
"seq_id": "5",
"match": {"ipv4": {"prefix_lists": "pf_ls_1_ipv4"}},
"set": {"weight": 1000},
},
{
"action": "permit",
"seq_id": "10",
"match": {"ipv6": {"prefix_lists": "pf_ls_1_ipv6"}},
"set": {"weight": 1000},
},
]
}
}
}
result = create_route_maps(tgen, input_dict_3)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Verifying best path
dut = "r1"
attribute = "weight"
for addr_type in ADDR_TYPES:
result = verify_best_path_as_per_bgp_attribute(
tgen, addr_type, dut, {"r7": input_dict["r7"]}, attribute
)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
write_test_footer(tc_name)
def test_origin_attribute(request):
" Verifying ORIGIN attribute functionality"
tgen = get_topogen()
# Don't run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
# test case name
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
reset_config_on_routers(tgen)
# Api call to advertise networks
input_dict = {
"r4": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"advertise_networks": [
{
"network": "200.50.2.0/32"
},
{
"network": "200.60.2.0/32"
}
]
}
}
}
}
},
"r2": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r2": {"next_hop_self": True}
}
}
}
}
}
}
}
},
"r3": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r3": {"next_hop_self": True}
}
}
}
}
}
}
}
},
"r5": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"redistribute": [
{"redist_type": "static"},
{"redist_type": "connected"}
]
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
# Api call to create static routes
input_dict_3 = {
"r5": {
"static_routes": [
{
"network": "200.50.2.0/32",
"next_hop": "10.0.0.26"
},
{
"network": "200.60.2.0/32",
"next_hop": "10.0.0.26"
}
]
}
}
result = create_static_routes(tgen, input_dict_3)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
# Api call to redistribute static routes
# Configure next-hop-self to bgp neighbor
# Verifying best path
dut = "r1"
attribute = "origin"
result = verify_best_path_as_per_bgp_attribute(tgen, "ipv4", dut,
input_dict, attribute)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
write_test_footer(tc_name)
