#include <gtest/gtest.h>

#include "utils.h"
#include "packet.h"
#include "packet_io.h"
#include "packet_io_util.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, "lo", 1, 1);
	EXPECT_NE(pdev, nullptr);
	packet_io_device_close(pdev);
	packet_io_fini(ppio_inst);
}

TEST(PACKET_IO_Test, packet_io_device_rx) {
	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, "./src/packet_io/test/test-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_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, "lo", 1, 1);
	EXPECT_NE(pdev, 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);
}

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, "./src/packet_io/test/test-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);
}

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, "./src/packet_io/test/test-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]);

	packet_io_pkts_free(pdev, 0, rx_pkts, 1);
	packet_io_device_close(pdev);
	packet_io_fini(ppio_inst);
}

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, "./src/packet_io/test/test-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);

	packet_io_pkts_free(pdev, 0, rx_pkts, 1);
	packet_io_device_close(pdev);
	packet_io_fini(ppio_inst);
}

TEST(PACKET_IO_UTIL_Test, strncpy_safe) {
	ssize_t res = strncpy_safe(nullptr, nullptr, 0);
	EXPECT_EQ(res, -1);

	char dst[5];
	res = strncpy_safe(dst, "hello", sizeof(dst));
	EXPECT_STREQ(dst, "hell");
	EXPECT_EQ(res, 0);

	memset(dst, 0, sizeof(dst));
	res = strncpy_safe(dst, "he", sizeof(dst));
	EXPECT_STREQ(dst, "he");
	EXPECT_EQ(res, 0);
}

TEST(PACKET_IO_UTIL_Test, packet_copy_data) {
	uint8_t dst[5];
	uint8_t src[4] = {0x12, 0x34, 0x56, 0x78};
	ssize_t res = packet_copy_data(dst, src, sizeof(src));
	EXPECT_EQ(res, 0);
	EXPECT_EQ(dst[0], 0x12);
	EXPECT_EQ(dst[1], 0x34);
	EXPECT_EQ(dst[2], 0x56);
	EXPECT_EQ(dst[3], 0x78);
}

TEST(PACKET_IO_UTIL_Test, pio_packet_hash) {
	struct pio_packet *p = (struct pio_packet *)malloc(MAX_SIZE_OF_PIO_PACKET);
	memset(p, 0, MAX_SIZE_OF_PIO_PACKET);
	uint64_t res = pio_packet_hash(p);
	EXPECT_EQ(res, 0);
	FREE(p);
}

TEST(PACKET_IO_UTIL_Test, pio_packet_queue_init) {

}

TEST(PACKET_IO_UTIL_Test, pio_packet_enqueue) {

}

TEST(PACKET_IO_UTIL_Test, pio_packet_dequeue) {

}

TEST(PACKET_IO_UTIL_Test, release_pio_packet_queue) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_instance_create) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_instance_destroy) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_device_open) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_device_close) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_device_receive) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_device_send) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_device_pkt_free) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_device_buff_ctrlzone) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_device_buff_mtod) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_device_buff_buflen) {

}

TEST(PACKET_IO_PIO_MARSIO_Test, pio_marsio_device_buff_datalen) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_instance_create) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_instance_destroy) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_open) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_close) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_receive) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_pkt_free) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_buff_ctrlzone) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_buff_mtod) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_buff_buflen) {

}

TEST(PACKET_IO_PIO_PCAP_FILE_Test, pio_pcap_file_device_buff_datalen) {

}

TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_instance_create) {

}

TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_instance_destroy) {

}

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) {

}

TEST(PACKET_IO_PIO_PCAP_LIVE_Test, pio_pcap_live_device_send) {

}

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) {

}

int main(int argc, char ** argv)
{
	int ret=0;
	::testing::InitGoogleTest(&argc, argv);
	ret=RUN_ALL_TESTS();
	return ret;
}