[PACKET_IO]add gtest case

src/packet_io/pcap_file_mode/pio_pcap_file.cpp

@@ -302,11 +302,13 @@ ssize_t pio_pcap_file_device_close(struct packet_io_device *pdev)
     }
 
     if (pdev->entity.pcap_file_dev_ctx != nullptr) {
-        if (pdev->entity.pcap_file_dev_ctx->entity.file != nullptr) {
+        if (!pdev->entity.pcap_file_dev_ctx->is_dir && 
+            pdev->entity.pcap_file_dev_ctx->entity.file != nullptr) {
             cleanup_pcap_plain_file_info(pdev->entity.pcap_file_dev_ctx->entity.file);
         }
 
-        if (pdev->entity.pcap_file_dev_ctx->entity.dir != nullptr) {
+        if (pdev->entity.pcap_file_dev_ctx->is_dir && 
+            pdev->entity.pcap_file_dev_ctx->entity.dir != nullptr) {
             cleanup_pcap_directory_info(pdev->entity.pcap_file_dev_ctx->entity.dir);
         }
 
@@ -315,9 +317,9 @@ ssize_t pio_pcap_file_device_close(struct packet_io_device *pdev)
                 release_pio_packet_queue(&pdev->entity.pcap_file_dev_ctx->pkt_queues[i]);
             }
         }
-    }
 
-    FREE(pdev->entity.pcap_file_dev_ctx);
+        FREE(pdev->entity.pcap_file_dev_ctx);
+    }
 
     return 0;
 }

src/packet_io/pcap_live_mode/pio_pcap_live.cpp

@@ -144,13 +144,15 @@ ssize_t pio_pcap_live_device_close(struct packet_io_device *pdev)
         return -1;
     }
 
-    for (uint32_t i = 0; i < VIRTUAL_QUEUE_MAX_NUM; i++) {
-        if (pdev->entity.pcap_live_dev_ctx->pkt_queues[i].len != 0) {
-            release_pio_packet_queue(&pdev->entity.pcap_live_dev_ctx->pkt_queues[i]);
+    if (pdev->entity.pcap_live_dev_ctx != nullptr) {
+        for (uint32_t i = 0; i < VIRTUAL_QUEUE_MAX_NUM; i++) {
+            if (pdev->entity.pcap_live_dev_ctx->pkt_queues[i].len != 0) {
+                release_pio_packet_queue(&pdev->entity.pcap_live_dev_ctx->pkt_queues[i]);
+            }
         }
-    }
 
-    FREE(pdev->entity.pcap_live_dev_ctx);
+        FREE(pdev->entity.pcap_live_dev_ctx);
+    }
 
     return 0;
 }
@@ -252,9 +254,9 @@ ssize_t pio_pcap_live_device_send(struct packet_io_device *pdev, uint32_t txq_id
     for (size_t i = 0; i < nr_pkts; i++) {
         struct pio_packet *p = (struct pio_packet *)pkts[i];
         res = pcap_sendpacket(plive_dev_ctx->pcap_handle, (u_char *)p->pkt_payload, p->pkt_len);
+        FREE(pkts[i]);
     }
     pthread_mutex_unlock(&plive_dev_ctx->handle_mutex);
-    /*TODO: when to free pio_packet? */
 
     return 0;
 }

src/packet_io/test/CMakeLists.txt

@@ -13,4 +13,4 @@ target_link_libraries(
 
 include(GoogleTest)
 gtest_discover_tests(gtest_packet_io)
-file(COPY test-64.pcapng DESTINATION ./)
+file(COPY pcap_sample DESTINATION ./)

src/packet_io/test/gtest_packet_io.cpp

@@ -4,60 +4,130 @@
 #include "packet.h"
 #include "packet_io.h"
 #include "packet_io_util.h"
+#include "packet_io_internal.h"
+#include "../pcap_file_mode/pio_pcap_file.h"
+#include "../pcap_live_mode/pio_pcap_live.h"
 
 TEST(PACKET_IO_Test, packet_io_instance_create_and_destroy) {
 	struct packet_io_instance *ppio_inst = packet_io_instance_create(nullptr, PACKET_IO_RUN_MODE_PCAP_FILE);
 	EXPECT_EQ(ppio_inst, nullptr);
+
 	ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_MAX);
   	EXPECT_EQ(ppio_inst, nullptr);
+
 	ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
 	EXPECT_NE(ppio_inst, nullptr);
+
 	packet_io_fini(ppio_inst);
 }
 
 TEST(PACKET_IO_Test, packet_io_device_open_and_close) {
 	struct packet_io_device *pdev = packet_io_device_open(nullptr, nullptr, 1, 1);
 	EXPECT_EQ(pdev, nullptr);
+
 	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_LIVE);
 	EXPECT_NE(ppio_inst, nullptr);
+
 	pdev = packet_io_device_open(ppio_inst, nullptr, 1, 1);
   	EXPECT_EQ(pdev, nullptr);
+
 	pdev = packet_io_device_open(ppio_inst, "tun0", 1, 1);
 	EXPECT_NE(pdev, nullptr);
+
 	packet_io_device_close(pdev);
 	packet_io_fini(ppio_inst);
 }
 
-TEST(PACKET_IO_Test, packet_io_device_rx) {
+/* case1: read 1 pkt and read 63 pkts */
+TEST(PACKET_IO_Test, packet_io_device_rx1) {
 	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
-	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./test-64.pcapng", 1, 1);
+	EXPECT_NE(ppio_inst, nullptr);
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 1, 1);
 	EXPECT_NE(pdev, nullptr);
+
 	struct stellar_packet *rx_pkts[64];
 	ssize_t fetch_num = packet_io_device_rx(pdev, 0, rx_pkts, 1);
 	EXPECT_EQ(fetch_num, 1);
+
+	fetch_num = packet_io_device_rx(pdev, 0, rx_pkts, 63);
+	EXPECT_EQ(fetch_num, 63);
+
+	packet_io_device_close(pdev);
+	packet_io_fini(ppio_inst);
+}
+
+/* case2: read 64 pkts */
+TEST(PACKET_IO_Test, packet_io_device_rx2) {
+	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
+	EXPECT_NE(ppio_inst, nullptr);
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 1, 1);
+	EXPECT_NE(pdev, nullptr);
+
+	struct stellar_packet *rx_pkts[64];
+	ssize_t fetch_num = packet_io_device_rx(pdev, 0, rx_pkts, 64);
+	EXPECT_EQ(fetch_num, 64);
+
+	fetch_num = packet_io_device_rx(pdev, 0, rx_pkts, 1);
+	EXPECT_EQ(fetch_num, 0);
+
+	packet_io_device_close(pdev);
+	packet_io_fini(ppio_inst);
+}
+
+/* case3: read 64 pkts with multi queue */
+TEST(PACKET_IO_Test, packet_io_device_rx3) {
+	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
+	EXPECT_NE(ppio_inst, nullptr);
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 3, 3);
+	EXPECT_NE(pdev, nullptr);
+
+	struct stellar_packet *rx_pkts[64];
+	ssize_t fetch_num1 = packet_io_device_rx(pdev, 0, rx_pkts, 64);
+	ssize_t fetch_num2 = packet_io_device_rx(pdev, 1, rx_pkts, 64);
+	ssize_t fetch_num3 = packet_io_device_rx(pdev, 2, rx_pkts, 64);
+	ssize_t fetch_num = fetch_num1 + fetch_num2 + fetch_num3;
+	EXPECT_EQ(fetch_num, 64);
+
 	packet_io_device_close(pdev);
 	packet_io_fini(ppio_inst);
 }
 
 TEST(PACKET_IO_Test, packet_io_device_tx) {
-	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_LIVE);
-	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "tun0", 1, 1);
-	EXPECT_NE(pdev, nullptr);
+	struct packet_io_instance *ppio_inst_file = packet_io_instance_create("stellar_file", PACKET_IO_RUN_MODE_PCAP_FILE);
+	EXPECT_NE(ppio_inst_file, nullptr);
+	struct packet_io_instance *ppio_inst_live = packet_io_instance_create("stellar_live", PACKET_IO_RUN_MODE_PCAP_LIVE);
+	EXPECT_NE(ppio_inst_live, nullptr);
+	struct packet_io_device *pdev_file = packet_io_device_open(ppio_inst_file, "./pcap_sample/test03-64.pcapng", 1, 1);
+	EXPECT_NE(pdev_file, nullptr);
+	struct packet_io_device *pdev_live = packet_io_device_open(ppio_inst_live, "tun0", 1, 1);
+	EXPECT_NE(pdev_live, nullptr);
+
 	struct stellar_packet *rx_pkts[64];
-	/*
-	ssize_t send_num = packet_io_device_tx(pdev, 0, rx_pkts, 1);
-	EXPECT_EQ(send_num, 0);*/
-	packet_io_device_close(pdev);
-	packet_io_fini(ppio_inst);
+	ssize_t pkt_num = packet_io_device_rx(pdev_file, 0, rx_pkts, 64);
+	EXPECT_EQ(pkt_num, 64);
+
+	ssize_t res = packet_io_device_tx(pdev_live, 0, rx_pkts, 1);
+	EXPECT_EQ(res, 0);
+
+	res = packet_io_device_tx(pdev_live, 0, rx_pkts + 1, 63);
+	EXPECT_EQ(res, 0);
+	
+	packet_io_device_close(pdev_file);
+	packet_io_device_close(pdev_live);
+	packet_io_fini(ppio_inst_file);
+	packet_io_fini(ppio_inst_live);
 }
 
 TEST(PACKET_IO_Test, packet_io_pkts_free) {
 	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
-	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./test-64.pcapng", 1, 1);
+	EXPECT_NE(ppio_inst, nullptr);
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 1, 1);
 	EXPECT_NE(pdev, nullptr);
+
 	struct stellar_packet *rx_pkts[64];
 	ssize_t fetch_num = packet_io_device_rx(pdev, 0, rx_pkts, 1);
 	EXPECT_EQ(fetch_num, 1);
+
 	packet_io_pkts_free(pdev, 0, rx_pkts, 1);
 	packet_io_device_close(pdev);
 	packet_io_fini(ppio_inst);
@@ -65,14 +135,18 @@ TEST(PACKET_IO_Test, packet_io_pkts_free) {
 
 TEST(PACKET_IO_Test, get_stellar_packet_ctrlzone) {
 	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
-	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./test-64.pcapng", 1, 1);
+	EXPECT_NE(ppio_inst, nullptr);
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 1, 1);
 	EXPECT_NE(pdev, nullptr);
+
 	struct stellar_packet *rx_pkts[64];
 	ssize_t fetch_num = packet_io_device_rx(pdev, 0, rx_pkts, 1);
 	EXPECT_EQ(fetch_num, 1);
+
 	size_t ctrlzone_len = 0;
 	void *buff_ctrlzone = get_stellar_packet_ctrlzone(rx_pkts[0], &ctrlzone_len);
 	EXPECT_EQ(buff_ctrlzone, rx_pkts[0]);
+	EXPECT_EQ(ctrlzone_len, CUSTOM_ZONE_LEN);
 
 	packet_io_pkts_free(pdev, 0, rx_pkts, 1);
 	packet_io_device_close(pdev);
@@ -81,14 +155,18 @@ TEST(PACKET_IO_Test, get_stellar_packet_ctrlzone) {
 
 TEST(PACKET_IO_Test, get_stellar_packet_data) {
 	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
-	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./test-64.pcapng", 1, 1);
+	EXPECT_NE(ppio_inst, nullptr);
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 1, 1);
 	EXPECT_NE(pdev, nullptr);
+
 	struct stellar_packet *rx_pkts[64];
 	ssize_t fetch_num = packet_io_device_rx(pdev, 0, rx_pkts, 1);
 	EXPECT_EQ(fetch_num, 1);
+
 	size_t data_len = 0;
 	void *buff_ctrlzone = get_stellar_packet_data(rx_pkts[0], &data_len);
-	EXPECT_EQ(buff_ctrlzone, (uint8_t *)rx_pkts[0]+64);
+	EXPECT_EQ(buff_ctrlzone, (uint8_t *)rx_pkts[0] + CUSTOM_ZONE_LEN);
+	EXPECT_NE(data_len, 0);
 
 	packet_io_pkts_free(pdev, 0, rx_pkts, 1);
 	packet_io_device_close(pdev);
@@ -130,103 +208,277 @@ TEST(PACKET_IO_UTIL_Test, pio_packet_hash) {
 }
 
 TEST(PACKET_IO_UTIL_Test, pio_packet_queue_init) {
-
+	struct pio_packet_queue pkt_queue;
+	pio_packet_queue_init(&pkt_queue);
 }
 
-TEST(PACKET_IO_UTIL_Test, pio_packet_enqueue) {
+TEST(PACKET_IO_UTIL_Test, pio_packet_enqueue_and_dequeue) {
+	struct pio_packet_queue pkt_queue;
+	pio_packet_queue_init(&pkt_queue);
 
-}
+	struct pio_packet *p = (struct pio_packet *)malloc(COMMON_SIZE_OF_PIO_PACKET);
+	EXPECT_NE(p, nullptr);
 
-TEST(PACKET_IO_UTIL_Test, pio_packet_dequeue) {
+	memset(p, 0, COMMON_SIZE_OF_PIO_PACKET);
 
+	p->pkt_hdr = p;
+	p->pkt_payload = p + CUSTOM_ZONE_LEN;
+	p->pkt_len = DEFAULT_MTU;
+
+	pio_packet_enqueue(&pkt_queue, p);
+	EXPECT_EQ(pkt_queue.len, 1);
+
+	struct pio_packet *dp = pio_packet_dequeue(&pkt_queue);
+	EXPECT_EQ(pkt_queue.len, 0);
+	FREE(dp);
 }
 
 TEST(PACKET_IO_UTIL_Test, release_pio_packet_queue) {
+	struct pio_packet_queue pkt_queue;
+	pio_packet_queue_init(&pkt_queue);
 
+	struct pio_packet *p = (struct pio_packet *)malloc(COMMON_SIZE_OF_PIO_PACKET);
+	EXPECT_NE(p, nullptr);
+
+	memset(p, 0, COMMON_SIZE_OF_PIO_PACKET);
+
+	p->pkt_hdr = p;
+	p->pkt_payload = p + CUSTOM_ZONE_LEN;
+	p->pkt_len = DEFAULT_MTU;
+
+	pio_packet_enqueue(&pkt_queue, p);
+	EXPECT_EQ(pkt_queue.len, 1);
+
+	release_pio_packet_queue(&pkt_queue);
+	EXPECT_EQ(pkt_queue.len, 0);
 }
 
-TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_instance_create) {
+TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_instance_create_and_destroy) {
+	struct packet_io_instance *pio_instance = CALLOC(struct packet_io_instance, 1);
+	EXPECT_NE(pio_instance, nullptr);
 
+	ssize_t res = strncpy_safe(pio_instance->inst_name, "stellar", sizeof(pio_instance->inst_name));
+	EXPECT_EQ(res, 0);
+
+	res = pio_pcap_file_instance_create(nullptr);
+	EXPECT_EQ(res, -1);
+
+	res = pio_pcap_file_instance_create(pio_instance);
+	EXPECT_EQ(res, 0);
+
+	pio_pcap_file_instance_destroy(nullptr);
+
+	pio_pcap_file_instance_destroy(pio_instance);
+	FREE(pio_instance);
 }
 
-TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_instance_destroy) {
+TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_open_and_close) {
+	struct packet_io_instance *pio_instance = CALLOC(struct packet_io_instance, 1);
+	EXPECT_NE(pio_instance, nullptr);
+	struct packet_io_device *pdev = CALLOC(struct packet_io_device, 1);
+	EXPECT_NE(pdev, nullptr);
 
-}
+	/* plain file */
+	ssize_t res = strncpy_safe(pdev->dev_name, "./pcap_sample/test03-64.pcapng", sizeof(pdev->dev_name));
+	EXPECT_EQ(res, 0);
 
-TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_open) {
+	pdev->rxq_num = 1;
+	pdev->txq_num = 1;
+	pdev->ppio_inst = pio_instance;
 
-}
+	res = pio_pcap_file_device_open(nullptr);
+	EXPECT_EQ(res, -1);
 
-TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_close) {
+	res = pio_pcap_file_device_open(pdev);
+	EXPECT_EQ(res, 0);
 
+	res = pio_pcap_file_device_close(nullptr);
+	EXPECT_EQ(res, -1);
+
+	res = pio_pcap_file_device_close(pdev);
+	EXPECT_EQ(res, 0);
+
+	/* directory */
+	memset(pdev, 0, sizeof(struct packet_io_device));
+	res = strncpy_safe(pdev->dev_name, "./pcap_sample", sizeof(pdev->dev_name));
+	EXPECT_EQ(res, 0);
+
+	pdev->rxq_num = 1;
+	pdev->txq_num = 1;
+	pdev->ppio_inst = pio_instance;
+
+	res = pio_pcap_file_device_open(pdev);
+	EXPECT_EQ(res, 0);
+
+	res = pio_pcap_file_device_close(pdev);
+	EXPECT_EQ(res, 0);
+
+	FREE(pdev);
+	FREE(pio_instance);
 }
 
 TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_receive) {
+	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
+	EXPECT_NE(ppio_inst, nullptr);
 
+	/* plain file */
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 1, 1);
+	EXPECT_NE(pdev, nullptr);
+
+	struct stellar_packet *rx_pkts[64];
+	ssize_t res = pio_pcap_file_device_receive(pdev, 0, rx_pkts, 64);
+	EXPECT_EQ(res, 64);
+	
+	packet_io_pkts_free(pdev, 0, rx_pkts, 64);
+	packet_io_device_close(pdev);
+
+	/* directory */
+	pdev = packet_io_device_open(ppio_inst, "./pcap_sample", 1, 1);
+	EXPECT_NE(pdev, nullptr);
+
+	res = pio_pcap_file_device_receive(pdev, 0, rx_pkts, 5);
+	EXPECT_EQ(res, 5);
+
+	packet_io_pkts_free(pdev, 0, rx_pkts, 5);
+	packet_io_device_close(pdev);
+
+	packet_io_instance_destroy(ppio_inst);
 }
 
 TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_pkt_free) {
+	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
+	EXPECT_NE(ppio_inst, nullptr);
 
+	/* plain file */
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 1, 1);
+	EXPECT_NE(pdev, nullptr);
+
+	struct stellar_packet *rx_pkts[64];
+	ssize_t res = pio_pcap_file_device_receive(pdev, 0, rx_pkts, 64);
+	EXPECT_EQ(res, 64);
+
+	pio_pcap_file_device_pkt_free(pdev, 0, rx_pkts, 64);
+
+	packet_io_device_close(pdev);
+	packet_io_instance_destroy(ppio_inst);
 }
 
 TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_buff_ctrlzone) {
+	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
+	EXPECT_NE(ppio_inst, nullptr);
 
+	/* plain file */
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 1, 1);
+	EXPECT_NE(pdev, nullptr);
+
+	struct stellar_packet *rx_pkts[64];
+	ssize_t res = pio_pcap_file_device_receive(pdev, 0, rx_pkts, 1);
+	EXPECT_EQ(res, 1);
+
+	size_t ctrlzone_len = 0;
+	char *ctrlzone = pio_pcap_file_device_buff_ctrlzone(rx_pkts[0], &ctrlzone_len);
+	EXPECT_EQ(ctrlzone, (char *)rx_pkts[0]);
+	EXPECT_EQ(ctrlzone_len, CUSTOM_ZONE_LEN);
+
+	pio_pcap_file_device_pkt_free(pdev, 0, rx_pkts, 1);
+
+	packet_io_device_close(pdev);
+	packet_io_instance_destroy(ppio_inst);
 }
 
 TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_buff_mtod) {
+	struct packet_io_instance *ppio_inst = packet_io_instance_create("stellar", PACKET_IO_RUN_MODE_PCAP_FILE);
+	EXPECT_NE(ppio_inst, nullptr);
 
+	/* plain file */
+	struct packet_io_device *pdev = packet_io_device_open(ppio_inst, "./pcap_sample/test03-64.pcapng", 1, 1);
+	EXPECT_NE(pdev, nullptr);
+
+	struct stellar_packet *rx_pkts[64];
+	ssize_t res = pio_pcap_file_device_receive(pdev, 0, rx_pkts, 1);
+	EXPECT_EQ(res, 1);
+
+	size_t data_len = 0;
+	char *data = pio_pcap_file_device_buff_mtod(rx_pkts[0], &data_len);
+	EXPECT_EQ(data, (char *)rx_pkts[0] + CUSTOM_ZONE_LEN);
+	EXPECT_NE(data_len, 0);
+
+	pio_pcap_file_device_pkt_free(pdev, 0, rx_pkts, 1);
+
+	packet_io_device_close(pdev);
+	packet_io_instance_destroy(ppio_inst);
 }
 
-TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_buff_buflen) {
+TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_instance_create_and_destroy) {
+	struct packet_io_instance *pio_instance = CALLOC(struct packet_io_instance, 1);
+	EXPECT_NE(pio_instance, nullptr);
 
+	ssize_t res = strncpy_safe(pio_instance->inst_name, "stellar", sizeof(pio_instance->inst_name));
+	EXPECT_EQ(res, 0);
+
+	res = pio_pcap_live_instance_create(nullptr);
+	EXPECT_EQ(res, -1);
+
+	res = pio_pcap_live_instance_create(pio_instance);
+	EXPECT_EQ(res, 0);
+
+	pio_pcap_live_instance_destroy(nullptr);
+
+	pio_pcap_live_instance_destroy(pio_instance);
+	FREE(pio_instance);
 }
 
-TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_buff_datalen) {
+TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_open_and_close) {
+	struct packet_io_instance *pio_instance = CALLOC(struct packet_io_instance, 1);
+	EXPECT_NE(pio_instance, nullptr);
+	struct packet_io_device *pdev = CALLOC(struct packet_io_device, 1);
+	EXPECT_NE(pdev, nullptr);
 
-}
+	/* plain file */
+	ssize_t res = strncpy_safe(pdev->dev_name, "tun0", sizeof(pdev->dev_name));
+	EXPECT_EQ(res, 0);
 
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_instance_create) {
+	pdev->rxq_num = 1;
+	pdev->txq_num = 1;
+	pdev->ppio_inst = pio_instance;
 
-}
+	res = pio_pcap_live_device_open(nullptr);
+	EXPECT_EQ(res, -1);
 
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_instance_destroy) {
+	res = pio_pcap_live_device_open(pdev);
+	EXPECT_EQ(res, 0);
 
-}
+	res = pio_pcap_live_device_close(nullptr);
+	EXPECT_EQ(res, -1);
 
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_open) {
-
-}
-
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_close) {
-
-}
-
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_receive) {
+	res = pio_pcap_live_device_close(pdev);
+	EXPECT_EQ(res, 0);
 
+	FREE(pdev);
+	FREE(pio_instance);
 }
 
 TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_send) {
+	struct packet_io_instance *ppio_inst_file = packet_io_instance_create("stellar_file", PACKET_IO_RUN_MODE_PCAP_FILE);
+	EXPECT_NE(ppio_inst_file, nullptr);
+	struct packet_io_instance *ppio_inst_live = packet_io_instance_create("stellar_live", PACKET_IO_RUN_MODE_PCAP_LIVE);
+	EXPECT_NE(ppio_inst_live, nullptr);
+	struct packet_io_device *pdev_file = packet_io_device_open(ppio_inst_file, "./pcap_sample/test03-64.pcapng", 1, 1);
+	EXPECT_NE(pdev_file, nullptr);
+	struct packet_io_device *pdev_live = packet_io_device_open(ppio_inst_live, "tun0", 1, 1);
+	EXPECT_NE(pdev_live, nullptr);
 
-}
-
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_pkt_free) {
-
-}
-
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_buff_ctrlzone) {
-
-}
-
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_buff_mtod) {
-
-}
-
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_buff_buflen) {
-
-}
-
-TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_buff_datalen) {
+	struct stellar_packet *tx_pkts[64];
+	ssize_t pkt_num = packet_io_device_rx(pdev_file, 0, tx_pkts, 64);
+	EXPECT_EQ(pkt_num, 64);
 
+	ssize_t res = packet_io_device_tx(pdev_live, 0, tx_pkts, 64);
+	EXPECT_EQ(res, 0);
+	
+	packet_io_device_close(pdev_file);
+	packet_io_device_close(pdev_live);
+	packet_io_fini(ppio_inst_file);
+	packet_io_fini(ppio_inst_live);
 }
 
 int main(int argc, char ** argv)