diff --git a/app/test/test_acl.c b/app/test/test_acl.c
index 5b32347954..4d51098925 100644
--- a/app/test/test_acl.c
+++ b/app/test/test_acl.c
@@ -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);
diff --git a/app/test/test_bpf.c b/app/test/test_bpf.c
index 2d755a872f..d1e10adab5 100644
--- a/app/test/test_bpf.c
+++ b/app/test/test_bpf.c
@@ -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
diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index ec4a61bdf9..8842e19d3d 100644
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -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 */
diff --git a/app/test/test_cryptodev_asym.c b/app/test/test_cryptodev_asym.c
index 68f4d8e7a6..9d3a5589bb 100644
--- a/app/test/test_cryptodev_asym.c
+++ b/app/test/test_cryptodev_asym.c
@@ -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 */
diff --git a/app/test/test_cryptodev_blockcipher.c b/app/test/test_cryptodev_blockcipher.c
index 5688a45377..0c6f3ff42d 100644
--- a/app/test/test_cryptodev_blockcipher.c
+++ b/app/test/test_cryptodev_blockcipher.c
@@ -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 */
diff --git a/app/test/test_cryptodev_security_ipsec.c b/app/test/test_cryptodev_security_ipsec.c
index e662ea279f..229eadf5de 100644
--- a/app/test/test_cryptodev_security_ipsec.c
+++ b/app/test/test_cryptodev_security_ipsec.c
@@ -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 */
diff --git a/app/test/test_cryptodev_security_pdcp.c b/app/test/test_cryptodev_security_pdcp.c
index a7641bab7a..30d86fb28e 100644
--- a/app/test/test_cryptodev_security_pdcp.c
+++ b/app/test/test_cryptodev_security_pdcp.c
@@ -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 */
diff --git a/app/test/test_debug.c b/app/test/test_debug.c
index 23b24db177..2704f5b927 100644
--- a/app/test/test_debug.c
+++ b/app/test/test_debug.c
@@ -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);
diff --git a/app/test/test_distributor.c b/app/test/test_distributor.c
index 961f326cd5..3efa4af104 100644
--- a/app/test/test_distributor.c
+++ b/app/test/test_distributor.c
@@ -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);
diff --git a/app/test/test_distributor_perf.c b/app/test/test_distributor_perf.c
index 92e330f194..ee4321486d 100644
--- a/app/test/test_distributor_perf.c
+++ b/app/test/test_distributor_perf.c
@@ -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);
diff --git a/app/test/test_eal_flags.c b/app/test/test_eal_flags.c
index d7f4c2cd47..bc158d7a4a 100644
--- a/app/test/test_eal_flags.c
+++ b/app/test/test_eal_flags.c
@@ -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);
diff --git a/app/test/test_eal_fs.c b/app/test/test_eal_fs.c
index 39ac6961b3..b3686edcb4 100644
--- a/app/test/test_eal_fs.c
+++ b/app/test/test_eal_fs.c
@@ -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);
diff --git a/app/test/test_efd.c b/app/test/test_efd.c
index 1b249e0447..7bea674086 100644
--- a/app/test/test_efd.c
+++ b/app/test/test_efd.c
@@ -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);
diff --git a/app/test/test_efd_perf.c b/app/test/test_efd_perf.c
index f3fe3b1736..d7f4d83549 100644
--- a/app/test/test_efd_perf.c
+++ b/app/test/test_efd_perf.c
@@ -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);
diff --git a/app/test/test_event_crypto_adapter.c b/app/test/test_event_crypto_adapter.c
index 3d7e9fb93c..688520db4e 100644
--- a/app/test/test_event_crypto_adapter.c
+++ b/app/test/test_event_crypto_adapter.c
@@ -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);
diff --git a/app/test/test_event_eth_rx_adapter.c b/app/test/test_event_eth_rx_adapter.c
index 7cb91b152f..e358a7056b 100644
--- a/app/test/test_event_eth_rx_adapter.c
+++ b/app/test/test_event_eth_rx_adapter.c
@@ -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,
diff --git a/app/test/test_event_eth_tx_adapter.c b/app/test/test_event_eth_tx_adapter.c
index cfcc784351..2900532f83 100644
--- a/app/test/test_event_eth_tx_adapter.c
+++ b/app/test/test_event_eth_tx_adapter.c
@@ -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);
diff --git a/app/test/test_event_ring.c b/app/test/test_event_ring.c
index 70eb9845e1..bc4a6e73f5 100644
--- a/app/test/test_event_ring.c
+++ b/app/test/test_event_ring.c
@@ -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);
diff --git a/app/test/test_event_timer_adapter.c b/app/test/test_event_timer_adapter.c
index 25bac2d155..d6170bb589 100644
--- a/app/test/test_event_timer_adapter.c
+++ b/app/test/test_event_timer_adapter.c
@@ -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);
diff --git a/app/test/test_eventdev.c b/app/test/test_eventdev.c
index 10028fe11d..4f51042bda 100644
--- a/app/test/test_eventdev.c
+++ b/app/test/test_eventdev.c
@@ -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 */
diff --git a/app/test/test_external_mem.c b/app/test/test_external_mem.c
index 5edf88b9f6..0c64b610a9 100644
--- a/app/test/test_external_mem.c
+++ b/app/test/test_external_mem.c
@@ -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);
diff --git a/app/test/test_fib.c b/app/test/test_fib.c
index eb69d6e2fd..a2d1ea8f3a 100644
--- a/app/test/test_fib.c
+++ b/app/test/test_fib.c
@@ -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);
diff --git a/app/test/test_fib6.c b/app/test/test_fib6.c
index 15ad09178a..cd971e6ecd 100644
--- a/app/test/test_fib6.c
+++ b/app/test/test_fib6.c
@@ -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);
diff --git a/app/test/test_fib6_perf.c b/app/test/test_fib6_perf.c
index e565799155..21d2b65318 100644
--- a/app/test/test_fib6_perf.c
+++ b/app/test/test_fib6_perf.c
@@ -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);
diff --git a/app/test/test_fib_perf.c b/app/test/test_fib_perf.c
index 7a25fe8df7..9787874cc9 100644
--- a/app/test/test_fib_perf.c
+++ b/app/test/test_fib_perf.c
@@ -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);
diff --git a/app/test/test_flow_classify.c b/app/test/test_flow_classify.c
index 4f64be5357..6e274d88e6 100644
--- a/app/test/test_flow_classify.c
+++ b/app/test/test_flow_classify.c
@@ -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);
diff --git a/app/test/test_func_reentrancy.c b/app/test/test_func_reentrancy.c
index ce40c3ce96..4ab4167eb0 100644
--- a/app/test/test_func_reentrancy.c
+++ b/app/test/test_func_reentrancy.c
@@ -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;
diff --git a/app/test/test_graph.c b/app/test/test_graph.c
index 81bdcb9bea..35e1a95b89 100644
--- a/app/test/test_graph.c
+++ b/app/test/test_graph.c
@@ -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);
diff --git a/app/test/test_graph_perf.c b/app/test/test_graph_perf.c
index 296d99a9d3..1d065438a6 100644
--- a/app/test/test_graph_perf.c
+++ b/app/test/test_graph_perf.c
@@ -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);
diff --git a/app/test/test_hash_perf.c b/app/test/test_hash_perf.c
index 7e98ec3964..104a70b397 100644
--- a/app/test/test_hash_perf.c
+++ b/app/test/test_hash_perf.c
@@ -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");
diff --git a/app/test/test_ipfrag.c b/app/test/test_ipfrag.c
index 1ced25a123..baff5ed083 100644
--- a/app/test/test_ipfrag.c
+++ b/app/test/test_ipfrag.c
@@ -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);
diff --git a/app/test/test_ipsec.c b/app/test/test_ipsec.c
index bc2a3dbc2e..8da025bf66 100644
--- a/app/test/test_ipsec.c
+++ b/app/test/test_ipsec.c
@@ -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);
diff --git a/app/test/test_ipsec_perf.c b/app/test/test_ipsec_perf.c
index 92106bf374..346a851648 100644
--- a/app/test/test_ipsec_perf.c
+++ b/app/test/test_ipsec_perf.c
@@ -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);
diff --git a/app/test/test_ipsec_sad.c b/app/test/test_ipsec_sad.c
index 491164689e..7534f16f89 100644
--- a/app/test/test_ipsec_sad.c
+++ b/app/test/test_ipsec_sad.c
@@ -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);
diff --git a/app/test/test_kni.c b/app/test/test_kni.c
index 2761de9b07..622315c8b1 100644
--- a/app/test/test_kni.c
+++ b/app/test/test_kni.c
@@ -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>
diff --git a/app/test/test_lcores.c b/app/test/test_lcores.c
index a0d8c6aa41..a6bb4124ad 100644
--- a/app/test/test_lcores.c
+++ b/app/test/test_lcores.c
@@ -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++;
diff --git a/app/test/test_lpm.c b/app/test/test_lpm.c
index 37b460af3a..bceb9ae743 100644
--- a/app/test/test_lpm.c
+++ b/app/test/test_lpm.c
@@ -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);
diff --git a/app/test/test_lpm6.c b/app/test/test_lpm6.c
index 17221f992a..1f44392db7 100644
--- a/app/test/test_lpm6.c
+++ b/app/test/test_lpm6.c
@@ -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);
diff --git a/app/test/test_lpm6_perf.c b/app/test/test_lpm6_perf.c
index 0b43ad824a..aaf2773b6f 100644
--- a/app/test/test_lpm6_perf.c
+++ b/app/test/test_lpm6_perf.c
@@ -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);
diff --git a/app/test/test_lpm_perf.c b/app/test/test_lpm_perf.c
index 2bed00d064..e858716f90 100644
--- a/app/test/test_lpm_perf.c
+++ b/app/test/test_lpm_perf.c
@@ -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);
diff --git a/app/test/test_malloc.c b/app/test/test_malloc.c
index 6d9249f831..8db500c514 100644
--- a/app/test/test_malloc.c
+++ b/app/test/test_malloc.c
@@ -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)
 {
diff --git a/app/test/test_mbuf.c b/app/test/test_mbuf.c
index f54d1d7c00..f762befb69 100644
--- a/app/test/test_mbuf.c
+++ b/app/test/test_mbuf.c
@@ -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)
diff --git a/app/test/test_member.c b/app/test/test_member.c
index af9d50915c..26a712439f 100644
--- a/app/test/test_member.c
+++ b/app/test/test_member.c
@@ -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);
diff --git a/app/test/test_member_perf.c b/app/test/test_member_perf.c
index e2840f12d3..978db0020a 100644
--- a/app/test/test_member_perf.c
+++ b/app/test/test_member_perf.c
@@ -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);
diff --git a/app/test/test_mp_secondary.c b/app/test/test_mp_secondary.c
index 021ca0547f..ad47d578f2 100644
--- a/app/test/test_mp_secondary.c
+++ b/app/test/test_mp_secondary.c
@@ -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);
diff --git a/app/test/test_pie.c b/app/test/test_pie.c
index 632d4b014d..a3c0f97c9d 100644
--- a/app/test/test_pie.c
+++ b/app/test/test_pie.c
@@ -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);
diff --git a/app/test/test_rawdev.c b/app/test/test_rawdev.c
index 081fab969b..3c780e3f9e 100644
--- a/app/test/test_rawdev.c
+++ b/app/test/test_rawdev.c
@@ -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);
diff --git a/app/test/test_rcu_qsbr_perf.c b/app/test/test_rcu_qsbr_perf.c
index cf7b158d22..b15e5cef88 100644
--- a/app/test/test_rcu_qsbr_perf.c
+++ b/app/test/test_rcu_qsbr_perf.c
@@ -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;
diff --git a/app/test/test_red.c b/app/test/test_red.c
index 33a9f4ebb7..84c292f8d8 100644
--- a/app/test/test_red.c
+++ b/app/test/test_red.c
@@ -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);
diff --git a/app/test/test_reorder.c b/app/test/test_reorder.c
index 1c4226da65..07dcce06d2 100644
--- a/app/test/test_reorder.c
+++ b/app/test/test_reorder.c
@@ -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);
diff --git a/app/test/test_rib.c b/app/test/test_rib.c
index 3dc48fe1f2..06058f8f7c 100644
--- a/app/test/test_rib.c
+++ b/app/test/test_rib.c
@@ -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);
diff --git a/app/test/test_rib6.c b/app/test/test_rib6.c
index c77df11298..ba79aedea5 100644
--- a/app/test/test_rib6.c
+++ b/app/test/test_rib6.c
@@ -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);
diff --git a/app/test/test_sched.c b/app/test/test_sched.c
index 958b631144..ddec572447 100644
--- a/app/test/test_sched.c
+++ b/app/test/test_sched.c
@@ -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);
diff --git a/app/test/test_table.c b/app/test/test_table.c
index 95034148cb..d100666e1c 100644
--- a/app/test/test_table.c
+++ b/app/test/test_table.c
@@ -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);
diff --git a/app/test/test_table_acl.c b/app/test/test_table_acl.c
index 0bdf76ab70..e66f06b84d 100644
--- a/app/test/test_table_acl.c
+++ b/app/test/test_table_acl.c
@@ -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 */
diff --git a/app/test/test_table_combined.c b/app/test/test_table_combined.c
index f72b634bff..1c2efe649d 100644
--- a/app/test/test_table_combined.c
+++ b/app/test/test_table_combined.c
@@ -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 */
diff --git a/app/test/test_table_pipeline.c b/app/test/test_table_pipeline.c
index 915c451fed..7adbbffbf5 100644
--- a/app/test/test_table_pipeline.c
+++ b/app/test/test_table_pipeline.c
@@ -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 */
diff --git a/app/test/test_table_ports.c b/app/test/test_table_ports.c
index d921b2e207..282ec2a3d2 100644
--- a/app/test/test_table_ports.c
+++ b/app/test/test_table_ports.c
@@ -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 */
diff --git a/app/test/test_table_tables.c b/app/test/test_table_tables.c
index 4ff6ab16aa..d5c5a426bc 100644
--- a/app/test/test_table_tables.c
+++ b/app/test/test_table_tables.c
@@ -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 */
diff --git a/app/test/test_timer_secondary.c b/app/test/test_timer_secondary.c
index 5795c97f07..4e220559b4 100644
--- a/app/test/test_timer_secondary.c
+++ b/app/test/test_timer_secondary.c
@@ -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);
diff --git a/app/test/test_trace.c b/app/test/test_trace.c
index 0f9df83c40..76af79162b 100644
--- a/app/test/test_trace.c
+++ b/app/test/test_trace.c
@@ -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);