d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

test: skip unsupported tests on Windows

Browse Source 
Skip tests which are not yet supported for Windows:
- The libraries that tests depend on are not enabled on Windows yet
- The tests can compile but with issue still under investigation
    * test_func_reentrancy:
      Windows EAL has no protection against repeated calls.
    * test_lcores:
      Execution enters an infinite loops, requires investigation.
    * test_rcu_qsbr_perf:
      Execution hangs on Windows, requires investigation.

Signed-off-by: Jie Zhou <jizh@linux.microsoft.com>
Signed-off-by: Dmitry Kozlyuk <dmitry.kozliuk@gmail.com>
Acked-by: Tyler Retzlaff <roretzla@linux.microsoft.com>
This commit is contained in:
Jie Zhou 2022-01-25 21:10:42 -08:00 committed by Thomas Monjalon
parent f684672947
commit 3c60274c09
61 changed files with 863 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
app/test/test_acl.c
View File

@ -11,6 +11,16 @@
#include <rte_mbuf.h>
#include <rte_byteorder.h>
#include <rte_ip.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_acl(void)
{
printf("ACL not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_acl.h>
#include <rte_common.h>
@ -1741,4 +1751,6 @@ test_acl(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(acl_autotest, test_acl);

16
app/test/test_bpf.c
View File

@ -14,11 +14,23 @@
#include <rte_random.h>
#include <rte_byteorder.h>
#include <rte_errno.h>
#include "test.h"
#if !defined(RTE_LIB_BPF)
static int
test_bpf(void)
{
printf("BPF not supported, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_bpf.h>
#include <rte_ether.h>
#include <rte_ip.h>
#include "test.h"
/*
* Basic functional tests for librte_bpf.
@ -3248,6 +3260,8 @@ test_bpf(void)
return rc;
}
#endif /* !RTE_LIB_BPF */
REGISTER_TEST_COMMAND(bpf_autotest, test_bpf);
#ifdef RTE_HAS_LIBPCAP

4
app/test/test_cryptodev.c
View File

@ -3,6 +3,8 @@
* Copyright 2020 NXP
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include <time.h>
#include <rte_common.h>
@ -16093,3 +16095,5 @@ REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);
#endif /* !RTE_EXEC_ENV_WINDOWS */

4
app/test/test_cryptodev_asym.c
View File

@ -3,6 +3,8 @@
* Copyright (c) 2019 Intel Corporation
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include <rte_bus_vdev.h>
#include <rte_common.h>
#include <rte_hexdump.h>
@ -2412,3 +2414,5 @@ REGISTER_TEST_COMMAND(cryptodev_octeontx_asym_autotest,
test_cryptodev_octeontx_asym);
REGISTER_TEST_COMMAND(cryptodev_cn9k_asym_autotest, test_cryptodev_cn9k_asym);
REGISTER_TEST_COMMAND(cryptodev_cn10k_asym_autotest, test_cryptodev_cn10k_asym);
#endif /* !RTE_EXEC_ENV_WINDOWS */

4
app/test/test_cryptodev_blockcipher.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2015-2017 Intel Corporation
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include <rte_common.h>
#include <rte_hexdump.h>
#include <rte_mbuf.h>
@ -1221,3 +1223,5 @@ free_blockcipher_test_suite(struct unit_test_suite *ts)
{
free(ts);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */

4
app/test/test_cryptodev_security_ipsec.c
View File

@ -2,6 +2,8 @@
* Copyright(C) 2021 Marvell.
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include <rte_common.h>
#include <rte_cryptodev.h>
#include <rte_esp.h>
@ -974,3 +976,5 @@ test_ipsec_pkt_update(uint8_t *pkt, const struct ipsec_test_flags *flags)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */

4
app/test/test_cryptodev_security_pdcp.c
View File

@ -4,6 +4,8 @@
* Copyright 2018-2019 NXP
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include <time.h>
#include <rte_common.h>
@ -587,3 +589,5 @@ test_PDCP_PROTO_uplane_decap_all(void)
return n - i;
};
#endif /* !RTE_EXEC_ENV_WINDOWS */

17
app/test/test_debug.c
View File

@ -2,8 +2,21 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <stdint.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_debug(void)
{
printf("debug not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <sys/resource.h>
#include <sys/time.h>
#include <sys/wait.h>
@ -14,8 +27,6 @@
#include <rte_eal.h>
#include <rte_service_component.h>
#include "test.h"
/*
* Debug test
* ==========
@ -127,4 +138,6 @@ test_debug(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(debug_autotest, test_debug);

13
app/test/test_distributor.c
View File

@ -11,6 +11,17 @@
#include <rte_mempool.h>
#include <rte_mbuf.h>
#include <rte_mbuf_dyn.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_distributor(void)
{
printf("distributor not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_distributor.h>
#include <rte_string_fns.h>
@ -939,4 +950,6 @@ test_distributor(void)
return -1;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(distributor_autotest, test_distributor);

13
app/test/test_distributor_perf.c
View File

@ -10,6 +10,17 @@
#include <rte_cycles.h>
#include <rte_common.h>
#include <rte_mbuf.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_distributor_perf(void)
{
printf("distributor perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_distributor.h>
#include <rte_pause.h>
@ -264,4 +275,6 @@ test_distributor_perf(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(distributor_perf_autotest, test_distributor_perf);

90
app/test/test_eal_flags.c
View File

@ -9,6 +9,94 @@
#include <string.h>
#include <stdarg.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_missing_c_flag(void)
{
printf("missing_c_flag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_main_lcore_flag(void)
{
printf("main_lcore_flag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_invalid_n_flag(void)
{
printf("invalid_n_flag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_no_hpet_flag(void)
{
printf("no_hpet_flag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_no_huge_flag(void)
{
printf("no_huge_flag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_allow_flag(void)
{
printf("allow_flag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_invalid_b_flag(void)
{
printf("invalid_b_flag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_invalid_vdev_flag(void)
{
printf("invalid_vdev_flag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_invalid_r_flag(void)
{
printf("invalid_r_flag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_memory_flags(void)
{
printf("memory_flags not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_file_prefix(void)
{
printf("file_prefix not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_misc_flags(void)
{
printf("misc_flags not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <libgen.h>
#include <stdlib.h>
#include <errno.h>
@ -1498,6 +1586,8 @@ test_memory_flags(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(eal_flags_c_opt_autotest, test_missing_c_flag);
REGISTER_TEST_COMMAND(eal_flags_main_opt_autotest, test_main_lcore_flag);
REGISTER_TEST_COMMAND(eal_flags_n_opt_autotest, test_invalid_n_flag);

12
app/test/test_eal_fs.c
View File

@ -10,6 +10,16 @@
#include "eal_filesystem.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_eal_fs(void)
{
printf("eal_fs not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
static int
test_parse_sysfs_value(void)
{
@ -173,4 +183,6 @@ test_eal_fs(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(eal_fs_autotest, test_eal_fs);

15
app/test/test_efd.c
View File

@ -1,6 +1,17 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2016-2017 Intel Corporation
*/
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_efd(void)
{
printf("EFD not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_memcpy.h>
#include <rte_malloc.h>
@ -10,8 +21,6 @@
#include <rte_debug.h>
#include <rte_ip.h>
#include "test.h"
#define EFD_TEST_KEY_LEN 8
#define TABLE_SIZE (1 << 21)
#define ITERATIONS 3
@ -462,4 +471,6 @@ test_efd(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(efd_autotest, test_efd);

16
app/test/test_efd_perf.c
View File

@ -2,6 +2,18 @@
* Copyright(c) 2016-2017 Intel Corporation
*/
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_efd_perf(void)
{
printf("EFD not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <stdio.h>
#include <inttypes.h>
@ -13,8 +25,6 @@
#include <rte_memcpy.h>
#include <rte_thash.h>
#include "test.h"
#define NUM_KEYSIZES 10
#define NUM_SHUFFLES 10
#define MAX_KEYSIZE 64
@ -382,4 +392,6 @@ test_efd_perf(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(efd_perf_autotest, test_efd_perf);

15
app/test/test_event_crypto_adapter.c
View File

@ -3,16 +3,27 @@
* All rights reserved.
*/
#include "test.h"
#include <string.h>
#include <rte_common.h>
#include <rte_mempool.h>
#include <rte_mbuf.h>
#include <rte_cryptodev.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_event_crypto_adapter(void)
{
printf("event_crypto_adapter not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_eventdev.h>
#include <rte_bus_vdev.h>
#include <rte_service.h>
#include <rte_event_crypto_adapter.h>
#include "test.h"
#define PKT_TRACE 0
#define NUM 1
@ -1011,5 +1022,7 @@ test_event_crypto_adapter(void)
return unit_test_suite_runner(&functional_testsuite);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(event_crypto_adapter_autotest,
test_event_crypto_adapter);

25
app/test/test_event_eth_rx_adapter.c
View File

@ -1,18 +1,37 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2017 Intel Corporation
*/
#include "test.h"
#include <string.h>
#include <rte_common.h>
#include <rte_mempool.h>
#include <rte_mbuf.h>
#include <rte_ethdev.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_event_eth_rx_adapter_common(void)
{
printf("event_eth_rx_adapter not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_event_eth_rx_intr_adapter_common(void)
{
printf("event_eth_rx_intr_adapter not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_eventdev.h>
#include <rte_bus_vdev.h>
#include <rte_event_eth_rx_adapter.h>
#include "test.h"
#define MAX_NUM_RX_QUEUE 64
#define NB_MBUFS (8192 * num_ports * MAX_NUM_RX_QUEUE)
#define MBUF_CACHE_SIZE 512
@ -1027,6 +1046,8 @@ test_event_eth_rx_intr_adapter_common(void)
return unit_test_suite_runner(&event_eth_rx_intr_tests);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
test_event_eth_rx_adapter_common);
REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest,

12
app/test/test_event_eth_tx_adapter.c
View File

@ -16,6 +16,16 @@
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_event_eth_tx_adapter_common(void)
{
printf("event_eth_tx_adapter not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#define MAX_NUM_QUEUE RTE_PMD_RING_MAX_RX_RINGS
#define TEST_INST_ID 0
#define TEST_DEV_ID 0
@ -696,5 +706,7 @@ test_event_eth_tx_adapter_common(void)
return unit_test_suite_runner(&event_eth_tx_tests);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(event_eth_tx_adapter_autotest,
test_event_eth_tx_adapter_common);

16
app/test/test_event_ring.c
View File

@ -2,11 +2,21 @@
* Copyright(c) 2010-2017 Intel Corporation
*/
#include "test.h"
#include <string.h>
#include <rte_event_ring.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_event_ring(void)
{
printf("event_ring not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#include "test.h"
#else
#include <rte_event_ring.h>
/*
* Event Ring
@ -244,4 +254,6 @@ test_event_ring(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(event_ring_autotest, test_event_ring);

17
app/test/test_event_timer_adapter.c
View File

@ -3,6 +3,8 @@
* Copyright(c) 2017-2018 Intel Corporation.
*/
#include "test.h"
#include <math.h>
#include <rte_common.h>
@ -10,6 +12,17 @@
#include <rte_debug.h>
#include <rte_eal.h>
#include <rte_ethdev.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_event_timer_adapter_func(void)
{
printf("event_timer_adapter not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_eventdev.h>
#include <rte_event_timer_adapter.h>
#include <rte_mempool.h>
@ -21,8 +34,6 @@
#include <rte_service.h>
#include <stdbool.h>
#include "test.h"
/* 4K timers corresponds to sw evdev max inflight events */
#define MAX_TIMERS (4 * 1024)
#define BKT_TCK_NSEC
@ -1950,4 +1961,6 @@ test_event_timer_adapter_func(void)
return unit_test_suite_runner(&event_timer_adptr_functional_testsuite);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(event_timer_adapter_test, test_event_timer_adapter_func);

21
app/test/test_eventdev.c
View File

@ -2,17 +2,28 @@
* Copyright(c) 2016 Cavium, Inc
*/
#include "test.h"
#include <rte_common.h>
#include <rte_hexdump.h>
#include <rte_mbuf.h>
#include <rte_malloc.h>
#include <rte_memcpy.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_eventdev_common(void)
{
printf("eventdev_common not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_eventdev.h>
#include <rte_dev.h>
#include <rte_bus_vdev.h>
#include "test.h"
#define TEST_DEV_ID 0
static int
@ -1042,7 +1053,11 @@ test_eventdev_selftest_cn10k(void)
return test_eventdev_selftest_impl("event_cn10k", "");
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(eventdev_common_autotest, test_eventdev_common);
#ifndef RTE_EXEC_ENV_WINDOWS
REGISTER_TEST_COMMAND(eventdev_selftest_sw, test_eventdev_selftest_sw);
REGISTER_TEST_COMMAND(eventdev_selftest_octeontx,
test_eventdev_selftest_octeontx);
@ -1050,3 +1065,5 @@ REGISTER_TEST_COMMAND(eventdev_selftest_dpaa2, test_eventdev_selftest_dpaa2);
REGISTER_TEST_COMMAND(eventdev_selftest_dlb2, test_eventdev_selftest_dlb2);
REGISTER_TEST_COMMAND(eventdev_selftest_cn9k, test_eventdev_selftest_cn9k);
REGISTER_TEST_COMMAND(eventdev_selftest_cn10k, test_eventdev_selftest_cn10k);
#endif /* !RTE_EXEC_ENV_WINDOWS */

17
app/test/test_external_mem.c
View File

@ -2,11 +2,24 @@
* Copyright(c) 2018 Intel Corporation
*/
#include "test.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_external_mem(void)
{
printf("external_mem not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <sys/mman.h>
#include <sys/wait.h>
@ -19,8 +32,6 @@
#include <rte_ring.h>
#include <rte_string_fns.h>
#include "test.h"
#define EXTERNAL_MEM_SZ (RTE_PGSIZE_4K << 10) /* 4M of data */
static int
@ -574,4 +585,6 @@ test_external_mem(void)
return ret;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(external_mem_autotest, test_external_mem);

22
app/test/test_fib.c
View File

@ -9,10 +9,28 @@
#include <rte_ip.h>
#include <rte_log.h>
#include <rte_fib.h>
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_fib(void)
{
printf("fib not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_slow_fib(void)
{
printf("slow_fib not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_fib.h>
typedef int32_t (*rte_fib_test)(void);
static int32_t test_create_invalid(void);
@ -415,5 +433,7 @@ test_slow_fib(void)
return unit_test_suite_runner(&fib_slow_tests);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(fib_autotest, test_fib);
REGISTER_TEST_COMMAND(fib_slow_autotest, test_slow_fib);

24
app/test/test_fib6.c
View File

@ -9,11 +9,29 @@
#include <rte_memory.h>
#include <rte_log.h>
#include <rte_rib6.h>
#include <rte_fib6.h>
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_fib6(void)
{
printf("fib not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_slow_fib6(void)
{
printf("slow_fib not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_rib6.h>
#include <rte_fib6.h>
typedef int32_t (*rte_fib6_test)(void);
static int32_t test_create_invalid(void);
@ -424,5 +442,7 @@ test_slow_fib6(void)
return unit_test_suite_runner(&fib6_slow_tests);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(fib6_autotest, test_fib6);
REGISTER_TEST_COMMAND(fib6_slow_autotest, test_slow_fib6);

16
app/test/test_fib6_perf.c
View File

@ -10,9 +10,21 @@
#include <rte_cycles.h>
#include <rte_random.h>
#include <rte_memory.h>
#include <rte_fib6.h>
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_fib6_perf(void)
{
printf("fib6_perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_fib6.h>
#include "test_lpm6_data.h"
#define TEST_FIB_ASSERT(cond) do { \
@ -155,4 +167,6 @@ test_fib6_perf(void)
return 0;
}
#endif /*ifdef RTE_EXEC_ENV_WINDOWS*/
REGISTER_TEST_COMMAND(fib6_perf_autotest, test_fib6_perf);

15
app/test/test_fib_perf.c
View File

@ -12,11 +12,22 @@
#include <rte_random.h>
#include <rte_branch_prediction.h>
#include <rte_ip.h>
#include <rte_fib.h>
#include "test.h"
#include "test_xmmt_ops.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_fib_perf(void)
{
printf("fib_perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_fib.h>
#define TEST_FIB_ASSERT(cond) do { \
if (!(cond)) { \
printf("Error at line %d:\n", __LINE__); \
@ -409,4 +420,6 @@ test_fib_perf(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(fib_perf_autotest, test_fib_perf);

13
app/test/test_flow_classify.c
View File

@ -11,6 +11,17 @@
#include <rte_mbuf.h>
#include <rte_byteorder.h>
#include <rte_ip.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_flow_classify(void)
{
printf("flow_classify not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_acl.h>
#include <rte_common.h>
#include <rte_table_acl.h>
@ -879,4 +890,6 @@ test_flow_classify(void)
return TEST_SUCCESS;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(flow_classify_autotest, test_flow_classify);

3
app/test/test_func_reentrancy.c
View File

@ -489,6 +489,9 @@ test_func_reentrancy(void)
uint32_t case_id;
struct test_case *pt_case = NULL;
if (RTE_EXEC_ENV_IS_WINDOWS)
return TEST_SKIPPED;
if (rte_lcore_count() < 2) {
printf("Not enough cores for func_reentrancy_autotest, expecting at least 2\n");
return TEST_SKIPPED;

19
app/test/test_graph.c
View File

@ -1,6 +1,9 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(C) 2020 Marvell International Ltd.
*/
#include "test.h"
#include <assert.h>
#include <inttypes.h>
#include <signal.h>
@ -9,14 +12,23 @@
#include <unistd.h>
#include <rte_errno.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_node_list_dump(void)
{
printf("node_list_dump not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_graph.h>
#include <rte_graph_worker.h>
#include <rte_mbuf.h>
#include <rte_mbuf_dyn.h>
#include <rte_random.h>
#include "test.h"
static uint16_t test_node_worker_source(struct rte_graph *graph,
struct rte_node *node, void **objs,
uint16_t nb_objs);
@ -841,4 +853,7 @@ test_node_list_dump(void)
return TEST_SUCCESS;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(node_list_dump, test_node_list_dump);

17
app/test/test_graph_perf.c
View File

@ -1,6 +1,9 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(C) 2020 Marvell International Ltd.
*/
#include "test.h"
#include <inttypes.h>
#include <signal.h>
#include <stdio.h>
@ -9,14 +12,22 @@
#include <rte_common.h>
#include <rte_cycles.h>
#include <rte_errno.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_graph_perf_func(void)
{
printf("graph_perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_graph.h>
#include <rte_graph_worker.h>
#include <rte_lcore.h>
#include <rte_malloc.h>
#include <rte_mbuf.h>
#include "test.h"
#define TEST_GRAPH_PERF_MZ "graph_perf_data"
#define TEST_GRAPH_SRC_NAME "test_graph_perf_source"
#define TEST_GRAPH_SRC_BRST_ONE_NAME "test_graph_perf_source_one"
@ -1060,4 +1071,6 @@ test_graph_perf_func(void)
return unit_test_suite_runner(&graph_perf_testsuite);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(graph_perf_autotest, test_graph_perf_func);

4
app/test/test_hash_perf.c
View File

@ -723,6 +723,10 @@ static int
test_hash_perf(void)
{
unsigned int with_pushes, with_locks;
if (RTE_EXEC_ENV_IS_WINDOWS)
return TEST_SKIPPED;
for (with_locks = 0; with_locks <= 1; with_locks++) {
if (with_locks)
printf("\nWith locks in the code\n");

17
app/test/test_ipfrag.c
View File

@ -2,19 +2,30 @@
* Copyright(c) 2020 Red Hat, Inc.
*/
#include "test.h"
#include <time.h>
#include <rte_common.h>
#include <rte_cycles.h>
#include <rte_hexdump.h>
#include <rte_ip.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_ipfrag(void)
{
printf("ipfrag not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_ip_frag.h>
#include <rte_mbuf.h>
#include <rte_memcpy.h>
#include <rte_random.h>
#include "test.h"
#define NUM_MBUFS 128
#define BURST 32
@ -322,4 +333,6 @@ test_ipfrag(void)
return unit_test_suite_runner(&ipfrag_testsuite);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(ipfrag_autotest, test_ipfrag);

17
app/test/test_ipsec.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2018 Intel Corporation
*/
#include "test.h"
#include <time.h>
#include <rte_common.h>
@ -12,16 +14,25 @@
#include <rte_cycles.h>
#include <rte_bus_vdev.h>
#include <rte_ip.h>
#include <rte_crypto.h>
#include <rte_cryptodev.h>
#include <rte_lcore.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_ipsec(void)
{
printf("ipsec not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_ipsec.h>
#include <rte_random.h>
#include <rte_esp.h>
#include <rte_security_driver.h>
#include "test.h"
#include "test_cryptodev.h"
#define VDEV_ARGS_SIZE 100
@ -2536,4 +2547,6 @@ test_ipsec(void)
return unit_test_suite_runner(&ipsec_testsuite);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(ipsec_autotest, test_ipsec);

16
app/test/test_ipsec_perf.c
View File

@ -2,16 +2,28 @@
* Copyright(c) 2020 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <rte_ip.h>
#include <rte_malloc.h>
#include <rte_ring.h>
#include <rte_mbuf.h>
#include <rte_cycles.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_libipsec_perf(void)
{
printf("ipsec_perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_ipsec.h>
#include <rte_random.h>
#include "test.h"
#include "test_cryptodev.h"
#define RING_SIZE 4096
@ -611,4 +623,6 @@ test_libipsec_perf(void)
return TEST_SUCCESS;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(ipsec_perf_autotest, test_libipsec_perf);

15
app/test/test_ipsec_sad.c
View File

@ -2,15 +2,26 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_ipsec_sad(void)
{
printf("ipsec_sad not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_ipsec_sad.h>
#include <rte_memory.h>
#include "test.h"
#include "test_xmmt_ops.h"
typedef int32_t (*rte_ipsec_sad_test)(void);
@ -884,4 +895,6 @@ test_ipsec_sad(void)
return unit_test_suite_runner(&ipsec_sad_tests);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(ipsec_sad_autotest, test_ipsec_sad);

10
app/test/test_kni.c
View File

@ -2,15 +2,12 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <dirent.h>
#include "test.h"
#if !defined(RTE_EXEC_ENV_LINUX) || !defined(RTE_LIB_KNI)
static int
@ -22,6 +19,9 @@ test_kni(void)
#else
#include <sys/wait.h>
#include <dirent.h>
#include <rte_string_fns.h>
#include <rte_mempool.h>
#include <rte_ethdev.h>

3
app/test/test_lcores.c
View File

@ -384,6 +384,9 @@ test_lcores(void)
unsigned int eal_threads_count = 0;
unsigned int i;
if (RTE_EXEC_ENV_IS_WINDOWS)
return TEST_SKIPPED;
for (i = 0; i < RTE_MAX_LCORE; i++) {
if (!rte_lcore_has_role(i, ROLE_OFF))
eal_threads_count++;

15
app/test/test_lpm.c
View File

@ -2,6 +2,18 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_lpm(void)
{
printf("lpm not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
@ -10,7 +22,6 @@
#include <rte_lpm.h>
#include <rte_malloc.h>
#include "test.h"
#include "test_xmmt_ops.h"
#define TEST_LPM_ASSERT(cond) do { \
@ -1584,4 +1595,6 @@ test_lpm(void)
return global_status;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(lpm_autotest, test_lpm);

15
app/test/test_lpm6.c
View File

@ -2,15 +2,26 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <rte_memory.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_lpm6(void)
{
printf("lpm6 not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_lpm6.h>
#include "test.h"
#include "test_lpm6_data.h"
#define TEST_LPM_ASSERT(cond) do { \
@ -1792,4 +1803,6 @@ test_lpm6(void)
return global_status;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(lpm6_autotest, test_lpm6);

15
app/test/test_lpm6_perf.c
View File

@ -2,6 +2,18 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_lpm6_perf(void)
{
printf("lpm6_perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
@ -12,7 +24,6 @@
#include <rte_memory.h>
#include <rte_lpm6.h>
#include "test.h"
#include "test_lpm6_data.h"
#define TEST_LPM_ASSERT(cond) do { \
@ -160,4 +171,6 @@ test_lpm6_perf(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(lpm6_perf_autotest, test_lpm6_perf);

14
app/test/test_lpm_perf.c
View File

@ -3,6 +3,17 @@
* Copyright(c) 2020 Arm Limited
*/
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_lpm_perf(void)
{
printf("lpm_perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
@ -15,7 +26,6 @@
#include <rte_ip.h>
#include <rte_lpm.h>
#include "test.h"
#include "test_xmmt_ops.h"
struct rte_lpm *lpm;
@ -763,4 +773,6 @@ test_lpm_perf(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(lpm_perf_autotest, test_lpm_perf);

23
app/test/test_malloc.c
View File

@ -2,13 +2,17 @@
* Copyright(c) 2010-2019 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#include <stdlib.h>
#ifndef RTE_EXEC_ENV_WINDOWS
#include <sys/mman.h>
#endif
#include <sys/queue.h>
#include <unistd.h>
@ -23,11 +27,8 @@
#include <rte_random.h>
#include <rte_string_fns.h>
#include "test.h"
#define N 10000
static int
is_mem_on_socket(int32_t socket);
@ -47,8 +48,8 @@ addr_to_socket(void *addr);
static int
is_memory_overlap(void *p1, size_t len1, void *p2, size_t len2)
{
unsigned long ptr1 = (unsigned long)p1;
unsigned long ptr2 = (unsigned long)p2;
uintptr_t ptr1 = (uintptr_t)p1;
uintptr_t ptr2 = (uintptr_t)p2;
if (ptr2 >= ptr1 && (ptr2 - ptr1) < len1)
return 1;
@ -60,7 +61,7 @@ is_memory_overlap(void *p1, size_t len1, void *p2, size_t len2)
static int
is_aligned(void *p, int align)
{
unsigned long addr = (unsigned long)p;
uintptr_t addr = (uintptr_t)p;
unsigned mask = align - 1;
if (addr & mask)
@ -373,6 +374,14 @@ test_multi_alloc_statistics(void)
return 0;
}
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_realloc(void)
{
return TEST_SKIPPED;
}
#else
static int
test_realloc_socket(int socket)
{
@ -671,6 +680,8 @@ test_realloc(void)
return ret;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
static int
test_random_alloc_free(void *_ __rte_unused)
{

15
app/test/test_mbuf.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
@ -33,8 +35,6 @@
#include <rte_tcp.h>
#include <rte_mbuf_dyn.h>
#include "test.h"
#define MEMPOOL_CACHE_SIZE 32
#define MBUF_DATA_SIZE 2048
#define NB_MBUF 128
@ -1172,6 +1172,15 @@ test_refcnt_mbuf(void)
#endif
}
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_failing_mbuf_sanity_check(struct rte_mempool *pktmbuf_pool)
{
RTE_SET_USED(pktmbuf_pool);
return TEST_SKIPPED;
}
#else
#include <unistd.h>
#include <sys/resource.h>
#include <sys/time.h>
@ -1267,6 +1276,8 @@ test_failing_mbuf_sanity_check(struct rte_mempool *pktmbuf_pool)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
static int
test_mbuf_linearize(struct rte_mempool *pktmbuf_pool, int pkt_len,
int nb_segs)

17
app/test/test_member.c
View File

@ -4,16 +4,27 @@
/* This test is for membership library's simple feature test */
#include "test.h"
#include <rte_memcpy.h>
#include <rte_malloc.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_member(void)
{
printf("member not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_member.h>
#include <rte_byteorder.h>
#include <rte_random.h>
#include <rte_debug.h>
#include <rte_ip.h>
#include "test.h"
struct rte_member_setsum *setsum_ht;
struct rte_member_setsum *setsum_cache;
struct rte_member_setsum *setsum_vbf;
@ -712,4 +723,6 @@ test_member(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(member_autotest, test_member);

17
app/test/test_member_perf.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2017 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <inttypes.h>
@ -11,9 +13,18 @@
#include <rte_random.h>
#include <rte_memcpy.h>
#include <rte_thash.h>
#include <rte_member.h>
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_member_perf(void)
{
printf("member_perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_member.h>
#define NUM_KEYSIZES 10
#define NUM_SHUFFLES 10
@ -622,4 +633,6 @@ test_member_perf(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(member_perf_autotest, test_member_perf);

12
app/test/test_mp_secondary.c
View File

@ -14,6 +14,16 @@
#include <errno.h>
#include <string.h>
#include <unistd.h>
#ifdef RTE_EXEC_ENV_WINDOWS
int
test_mp_secondary(void)
{
printf("mp_secondary not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <sys/wait.h>
#include <libgen.h>
#include <dirent.h>
@ -211,4 +221,6 @@ test_mp_secondary(void)
return run_object_creation_tests();
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(multiprocess_autotest, test_mp_secondary);

31
app/test/test_pie.c
View File

@ -2,6 +2,33 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_pie(void)
{
printf("pie not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_pie_perf(void)
{
printf("pie_perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_pie_all(void)
{
printf("pie_all not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@ -12,8 +39,6 @@
#include <time.h>
#include <math.h>
#include "test.h"
#include <rte_pie.h>
#ifdef __INTEL_COMPILER
@ -1060,6 +1085,8 @@ test_pie_all(void)
return tell_the_result(num_tests, num_pass);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(pie_autotest, test_pie);
REGISTER_TEST_COMMAND(pie_perf, test_pie_perf);
REGISTER_TEST_COMMAND(pie_all, test_pie_all);

17
app/test/test_rawdev.c
View File

@ -1,16 +1,27 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright 2017 NXP
*/
#include "test.h"
#include <rte_common.h>
#include <rte_mbuf.h>
#include <rte_malloc.h>
#include <rte_memcpy.h>
#include <rte_dev.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_rawdev_selftests(void)
{
printf("rawdev not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_rawdev.h>
#include <rte_bus_vdev.h>
#include "test.h"
static int
test_rawdev_selftest_impl(const char *pmd, const char *opts)
{
@ -54,4 +65,6 @@ test_rawdev_selftests(void)
return ret;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(rawdev_autotest, test_rawdev_selftests);

3
app/test/test_rcu_qsbr_perf.c
View File

@ -614,6 +614,9 @@ test_rcu_qsbr_main(void)
{
uint16_t core_id;
if (RTE_EXEC_ENV_IS_WINDOWS)
return TEST_SKIPPED;
if (rte_lcore_count() < 3) {
printf("Not enough cores for rcu_qsbr_perf_autotest, expecting at least 3\n");
return TEST_SKIPPED;

30
app/test/test_red.c
View File

@ -2,18 +2,42 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <inttypes.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_red(void)
{
printf("red not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_red_perf(void)
{
printf("red_perf not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_red_all(void)
{
printf("red_all not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <sys/time.h>
#include <time.h>
#include <math.h>
#include "test.h"
#include <rte_red.h>
#ifdef __INTEL_COMPILER
@ -1851,6 +1875,8 @@ test_red_all(void)
return tell_the_result(num_tests, num_pass);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(red_autotest, test_red);
REGISTER_TEST_COMMAND(red_perf, test_red_perf);
REGISTER_TEST_COMMAND(red_all, test_red_all);

16
app/test/test_reorder.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <unistd.h>
#include <string.h>
@ -9,12 +11,20 @@
#include <rte_cycles.h>
#include <rte_errno.h>
#include <rte_mbuf.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_reorder(void)
{
printf("reorder not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_reorder.h>
#include <rte_lcore.h>
#include <rte_malloc.h>
#include "test.h"
#define BURST 32
#define REORDER_BUFFER_SIZE 16384
#define NUM_MBUFS (2*REORDER_BUFFER_SIZE)
@ -390,4 +400,6 @@ test_reorder(void)
return unit_test_suite_runner(&reorder_test_suite);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(reorder_autotest, test_reorder);

23
app/test/test_rib.c
View File

@ -3,14 +3,31 @@
* Copyright(c) 2019 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <rte_ip.h>
#include <rte_rib.h>
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_rib(void)
{
printf("rib not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_slow_rib(void)
{
printf("slow_rib not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_rib.h>
typedef int32_t (*rte_rib_test)(void);
@ -363,5 +380,7 @@ test_slow_rib(void)
return unit_test_suite_runner(&rib_slow_tests);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(rib_autotest, test_rib);
REGISTER_TEST_COMMAND(rib_slow_autotest, test_slow_rib);

23
app/test/test_rib6.c
View File

@ -3,14 +3,31 @@
* Copyright(c) 2019 Intel Corporation
*/
#include "test.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <rte_ip.h>
#include <rte_rib6.h>
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_rib6(void)
{
printf("rib6 not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_slow_rib6(void)
{
printf("slow_rib6 not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_rib6.h>
typedef int32_t (*rte_rib6_test)(void);
@ -368,5 +385,7 @@ test_slow_rib6(void)
return unit_test_suite_runner(&rib6_slow_tests);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(rib6_autotest, test_rib6);
REGISTER_TEST_COMMAND(rib6_slow_autotest, test_slow_rib6);

13
app/test/test_sched.c
View File

@ -14,8 +14,17 @@
#include <rte_ether.h>
#include <rte_ip.h>
#include <rte_byteorder.h>
#include <rte_sched.h>
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_sched(void)
{
printf("sched not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <rte_sched.h>
#define SUBPORT 0
#define PIPE 1
@ -204,4 +213,6 @@ test_sched(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(sched_autotest, test_sched);

12
app/test/test_table.c
View File

@ -7,6 +7,16 @@
#include <rte_string_fns.h>
#include <string.h>
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_table(void)
{
printf("table not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include "test_table.h"
#include "test_table_pipeline.h"
#include "test_table_ports.h"
@ -194,4 +204,6 @@ test_table(void)
return ret;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(table_autotest, test_table);

4
app/test/test_table_acl.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include <rte_ip.h>
#include <rte_string_fns.h>
#include <rte_hexdump.h>
@ -728,3 +730,5 @@ test_table_acl(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */

4
app/test/test_table_combined.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2010-2016 Intel Corporation
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include <string.h>
#include "test_table_combined.h"
#include "test_table.h"
@ -840,3 +842,5 @@ test_table_hash_cuckoo_combined(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */

4
app/test/test_table_pipeline.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include <string.h>
#include <rte_pipeline.h>
#include <rte_log.h>
@ -569,3 +571,5 @@ test_table_pipeline(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */

4
app/test/test_table_ports.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2010-2014 Intel Corporation
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include "test_table_ports.h"
#include "test_table.h"
@ -189,3 +191,5 @@ test_port_ring_writer(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */

4
app/test/test_table_tables.c
View File

@ -2,6 +2,8 @@
* Copyright(c) 2010-2016 Intel Corporation
*/
#ifndef RTE_EXEC_ENV_WINDOWS
#include <string.h>
#include <rte_byteorder.h>
#include <rte_table_lpm_ipv6.h>
@ -1052,3 +1054,5 @@ test_table_hash_cuckoo(void)
return 0;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */

12
app/test/test_timer_secondary.c
View File

@ -15,6 +15,16 @@
#include <rte_random.h>
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
int
test_timer_secondary(void)
{
printf("timer_secondary not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include "process.h"
#define NUM_TIMERS (1 << 20) /* ~1M timers */
@ -212,4 +222,6 @@ test_timer_secondary(void)
return TEST_FAILED;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(timer_secondary_autotest, test_timer_secondary);

33
app/test/test_trace.c
View File

@ -9,6 +9,31 @@
#include "test.h"
#include "test_trace.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_trace(void)
{
printf("trace not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_trace_dump(void)
{
printf("trace_dump not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
static int
test_trace_metadata_dump(void)
{
printf("trace_metadata_dump not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
static int32_t
test_trace_point_globbing(void)
{
@ -194,8 +219,6 @@ test_trace(void)
return unit_test_suite_runner(&trace_tests);
}
REGISTER_TEST_COMMAND(trace_autotest, test_trace);
static int
test_trace_dump(void)
{
@ -203,12 +226,14 @@ test_trace_dump(void)
return 0;
}
REGISTER_TEST_COMMAND(trace_dump, test_trace_dump);
static int
test_trace_metadata_dump(void)
{
return rte_trace_metadata_dump(stdout);
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(trace_autotest, test_trace);
REGISTER_TEST_COMMAND(trace_dump, test_trace_dump);
REGISTER_TEST_COMMAND(trace_metadata_dump, test_trace_metadata_dump);