diff --git a/doc/sai-ptf/config_data/config_t0.md b/doc/sai-ptf/config_data/config_t0.md new file mode 100644 index 000000000..fe5fac4c9 --- /dev/null +++ b/doc/sai-ptf/config_data/config_t0.md @@ -0,0 +1,148 @@ +# Sample T0 Configurations and data +- [Overriew](#overriew) +- [IP and MAC naming convention](#ip-and-mac-naming-convention) + - [MAC](#mac) + - [IP](#ip) +- [1. L2 Configurations](#1-l2-configurations) + - [1.1 FDB Configuration](#11-fdb-configuration) + - [1.2 VLAN configuration](#12-vlan-configuration) +- [2. L3 configuration](#2-l3-configuration) + - [2.1 VLAN Interfaces](#21-vlan-interfaces) + - [2.2 LAG configuration](#22-lag-configuration) + - [2.2.1 LAG Hash Rule](#221-lag-hash-rule) + - [2.3 Route Configuration](#23-route-configuration) + - [2.3.1 VLAN interfaces route entries](#231-vlan-interfaces-route-entries) + - [2.3.2 LAG Route entry](#232-lag-route-entry) + - [2.4 Neighbor Configuration](#24-neighbor-configuration) + - [2.4.1 VLAN Neighbors](#241-vlan-neighbors) + - [2.4.2 LAG Neighbors](#242-lag-neighbors) +# Overriew +This document describes the sample configuration data. + +**Note: This configuration focused on T0 topology.** + +# IP and MAC naming convention +In this configuration, we mapped the IP and MAC address into different parts of this configuration as below. + +## MAC +For MAC addresses, we can use different sections in the MAC addresses to map different title numbers. +The pattern is +``` +00:TITLE_L1_NUM:TITLE_L2_NUM:ROLE:EXTRA:SEQ +ROLE: T1=1, Server=99 +``` + +For example: +For the MAC address in ``1.1 FDB Configuration``. +`1.1` is the title number. +``` +#Server MAC +00:01:01:99:02:01~00:01:01:99:02:32 +# 99: Server +# 02: EXTRA (Group ID) +``` + + +## IP +For IP addresses, we will use different prefix for different role + +Format: ROLE.NUM.GROUP_ID.SEQ + +- ROLE_NUM +T0: 10.0.0.0 +T1: 10.1.0.0 +Server: 192.168.0.0 + +For example +``` +# IP in +# 2.4.1 VLAN Neighbors +#Group0 (For Vlan10) +192.168.1.1~ 192.168.1.8 +#Group1 (ForVlan20) +192.168.2.1~ 192.168.2.8 +``` + + + + +# 1. L2 Configurations + +## 1.1 FDB Configuration + +The MAC Table for VLAN L2 forwarding as below +|Name|MAC|PORT|VLAN|HostIf| +|-|-|-|-|-| +|mac0|01:01:00:99:00:00|Port0||Ethernet0| +|mac1-8 |00:01:01:99:01:01 - 00:01:01:99:01:08|Port1-8|10|Ethernet4-Ethernet32| +|mac9-16 |00:01:01:99:02:09 - 00:01:01:99:02:16|Port9-16|20|Ethernet36-Ethernet64| + +## 1.2 VLAN configuration + +|HostIf|VLAN ID|Ports|Tag mode| +|-|-|-|-| +|Ethernet4-32|10|Port1-8|Untag| +|Ethernet36-72|20|Port9-16|Untag| + + +# 2. L3 configuration + +Host interface IP +|Port|Interface IP| +|-|-| +|port0|10.0.0.100| + +## 2.1 VLAN Interfaces +|VLAN ID | VLAN Interface IP| +|-|-| +|10|192.168.1.100| +|20|192.168.2.100| + +## 2.2 LAG configuration + +|HostIf|LAG ID|Ports| +|-|-|-| +|Ethernet76-80|lag1|Port17-18| +|Ethernet84-88|lag2|Port19-20| + +### 2.2.1 LAG Hash Rule +- Set hash algorithm as SAI_HASH_ALGORITHM_CRC +- Set switch hash attribute as below, which means switch computes hash using the five fields and seed(SAI_SWITCH_ATTR_LAG_DEFAULT_HASH_SEED) as the hash configuration. +``` +SAI_NATIVE_HASH_FIELD_SRC_IP +SAI_NATIVE_HASH_FIELD_DST_IP +SAI_NATIVE_HASH_FIELD_IP_PROTOCOL +SAI_NATIVE_HASH_FIELD_L4_DST_PORT +SAI_NATIVE_HASH_FIELD_L4_SRC_PORT +``` + +## 2.3 Route Configuration + +### 2.3.1 VLAN interfaces route entries +|VLAN ID | route IP | Type | +|-|-| - | +|10| 192.168.1.100/24 | Direct Connect| +|20| 192.168.2.100/24 | Direct Connect| +### 2.3.2 LAG Route entry + +|LAG ID | route IP | Type | VALUE| +|-|-| - |-| +|1| 10.0.1.100/31 | Direct Connect|| +|2| 10.0.2.100/31 | Direct Connect|| +|1| 192.168.10.1-192.168.10.100| NH|lag1_nb| +|2| 192.168.11.1-192.168.11.100| NH|lag2_nb| + +## 2.4 Neighbor Configuration +### 2.4.1 VLAN Neighbors +|Name|Port|IP|dest_mac| +|-|-|-|-| +|vlan10_nb1-nb8|Port1-8 |192.168.1.1 ~ 192.168.1.8 |00:01:01:99:01:01 - 00:01:01:99:01:08| +|vlan20_nb1-nb8|Port9-16|192.168.2.9 ~ 192.168.2.16 |00:01:01:99:02:09 - 00:01:01:99:02:16| + + +### 2.4.2 LAG Neighbors + +|Name|Port|IP|dest_mac| +|-|-|-|-| +|lag1_nb|lag1| 10.1.1.101 | 02:04:02:01:01:01| +|lag2_nb|lag2| 10.1.2.101 | 02:04:02:01:02:01| diff --git a/doc/sai-ptf/lag_test_plan.md b/doc/sai-ptf/lag_test_plan.md new file mode 100644 index 000000000..b80672adb --- /dev/null +++ b/doc/sai-ptf/lag_test_plan.md @@ -0,0 +1,154 @@ +# SAI LAG Test plan +- [SAI LAG Test plan](#sai-lag-test-plan) +- [Overriew](#overriew) +- [Test Configuration](#test-configuration) +- [Test Execution](#test-execution) + - [Test Data/Packet](#test-datapacket) + - [Test Group1: L3 PortChannel Load balancing](#test-group1-l3-portchannel-load-balancing) + - [Case1: test_loadbalance_on_source_port](#case1-test_loadbalance_on_source_port) + - [Case2: test_loadbalance_on_destinstion_port](#case2-test_loadbalance_on_destinstion_port) + - [Case3: test_loadbalance_on_source_ip](#case3-test_loadbalance_on_source_ip) + - [Case4: test_loadbalance_on_destinstion_ip](#case4-test_loadbalance_on_destinstion_ip) + - [Case5: test_loadbalance_on_protocol](#case5-test_loadbalance_on_protocol) + - [Test Group2: Disable Egress/Ingress](#test-group2-disable-egressingress) + - [Case1: test_disable_egress](#case1-test_disable_egress) + - [Case2: test_disable_ingress](#case2-test_disable_ingress) + - [Test Group3: Remove/Add LAG member](#test-group3-removeadd-lag-member) + - [Case1: test_remove_lag_member](#case1-test_remove_lag_member) + - [Case2: test_add_lag_member](#case2-test_add_lag_member) + - [Test Group4: Indifference Ingress Port in Hash](#test-group4-indifference-ingress-port-in-hash) + - [Case1: test_ingress_port_hash_indiff](#case1-test_ingress_port_hash_indiff) +# Overriew +The purpose of this test plan is to test the LAG/PortChannel function from SAI. + + +# Test Configuration + +For the test configuration, please refer to LAG configuration section of the file + - [Config_t0](./config_data/config_t0.md) + +**Note. All the tests will be based on the configuration above, if any additional configuration is required, it will be specified in the Test case.** + +# Test Execution +## Test Data/Packet +```Python +pkt = simple_udp_packet(eth_dst=ROUTER_MAC, + eth_src=src_mac, + ip_dst=dst_ip_addr, + ip_src=src_ip_addr, + udp_sport=udp_sport, + udp_dport=udp_dport, + ip_id=106, + ip_ttl=64) + + exp_pkt = simple_udp_packet(eth_dst=dstmac, + eth_src=ROUTER_MAC, + ip_dst=dst_ip_addr, + ip_src=src_ip_addr, + udp_sport=udp_sport, + udp_dport=udp_dport, + ip_id=106, + ip_ttl=63) +``` + +```Python +pkt = simple_tcp_packet(eth_dst=ROUTER_MAC, + eth_src=src_mac, + ip_dst=dst_ip_addr, + ip_src=src_ip_addr, + tcp_sport=tcp_sport, + tcpp_dport=tcp_dport, + ip_id=106, + ip_ttl=64) + + exp_pkt = simple_udp_packet(eth_dst=dstmac, + eth_src=ROUTER_MAC, + ip_dst=dst_ip_addr, + ip_src=src_ip_addr, + tcp_sport=tcp_sport, + tcp_dport=tcp_dport, + ip_id=106, + ip_ttl=63) +``` +## Test Group1: L3 PortChannel Load balancing +These cases will cover five scenarios: src/dst IP, src/dst port, and protocol. considering the mighty hash collision, please make sure the volume of the test data, and we can check the final result is in a range. + + +### Case1: test_loadbalance_on_source_port +### Case2: test_loadbalance_on_destinstion_port +### Case3: test_loadbalance_on_source_ip +### Case4: test_loadbalance_on_destinstion_ip +### Case5: test_loadbalance_on_protocol + + +### Testing Objective +For load balancing, expecting the ports in a lag should receive the packet equally. Traffic direction: from server-side to T1 side. + +### Test steps: +1. Generate different packets by updating different factors for each case. The factor includes source port(L4), destination port(L4), source IP, and destination IP of the packet. Packets use lag1 neighbor IPs as destination IP, and lag1 MAC (Switch MAC) as destination MAC. +2. Send these packets with different protocols on port1(with different cases). +3. Check if packets are received on ports of lag1 equally. + +## Test Group2: Disable Egress/Ingress + + +### Case1: test_disable_egress +### Case2: test_disable_ingress + +### Testing Objective +These cases will cover two scenarios: disable egress and ingress. We can disable ingress or egress on a lag member, then we expect traffic drop on the disabled lag member. + +### Test steps: +- test_disable_egress + +1. Generate different packets by updating different factors for each case. The factor includes source port(L4), destination port(L4), source IP, and destination IP of the packet. Packets use lag1 neighbor IPs as destination IP, and lag1 MAC (Switch MAC) as destination MAC. +2. Send packet from port1 +3. Verify packets appear on different lag1 members(Baseline check). +4. Disable egress on lag1 member port18 +5. Send packets in step1 from port1 again +6. Check if the Packet drop on port18 + +- test_disable_ingress + +1. Generate packet using port1 neighbor IP as destination IP, VLAN Interface MAC (Switch MAC) as destination MAC. +2. Send packet from lag1 port18 +3. Verify packets appear on Port1(Baseline check). +4. Disable ingress on lag1 member port18 +5. Send packet in step1 again from lag1 port18 +6. Check if Packet drop on port1 + +## Test Group3: Remove/Add LAG member +### Case1: test_remove_lag_member +### Case2: test_add_lag_member +### Testing Objective +These cases will cover adding and removing the lag members. We can remove or add a lag member, then expect traffic to drop/appear on the lag member. + +### Test steps: +- test_remove_lag_member + +1. Generate different packets by updating different factors for each case. The factor includes source port(L4), destination port(L4), source IP, and destination IP of the packet. Packets use lag1 neighbor IPs as destination IP and lag1 MAC (Switch MAC) as destination MAC. +2. Send packet from port1 +3. Verify packets appear on lag1 port18(Baseline check). +4. Remove port18 from lag1 +5. Send packets in step1 from port1 again +6. Check if the Packet drop on port18 + +- test_add_lag_member + +1. Add port21 to lag1 +2. Create packets with variations of the src_ip, dest_ip, src_port,dest_port.(dest_ip is lag1 neighbor IP and MAC is lag1 neighbor MAC) +3. Send packet from port1 +4. Verify packets appear on all the lag1 members, including port21. + + +## Test Group4: Indifference Ingress Port in Hash +### Case1: test_ingress_port_hash_indiff + +### Test Objective +This case will verify the ingress ports should not be as a Hash Factor in Lag loadbalance. +When forwarding the packet from different ingress ports, if only the ingress port changed, then the loadbalance should not happen among lag members. + +### Test steps: +1. Generate packet using one lag1 neighbor IP as destination IP, lag1 MAC (Switch MAC) as destination MAC, and keep all packets from different ports have the same src_ip, dest_ip, src_port(L4),dest_port(L4), and protocol. +2. Send packet from Port1 ~ Port16 +3. Verify packets only appear on one LAG member port diff --git a/doc/sai-ptf/vlan_test_plan.md b/doc/sai-ptf/vlan_test_plan.md new file mode 100644 index 000000000..c5dca691b --- /dev/null +++ b/doc/sai-ptf/vlan_test_plan.md @@ -0,0 +1,299 @@ +# SAI VLAN Test plan + +- [Test Configuration](#test-configuration) +- [Test Execution](#test-execution) + - [Common Test Data/Packet](#common-test-datapacket) + - [Test Group1: Tagging and access](#test-group1-tagging-and-access) + - [Case1: test_untag_access_to_access](#case1-test_untag_access_to_access) + - [Case2: test_unmatch_drop](#case2-test_unmatch_drop) + - [Test Group2: Frame Filtering](#test-group2-frame-filtering) + - [Case1: test_untagged_frame_filtering](#case1-test_untagged_frame_filtering) + - [Case2: test_tagged_frame_filtering](#case2-test_tagged_frame_filtering) + - [Test Group3: VLAN flooding](#test-group3-vlan-flooding) + - [Case1: test_tagged_vlan_flooding](#case1-test_tagged_vlan_flooding) + - [Case2: test_untagged_vlan_flooding](#case2-test_untagged_vlan_flooding) + - [Test Group4: VLAN broadcast](#test-group4-vlan-broadcast) + - [Case1: test_vlan_broadcast](#case1-test_vlan_broadcast) + - [Test Group5: MAC learning](#test-group5-mac-learning) + - [Case1: test_untagged_mac_learning](#case1-test_untagged_mac_learning) + - [Case2: test_tagged_mac_learning](#case2-test_tagged_mac_learning) + - [Test Group6: Vlan member API](#test-group6-vlan-member-api) + - [Case1:test_vlan_member_api](#case1test_vlan_member_api) + - [Test Group7: Add member to invalidate VLAN](#test-group7-add-member-to-invalidate-vlan) + - [Case1:test_add_vlan_member_failed](#case1test_add_vlan_member_failed) + - [Test Group8: Disable mac learning](#test-group8-disable-mac-learning) + - [Case1: test_disable_mac_learning_tagged](#case1-test_disable_mac_learning_tagged) + - [Case2: test_disable_mac_learning_untagged](#case2-test_disable_mac_learning_untagged) + - [Test Group9: ARP Flooding and mac learning](#test-group9-arp-flooding-and-mac-learning) + - [Case1: test_arp_request_flooding](#case1-test_arp_request_flooding) + - [Case2: test_arp_response_learning](#case2-test_arp_response_learning) + - [Test Group10: VLAN Counters/Status](#test-group10-vlan-countersstatus) + - [Case1: test_tagged_vlan_status](#case1-test_tagged_vlan_status) + - [Case2: test_untagged_vlan_status](#case2-test_untagged_vlan_status) +# Test Configuration + +For the test configuration, please refer to the file + - [Config_t0](./config_data/config_t0.md) + +**Note. All the tests will be based on the configuration above, if any additional configuration is required, it will be specified in the Test case.** + +# Test Execution + +## Common Test Data/Packet +In this VLAN test, most of the test cases will be tested with a Tagged or Untagged packet, the example packet structure as below. +- Tagged packet with VLAN id + + ```python + tagged_packet(eth_dst='00:11:11:11:11:11', + eth_src='00:22:22:22:22:22', + vlan_vid=10, + ip_dst='172.16.0.1', + ip_ttl=64) + ``` +- Untagged packet + ```Python + simple_tcp_packet(eth_dst='00:11:11:11:11:11', + eth_src='00:22:22:22:22:22', + ip_dst='172.16.0.1', + ip_ttl=64) + ``` +**Note. If need other kinds of packets, they will be added to the test case/group respectively.** + +## Test Group1: Tagging and access +### Case1: test_untag_access_to_access +### Case2: test_unmatch_drop + +### Testing Objective +This test verifies the VLAN function around untag and access ports. + +*p.s. This test will not check the function with the native VLAN scenario. Please make sure the native VLAN will not impact the result.* + +With an untagged packet, on the access port, when ingress and egress happen, the behavior as below +| Port mode | packet tag mode | Direction | Action | +| :---------|--------------- | :-------- | :--------------------------------------- | +| Access|Untag| Ingress | Accept the packet. | +| |Untag | Egress | Untag the packet. | + + +``` +Test example: +Untagged: + pkt(Untag:DMAC=MAC2) -> Port1:Access:VLAN10-> Port2:Access:VLAN10 -> pkt(Untag:DMAC=MAC2) +``` + +### Test steps: +- test_untag_access_to_access + +1. Create ``Untagged`` packet with ``mac2`` as dest mac. +2. Send packet on Port1. +3. Verify ``Untagged`` packet received port2. + +- test_unmatch_drop + +1. Create ``Tagged VLAN 11`` packet with ``mac2`` as dest mac. +2. Send packet on Port1. +3. Verify packet is dropped. + +## Test Group2: Frame Filtering +### Case1: test_untagged_frame_filtering +### Case2: test_tagged_frame_filtering +### Testing Objective + +Drop packet when the destination port from MAC table search is the port which packet comes into the switch. + + +``` +Test example(Untag): + | MAC1 | + pkt(Untag:DMAC=MAC1 or MACX) -> Port1:Access:VLAN10 -> FDB(contains:MAC1,MACX)| | -> X + | MACX | +``` + +### Test steps + 1. Add another ``MacX`` as Port1 mac address into the MAC table + 1. Create ``Untagged``/``Tagged VLAN10`` packet, ``mac1`` as src mac, ``MacX`` as dest mac + 1. Send packet on VLAN Port. + 1. Verify no packet was received on any port. + +## Test Group3: VLAN flooding +### Case1: test_tagged_vlan_flooding +### Case2: test_untagged_vlan_flooding +### Testing Objective +For mac flooding in the VLAN scenario, before learning the mac address from the packet, the packet sent to the VLAN port will flood to other ports, and the egress ports will be in the same VLAN as the ingress port. +``` +Flooding + | Port2| + pkt(Untag:DMAC=MAC2) -> Port1:Access:VLAN10 -> Flooding ->| To |-> pkt(Untag) + | Port8| +``` + + +### Test Steps: + 1. Create ``Untagged``/``Tagged VLAN10`` packet, with ``mac1`` as source MAC and an un-existing ``MacX`` as dest MAC + 1. Send packet on Port1. + 1. Verify received packet on all VLAN 10 ports expect Port1. + + +## Test Group4: VLAN broadcast +### Case1: test_vlan_broadcast +### Testing Objective +A VLAN is a logical broadcast domain that can span multiple physical LAN segments. + + +### Test Steps: + 1. Create ``Untagged``/``Tagged VLAN10`` packet, with ``broadcast`` MAC as dest MAC + 2. Send packet on Port1. + 3. Verify received packet on all VLAN 10 ports expect Port1. + +## Test Group5: MAC learning +### Case1: test_untagged_mac_learning +### Case2: test_tagged_mac_learning +### Testing Objective +For mac learning in the VLAN scenario, after learning the mac address from the packet, the packet sent to the VLAN port will only send to the port whose MAC address matches the MAC table entry. + +``` + unicast + pkt(Untag:DMAC=MAC1) -> Port2:Access:VLAN10-> Port1:Access:VLAN10 -> pkt(Untag:DMAC=MAC1) + +``` +### Test Steps: + 1. Create ``Untagged``/``Tagged VLAN10`` packet, with an un-existing ``MacX`` as src MAC and ``mac2`` as dest MAC + 1. Send packet on a VLAN source port1. + 1. Verify packet received on port2. + 1. Verify MAC table get a new entry for ``MacX`` on port1, + +## Test Group6: Vlan member API +### Case1:test_vlan_member_api + +### Testing Objective + +Test VLAN and member APIs. + +### Test steps: + 1. Use VLAN API to list all of the VLAN members in VLAN + 1. Verify the VLAN member and the account of the VLAN member are the same as config in [config](./config_data/config_t0.md) + 1. Use VLAN API to add a new Member to VLAN + 1. Verify the VLAN member and the account of the VLAN member is increased by 1. + +## Test Group7: Add member to invalidate VLAN +### Case1:test_add_vlan_member_failed +### Testing Objective + +When adding a VLAN member to a non-exist VLAN, it will fail. + +### Test Steps: + 1. Use VLAN API to add a new Member to a non-exist VLAN, ``VLAN11`` + 1. Verify the VLAN member added failed. + + +## Test Group8: Disable mac learning +### Case1: test_disable_mac_learning_tagged +### Case2: test_disable_mac_learning_untagged +### Testing Objective +Test the function when disabling VLAN MAC learning. +When disabled, no new MAC will be learned in the MAC table. + +### Additional config: +- Do not config the MAC table + +### Test steps: + 1. Create ``Untagged``/``Tagged VLAN10`` packet, with ``mac1`` as src MAC and ``mac2`` as dest MAC + 1. Send packet from the source port1. + 1. Verify packets received on all ports except the source port1. + 1. Verify MAC table, no new entry added in MAC table + + +## Test Group9: ARP Flooding and mac learning +### Case1: test_arp_request_flooding +### Case2: test_arp_response_learning +### Testing Objective +In the ARP scenario, the mac learning process is: +1. Send an ARP request, with the source MAC, dest IP, and src IP, for broadcast, the DST MAC is ff:ff:ff:ff:ff:ff +2. After the target port gets the ARP packet MAC table fills with port SRC MAC. +3. Switch received that response, based on the MAC table, it makes a unicast here. + +**p.s. The test will be ended here, will not test the send from the port in step 1 again, it is already covered in other tests.** + +Testing ARP scenario +``` +Test example: +1. ARP Request + | Port2| + ARP Req pkt(Untag:DMAC=MAC2) -> Port1:Access:VLAN10 -> Flooding ->| to |-> pkt(Untag) + | Port8| + +2. ARP Response + ARP Resp pkt(Untag:DMAC=MAC1) -> Port2:Access:VLAN10-> Port1:Access:VLAN10 -> pkt(Untag:DMAC=MAC1) + +``` +### Test Data/Packet +**Both those two packets will be used in input and output.** +- ARP request + ```Python + simple_arp_packet( + eth_dst='FF:FF:FF:FF:FF:FF', # boardcast + eth_src=MAC1, + arp_op=1, # ARP request + ip_tgt=IP2, + ip_snd=IP1, + hw_snd=MAC1, + hw_tgt=MAC2) + ``` +- ARP response + ```Python + #Untagged: + simple_arp_packet( + eth_dst=MAC1, + eth_src=MAC2, + arp_op=2, # ARP response + ip_tgt=IP1, + ip_snd=IP2, + hw_snd=MAC2, + hw_tgt=MAC1) + + #Tagged(Just Sample, not used in this case): + simple_arp_packet( + eth_dst=MAC1, + eth_src=MAC2, + arp_op=2, # ARP response + ip_tgt=IP1, + ip_snd=IP2, + vlan_vid=10, + hw_snd=MAC2, + hw_tgt=MAC2) + ``` + +### Additional config: +- Do not config the MAC table + +### Test Steps: + +- test_arp_request_flooding + + +1. Create ARP packet with dest ``mac2`` +2. Send ``Untagged`` ARP packet on ``port1`` +3. Verify ``Untagged`` Arp request received from Port2 to Port8 + +- test_arp_response_learning + +1. Create ARP response packet with src:mac2, dest:mac1 +2. Send ARP response packet on port2 +3. Verify ``Untagged`` ARP response from Port1 + + +## Test Group10: VLAN Counters/Status +### Case1: test_tagged_vlan_status +### Case2: test_untagged_vlan_status +### Testing Objective + +For VLAN-related counters, SAI should be able to get the counter and clear them. + +### Test Steps: + 1. Use SAI API to get the VLAN Status ``_sai_vlan_stat_t`` (defined in [saivlan.h](https://github.com/opencomputeproject/SAI/blob/master/inc/saivlan.h) ) + 2. Create ``Untagged``/``Tagged VLAN10`` packet, with ``mac1`` as src MAC and ``mac2`` as dest MAC + 3. Send packet from the source port1 + 4. Verify the packet received on the target port2 + 5. Verify counters increased, bytes counter: OCTETS increased, other counters + 1 + 6. Use VLAN clear status API + 7. Verify counters have been reset \ No newline at end of file