test: skip tests when missing requirements

Let's mark as skipped the tests when they are missing some requirements
like a number of used cores or specific hardware availability, like
compress, crypto or eventdev devices.

Signed-off-by: David Marchand <david.marchand@redhat.com>

diff --git a/app/test/test.c b/app/test/test.c
index ea1e98f2ec386ec6e02ceec129c57f4cb92394de..194a92a398a900d825921050d09cb94fede90488 100644 (file)
--- a/app/test/test.c
+++ b/app/test/test.c
@@ -208,14 +208,16 @@ unit_test_suite_runner(struct unit_test_suite *suite)
                printf(" + Test Suite : %s\n", suite->suite_name);
        }
 
-       if (suite->setup)
-               if (suite->setup() != 0) {
+       if (suite->setup) {
+               test_success = suite->setup();
+               if (test_success != 0) {
                        /*
-                        * setup failed, so count all enabled tests and mark
-                        * them as failed
+                        * setup did not pass, so count all enabled tests and
+                        * mark them as failed/skipped
                         */
                        while (suite->unit_test_cases[total].testcase) {
-                               if (!suite->unit_test_cases[total].enabled)
+                               if (!suite->unit_test_cases[total].enabled ||
+                                   test_success == TEST_SKIPPED)
                                        skipped++;
                                else
                                        failed++;
@@ -223,6 +225,7 @@ unit_test_suite_runner(struct unit_test_suite *suite)
                        }
                        goto suite_summary;
                }
+       }
 
        printf(" + ------------------------------------------------------- +\n");
 
@@ -246,6 +249,8 @@ unit_test_suite_runner(struct unit_test_suite *suite)
                        test_success = suite->unit_test_cases[total].testcase();
                        if (test_success == TEST_SUCCESS)
                                succeeded++;
+                       else if (test_success == TEST_SKIPPED)
+                               skipped++;
                        else if (test_success == -ENOTSUP)
                                unsupported++;
                        else
@@ -262,6 +267,8 @@ unit_test_suite_runner(struct unit_test_suite *suite)
 
                if (test_success == TEST_SUCCESS)
                        status = "succeeded";
+               else if (test_success == TEST_SKIPPED)
+                       status = "skipped";
                else if (test_success == -ENOTSUP)
                        status = "unsupported";
                else
@@ -293,7 +300,8 @@ suite_summary:
        last_test_result = failed;
 
        if (failed)
-               return -1;
-
-       return 0;
+               return TEST_FAILED;
+       if (total == skipped)
+               return TEST_SKIPPED;
+       return TEST_SUCCESS;
 }

diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c
index 1b1983e2198d789a8cb211bf9eab12b95707e84a..cf78775f736d5e66f3373d70a811305778457fc4 100644 (file)
--- a/app/test/test_compressdev.c
+++ b/app/test/test_compressdev.c
@@ -134,8 +134,8 @@ testsuite_setup(void)
        unsigned int i;
 
        if (rte_compressdev_count() == 0) {
-               RTE_LOG(ERR, USER1, "Need at least one compress device\n");
-               return TEST_FAILED;
+               RTE_LOG(WARNING, USER1, "Need at least one compress device\n");
+               return TEST_SKIPPED;
        }
 
        RTE_LOG(NOTICE, USER1, "Running tests on device %s\n",

diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index eca6d3db16a5cc66966ad0498f2ed76a07aeaebe..0509af7b6ccb0bed1dab81168f0c31dc21337eda 100644 (file)
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -408,8 +408,8 @@ testsuite_setup(void)
 
        nb_devs = rte_cryptodev_count();
        if (nb_devs < 1) {
-               RTE_LOG(ERR, USER1, "No crypto devices found?\n");
-               return TEST_FAILED;
+               RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
+               return TEST_SKIPPED;
        }
 
        /* Create list of valid crypto devs */

diff --git a/app/test/test_distributor.c b/app/test/test_distributor.c
index da3348fd1f48bf588a4f360ddabcd94bb3cf053e..8084c07943ebc88da0e14362b6559b01106a79bf 100644 (file)
--- a/app/test/test_distributor.c
+++ b/app/test/test_distributor.c
@@ -594,8 +594,8 @@ test_distributor(void)
        int i;
 
        if (rte_lcore_count() < 2) {
-               printf("ERROR: not enough cores to test distributor\n");
-               return -1;
+               printf("Not enough cores for distributor_autotest, expecting at least 2\n");
+               return TEST_SKIPPED;
        }
 
        if (db == NULL) {

diff --git a/app/test/test_distributor_perf.c b/app/test/test_distributor_perf.c
index edf1998ab0844fdca4021ad677c421dd9258503b..f6f11394924e81298d3047ebbc730194ae88f197 100644 (file)
--- a/app/test/test_distributor_perf.c
+++ b/app/test/test_distributor_perf.c
@@ -208,8 +208,8 @@ test_distributor_perf(void)
        static struct rte_mempool *p;
 
        if (rte_lcore_count() < 2) {
-               printf("ERROR: not enough cores to test distributor\n");
-               return -1;
+               printf("Not enough cores for distributor_perf_autotest, expecting at least 2\n");
+               return TEST_SKIPPED;
        }
 
        /* first time how long it takes to round-trip a cache line */

diff --git a/app/test/test_event_timer_adapter.c b/app/test/test_event_timer_adapter.c
index 742ca81818a77b15b62497258323ee688cd489e1..ad3f4dcc205fd5664a4c0f655e32df596e12a97d 100644 (file)
--- a/app/test/test_event_timer_adapter.c
+++ b/app/test/test_event_timer_adapter.c
@@ -158,8 +158,9 @@ testsuite_setup(void)
        }
 
        if (rte_lcore_count() < required_lcore_count) {
-               printf("%d lcores needed to run tests", required_lcore_count);
-               return TEST_FAILED;
+               printf("Not enough cores for event_timer_adapter_test, expecting at least %u\n",
+                      required_lcore_count);
+               return TEST_SKIPPED;
        }
 
        /* Assign lcores for various tasks */

diff --git a/app/test/test_eventdev.c b/app/test/test_eventdev.c
index 00d73275c8660dc8738d3f67ce6dd49d25609586..c745e997ebcab7c4b45b0f6b087ef1f236300d6c 100644 (file)
--- a/app/test/test_eventdev.c
+++ b/app/test/test_eventdev.c
@@ -997,6 +997,8 @@ static int
 test_eventdev_selftest_impl(const char *pmd, const char *opts)
 {
        rte_vdev_init(pmd, opts);
+       if (rte_event_dev_get_dev_id(pmd) == -ENODEV)
+               return TEST_SKIPPED;
        return rte_event_dev_selftest(rte_event_dev_get_dev_id(pmd));
 }
 

diff --git a/app/test/test_func_reentrancy.c b/app/test/test_func_reentrancy.c
index e27d1e020ff688526572c57b2861a409d46f648e..99ad902a24886ed168fff27f4b49584717066cd6 100644 (file)
--- a/app/test/test_func_reentrancy.c
+++ b/app/test/test_func_reentrancy.c
@@ -473,9 +473,9 @@ test_func_reentrancy(void)
        uint32_t case_id;
        struct test_case *pt_case = NULL;
 
-       if (rte_lcore_count() <= 1) {
-               printf("Not enough lcore for testing\n");
-               return -1;
+       if (rte_lcore_count() < 2) {
+               printf("Not enough cores for func_reentrancy_autotest, expecting at least 2\n");
+               return TEST_SKIPPED;
        }
        else if (rte_lcore_count() > MAX_LCORES)
                printf("Too many lcores, some cores will be disabled\n");

diff --git a/app/test/test_hash_multiwriter.c b/app/test/test_hash_multiwriter.c
index 50018db56c86874fb2f3d7320b5803f289782d8e..46ab45f82a99327c7fa167e309a40df4e667f172 100644 (file)
--- a/app/test/test_hash_multiwriter.c
+++ b/app/test/test_hash_multiwriter.c
@@ -260,12 +260,11 @@ err1:
 static int
 test_hash_multiwriter_main(void)
 {
-       if (rte_lcore_count() == 1) {
-               printf("More than one lcore is required to do multiwriter test\n");
-               return 0;
+       if (rte_lcore_count() < 2) {
+               printf("Not enough cores for distributor_autotest, expecting at least 2\n");
+               return TEST_SKIPPED;
        }
 
-
        setlocale(LC_NUMERIC, "");
 
 

diff --git a/app/test/test_hash_readwrite.c b/app/test/test_hash_readwrite.c
index 480ae97d857d454a4a63ca7d2e09a6ad788135cb..4376b099b3619db9debf2bbfc93e0bc686b1fd89 100644 (file)
--- a/app/test/test_hash_readwrite.c
+++ b/app/test/test_hash_readwrite.c
@@ -618,10 +618,9 @@ test_hash_readwrite_main(void)
        int use_htm, use_ext,  reader_faster;
        unsigned int i = 0, core_id = 0;
 
-       if (rte_lcore_count() <= 2) {
-               printf("More than two lcores are required "
-                       "to do read write test\n");
-               return -1;
+       if (rte_lcore_count() < 3) {
+               printf("Not enough cores for hash_readwrite_autotest, expecting at least 3\n");
+               return TEST_SKIPPED;
        }
 
        RTE_LCORE_FOREACH_SLAVE(core_id) {

diff --git a/app/test/test_hash_readwrite_lf.c b/app/test/test_hash_readwrite_lf.c
index 56443619687377fea79637072b6fedf0a0bbd5cd..2664f5138c68d09222cd9fe6c0ee6b295743f9da 100644 (file)
--- a/app/test/test_hash_readwrite_lf.c
+++ b/app/test/test_hash_readwrite_lf.c
@@ -1254,10 +1254,10 @@ test_hash_readwrite_lf_main(void)
        int htm;
        int use_jhash = 0;
        int ext_bkt = 0;
-       if (rte_lcore_count() == 1) {
-               printf("More than one lcore is required "
-                       "to do read write lock-free concurrency test\n");
-               return -1;
+
+       if (rte_lcore_count() < 2) {
+               printf("Not enough cores for hash_readwrite_lf_autotest, expecting at least 2\n");
+               return TEST_SKIPPED;
        }
 
        setlocale(LC_NUMERIC, "");

diff --git a/app/test/test_ipsec.c b/app/test/test_ipsec.c
index 3993ff465a90b4fba01f3d45e488cb3c7b6b6382..83f789508fe5d6bd50d71bf0a7bdacf9b01b5bf7 100644 (file)
--- a/app/test/test_ipsec.c
+++ b/app/test/test_ipsec.c
@@ -296,8 +296,8 @@ testsuite_setup(void)
 
        nb_devs = rte_cryptodev_count();
        if (nb_devs < 1) {
-               RTE_LOG(ERR, USER1, "No crypto devices found?\n");
-               return TEST_FAILED;
+               RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
+               return TEST_SKIPPED;
        }
 
        /* Find first valid crypto device */

diff --git a/app/test/test_mbuf.c b/app/test/test_mbuf.c
index 030385ec59644c7eb41b709316d48b020bca1cb7..2a97afe2044a3e0ff490c3e6540593d7fb234e37 100644 (file)
--- a/app/test/test_mbuf.c
+++ b/app/test/test_mbuf.c
@@ -753,18 +753,17 @@ static int
 test_refcnt_mbuf(void)
 {
 #ifdef RTE_MBUF_REFCNT_ATOMIC
-       unsigned lnum, master, slave, tref;
+       unsigned int master, slave, tref;
        int ret = -1;
        struct rte_mempool *refcnt_pool = NULL;
        struct rte_ring *refcnt_mbuf_ring = NULL;
 
-       if ((lnum = rte_lcore_count()) == 1) {
-               printf("skipping %s, number of lcores: %u is not enough\n",
-                   __func__, lnum);
-               return 0;
+       if (rte_lcore_count() < 2) {
+               printf("Not enough cores for test_refcnt_mbuf, expecting at least 2\n");
+               return TEST_SKIPPED;
        }
 
-       printf("starting %s, at %u lcores\n", __func__, lnum);
+       printf("starting %s, at %u lcores\n", __func__, rte_lcore_count());
 
        /* create refcnt pool & ring if they don't exist */
 
@@ -1206,7 +1205,7 @@ test_mbuf(void)
                goto err;
        }
 
-       if (test_refcnt_mbuf()<0){
+       if (test_refcnt_mbuf() < 0) {
                printf("test_refcnt_mbuf() failed \n");
                goto err;
        }

diff --git a/app/test/test_rcu_qsbr.c b/app/test/test_rcu_qsbr.c
index 97af08713693bb65cd5cb08ff84590d406c22235..943a1e370e0855c7d94e3076fb87a31099976194 100644 (file)
--- a/app/test/test_rcu_qsbr.c
+++ b/app/test/test_rcu_qsbr.c
@@ -978,17 +978,17 @@ test_rcu_qsbr_main(void)
 {
        uint16_t core_id;
 
+       if (rte_lcore_count() < 5) {
+               printf("Not enough cores for rcu_qsbr_autotest, expecting at least 5\n");
+               return TEST_SKIPPED;
+       }
+
        num_cores = 0;
        RTE_LCORE_FOREACH_SLAVE(core_id) {
                enabled_core_ids[num_cores] = core_id;
                num_cores++;
        }
 
-       if (num_cores < 4) {
-               printf("Test failed! Need 4 or more cores\n");
-               goto test_fail;
-       }
-
        /* Error-checking test cases */
        if (test_rcu_qsbr_get_memsize() < 0)
                goto test_fail;

diff --git a/app/test/test_rcu_qsbr_perf.c b/app/test/test_rcu_qsbr_perf.c
index c918a9433c558dd201115c28b254d44d0152ab9e..363365f4633a7117e52291fed9042d055b7b21db 100644 (file)
--- a/app/test/test_rcu_qsbr_perf.c
+++ b/app/test/test_rcu_qsbr_perf.c
@@ -606,6 +606,11 @@ test_rcu_qsbr_main(void)
 {
        uint16_t core_id;
 
+       if (rte_lcore_count() < 3) {
+               printf("Not enough cores for rcu_qsbr_perf_autotest, expecting at least 3\n");
+               return TEST_SKIPPED;
+       }
+
        rte_atomic64_init(&updates);
        rte_atomic64_init(&update_cycles);
        rte_atomic64_init(&checks);
@@ -618,11 +623,6 @@ test_rcu_qsbr_main(void)
        }
 
        printf("Number of cores provided = %d\n", num_cores);
-       if (num_cores < 2) {
-               printf("Test failed! Need 2 or more cores\n");
-               goto test_fail;
-       }
-
        printf("Perf test with all reader threads registered\n");
        printf("--------------------------------------------\n");
        all_registered = 1;

diff --git a/app/test/test_service_cores.c b/app/test/test_service_cores.c
index 82bb2ce50b24e92d7250c9071b122cb4b488d0b3..9fe38f5e08ce7676a48143da2ed06fc8f1cce3a5 100644 (file)
--- a/app/test/test_service_cores.c
+++ b/app/test/test_service_cores.c
@@ -502,6 +502,10 @@ service_lcore_running_check(void)
 static int
 service_lcore_add_del(void)
 {
+       if (!rte_lcore_is_enabled(0) || !rte_lcore_is_enabled(1) ||
+           !rte_lcore_is_enabled(2) || !rte_lcore_is_enabled(3))
+               return TEST_SKIPPED;
+
        /* check initial count */
        TEST_ASSERT_EQUAL(0, rte_service_lcore_count(),
                        "Service lcore count has value before adding a lcore");
@@ -669,6 +673,11 @@ static int
 service_mt_safe_poll(void)
 {
        int mt_safe = 1;
+
+       if (!rte_lcore_is_enabled(0) || !rte_lcore_is_enabled(1) ||
+           !rte_lcore_is_enabled(2))
+               return TEST_SKIPPED;
+
        TEST_ASSERT_EQUAL(1, service_threaded_test(mt_safe),
                        "Error: MT Safe service not run by two cores concurrently");
        return TEST_SUCCESS;
@@ -681,6 +690,11 @@ static int
 service_mt_unsafe_poll(void)
 {
        int mt_safe = 0;
+
+       if (!rte_lcore_is_enabled(0) || !rte_lcore_is_enabled(1) ||
+           !rte_lcore_is_enabled(2))
+               return TEST_SKIPPED;
+
        TEST_ASSERT_EQUAL(1, service_threaded_test(mt_safe),
                        "Error: NON MT Safe service run by two cores concurrently");
        return TEST_SUCCESS;

diff --git a/app/test/test_stack.c b/app/test/test_stack.c
index e972a61a7fb19b39672c06f05c8b160ccd174e9a..c8dac1f55cdce8ae31e6b6dce0cabebcbfd69904 100644 (file)
--- a/app/test/test_stack.c
+++ b/app/test/test_stack.c
@@ -336,12 +336,14 @@ test_stack_multithreaded(uint32_t flags)
        struct rte_stack *s;
        rte_atomic64_t size;
 
+       if (rte_lcore_count() < 2) {
+               printf("Not enough cores for test_stack_multithreaded, expecting at least 2\n");
+               return TEST_SKIPPED;
+       }
+
        printf("[%s():%u] Running with %u lcores\n",
               __func__, __LINE__, rte_lcore_count());
 
-       if (rte_lcore_count() < 2)
-               return 0;
-
        args = rte_malloc(NULL, sizeof(struct test_args) * RTE_MAX_LCORE, 0);
        if (args == NULL) {
                printf("[%s():%u] failed to malloc %zu bytes\n",

diff --git a/app/test/test_timer.c b/app/test/test_timer.c
index e2aab53085fcff3d379c9066319d19ccbad0fdfe..8e0a5898284e5fc46039f304f6ec8be9556ed9a2 100644 (file)
--- a/app/test/test_timer.c
+++ b/app/test/test_timer.c
@@ -538,17 +538,17 @@ test_timer(void)
        uint64_t cur_time;
        uint64_t hz;
 
+       if (rte_lcore_count() < 2) {
+               printf("Not enough cores for timer_autotest, expecting at least 2\n");
+               return TEST_SKIPPED;
+       }
+
        /* sanity check our timer sources and timer config values */
        if (timer_sanity_check() < 0) {
                printf("Timer sanity checks failed\n");
                return TEST_FAILED;
        }
 
-       if (rte_lcore_count() < 2) {
-               printf("not enough lcores for this test\n");
-               return TEST_FAILED;
-       }
-
        /* init timer */
        for (i=0; i<NB_TIMER; i++) {
                memset(&mytiminfo[i], 0, sizeof(struct mytimerinfo));

diff --git a/app/test/test_timer_secondary.c b/app/test/test_timer_secondary.c
index 31e4a7f083a97c92e29f23a744fb89093d8b86f9..790f1805215215c9a732b4727ad0fdded3d03ae9 100644 (file)
--- a/app/test/test_timer_secondary.c
+++ b/app/test/test_timer_secondary.c
@@ -118,16 +118,18 @@ test_timer_secondary(void)
        int ret;
 
        if (proc_type == RTE_PROC_PRIMARY) {
+               if (rte_lcore_count() < NUM_LCORES_NEEDED) {
+                       printf("Not enough cores for test_timer_secondary, expecting at least %u\n",
+                              NUM_LCORES_NEEDED);
+                       return TEST_SKIPPED;
+               }
+
                mz = rte_memzone_reserve(TEST_INFO_MZ_NAME, sizeof(*test_info),
                                         SOCKET_ID_ANY, 0);
                test_info = mz->addr;
                TEST_ASSERT_NOT_NULL(test_info, "Couldn't allocate memory for "
                                     "test data");
 
-               TEST_ASSERT(rte_lcore_count() >= NUM_LCORES_NEEDED,
-                           "at least %d lcores needed to run tests",
-                           NUM_LCORES_NEEDED);
-
                test_info->tim_mempool = rte_mempool_create("test_timer_mp",
                                NUM_TIMERS, sizeof(struct rte_timer), 0, 0,
                                NULL, NULL, NULL, NULL, rte_socket_id(), 0);