X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_link_bonding.c;h=5a7f45f94a02faf0ed2bed4b696bbdddf2943f89;hb=538da7a1cad25fbdffe298c8ca76fc4dbd262d1b;hp=ef8207ebf049eb35cf1a9f4384b9124774c84a00;hpb=200866003a89ebfb4720f20845f130cfc89cd9f2;p=dpdk.git

diff --git a/app/test/test_link_bonding.c b/app/test/test_link_bonding.c
index ef8207ebf0..5a7f45f94a 100644
--- a/app/test/test_link_bonding.c
+++ b/app/test/test_link_bonding.c
@@ -1,34 +1,5 @@
-/*-
- *   BSD LICENSE
- *
- *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
- *   All rights reserved.
- *
- *   Redistribution and use in source and binary forms, with or without
- *   modification, are permitted provided that the following conditions
- *   are met:
- *
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in
- *       the documentation and/or other materials provided with the
- *       distribution.
- *     * Neither the name of Intel Corporation nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2010-2014 Intel Corporation
  */
 
 #include "unistd.h"
@@ -46,6 +17,7 @@
 #include <rte_common.h>
 #include <rte_debug.h>
 #include <rte_ethdev.h>
+#include <rte_ethdev_driver.h>
 #include <rte_log.h>
 #include <rte_lcore.h>
 #include <rte_memory.h>
@@ -59,34 +31,28 @@
 
 #define TEST_MAX_NUMBER_OF_PORTS (6)
 
-#define RX_RING_SIZE 128
+#define RX_RING_SIZE 1024
 #define RX_FREE_THRESH 32
 #define RX_PTHRESH 8
 #define RX_HTHRESH 8
 #define RX_WTHRESH 0
 
-#define TX_RING_SIZE 512
+#define TX_RING_SIZE 1024
 #define TX_FREE_THRESH 32
 #define TX_PTHRESH 32
 #define TX_HTHRESH 0
 #define TX_WTHRESH 0
 #define TX_RSBIT_THRESH 32
-#define TX_Q_FLAGS (ETH_TXQ_FLAGS_NOMULTSEGS | ETH_TXQ_FLAGS_NOVLANOFFL |\
-	ETH_TXQ_FLAGS_NOXSUMSCTP | ETH_TXQ_FLAGS_NOXSUMUDP | \
-	ETH_TXQ_FLAGS_NOXSUMTCP)
 
-#define MBUF_PAYLOAD_SIZE	(2048)
-#define MBUF_SIZE (MBUF_PAYLOAD_SIZE + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM)
 #define MBUF_CACHE_SIZE (250)
 #define BURST_SIZE (32)
 
-#define DEFAULT_MBUF_DATA_SIZE	(2048)
 #define RTE_TEST_RX_DESC_MAX	(2048)
 #define RTE_TEST_TX_DESC_MAX	(2048)
 #define MAX_PKT_BURST			(512)
 #define DEF_PKT_BURST			(16)
 
-#define BONDED_DEV_NAME			("unit_test_bonded_device")
+#define BONDED_DEV_NAME			("net_bonding_ut")
 
 #define INVALID_SOCKET_ID		(-1)
 #define INVALID_PORT_ID			(-1)
@@ -97,9 +63,9 @@ uint8_t slave_mac[] = {0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 };
 uint8_t bonded_mac[] = {0xAA, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF };
 
 struct link_bonding_unittest_params {
-	int8_t bonded_port_id;
-	int8_t slave_port_ids[TEST_MAX_NUMBER_OF_PORTS];
-	uint8_t bonded_slave_count;
+	int16_t bonded_port_id;
+	int16_t slave_port_ids[TEST_MAX_NUMBER_OF_PORTS];
+	uint16_t bonded_slave_count;
 	uint8_t bonding_mode;
 
 	uint16_t nb_rx_q;
@@ -107,11 +73,11 @@ struct link_bonding_unittest_params {
 
 	struct rte_mempool *mbuf_pool;
 
-	struct ether_addr *default_slave_mac;
-	struct ether_addr *default_bonded_mac;
+	struct rte_ether_addr *default_slave_mac;
+	struct rte_ether_addr *default_bonded_mac;
 
 	/* Packet Headers */
-	struct ether_hdr *pkt_eth_hdr;
+	struct rte_ether_hdr *pkt_eth_hdr;
 	struct ipv4_hdr *pkt_ipv4_hdr;
 	struct ipv6_hdr *pkt_ipv6_hdr;
 	struct udp_hdr *pkt_udp_hdr;
@@ -133,8 +99,8 @@ static struct link_bonding_unittest_params default_params  = {
 
 	.mbuf_pool = NULL,
 
-	.default_slave_mac = (struct ether_addr *)slave_mac,
-	.default_bonded_mac = (struct ether_addr *)bonded_mac,
+	.default_slave_mac = (struct rte_ether_addr *)slave_mac,
+	.default_bonded_mac = (struct rte_ether_addr *)bonded_mac,
 
 	.pkt_eth_hdr = NULL,
 	.pkt_ipv4_hdr = &pkt_ipv4_hdr,
@@ -166,36 +132,11 @@ static uint16_t dst_port_1 = 2024;
 
 static uint16_t vlan_id = 0x100;
 
-struct rte_eth_rxmode rx_mode = {
-	.max_rx_pkt_len = ETHER_MAX_LEN, /**< Default maximum frame length. */
-	.split_hdr_size = 0,
-	.header_split   = 0, /**< Header Split disabled. */
-	.hw_ip_checksum = 0, /**< IP checksum offload disabled. */
-	.hw_vlan_filter = 1, /**< VLAN filtering enabled. */
-	.hw_vlan_strip  = 1, /**< VLAN strip enabled. */
-	.hw_vlan_extend = 0, /**< Extended VLAN disabled. */
-	.jumbo_frame    = 0, /**< Jumbo Frame Support disabled. */
-	.hw_strip_crc   = 0, /**< CRC stripping by hardware disabled. */
-};
-
-struct rte_fdir_conf fdir_conf = {
-	.mode = RTE_FDIR_MODE_NONE,
-	.pballoc = RTE_FDIR_PBALLOC_64K,
-	.status = RTE_FDIR_REPORT_STATUS,
-	.flexbytes_offset = 0x6,
-	.drop_queue = 127,
-};
-
 static struct rte_eth_conf default_pmd_conf = {
 	.rxmode = {
 		.mq_mode = ETH_MQ_RX_NONE,
-		.max_rx_pkt_len = ETHER_MAX_LEN,
 		.split_hdr_size = 0,
-		.header_split   = 0, /**< Header Split disabled */
-		.hw_ip_checksum = 0, /**< IP checksum offload enabled */
-		.hw_vlan_filter = 0, /**< VLAN filtering disabled */
-		.jumbo_frame    = 0, /**< Jumbo Frame Support disabled */
-		.hw_strip_crc   = 0, /**< CRC stripped by hardware */
+		.max_rx_pkt_len = ETHER_MAX_LEN,
 	},
 	.txmode = {
 		.mq_mode = ETH_MQ_TX_NONE,
@@ -221,12 +162,14 @@ static struct rte_eth_txconf tx_conf_default = {
 	},
 	.tx_free_thresh = TX_FREE_THRESH,
 	.tx_rs_thresh = TX_RSBIT_THRESH,
-	.txq_flags = TX_Q_FLAGS
-
 };
 
+static void free_virtualpmd_tx_queue(void);
+
+
+
 static int
-configure_ethdev(uint8_t port_id, uint8_t start, uint8_t en_isr)
+configure_ethdev(uint16_t port_id, uint8_t start, uint8_t en_isr)
 {
 	int q_id;
 
@@ -258,6 +201,7 @@ configure_ethdev(uint8_t port_id, uint8_t start, uint8_t en_isr)
 }
 
 static int slaves_initialized;
+static int mac_slaves_initialized;
 
 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t cvar = PTHREAD_COND_INITIALIZER;
@@ -267,12 +211,12 @@ static int
 test_setup(void)
 {
 	int i, nb_mbuf_per_pool;
-	struct ether_addr *mac_addr = (struct ether_addr *)slave_mac;
+	struct rte_ether_addr *mac_addr = (struct rte_ether_addr *)slave_mac;
 
 	/* Allocate ethernet packet header with space for VLAN header */
 	if (test_params->pkt_eth_hdr == NULL) {
-		test_params->pkt_eth_hdr = malloc(sizeof(struct ether_hdr) +
-				sizeof(struct vlan_hdr));
+		test_params->pkt_eth_hdr = malloc(sizeof(struct rte_ether_hdr) +
+				sizeof(struct rte_vlan_hdr));
 
 		TEST_ASSERT_NOT_NULL(test_params->pkt_eth_hdr,
 				"Ethernet header struct allocation failed!");
@@ -281,10 +225,9 @@ test_setup(void)
 	nb_mbuf_per_pool = RTE_TEST_RX_DESC_MAX + DEF_PKT_BURST +
 			RTE_TEST_TX_DESC_MAX + MAX_PKT_BURST;
 	if (test_params->mbuf_pool == NULL) {
-		test_params->mbuf_pool = rte_mempool_create("MBUF_POOL", nb_mbuf_per_pool,
-				MBUF_SIZE, MBUF_CACHE_SIZE, sizeof(struct rte_pktmbuf_pool_private),
-				rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, NULL,
-				rte_socket_id(), 0);
+		test_params->mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
+			nb_mbuf_per_pool, MBUF_CACHE_SIZE, 0,
+			RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
 		TEST_ASSERT_NOT_NULL(test_params->mbuf_pool,
 				"rte_mempool_create failed");
 	}
@@ -318,7 +261,7 @@ test_create_bonded_device(void)
 {
 	int current_slave_count;
 
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
 	/* Don't try to recreate bonded device if re-running test suite*/
 	if (test_params->bonded_port_id == -1) {
@@ -388,7 +331,7 @@ test_add_slave_to_bonded_device(void)
 {
 	int current_slave_count;
 
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
 	TEST_ASSERT_SUCCESS(rte_eth_bond_slave_add(test_params->bonded_port_id,
 			test_params->slave_port_ids[test_params->bonded_slave_count]),
@@ -434,8 +377,8 @@ static int
 test_remove_slave_from_bonded_device(void)
 {
 	int current_slave_count;
-	struct ether_addr read_mac_addr, *mac_addr;
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	struct rte_ether_addr read_mac_addr, *mac_addr;
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
 	TEST_ASSERT_SUCCESS(rte_eth_bond_slave_remove(test_params->bonded_port_id,
 			test_params->slave_port_ids[test_params->bonded_slave_count-1]),
@@ -452,7 +395,7 @@ test_remove_slave_from_bonded_device(void)
 			current_slave_count, test_params->bonded_slave_count - 1);
 
 
-	mac_addr = (struct ether_addr *)slave_mac;
+	mac_addr = (struct rte_ether_addr *)slave_mac;
 	mac_addr->addr_bytes[ETHER_ADDR_LEN-1] =
 			test_params->bonded_slave_count-1;
 
@@ -497,7 +440,7 @@ static int
 test_add_already_bonded_slave_to_bonded_device(void)
 {
 	int port_id, current_slave_count;
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 	char pmd_name[RTE_ETH_NAME_MAX_LEN];
 
 	test_add_slave_to_bonded_device();
@@ -529,7 +472,7 @@ static int
 test_get_slaves_from_bonded_device(void)
 {
 	int current_slave_count;
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
 	TEST_ASSERT_SUCCESS(test_add_slave_to_bonded_device(),
 			"Failed to add slave to bonded device");
@@ -610,7 +553,7 @@ test_start_bonded_device(void)
 	struct rte_eth_link link_status;
 
 	int current_slave_count, current_bonding_mode, primary_port;
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
 	/* Add slave to bonded device*/
 	TEST_ASSERT_SUCCESS(test_add_slave_to_bonded_device(),
@@ -659,7 +602,7 @@ static int
 test_stop_bonded_device(void)
 {
 	int current_slave_count;
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
 	struct rte_eth_link link_status;
 
@@ -689,6 +632,7 @@ static int
 remove_slaves_and_stop_bonded_device(void)
 {
 	/* Clean up and remove slaves from bonded device */
+	free_virtualpmd_tx_queue();
 	while (test_params->bonded_slave_count > 0)
 		TEST_ASSERT_SUCCESS(test_remove_slave_from_bonded_device(),
 				"test_remove_slave_from_bonded_device failed");
@@ -708,9 +652,7 @@ test_set_bonding_mode(void)
 	int bonding_modes[] = { BONDING_MODE_ROUND_ROBIN,
 							BONDING_MODE_ACTIVE_BACKUP,
 							BONDING_MODE_BALANCE,
-#ifdef RTE_MBUF_REFCNT
 							BONDING_MODE_BROADCAST
-#endif
 							};
 
 	/* Test supported link bonding modes */
@@ -758,8 +700,8 @@ static int
 test_set_primary_slave(void)
 {
 	int i, j, retval;
-	struct ether_addr read_mac_addr;
-	struct ether_addr *expected_mac_addr;
+	struct rte_ether_addr read_mac_addr;
+	struct rte_ether_addr *expected_mac_addr;
 
 	/* Add 4 slaves to bonded device */
 	for (i = test_params->bonded_slave_count; i < 4; i++)
@@ -809,7 +751,7 @@ test_set_primary_slave(void)
 				"Failed to start bonded port %d",
 				test_params->bonded_port_id);
 
-		expected_mac_addr = (struct ether_addr *)&slave_mac;
+		expected_mac_addr = (struct rte_ether_addr *)&slave_mac;
 		expected_mac_addr->addr_bytes[ETHER_ADDR_LEN-1] = i;
 
 		/* Check primary slave MAC */
@@ -860,12 +802,12 @@ static int
 test_set_explicit_bonded_mac(void)
 {
 	int i;
-	struct ether_addr read_mac_addr;
-	struct ether_addr *mac_addr;
+	struct rte_ether_addr read_mac_addr;
+	struct rte_ether_addr *mac_addr;
 
 	uint8_t explicit_bonded_mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01 };
 
-	mac_addr = (struct ether_addr *)explicit_bonded_mac;
+	mac_addr = (struct rte_ether_addr *)explicit_bonded_mac;
 
 	/* Invalid port ID */
 	TEST_ASSERT_FAIL(rte_eth_bond_mac_address_set(INVALID_PORT_ID, mac_addr),
@@ -932,43 +874,51 @@ test_set_explicit_bonded_mac(void)
 static int
 test_set_bonded_port_initialization_mac_assignment(void)
 {
-	int i, slave_count, bonded_port_id;
+	int i, slave_count;
 
-	uint8_t slaves[RTE_MAX_ETHPORTS];
-	int slave_port_ids[BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
+	static int bonded_port_id = -1;
+	static int slave_port_ids[BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT];
 
-	struct ether_addr slave_mac_addr, bonded_mac_addr, read_mac_addr;
+	struct rte_ether_addr slave_mac_addr, bonded_mac_addr, read_mac_addr;
 
 	/* Initialize default values for MAC addresses */
-	memcpy(&slave_mac_addr, slave_mac, sizeof(struct ether_addr));
-	memcpy(&bonded_mac_addr, slave_mac, sizeof(struct ether_addr));
+	memcpy(&slave_mac_addr, slave_mac, sizeof(struct rte_ether_addr));
+	memcpy(&bonded_mac_addr, slave_mac, sizeof(struct rte_ether_addr));
 
 	/*
 	 * 1. a - Create / configure  bonded / slave ethdevs
 	 */
-	bonded_port_id = rte_eth_bond_create("ethdev_bond_mac_ass_test",
-			BONDING_MODE_ACTIVE_BACKUP, rte_socket_id());
-	TEST_ASSERT(bonded_port_id > 0, "failed to create bonded device");
+	if (bonded_port_id == -1) {
+		bonded_port_id = rte_eth_bond_create("net_bonding_mac_ass_test",
+				BONDING_MODE_ACTIVE_BACKUP, rte_socket_id());
+		TEST_ASSERT(bonded_port_id > 0, "failed to create bonded device");
 
-	TEST_ASSERT_SUCCESS(configure_ethdev(bonded_port_id, 0, 0),
-				"Failed to configure bonded ethdev");
+		TEST_ASSERT_SUCCESS(configure_ethdev(bonded_port_id, 0, 0),
+					"Failed to configure bonded ethdev");
+	}
 
-	for (i = 0; i < BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT; i++) {
-		char pmd_name[RTE_ETH_NAME_MAX_LEN];
+	if (!mac_slaves_initialized) {
+		for (i = 0; i < BONDED_INIT_MAC_ASSIGNMENT_SLAVE_COUNT; i++) {
+			char pmd_name[RTE_ETH_NAME_MAX_LEN];
 
-		slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = i + 100;
+			slave_mac_addr.addr_bytes[ETHER_ADDR_LEN-1] = i + 100;
 
-		snprintf(pmd_name, RTE_ETH_NAME_MAX_LEN, "eth_slave_%d", i);
+			snprintf(pmd_name, RTE_ETH_NAME_MAX_LEN,
+				"eth_slave_%d", i);
 
-		slave_port_ids[i] = virtual_ethdev_create(pmd_name,
-				&slave_mac_addr, rte_socket_id(), 1);
+			slave_port_ids[i] = virtual_ethdev_create(pmd_name,
+					&slave_mac_addr, rte_socket_id(), 1);
 
-		TEST_ASSERT(slave_port_ids[i] >= 0,
-				"Failed to create slave ethdev %s", pmd_name);
+			TEST_ASSERT(slave_port_ids[i] >= 0,
+					"Failed to create slave ethdev %s",
+					pmd_name);
 
-		TEST_ASSERT_SUCCESS(configure_ethdev(slave_port_ids[i], 1, 0),
-				"Failed to configure virtual ethdev %s",
-				pmd_name);
+			TEST_ASSERT_SUCCESS(configure_ethdev(slave_port_ids[i], 1, 0),
+					"Failed to configure virtual ethdev %s",
+					pmd_name);
+		}
+		mac_slaves_initialized = 1;
 	}
 
 
@@ -1116,7 +1066,7 @@ test_set_bonded_port_initialization_mac_assignment(void)
 
 static int
 initialize_bonded_device_with_slaves(uint8_t bonding_mode, uint8_t bond_en_isr,
-		uint8_t number_of_slaves, uint8_t enable_slave)
+		uint16_t number_of_slaves, uint8_t enable_slave)
 {
 	/* Configure bonded device */
 	TEST_ASSERT_SUCCESS(configure_ethdev(test_params->bonded_port_id, 0,
@@ -1180,15 +1130,19 @@ test_adding_slave_after_bonded_device_started(void)
 int test_lsc_interrupt_count;
 
 
-static void
-test_bonding_lsc_event_callback(uint8_t port_id __rte_unused,
-		enum rte_eth_event_type type  __rte_unused, void *param __rte_unused)
+static int
+test_bonding_lsc_event_callback(uint16_t port_id __rte_unused,
+		enum rte_eth_event_type type  __rte_unused,
+		void *param __rte_unused,
+		void *ret_param __rte_unused)
 {
 	pthread_mutex_lock(&mutex);
 	test_lsc_interrupt_count++;
 
 	pthread_cond_signal(&cvar);
 	pthread_mutex_unlock(&mutex);
+
+	return 0;
 }
 
 static inline int
@@ -1222,7 +1176,7 @@ static int
 test_status_interrupt(void)
 {
 	int slave_count;
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
 	/* initialized bonding device with T slaves */
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
@@ -1311,19 +1265,26 @@ test_status_interrupt(void)
 static int
 generate_test_burst(struct rte_mbuf **pkts_burst, uint16_t burst_size,
 		uint8_t vlan, uint8_t ipv4, uint8_t toggle_dst_mac,
-		uint8_t toggle_ip_addr, uint8_t toggle_udp_port)
+		uint8_t toggle_ip_addr, uint16_t toggle_udp_port)
 {
-	uint16_t pktlen, generated_burst_size;
+	uint16_t pktlen, generated_burst_size, ether_type;
 	void *ip_hdr;
 
+	if (ipv4)
+		ether_type = ETHER_TYPE_IPv4;
+	else
+		ether_type = ETHER_TYPE_IPv6;
+
 	if (toggle_dst_mac)
 		initialize_eth_header(test_params->pkt_eth_hdr,
-				(struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_1,
-				ipv4, vlan, vlan_id);
+				(struct rte_ether_addr *)src_mac,
+				(struct rte_ether_addr *)dst_mac_1,
+				ether_type, vlan, vlan_id);
 	else
 		initialize_eth_header(test_params->pkt_eth_hdr,
-				(struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0,
-				ipv4, vlan, vlan_id);
+				(struct rte_ether_addr *)src_mac,
+				(struct rte_ether_addr *)dst_mac_0,
+				ether_type, vlan, vlan_id);
 
 
 	if (toggle_udp_port)
@@ -1377,7 +1338,7 @@ test_roundrobin_tx_burst(void)
 
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_ROUND_ROBIN, 0, 2, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	burst_size = 20 * test_params->bonded_slave_count;
 
@@ -1425,7 +1386,6 @@ test_roundrobin_tx_burst(void)
 	return remove_slaves_and_stop_bonded_device();
 }
 
-#ifdef RTE_MBUF_REFCNT
 static int
 verify_mbufs_ref_count(struct rte_mbuf **mbufs, int nb_mbufs, int val)
 {
@@ -1439,8 +1399,6 @@ verify_mbufs_ref_count(struct rte_mbuf **mbufs, int nb_mbufs, int val)
 	}
 	return 0;
 }
-#endif
-
 
 static void
 free_mbufs(struct rte_mbuf **mbufs, int nb_mbufs)
@@ -1469,7 +1427,7 @@ test_roundrobin_tx_burst_slave_tx_fail(void)
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_ROUND_ROBIN, 0,
 			TEST_RR_SLAVE_TX_FAIL_SLAVE_COUNT, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	/* Generate test bursts of packets to transmit */
 	TEST_ASSERT_EQUAL(generate_test_burst(pkt_burst,
@@ -1545,12 +1503,10 @@ test_roundrobin_tx_burst_slave_tx_fail(void)
 				(unsigned int)port_stats.opackets, slave_expected_tx_count);
 	}
 
-#ifdef RTE_MBUF_REFCNT
 	/* Verify that all mbufs have a ref value of zero */
 	TEST_ASSERT_SUCCESS(verify_mbufs_ref_count(&pkt_burst[tx_count],
 			TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT, 1),
 			"mbufs refcnts not as expected");
-#endif
 	free_mbufs(&pkt_burst[tx_count], TEST_RR_SLAVE_TX_FAIL_PACKETS_COUNT);
 
 	/* Clean up and remove slaves from bonded device */
@@ -1624,9 +1580,6 @@ test_roundrobin_rx_burst_on_single_slave(void)
 
 	/* free mbufs */
 	for (i = 0; i < MAX_PKT_BURST; i++) {
-		if (gen_pkt_burst[i] != NULL)
-			rte_pktmbuf_free(gen_pkt_burst[i]);
-
 		if (rx_pkt_burst[i] != NULL)
 			rte_pktmbuf_free(rx_pkt_burst[i]);
 	}
@@ -1721,7 +1674,8 @@ test_roundrobin_rx_burst_on_multiple_slaves(void)
 static int
 test_roundrobin_verify_mac_assignment(void)
 {
-	struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_2;
+	struct rte_ether_addr read_mac_addr;
+	struct rte_ether_addr expected_mac_addr_0, expected_mac_addr_2;
 
 	int i;
 
@@ -1780,7 +1734,8 @@ test_roundrobin_verify_mac_assignment(void)
 
 	/* Set explicit MAC address */
 	TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-			test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
+			test_params->bonded_port_id,
+			(struct rte_ether_addr *)bonded_mac),
 			"Failed to set MAC");
 
 	rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
@@ -1855,7 +1810,7 @@ test_roundrobin_verify_slave_link_status_change_behaviour(void)
 	struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL };
 
 	struct rte_eth_stats port_stats;
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
 	int i, burst_size, slave_count;
 
@@ -1973,12 +1928,6 @@ test_roundrobin_verify_slave_link_status_change_behaviour(void)
 	for (i = 0; i < MAX_PKT_BURST; i++) {
 		if (rx_pkt_burst[i] != NULL)
 			rte_pktmbuf_free(rx_pkt_burst[i]);
-
-		if (gen_pkt_burst[1][i] != NULL)
-			rte_pktmbuf_free(gen_pkt_burst[1][i]);
-
-		if (gen_pkt_burst[3][i] != NULL)
-			rte_pktmbuf_free(gen_pkt_burst[1][i]);
 	}
 
 	/* Clean up and remove slaves from bonded device */
@@ -1995,7 +1944,8 @@ int polling_test_slaves[TEST_RR_POLLING_LINK_STATUS_SLAVE_COUNT] = { -1, -1 };
 static int
 test_roundrobin_verfiy_polling_slave_link_status_change(void)
 {
-	struct ether_addr *mac_addr = (struct ether_addr *)polling_slave_mac;
+	struct rte_ether_addr *mac_addr =
+		(struct rte_ether_addr *)polling_slave_mac;
 	char slave_name[RTE_ETH_NAME_MAX_LEN];
 
 	int i;
@@ -2094,7 +2044,9 @@ test_activebackup_tx_burst(void)
 			"Failed to initialize bonded device with slaves");
 
 	initialize_eth_header(test_params->pkt_eth_hdr,
-			(struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0, 1, 0, 0);
+			(struct rte_ether_addr *)src_mac,
+			(struct rte_ether_addr *)dst_mac_0,
+			ETHER_TYPE_IPv4,  0, 0);
 	pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port,
 			dst_port_0, 16);
 	pktlen = initialize_ipv4_header(test_params->pkt_ipv4_hdr, src_addr,
@@ -2300,7 +2252,8 @@ test_activebackup_verify_promiscuous_enable_disable(void)
 static int
 test_activebackup_verify_mac_assignment(void)
 {
-	struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
+	struct rte_ether_addr read_mac_addr;
+	struct rte_ether_addr expected_mac_addr_0, expected_mac_addr_1;
 
 	rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0);
 	rte_eth_macaddr_get(test_params->slave_port_ids[1], &expected_mac_addr_1);
@@ -2382,7 +2335,8 @@ test_activebackup_verify_mac_assignment(void)
 
 	/* Set explicit MAC address */
 	TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-			test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
+			test_params->bonded_port_id,
+			(struct rte_ether_addr *)bonded_mac),
 			"failed to set MAC address");
 
 	rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
@@ -2414,9 +2368,9 @@ test_activebackup_verify_slave_link_status_change_failover(void)
 	struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL };
 	struct rte_eth_stats port_stats;
 
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
-	int i, j, burst_size, slave_count, primary_port;
+	int i, burst_size, slave_count, primary_port;
 
 	burst_size = 21;
 
@@ -2549,16 +2503,6 @@ test_activebackup_verify_slave_link_status_change_failover(void)
 			"(%d) port_stats.opackets not as expected",
 			test_params->slave_port_ids[3]);
 
-	/* free mbufs */
-	for (i = 0; i < TEST_ACTIVE_BACKUP_RX_BURST_SLAVE_COUNT; i++) {
-		for (j = 0; j < MAX_PKT_BURST; j++) {
-			if (pkt_burst[i][j] != NULL) {
-				rte_pktmbuf_free(pkt_burst[i][j]);
-				pkt_burst[i][j] = NULL;
-			}
-		}
-	}
-
 	/* Clean up and remove slaves from bonded device */
 	return remove_slaves_and_stop_bonded_device();
 }
@@ -2637,7 +2581,9 @@ test_balance_l2_tx_burst(void)
 			"Failed to set balance xmit policy.");
 
 	initialize_eth_header(test_params->pkt_eth_hdr,
-			(struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0, 1, 0, 0);
+			(struct rte_ether_addr *)src_mac,
+			(struct rte_ether_addr *)dst_mac_0,
+			ETHER_TYPE_IPv4, 0, 0);
 	pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port,
 			dst_port_0, 16);
 	pktlen = initialize_ipv4_header(test_params->pkt_ipv4_hdr, src_addr,
@@ -2651,7 +2597,9 @@ test_balance_l2_tx_burst(void)
 			"failed to generate packet burst");
 
 	initialize_eth_header(test_params->pkt_eth_hdr,
-			(struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_1, 1, 0, 0);
+			(struct rte_ether_addr *)src_mac,
+			(struct rte_ether_addr *)dst_mac_1,
+			ETHER_TYPE_IPv4, 0, 0);
 
 	/* Generate a burst 2 of packets to transmit */
 	TEST_ASSERT_EQUAL(generate_packet_burst(test_params->mbuf_pool, &pkts_burst[1][0],
@@ -2789,7 +2737,7 @@ balance_l23_tx_burst(uint8_t vlan_enabled, uint8_t ipv4,
 static int
 test_balance_l23_tx_burst_ipv4_toggle_ip_addr(void)
 {
-	return balance_l23_tx_burst(0, 1, 1, 0);
+	return balance_l23_tx_burst(0, 1, 0, 1);
 }
 
 static int
@@ -2955,7 +2903,7 @@ test_balance_tx_burst_slave_tx_fail(void)
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BALANCE, 0,
 			TEST_BAL_SLAVE_TX_FAIL_SLAVE_COUNT, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set(
 			test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER2),
@@ -3056,12 +3004,10 @@ test_balance_tx_burst_slave_tx_fail(void)
 				(unsigned int)port_stats.opackets,
 				TEST_BAL_SLAVE_TX_FAIL_BURST_SIZE_2);
 
-#ifdef RTE_MBUF_REFCNT
 	/* Verify that all mbufs have a ref value of zero */
 	TEST_ASSERT_SUCCESS(verify_mbufs_ref_count(&pkts_burst_1[tx_count_1],
 			TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT, 1),
 			"mbufs refcnts not as expected");
-#endif
 
 	free_mbufs(&pkts_burst_1[tx_count_1],
 			TEST_BAL_SLAVE_TX_FAIL_PACKETS_COUNT);
@@ -3088,7 +3034,7 @@ test_balance_rx_burst(void)
 	/* Initialize bonded device with 4 slaves in round robin mode */
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BALANCE, 0, 3, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	/* Generate test bursts of packets to transmit */
 	for (i = 0; i < TEST_BALANCE_RX_BURST_SLAVE_COUNT; i++) {
@@ -3167,7 +3113,7 @@ test_balance_verify_promiscuous_enable_disable(void)
 	/* Initialize bonded device with 4 slaves in round robin mode */
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BALANCE, 0, 4, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	rte_eth_promiscuous_enable(test_params->bonded_port_id);
 
@@ -3202,7 +3148,8 @@ test_balance_verify_promiscuous_enable_disable(void)
 static int
 test_balance_verify_mac_assignment(void)
 {
-	struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
+	struct rte_ether_addr read_mac_addr;
+	struct rte_ether_addr expected_mac_addr_0, expected_mac_addr_1;
 
 	rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0);
 	rte_eth_macaddr_get(test_params->slave_port_ids[1], &expected_mac_addr_1);
@@ -3210,7 +3157,7 @@ test_balance_verify_mac_assignment(void)
 	/* Initialize bonded device with 2 slaves in active backup mode */
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BALANCE, 0, 2, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	/* Verify that bonded MACs is that of first slave and that the other slave
 	 * MAC hasn't been changed */
@@ -3284,7 +3231,8 @@ test_balance_verify_mac_assignment(void)
 
 	/* Set explicit MAC address */
 	TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-			test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
+			test_params->bonded_port_id,
+			(struct rte_ether_addr *)bonded_mac),
 			"failed to set MAC");
 
 	rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
@@ -3318,16 +3266,16 @@ test_balance_verify_slave_link_status_change_behaviour(void)
 	struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL };
 	struct rte_eth_stats port_stats;
 
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
-	int i, j, burst_size, slave_count;
+	int i, burst_size, slave_count;
 
 	memset(pkt_burst, 0, sizeof(pkt_burst));
 
 	/* Initialize bonded device with 4 slaves in round robin mode */
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BALANCE, 0, TEST_BALANCE_LINK_STATUS_SLAVE_COUNT, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	TEST_ASSERT_SUCCESS(rte_eth_bond_xmit_policy_set(
 			test_params->bonded_port_id, BALANCE_XMIT_POLICY_LAYER2),
@@ -3458,23 +3406,10 @@ test_balance_verify_slave_link_status_change_behaviour(void)
 			test_params->bonded_port_id, (int)port_stats.ipackets,
 			burst_size * 3);
 
-	/* free mbufs allocate for rx testing */
-	for (i = 0; i < TEST_BALANCE_RX_BURST_SLAVE_COUNT; i++) {
-		for (j = 0; j < MAX_PKT_BURST; j++) {
-			if (pkt_burst[i][j] != NULL) {
-				rte_pktmbuf_free(pkt_burst[i][j]);
-				pkt_burst[i][j] = NULL;
-			}
-		}
-	}
-
 	/* Clean up and remove slaves from bonded device */
 	return remove_slaves_and_stop_bonded_device();
 }
 
-#ifdef RTE_MBUF_REFCNT
-/** Broadcast Mode Tests */
-
 static int
 test_broadcast_tx_burst(void)
 {
@@ -3485,10 +3420,12 @@ test_broadcast_tx_burst(void)
 
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BROADCAST, 0, 2, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	initialize_eth_header(test_params->pkt_eth_hdr,
-			(struct ether_addr *)src_mac, (struct ether_addr *)dst_mac_0, 1, 0, 0);
+			(struct rte_ether_addr *)src_mac,
+			(struct rte_ether_addr *)dst_mac_0,
+			ETHER_TYPE_IPv4, 0, 0);
 
 	pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port,
 			dst_port_0, 16);
@@ -3565,7 +3502,7 @@ test_broadcast_tx_burst_slave_tx_fail(void)
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BROADCAST, 0,
 			TEST_BCAST_SLAVE_TX_FAIL_SLAVE_COUNT, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	/* Generate test bursts for transmission */
 	TEST_ASSERT_EQUAL(generate_test_burst(pkts_burst,
@@ -3683,7 +3620,7 @@ test_broadcast_rx_burst(void)
 	/* Initialize bonded device with 4 slaves in round robin mode */
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BROADCAST, 0, 3, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	/* Generate test bursts of packets to transmit */
 	for (i = 0; i < BROADCAST_RX_BURST_NUM_OF_SLAVES; i++) {
@@ -3762,7 +3699,7 @@ test_broadcast_verify_promiscuous_enable_disable(void)
 	/* Initialize bonded device with 4 slaves in round robin mode */
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BROADCAST, 0, 4, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	rte_eth_promiscuous_enable(test_params->bonded_port_id);
 
@@ -3798,7 +3735,8 @@ test_broadcast_verify_promiscuous_enable_disable(void)
 static int
 test_broadcast_verify_mac_assignment(void)
 {
-	struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
+	struct rte_ether_addr read_mac_addr;
+	struct rte_ether_addr expected_mac_addr_0, expected_mac_addr_1;
 
 	int i;
 
@@ -3808,7 +3746,7 @@ test_broadcast_verify_mac_assignment(void)
 	/* Initialize bonded device with 4 slaves in round robin mode */
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 			BONDING_MODE_BROADCAST, 0, 4, 1),
-			"Failed to intialise bonded device");
+			"Failed to initialise bonded device");
 
 	/* Verify that all MACs are the same as first slave added to bonded
 	 * device */
@@ -3859,7 +3797,8 @@ test_broadcast_verify_mac_assignment(void)
 
 	/* Set explicit MAC address */
 	TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-			test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
+			test_params->bonded_port_id,
+			(struct rte_ether_addr *)bonded_mac),
 			"Failed to set MAC address");
 
 	rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
@@ -3889,16 +3828,16 @@ test_broadcast_verify_slave_link_status_change_behaviour(void)
 	struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL };
 	struct rte_eth_stats port_stats;
 
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
-	int i, j, burst_size, slave_count;
+	int i, burst_size, slave_count;
 
 	memset(pkt_burst, 0, sizeof(pkt_burst));
 
 	/* Initialize bonded device with 4 slaves in round robin mode */
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
 				BONDING_MODE_BROADCAST, 0, BROADCAST_LINK_STATUS_NUM_OF_SLAVES,
-				1), "Failed to intialise bonded device");
+				1), "Failed to initialise bonded device");
 
 	/* Verify Current Slaves Count /Active Slave Count is */
 	slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id, slaves,
@@ -3988,20 +3927,9 @@ test_broadcast_verify_slave_link_status_change_behaviour(void)
 			"(%d) port_stats.ipackets not as expected\n",
 			test_params->bonded_port_id);
 
-	/* free mbufs allocate for rx testing */
-	for (i = 0; i < BROADCAST_LINK_STATUS_NUM_OF_SLAVES; i++) {
-		for (j = 0; j < MAX_PKT_BURST; j++) {
-			if (pkt_burst[i][j] != NULL) {
-				rte_pktmbuf_free(pkt_burst[i][j]);
-				pkt_burst[i][j] = NULL;
-			}
-		}
-	}
-
 	/* Clean up and remove slaves from bonded device */
 	return remove_slaves_and_stop_bonded_device();
 }
-#endif
 
 static int
 test_reconfigure_bonded_device(void)
@@ -4029,16 +3957,31 @@ test_close_bonded_device(void)
 	return 0;
 }
 
-static int
+static void
 testsuite_teardown(void)
 {
-	if (test_params->pkt_eth_hdr != NULL) {
-		free(test_params->pkt_eth_hdr);
-		test_params->pkt_eth_hdr = NULL;
-	}
+	free(test_params->pkt_eth_hdr);
+	test_params->pkt_eth_hdr = NULL;
 
 	/* Clean up and remove slaves from bonded device */
-	return remove_slaves_and_stop_bonded_device();
+	remove_slaves_and_stop_bonded_device();
+}
+
+static void
+free_virtualpmd_tx_queue(void)
+{
+	int i, slave_port, to_free_cnt;
+	struct rte_mbuf *pkts_to_free[MAX_PKT_BURST];
+
+	/* Free tx queue of virtual pmd */
+	for (slave_port = 0; slave_port < test_params->bonded_slave_count;
+			slave_port++) {
+		to_free_cnt = virtual_ethdev_get_mbufs_from_tx_queue(
+				test_params->slave_port_ids[slave_port],
+				pkts_to_free, MAX_PKT_BURST);
+		for (i = 0; i < to_free_cnt; i++)
+			rte_pktmbuf_free(pkts_to_free[i]);
+	}
 }
 
 static int
@@ -4050,7 +3993,6 @@ test_tlb_tx_burst(void)
 	struct rte_eth_stats port_stats[32];
 	uint64_t sum_ports_opackets = 0, all_bond_opackets = 0, all_bond_obytes = 0;
 	uint16_t pktlen;
-	uint64_t floor_obytes = 0, ceiling_obytes = 0;
 
 	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves
 			(BONDING_MODE_TLB, 1, 3, 1),
@@ -4062,17 +4004,19 @@ test_tlb_tx_burst(void)
 			"Burst size specified is greater than supported.\n");
 
 
-	/* Generate 400000 test bursts in 2s of packets to transmit  */
+	/* Generate bursts of packets */
 	for (i = 0; i < 400000; i++) {
 		/*test two types of mac src own(bonding) and others */
 		if (i % 2 == 0) {
 			initialize_eth_header(test_params->pkt_eth_hdr,
-					(struct ether_addr *)src_mac,
-					(struct ether_addr *)dst_mac_0, 1, 0, 0);
+					(struct rte_ether_addr *)src_mac,
+					(struct rte_ether_addr *)dst_mac_0,
+					ETHER_TYPE_IPv4, 0, 0);
 		} else {
 			initialize_eth_header(test_params->pkt_eth_hdr,
-					(struct ether_addr *)test_params->default_slave_mac,
-					(struct ether_addr *)dst_mac_0, 1, 0, 0);
+					(struct rte_ether_addr *)test_params->default_slave_mac,
+					(struct rte_ether_addr *)dst_mac_0,
+					ETHER_TYPE_IPv4, 0, 0);
 		}
 		pktlen = initialize_udp_header(test_params->pkt_udp_hdr, src_port,
 				dst_port_0, 16);
@@ -4086,6 +4030,8 @@ test_tlb_tx_burst(void)
 				burst_size);
 		nb_tx2 += nb_tx;
 
+		free_virtualpmd_tx_queue();
+
 		TEST_ASSERT_EQUAL(nb_tx, burst_size,
 				"number of packet not equal burst size");
 
@@ -4113,15 +4059,14 @@ test_tlb_tx_burst(void)
 
 	TEST_ASSERT_EQUAL(sum_ports_opackets, (uint64_t)all_bond_opackets,
 			"Total packets sent by slaves is not equal to packets sent by bond interface");
-	/* distribution of packets on each slave within +/- 10% of the expected value. */
-	for (i = 0; i < test_params->bonded_slave_count; i++) {
 
-		floor_obytes = (all_bond_obytes*90)/(test_params->bonded_slave_count*100);
-		ceiling_obytes = (all_bond_obytes*110)/(test_params->bonded_slave_count*100);
-		TEST_ASSERT(port_stats[i].obytes >= floor_obytes &&
-				port_stats[i].obytes <= ceiling_obytes,
-						"Distribution is not even");
+	/* checking if distribution of packets is balanced over slaves */
+	for (i = 0; i < test_params->bonded_slave_count; i++) {
+		TEST_ASSERT(port_stats[i].obytes > 0 &&
+				port_stats[i].obytes < all_bond_obytes,
+						"Packets are not balanced over slaves");
 	}
+
 	/* Put all slaves down and try and transmit */
 	for (i = 0; i < test_params->bonded_slave_count; i++) {
 		virtual_ethdev_simulate_link_status_interrupt(
@@ -4282,7 +4227,8 @@ test_tlb_verify_promiscuous_enable_disable(void)
 static int
 test_tlb_verify_mac_assignment(void)
 {
-	struct ether_addr read_mac_addr, expected_mac_addr_0, expected_mac_addr_1;
+	struct rte_ether_addr read_mac_addr;
+	struct rte_ether_addr expected_mac_addr_0, expected_mac_addr_1;
 
 	rte_eth_macaddr_get(test_params->slave_port_ids[0], &expected_mac_addr_0);
 	rte_eth_macaddr_get(test_params->slave_port_ids[1], &expected_mac_addr_1);
@@ -4365,8 +4311,9 @@ test_tlb_verify_mac_assignment(void)
 
 	/* Set explicit MAC address */
 	TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
-			test_params->bonded_port_id, (struct ether_addr *)bonded_mac),
-			"failed to set MAC addres");
+			test_params->bonded_port_id,
+			(struct rte_ether_addr *)bonded_mac),
+			"failed to set MAC address");
 
 	rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
 	TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr,
@@ -4397,9 +4344,9 @@ test_tlb_verify_slave_link_status_change_failover(void)
 	struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL };
 	struct rte_eth_stats port_stats;
 
-	uint8_t slaves[RTE_MAX_ETHPORTS];
+	uint16_t slaves[RTE_MAX_ETHPORTS];
 
-	int i, j, burst_size, slave_count, primary_port;
+	int i, burst_size, slave_count, primary_port;
 
 	burst_size = 21;
 
@@ -4474,14 +4421,13 @@ test_tlb_verify_slave_link_status_change_failover(void)
 
 	rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats);
 	TEST_ASSERT_EQUAL(port_stats.opackets, (int8_t)0,
-				"(%d) port_stats.opackets not as expected\n",
-				test_params->slave_port_ids[0]);
+			"(%d) port_stats.opackets not as expected\n",
+			test_params->slave_port_ids[0]);
 
 	rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats);
 	TEST_ASSERT_NOT_EQUAL(port_stats.opackets, (int8_t)0,
-					"(%d) port_stats.opackets not as expected\n",
-					test_params->slave_port_ids[1]);
-
+			"(%d) port_stats.opackets not as expected\n",
+			test_params->slave_port_ids[1]);
 
 	rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats);
 	TEST_ASSERT_NOT_EQUAL(port_stats.opackets, (int8_t)0,
@@ -4518,22 +4464,408 @@ test_tlb_verify_slave_link_status_change_failover(void)
 			"(%d) port_stats.ipackets not as expected\n",
 			test_params->bonded_port_id);
 
-	/* free mbufs */
+	/* Clean up and remove slaves from bonded device */
+	return remove_slaves_and_stop_bonded_device();
+}
 
-	for (i = 0; i < TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT; i++) {
-		for (j = 0; j < MAX_PKT_BURST; j++) {
-			if (pkt_burst[i][j] != NULL) {
-				rte_pktmbuf_free(pkt_burst[i][j]);
-				pkt_burst[i][j] = NULL;
+#define TEST_ALB_SLAVE_COUNT	2
+
+static uint8_t mac_client1[] = {0x00, 0xAA, 0x55, 0xFF, 0xCC, 1};
+static uint8_t mac_client2[] = {0x00, 0xAA, 0x55, 0xFF, 0xCC, 2};
+static uint8_t mac_client3[] = {0x00, 0xAA, 0x55, 0xFF, 0xCC, 3};
+static uint8_t mac_client4[] = {0x00, 0xAA, 0x55, 0xFF, 0xCC, 4};
+
+static uint32_t ip_host = IPV4_ADDR(192, 168, 0, 0);
+static uint32_t ip_client1 = IPV4_ADDR(192, 168, 0, 1);
+static uint32_t ip_client2 = IPV4_ADDR(192, 168, 0, 2);
+static uint32_t ip_client3 = IPV4_ADDR(192, 168, 0, 3);
+static uint32_t ip_client4 = IPV4_ADDR(192, 168, 0, 4);
+
+static int
+test_alb_change_mac_in_reply_sent(void)
+{
+	struct rte_mbuf *pkt;
+	struct rte_mbuf *pkts_sent[MAX_PKT_BURST];
+
+	struct rte_ether_hdr *eth_pkt;
+	struct rte_arp_hdr *arp_pkt;
+
+	int slave_idx, nb_pkts, pkt_idx;
+	int retval = 0;
+
+	struct rte_ether_addr bond_mac, client_mac;
+	struct rte_ether_addr *slave_mac1, *slave_mac2;
+
+	TEST_ASSERT_SUCCESS(
+			initialize_bonded_device_with_slaves(BONDING_MODE_ALB,
+					0, TEST_ALB_SLAVE_COUNT, 1),
+			"Failed to initialize_bonded_device_with_slaves.");
+
+	/* Flush tx queue */
+	rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0);
+	for (slave_idx = 0; slave_idx < test_params->bonded_slave_count;
+			slave_idx++) {
+		nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue(
+				test_params->slave_port_ids[slave_idx], pkts_sent,
+				MAX_PKT_BURST);
+	}
+
+	rte_ether_addr_copy(
+			rte_eth_devices[test_params->bonded_port_id].data->mac_addrs,
+			&bond_mac);
+
+	/*
+	 * Generating four packets with different mac and ip addresses and sending
+	 * them through the bonding port.
+	 */
+	pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
+	memcpy(client_mac.addr_bytes, mac_client1, ETHER_ADDR_LEN);
+	eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
+			0);
+	arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+					sizeof(struct rte_ether_hdr));
+	initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client1,
+			RTE_ARP_OP_REPLY);
+	rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1);
+
+	pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
+	memcpy(client_mac.addr_bytes, mac_client2, ETHER_ADDR_LEN);
+	eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
+			0);
+	arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+					sizeof(struct rte_ether_hdr));
+	initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client2,
+			RTE_ARP_OP_REPLY);
+	rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1);
+
+	pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
+	memcpy(client_mac.addr_bytes, mac_client3, ETHER_ADDR_LEN);
+	eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
+			0);
+	arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+					sizeof(struct rte_ether_hdr));
+	initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client3,
+			RTE_ARP_OP_REPLY);
+	rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1);
+
+	pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
+	memcpy(client_mac.addr_bytes, mac_client4, ETHER_ADDR_LEN);
+	eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
+			0);
+	arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+					sizeof(struct rte_ether_hdr));
+	initialize_arp_header(arp_pkt, &bond_mac, &client_mac, ip_host, ip_client4,
+			RTE_ARP_OP_REPLY);
+	rte_eth_tx_burst(test_params->bonded_port_id, 0, &pkt, 1);
+
+	slave_mac1 =
+			rte_eth_devices[test_params->slave_port_ids[0]].data->mac_addrs;
+	slave_mac2 =
+			rte_eth_devices[test_params->slave_port_ids[1]].data->mac_addrs;
+
+	/*
+	 * Checking if packets are properly distributed on bonding ports. Packets
+	 * 0 and 2 should be sent on port 0 and packets 1 and 3 on port 1.
+	 */
+	for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) {
+		nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue(
+				test_params->slave_port_ids[slave_idx], pkts_sent,
+				MAX_PKT_BURST);
+
+		for (pkt_idx = 0; pkt_idx < nb_pkts; pkt_idx++) {
+			eth_pkt = rte_pktmbuf_mtod(
+				pkts_sent[pkt_idx], struct rte_ether_hdr *);
+			arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+						sizeof(struct rte_ether_hdr));
+
+			if (slave_idx%2 == 0) {
+				if (!rte_is_same_ether_addr(slave_mac1,
+						&arp_pkt->arp_data.arp_sha)) {
+					retval = -1;
+					goto test_end;
+				}
+			} else {
+				if (!rte_is_same_ether_addr(slave_mac2,
+						&arp_pkt->arp_data.arp_sha)) {
+					retval = -1;
+					goto test_end;
+				}
 			}
 		}
 	}
 
+test_end:
+	retval += remove_slaves_and_stop_bonded_device();
+	return retval;
+}
 
-	/* Clean up and remove slaves from bonded device */
-	return remove_slaves_and_stop_bonded_device();
+static int
+test_alb_reply_from_client(void)
+{
+	struct rte_ether_hdr *eth_pkt;
+	struct rte_arp_hdr *arp_pkt;
+
+	struct rte_mbuf *pkt;
+	struct rte_mbuf *pkts_sent[MAX_PKT_BURST];
+
+	int slave_idx, nb_pkts, pkt_idx, nb_pkts_sum = 0;
+	int retval = 0;
+
+	struct rte_ether_addr bond_mac, client_mac;
+	struct rte_ether_addr *slave_mac1, *slave_mac2;
+
+	TEST_ASSERT_SUCCESS(
+			initialize_bonded_device_with_slaves(BONDING_MODE_ALB,
+					0, TEST_ALB_SLAVE_COUNT, 1),
+			"Failed to initialize_bonded_device_with_slaves.");
+
+	/* Flush tx queue */
+	rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0);
+	for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) {
+		nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue(
+				test_params->slave_port_ids[slave_idx], pkts_sent,
+				MAX_PKT_BURST);
+	}
+
+	rte_ether_addr_copy(
+			rte_eth_devices[test_params->bonded_port_id].data->mac_addrs,
+			&bond_mac);
+
+	/*
+	 * Generating four packets with different mac and ip addresses and placing
+	 * them in the rx queue to be received by the bonding driver on rx_burst.
+	 */
+	pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
+	memcpy(client_mac.addr_bytes, mac_client1, ETHER_ADDR_LEN);
+	eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
+			0);
+	arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+					sizeof(struct rte_ether_hdr));
+	initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client1, ip_host,
+			RTE_ARP_OP_REPLY);
+	virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt,
+			1);
+
+	pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
+	memcpy(client_mac.addr_bytes, mac_client2, ETHER_ADDR_LEN);
+	eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
+			0);
+	arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+					sizeof(struct rte_ether_hdr));
+	initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client2, ip_host,
+			RTE_ARP_OP_REPLY);
+	virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt,
+			1);
+
+	pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
+	memcpy(client_mac.addr_bytes, mac_client3, ETHER_ADDR_LEN);
+	eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
+			0);
+	arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+					sizeof(struct rte_ether_hdr));
+	initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client3, ip_host,
+			RTE_ARP_OP_REPLY);
+	virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt,
+			1);
+
+	pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
+	memcpy(client_mac.addr_bytes, mac_client4, ETHER_ADDR_LEN);
+	eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_ARP, 0,
+			0);
+	arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+					sizeof(struct rte_ether_hdr));
+	initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client4, ip_host,
+			RTE_ARP_OP_REPLY);
+	virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt,
+			1);
+
+	/*
+	 * Issue rx_burst and tx_burst to force bonding driver to send update ARP
+	 * packets to every client in alb table.
+	 */
+	rte_eth_rx_burst(test_params->bonded_port_id, 0, pkts_sent, MAX_PKT_BURST);
+	rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0);
+
+	slave_mac1 = rte_eth_devices[test_params->slave_port_ids[0]].data->mac_addrs;
+	slave_mac2 = rte_eth_devices[test_params->slave_port_ids[1]].data->mac_addrs;
+
+	/*
+	 * Checking if update ARP packets were properly send on slave ports.
+	 */
+	for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) {
+		nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue(
+				test_params->slave_port_ids[slave_idx], pkts_sent, MAX_PKT_BURST);
+		nb_pkts_sum += nb_pkts;
+
+		for (pkt_idx = 0; pkt_idx < nb_pkts; pkt_idx++) {
+			eth_pkt = rte_pktmbuf_mtod(
+				pkts_sent[pkt_idx], struct rte_ether_hdr *);
+			arp_pkt = (struct rte_arp_hdr *)((char *)eth_pkt +
+						sizeof(struct rte_ether_hdr));
+
+			if (slave_idx%2 == 0) {
+				if (!rte_is_same_ether_addr(slave_mac1,
+						&arp_pkt->arp_data.arp_sha)) {
+					retval = -1;
+					goto test_end;
+				}
+			} else {
+				if (!rte_is_same_ether_addr(slave_mac2,
+						&arp_pkt->arp_data.arp_sha)) {
+					retval = -1;
+					goto test_end;
+				}
+			}
+		}
+	}
+
+	/* Check if proper number of packets was send */
+	if (nb_pkts_sum < 4) {
+		retval = -1;
+		goto test_end;
+	}
+
+test_end:
+	retval += remove_slaves_and_stop_bonded_device();
+	return retval;
 }
 
+static int
+test_alb_receive_vlan_reply(void)
+{
+	struct rte_ether_hdr *eth_pkt;
+	struct rte_vlan_hdr *vlan_pkt;
+	struct rte_arp_hdr *arp_pkt;
+
+	struct rte_mbuf *pkt;
+	struct rte_mbuf *pkts_sent[MAX_PKT_BURST];
+
+	int slave_idx, nb_pkts, pkt_idx;
+	int retval = 0;
+
+	struct rte_ether_addr bond_mac, client_mac;
+
+	TEST_ASSERT_SUCCESS(
+			initialize_bonded_device_with_slaves(BONDING_MODE_ALB,
+					0, TEST_ALB_SLAVE_COUNT, 1),
+			"Failed to initialize_bonded_device_with_slaves.");
+
+	/* Flush tx queue */
+	rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0);
+	for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) {
+		nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue(
+				test_params->slave_port_ids[slave_idx], pkts_sent,
+				MAX_PKT_BURST);
+	}
+
+	rte_ether_addr_copy(
+			rte_eth_devices[test_params->bonded_port_id].data->mac_addrs,
+			&bond_mac);
+
+	/*
+	 * Generating packet with double VLAN header and placing it in the rx queue.
+	 */
+	pkt = rte_pktmbuf_alloc(test_params->mbuf_pool);
+	memcpy(client_mac.addr_bytes, mac_client1, ETHER_ADDR_LEN);
+	eth_pkt = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	initialize_eth_header(eth_pkt, &bond_mac, &client_mac, ETHER_TYPE_VLAN, 0,
+			0);
+	vlan_pkt = (struct rte_vlan_hdr *)((char *)(eth_pkt + 1));
+	vlan_pkt->vlan_tci = rte_cpu_to_be_16(1);
+	vlan_pkt->eth_proto = rte_cpu_to_be_16(ETHER_TYPE_VLAN);
+	vlan_pkt = vlan_pkt+1;
+	vlan_pkt->vlan_tci = rte_cpu_to_be_16(2);
+	vlan_pkt->eth_proto = rte_cpu_to_be_16(ETHER_TYPE_ARP);
+	arp_pkt = (struct rte_arp_hdr *)((char *)(vlan_pkt + 1));
+	initialize_arp_header(arp_pkt, &client_mac, &bond_mac, ip_client1, ip_host,
+			RTE_ARP_OP_REPLY);
+	virtual_ethdev_add_mbufs_to_rx_queue(test_params->slave_port_ids[0], &pkt,
+			1);
+
+	rte_eth_rx_burst(test_params->bonded_port_id, 0, pkts_sent, MAX_PKT_BURST);
+	rte_eth_tx_burst(test_params->bonded_port_id, 0, NULL, 0);
+
+	/*
+	 * Checking if VLAN headers in generated ARP Update packet are correct.
+	 */
+	for (slave_idx = 0; slave_idx < test_params->bonded_slave_count; slave_idx++) {
+		nb_pkts = virtual_ethdev_get_mbufs_from_tx_queue(
+				test_params->slave_port_ids[slave_idx], pkts_sent,
+				MAX_PKT_BURST);
+
+		for (pkt_idx = 0; pkt_idx < nb_pkts; pkt_idx++) {
+			eth_pkt = rte_pktmbuf_mtod(
+				pkts_sent[pkt_idx], struct rte_ether_hdr *);
+			vlan_pkt = (struct rte_vlan_hdr *)(
+				(char *)(eth_pkt + 1));
+			if (vlan_pkt->vlan_tci != rte_cpu_to_be_16(1)) {
+				retval = -1;
+				goto test_end;
+			}
+			if (vlan_pkt->eth_proto != rte_cpu_to_be_16(ETHER_TYPE_VLAN)) {
+				retval = -1;
+				goto test_end;
+			}
+			vlan_pkt = vlan_pkt+1;
+			if (vlan_pkt->vlan_tci != rte_cpu_to_be_16(2)) {
+				retval = -1;
+				goto test_end;
+			}
+			if (vlan_pkt->eth_proto != rte_cpu_to_be_16(ETHER_TYPE_ARP)) {
+				retval = -1;
+				goto test_end;
+			}
+		}
+	}
+
+test_end:
+	retval += remove_slaves_and_stop_bonded_device();
+	return retval;
+}
+
+static int
+test_alb_ipv4_tx(void)
+{
+	int burst_size, retval, pkts_send;
+	struct rte_mbuf *pkt_burst[MAX_PKT_BURST];
+
+	retval = 0;
+
+	TEST_ASSERT_SUCCESS(
+			initialize_bonded_device_with_slaves(BONDING_MODE_ALB,
+					0, TEST_ALB_SLAVE_COUNT, 1),
+			"Failed to initialize_bonded_device_with_slaves.");
+
+	burst_size = 32;
+
+	/* Generate test bursts of packets to transmit */
+	if (generate_test_burst(pkt_burst, burst_size, 0, 1, 0, 0, 0) != burst_size) {
+		retval = -1;
+		goto test_end;
+	}
+
+	/*
+	 * Checking if ipv4 traffic is transmitted via TLB policy.
+	 */
+	pkts_send = rte_eth_tx_burst(
+			test_params->bonded_port_id, 0, pkt_burst, burst_size);
+	if (pkts_send != burst_size) {
+		retval = -1;
+		goto test_end;
+	}
+
+test_end:
+	retval += remove_slaves_and_stop_bonded_device();
+	return retval;
+}
 
 static struct unit_test_suite link_bonding_test_suite  = {
 	.suite_name = "Link Bonding Unit Test Suite",
@@ -4593,18 +4925,20 @@ static struct unit_test_suite link_bonding_test_suite  = {
 		TEST_CASE(test_tlb_verify_mac_assignment),
 		TEST_CASE(test_tlb_verify_promiscuous_enable_disable),
 		TEST_CASE(test_tlb_verify_slave_link_status_change_failover),
-#ifdef RTE_MBUF_REFCNT
+		TEST_CASE(test_alb_change_mac_in_reply_sent),
+		TEST_CASE(test_alb_reply_from_client),
+		TEST_CASE(test_alb_receive_vlan_reply),
+		TEST_CASE(test_alb_ipv4_tx),
 		TEST_CASE(test_broadcast_tx_burst),
 		TEST_CASE(test_broadcast_tx_burst_slave_tx_fail),
 		TEST_CASE(test_broadcast_rx_burst),
 		TEST_CASE(test_broadcast_verify_promiscuous_enable_disable),
 		TEST_CASE(test_broadcast_verify_mac_assignment),
 		TEST_CASE(test_broadcast_verify_slave_link_status_change_behaviour),
-#endif
 		TEST_CASE(test_reconfigure_bonded_device),
 		TEST_CASE(test_close_bonded_device),
 
-		{ NULL, NULL, NULL, NULL, NULL } /**< NULL terminate unit test array */
+		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
 
@@ -4615,8 +4949,4 @@ test_link_bonding(void)
 	return unit_test_suite_runner(&link_bonding_test_suite);
 }
 
-static struct test_command link_bonding_cmd = {
-	.command = "link_bonding_autotest",
-	.callback = test_link_bonding,
-};
-REGISTER_TEST_COMMAND(link_bonding_cmd);
+REGISTER_TEST_COMMAND(link_bonding_autotest, test_link_bonding);