Add some test for /proc/net/pktgen/... interface.
Signed-off-by: Peter Seiderer <ps.report@xxxxxxx>
---
tools/testing/selftests/net/Makefile | 1 +
tools/testing/selftests/net/proc_net_pktgen.c | 575 ++++++++++++++++++
2 files changed, 576 insertions(+)
create mode 100644 tools/testing/selftests/net/proc_net_pktgen.c
diff --git a/tools/testing/selftests/net/Makefile b/tools/testing/selftests/net/Makefile
index 73ee88d6b043..095708cd8345 100644
--- a/tools/testing/selftests/net/Makefile
+++ b/tools/testing/selftests/net/Makefile
@@ -100,6 +100,7 @@ TEST_PROGS += vlan_bridge_binding.sh
TEST_PROGS += bpf_offload.py
TEST_PROGS += ipv6_route_update_soft_lockup.sh
TEST_PROGS += busy_poll_test.sh
+TEST_GEN_PROGS += proc_net_pktgen
# YNL files, must be before "include ..lib.mk"
YNL_GEN_FILES := busy_poller netlink-dumps
diff --git a/tools/testing/selftests/net/proc_net_pktgen.c b/tools/testing/selftests/net/proc_net_pktgen.c
new file mode 100644
index 000000000000..1d01fa2a96e9
--- /dev/null
+++ b/tools/testing/selftests/net/proc_net_pktgen.c
@@ -0,0 +1,575 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * proc_net_pktgen: kselftest for /proc/net/pktgen interface
+ *
+ * Copyright (c) 2025 Peter Seiderer <ps.report@xxxxxxx>
+ *
+ */
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "../kselftest_harness.h"
+
+static const char add_loopback_0[] = "add_device lo@0";
+static const char rm_loopback_0[] = "rem_device_all";
+
+static const char wrong_ctrl_command[] = "forsureawrongcommand";
+static const char legacy_ctrl_command[] = "max_before_softirq";
+
+static const char wrong_device_command[] = "forsurewrongcommand";
+static const char device_command_min_pkt_size_0[] = "min_pkt_size";
+static const char device_command_min_pkt_size_1[] = "min_pkt_size ";
+static const char device_command_min_pkt_size_2[] = "min_pkt_size 0";
+static const char device_command_min_pkt_size_3[] = "min_pkt_size 1";
+static const char device_command_min_pkt_size_4[] = "min_pkt_size 100";
+static const char device_command_min_pkt_size_5[] = "min_pkt_size=1001";
+static const char device_command_min_pkt_size_6[] = "min_pkt_size =2002";
+static const char device_command_min_pkt_size_7[] = "min_pkt_size= 3003";
+static const char device_command_min_pkt_size_8[] = "min_pkt_size = 4004";
+static const char device_command_max_pkt_size_0[] = "max_pkt_size 200";
+static const char device_command_pkt_size_0[] = "pkt_size 300";
+static const char device_command_imix_weights_0[] = "imix_weights 0,7 576,4 1500,1";
+static const char device_command_imix_weights_1[] = "imix_weights 101,1 102,2 103,3 104,4 105,5 106,6 107,7 108,8 109,9 110,10 111,11 112,12 113,13 114,14 115,15 116,16 117,17 118,18 119,19 120,20";
+static const char device_command_imix_weights_2[] = "imix_weights 100,1 102,2 103,3 104,4 105,5 106,6 107,7 108,8 109,9 110,10 111,11 112,12 113,13 114,14 115,15 116,16 117,17 118,18 119,19 120,20 121,21";
+static const char device_command_debug_0[] = "debug 1";
+static const char device_command_debug_1[] = "debug 0";
+static const char device_command_frags_0[] = "frags 100";
+static const char device_command_delay_0[] = "delay 100";
+static const char device_command_delay_1[] = "delay 2147483647";
+static const char device_command_rate_0[] = "rate 100";
+static const char device_command_ratep_0[] = "ratep 200";
+static const char device_command_udp_src_min_0[] = "udp_src_min 1";
+static const char device_command_udp_dst_min_0[] = "udp_dst_min 2";
+static const char device_command_udp_src_max_0[] = "udp_src_max 3";
+static const char device_command_udp_dst_max_0[] = "udp_dst_max 4";
+static const char device_command_clone_skb_0[] = "clone_skb 1";
+static const char device_command_clone_skb_1[] = "clone_skb 0";
+static const char device_command_count_0[] = "count 100";
+static const char device_command_src_mac_count_0[] = "src_mac_count 100";
+static const char device_command_dst_mac_count_0[] = "dst_mac_count 100";
+static const char device_command_burst_0[] = "burst 0";
+static const char device_command_node_0[] = "node 100";
+static const char device_command_xmit_mode_0[] = "xmit_mode start_xmit";
+static const char device_command_xmit_mode_1[] = "xmit_mode netif_receive";
+static const char device_command_xmit_mode_2[] = "xmit_mode queue_xmit";
+static const char device_command_xmit_mode_3[] = "xmit_mode nonsense";
+static const char device_command_flag_0[] = "flag UDPCSUM";
+static const char device_command_flag_1[] = "flag !UDPCSUM";
+static const char device_command_flag_2[] = "flag nonsense";
+static const char device_command_dst_min_0[] = "dst_min 101.102.103.104";
+static const char device_command_dst_0[] = "dst 101.102.103.104";
+static const char device_command_dst_max_0[] = "dst_max 201.202.203.204";
+static const char device_command_dst6_0[] = "dst6 2001:db38:1234:0000:0000:0000:0000:0000";
+static const char device_command_dst6_min_0[] = "dst6_min 2001:db8:1234:0000:0000:0000:0000:0000";
+static const char device_command_dst6_max_0[] = "dst6_max 2001:db8:1234:0000:0000:0000:0000:0000";
+static const char device_command_src6_0[] = "src6 2001:db38:1234:0000:0000:0000:0000:0000";
+static const char device_command_src_min_0[] = "src_min 101.102.103.104";
+static const char device_command_src_max_0[] = "src_max 201.202.203.204";
+static const char device_command_dst_mac_0[] = "dst_mac 01:02:03:04:05:06";
+static const char device_command_src_mac_0[] = "src_mac 11:12:13:14:15:16";
+static const char device_command_clear_counters_0[] = "clear_counters";
+static const char device_command_flows_0[] = "flows 100";
+#if 0 // needs CONFIG_XFRM
+static const char device_command_spi_0[] = "spi 100";
+#endif
+static const char device_command_flowlen_0[] = "flowlen 100";
+static const char device_command_queue_map_min_0[] = "queue_map_min 1";
+static const char device_command_queue_map_max_0[] = "queue_map_max 2";
+static const char device_command_mpls_0[] = "mpls 00000001,000000f2,00000ff3,0000fff4,000ffff5,00fffff6,0ffffff7,fffffff8";
+static const char device_command_vlan_id_0[] = "vlan_id 1";
+static const char device_command_vlan_p_0[] = "vlan_p 1";
+static const char device_command_vlan_cfi_0[] = "vlan_cfi 1";
+static const char device_command_vlan_id_1[] = "vlan_id 4096";
+static const char device_command_svlan_id_0[] = "svlan_id 1";
+static const char device_command_svlan_p_0[] = "svlan_p 1";
+static const char device_command_svlan_cfi_0[] = "svlan_cfi 1";
+static const char device_command_svlan_id_1[] = "svlan_id 4096";
+static const char device_command_tos_0[] = "tos 0";
+static const char device_command_tos_1[] = "tos 0f";
+static const char device_command_tos_2[] = "tos 0ff";
+static const char device_command_traffic_class_0[] = "traffic_class f0";
+static const char device_command_skb_priority_0[] = "skb_priority 999";
+
+FIXTURE(proc_net_pktgen) {
+ int ctrl_fd;
+ int device_fd;
+};
+
+FIXTURE_SETUP(proc_net_pktgen) {
+ ssize_t len;
+
+ self->ctrl_fd = open("/proc/net/pktgen/kpktgend_0", O_RDWR);
+ ASSERT_GE(self->ctrl_fd, 0) TH_LOG("CONFIG_NET_PKTGEN not enabled, module pktgen nod loaded?");
+
+ len = write(self->ctrl_fd, add_loopback_0, sizeof(add_loopback_0));
+ ASSERT_EQ(len, sizeof(add_loopback_0)) TH_LOG("device lo@0 already registered?");
+
+ self->device_fd = open("/proc/net/pktgen/lo@0", O_RDWR);
+ ASSERT_GE(self->device_fd, 0) TH_LOG("device entry for lo@0 missing?");
+}
+
+FIXTURE_TEARDOWN(proc_net_pktgen) {
+ int ret;
+ ssize_t len;
+
+ ret = close(self->device_fd);
+ EXPECT_EQ(ret, 0);
+
+ len = write(self->ctrl_fd, rm_loopback_0, sizeof(rm_loopback_0));
+ EXPECT_EQ(len, sizeof(rm_loopback_0));
+
+ ret = close(self->ctrl_fd);
+ EXPECT_EQ(ret, 0);
+}
+
+TEST_F(proc_net_pktgen, wrong_ctrl_command) {
+ for (int i = 0; i <= sizeof(wrong_ctrl_command); i++) {
+ ssize_t len = write(self->ctrl_fd, wrong_ctrl_command, i);
+ EXPECT_EQ(len, -1);
+ EXPECT_EQ(errno, EINVAL);
+ }
+}
+
+TEST_F(proc_net_pktgen, legacy_ctrl_command) {
+ for (int i = 0; i <= sizeof(legacy_ctrl_command); i++) {
+ ssize_t len = write(self->ctrl_fd, legacy_ctrl_command, i);
+ if (i < (sizeof(legacy_ctrl_command) - 1)) {
+ // incomplete command string
+ EXPECT_EQ(len, -1);
+ EXPECT_EQ(errno, EINVAL);
+ } else {
+ // complete command string without/with trailing '\0'
+ EXPECT_EQ(len, i);
+ }
+ }
+}
+
+TEST_F(proc_net_pktgen, wrong_device_command) {
+ for (int i = 0; i <= sizeof(wrong_device_command); i++) {
+ ssize_t len = write(self->device_fd, wrong_device_command, i);
+ EXPECT_EQ(len, -1);
+ EXPECT_EQ(errno, EINVAL);
+ }
+}
+
+TEST_F(proc_net_pktgen, device_command_min_pkt_size) {
+ ssize_t len;
+
+ // with trailing '\0'
+ len = write(self->device_fd, device_command_min_pkt_size_0, sizeof(device_command_min_pkt_size_0));
+ EXPECT_EQ(len, -1);
+ EXPECT_EQ(errno, EINVAL);
+
+ // without trailing '\0'
+ len = write(self->device_fd, device_command_min_pkt_size_0, sizeof(device_command_min_pkt_size_0) - 1);
+ EXPECT_EQ(len, -1);
+ EXPECT_EQ(errno, EINVAL);
+
+ // with trailing '\0'
+ len = write(self->device_fd, device_command_min_pkt_size_1, sizeof(device_command_min_pkt_size_1));
+ EXPECT_EQ(len, -1);
+ EXPECT_EQ(errno, EINVAL);
+
+ // without trailing '\0'
+ len = write(self->device_fd, device_command_min_pkt_size_1, sizeof(device_command_min_pkt_size_1) - 1);
+ EXPECT_EQ(len, -1);
+ EXPECT_EQ(errno, EINVAL);
+
+ // with trailing '\0'
+ len = write(self->device_fd, device_command_min_pkt_size_2, sizeof(device_command_min_pkt_size_2));
+ EXPECT_EQ(len, sizeof(device_command_min_pkt_size_2));
+
+ // without trailing '\0'
+ len = write(self->device_fd, device_command_min_pkt_size_2, sizeof(device_command_min_pkt_size_2) - 1);
+ EXPECT_EQ(len, sizeof(device_command_min_pkt_size_2) - 1);
+
+ len = write(self->device_fd, device_command_min_pkt_size_3, sizeof(device_command_min_pkt_size_3));
+ EXPECT_EQ(len, sizeof(device_command_min_pkt_size_3));
+
+ len = write(self->device_fd, device_command_min_pkt_size_4, sizeof(device_command_min_pkt_size_4));
+ EXPECT_EQ(len, sizeof(device_command_min_pkt_size_4));
+
+ len = write(self->device_fd, device_command_min_pkt_size_5, sizeof(device_command_min_pkt_size_5));
+ EXPECT_EQ(len, sizeof(device_command_min_pkt_size_5));
+
+ len = write(self->device_fd, device_command_min_pkt_size_6, sizeof(device_command_min_pkt_size_6));
+ EXPECT_EQ(len, sizeof(device_command_min_pkt_size_6));
+
+ len = write(self->device_fd, device_command_min_pkt_size_7, sizeof(device_command_min_pkt_size_7));
+ EXPECT_EQ(len, sizeof(device_command_min_pkt_size_7));
+
+ len = write(self->device_fd, device_command_min_pkt_size_8, sizeof(device_command_min_pkt_size_8));
+ EXPECT_EQ(len, sizeof(device_command_min_pkt_size_8));
+}
+
+TEST_F(proc_net_pktgen, device_command_max_pkt_size) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_max_pkt_size_0, sizeof(device_command_max_pkt_size_0));
+ EXPECT_EQ(len, sizeof(device_command_max_pkt_size_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_pkt_size) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_pkt_size_0, sizeof(device_command_pkt_size_0));
+ EXPECT_EQ(len, sizeof(device_command_pkt_size_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_imix_weights) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_imix_weights_0, sizeof(device_command_imix_weights_0));
+ EXPECT_EQ(len, sizeof(device_command_imix_weights_0));
+
+ len = write(self->device_fd, device_command_imix_weights_1, sizeof(device_command_imix_weights_1));
+ EXPECT_EQ(len, sizeof(device_command_imix_weights_1));
+
+ len = write(self->device_fd, device_command_imix_weights_2, sizeof(device_command_imix_weights_2));
+ EXPECT_EQ(len, -1);
+ EXPECT_EQ(errno, E2BIG);
+}
+
+TEST_F(proc_net_pktgen, device_command_debug) {
+ ssize_t len;
+
+ // debug on
+ len = write(self->device_fd, device_command_debug_0, sizeof(device_command_debug_0));
+ EXPECT_EQ(len, sizeof(device_command_debug_0));
+
+ // debug off
+ len = write(self->device_fd, device_command_debug_1, sizeof(device_command_debug_1));
+ EXPECT_EQ(len, sizeof(device_command_debug_1));
+}
+
+TEST_F(proc_net_pktgen, device_command_frags) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_frags_0, sizeof(device_command_frags_0));
+ EXPECT_EQ(len, sizeof(device_command_frags_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_delay) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_delay_0, sizeof(device_command_delay_0));
+ EXPECT_EQ(len, sizeof(device_command_delay_0));
+
+ len = write(self->device_fd, device_command_delay_1, sizeof(device_command_delay_1));
+ EXPECT_EQ(len, sizeof(device_command_delay_1));
+}
+
+TEST_F(proc_net_pktgen, device_command_rate) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_rate_0, sizeof(device_command_rate_0));
+ EXPECT_EQ(len, sizeof(device_command_rate_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_ratep) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_ratep_0, sizeof(device_command_ratep_0));
+ EXPECT_EQ(len, sizeof(device_command_ratep_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_udp_src_min) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_udp_src_min_0, sizeof(device_command_udp_src_min_0));
+ EXPECT_EQ(len, sizeof(device_command_udp_src_min_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_udp_dst_min) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_udp_dst_min_0, sizeof(device_command_udp_dst_min_0));
+ EXPECT_EQ(len, sizeof(device_command_udp_dst_min_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_udp_src_max) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_udp_src_max_0, sizeof(device_command_udp_src_max_0));
+ EXPECT_EQ(len, sizeof(device_command_udp_src_max_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_udp_dst_max) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_udp_dst_max_0, sizeof(device_command_udp_dst_max_0));
+ EXPECT_EQ(len, sizeof(device_command_udp_dst_max_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_clone_skb) {
+ ssize_t len;
+
+ // clone_skb on (gives EOPNOTSUPP on lo device)
+ len = write(self->device_fd, device_command_clone_skb_0, sizeof(device_command_clone_skb_0));
+ EXPECT_EQ(len, -1);
+ EXPECT_EQ(errno, EOPNOTSUPP);
+
+ // clone_skb off
+ len = write(self->device_fd, device_command_clone_skb_1, sizeof(device_command_clone_skb_1));
+ EXPECT_EQ(len, sizeof(device_command_clone_skb_1));
+}
+
+TEST_F(proc_net_pktgen, device_command_count) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_count_0, sizeof(device_command_count_0));
+ EXPECT_EQ(len, sizeof(device_command_count_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_src_mac_count) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_src_mac_count_0, sizeof(device_command_src_mac_count_0));
+ EXPECT_EQ(len, sizeof(device_command_src_mac_count_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_dst_mac_count) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_dst_mac_count_0, sizeof(device_command_dst_mac_count_0));
+ EXPECT_EQ(len, sizeof(device_command_dst_mac_count_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_burst) {
+ ssize_t len;
+
+ // burst off
+ len = write(self->device_fd, device_command_burst_0, sizeof(device_command_burst_0));
+ EXPECT_EQ(len, sizeof(device_command_burst_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_node) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_node_0, sizeof(device_command_node_0));
+ EXPECT_EQ(len, sizeof(device_command_node_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_xmit_mode) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_xmit_mode_0, sizeof(device_command_xmit_mode_0));
+ EXPECT_EQ(len, sizeof(device_command_xmit_mode_0));
+
+ len = write(self->device_fd, device_command_xmit_mode_1, sizeof(device_command_xmit_mode_1));
+ EXPECT_EQ(len, sizeof(device_command_xmit_mode_1));
+
+ len = write(self->device_fd, device_command_xmit_mode_2, sizeof(device_command_xmit_mode_2));
+ EXPECT_EQ(len, sizeof(device_command_xmit_mode_2));
+
+ len = write(self->device_fd, device_command_xmit_mode_3, sizeof(device_command_xmit_mode_3));
+ EXPECT_EQ(len, sizeof(device_command_xmit_mode_3));
+}
+
+TEST_F(proc_net_pktgen, device_command_flag) {
+ ssize_t len;
+
+ // flag UDPCSUM on
+ len = write(self->device_fd, device_command_flag_0, sizeof(device_command_flag_0));
+ EXPECT_EQ(len, sizeof(device_command_flag_0));
+
+ // flag UDPCSUM off
+ len = write(self->device_fd, device_command_flag_1, sizeof(device_command_flag_1));
+ EXPECT_EQ(len, sizeof(device_command_flag_1));
+
+ // flag invalid
+ len = write(self->device_fd, device_command_flag_2, sizeof(device_command_flag_2));
+ EXPECT_EQ(len, sizeof(device_command_flag_2));
+}
+
+TEST_F(proc_net_pktgen, device_command_dst_min) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_dst_min_0, sizeof(device_command_dst_min_0));
+ EXPECT_EQ(len, sizeof(device_command_dst_min_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_dst) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_dst_0, sizeof(device_command_dst_0));
+ EXPECT_EQ(len, sizeof(device_command_dst_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_dst_max) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_dst_max_0, sizeof(device_command_dst_max_0));
+ EXPECT_EQ(len, sizeof(device_command_dst_max_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_dst6) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_dst6_0, sizeof(device_command_dst6_0));
+ EXPECT_EQ(len, sizeof(device_command_dst6_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_dst6_min) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_dst6_min_0, sizeof(device_command_dst6_min_0));
+ EXPECT_EQ(len, sizeof(device_command_dst6_min_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_dst6_max) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_dst6_max_0, sizeof(device_command_dst6_max_0));
+ EXPECT_EQ(len, sizeof(device_command_dst6_max_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_src6) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_src6_0, sizeof(device_command_src6_0));
+ EXPECT_EQ(len, sizeof(device_command_src6_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_src_min) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_src_min_0, sizeof(device_command_src_min_0));
+ EXPECT_EQ(len, sizeof(device_command_src_min_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_src_max) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_src_max_0, sizeof(device_command_src_max_0));
+ EXPECT_EQ(len, sizeof(device_command_src_max_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_dst_mac) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_dst_mac_0, sizeof(device_command_dst_mac_0));
+ EXPECT_EQ(len, sizeof(device_command_dst_mac_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_src_mac) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_src_mac_0, sizeof(device_command_src_mac_0));
+ EXPECT_EQ(len, sizeof(device_command_src_mac_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_clear_counters) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_clear_counters_0, sizeof(device_command_clear_counters_0));
+ EXPECT_EQ(len, sizeof(device_command_clear_counters_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_flows) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_flows_0, sizeof(device_command_flows_0));
+ EXPECT_EQ(len, sizeof(device_command_flows_0));
+}
+
+#if 0 // needs CONFIG_XFRM
+TEST_F(proc_net_pktgen, device_command_spi) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_spi_0, sizeof(device_command_spi_0));
+ EXPECT_EQ(len, sizeof(device_command_spi_0));
+}
+#endif
+
+TEST_F(proc_net_pktgen, device_command_flowlen) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_flowlen_0, sizeof(device_command_flowlen_0));
+ EXPECT_EQ(len, sizeof(device_command_flowlen_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_queue_map_min) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_queue_map_min_0, sizeof(device_command_queue_map_min_0));
+ EXPECT_EQ(len, sizeof(device_command_queue_map_min_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_queue_map_max) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_queue_map_max_0, sizeof(device_command_queue_map_max_0));
+ EXPECT_EQ(len, sizeof(device_command_queue_map_max_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_mpls) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_mpls_0, sizeof(device_command_mpls_0));
+ EXPECT_EQ(len, sizeof(device_command_mpls_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_vlan_id) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_vlan_id_0, sizeof(device_command_vlan_id_0));
+ EXPECT_EQ(len, sizeof(device_command_vlan_id_0));
+
+ len = write(self->device_fd, device_command_vlan_p_0, sizeof(device_command_vlan_p_0));
+ EXPECT_EQ(len, sizeof(device_command_vlan_p_0));
+
+ len = write(self->device_fd, device_command_vlan_cfi_0, sizeof(device_command_vlan_cfi_0));
+ EXPECT_EQ(len, sizeof(device_command_vlan_cfi_0));
+
+ len = write(self->device_fd, device_command_vlan_id_1, sizeof(device_command_vlan_id_1));
+ EXPECT_EQ(len, sizeof(device_command_vlan_id_1));
+}
+
+TEST_F(proc_net_pktgen, device_command_svlan_id) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_svlan_id_0, sizeof(device_command_svlan_id_0));
+ EXPECT_EQ(len, sizeof(device_command_svlan_id_0));
+
+ len = write(self->device_fd, device_command_svlan_p_0, sizeof(device_command_svlan_p_0));
+ EXPECT_EQ(len, sizeof(device_command_svlan_p_0));
+
+ len = write(self->device_fd, device_command_svlan_cfi_0, sizeof(device_command_svlan_cfi_0));
+ EXPECT_EQ(len, sizeof(device_command_svlan_cfi_0));
+
+ len = write(self->device_fd, device_command_svlan_id_1, sizeof(device_command_svlan_id_1));
+ EXPECT_EQ(len, sizeof(device_command_svlan_id_1));
+}
+
+
+TEST_F(proc_net_pktgen, device_command_tos) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_tos_0, sizeof(device_command_tos_0));
+ EXPECT_EQ(len, sizeof(device_command_tos_0));
+
+ len = write(self->device_fd, device_command_tos_1, sizeof(device_command_tos_1));
+ EXPECT_EQ(len, sizeof(device_command_tos_1));
+
+ len = write(self->device_fd, device_command_tos_2, sizeof(device_command_tos_2));
+ EXPECT_EQ(len, sizeof(device_command_tos_2));
+}
+
+
+TEST_F(proc_net_pktgen, device_command_traffic_class) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_traffic_class_0, sizeof(device_command_traffic_class_0));
+ EXPECT_EQ(len, sizeof(device_command_traffic_class_0));
+}
+
+TEST_F(proc_net_pktgen, device_command_skb_priority) {
+ ssize_t len;
+
+ len = write(self->device_fd, device_command_skb_priority_0, sizeof(device_command_skb_priority_0));
+ EXPECT_EQ(len, sizeof(device_command_skb_priority_0));
+}
+
+TEST_HARNESS_MAIN
--
2.48.0
