mbuf: add a copy routine

[dpdk.git] / app / test / test_lpm6.c

diff --git a/app/test/test_lpm6.c b/app/test/test_lpm6.c
index 458a10b..670aadb 100644 (file)
--- a/app/test/test_lpm6.c
+++ b/app/test/test_lpm6.c
@@ -1,34 +1,5 @@
-/*-
- *   BSD LICENSE
- *
- *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
- *   All rights reserved.
- *
- *   Redistribution and use in source and binary forms, with or without
- *   modification, are permitted provided that the following conditions
- *   are met:
- *
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in
- *       the documentation and/or other materials provided with the
- *       distribution.
- *     * Neither the name of Intel Corporation nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2010-2014 Intel Corporation
  */
 
 #include <stdio.h>
@@ -40,7 +11,7 @@
 #include <rte_lpm6.h>
 
 #include "test.h"
-#include "test_lpm6_routes.h"
+#include "test_lpm6_data.h"
 
 #define TEST_LPM_ASSERT(cond) do {                                            \
        if (!(cond)) {                                                        \
@@ -79,6 +50,7 @@ static int32_t test24(void);
 static int32_t test25(void);
 static int32_t test26(void);
 static int32_t test27(void);
+static int32_t test28(void);
 
 rte_lpm6_test tests6[] = {
 /* Test Cases */
@@ -110,6 +82,7 @@ rte_lpm6_test tests6[] = {
        test25,
        test26,
        test27,
+       test28,
 };
 
 #define NUM_LPM6_TESTS                (sizeof(tests6)/sizeof(tests6[0]))
@@ -354,7 +327,7 @@ test6(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t next_hop_return = 0;
+       uint32_t next_hop_return = 0;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -392,7 +365,7 @@ test7(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[10][16];
-       int16_t next_hop_return[10];
+       int32_t next_hop_return[10];
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -469,7 +442,8 @@ test9(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t depth = 16, next_hop_add = 100, next_hop_return = 0;
+       uint8_t depth = 16;
+       uint32_t next_hop_add = 100, next_hop_return = 0;
        int32_t status = 0;
        uint8_t i;
 
@@ -513,7 +487,8 @@ test10(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t depth, next_hop_add = 100;
+       uint8_t depth;
+       uint32_t next_hop_add = 100;
        int32_t status = 0;
        int i;
 
@@ -557,7 +532,8 @@ test11(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t depth, next_hop_add = 100;
+       uint8_t depth;
+       uint32_t next_hop_add = 100;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -617,7 +593,8 @@ test12(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t depth, next_hop_add = 100;
+       uint8_t depth;
+       uint32_t next_hop_add = 100;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -655,7 +632,8 @@ test13(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t depth, next_hop_add = 100;
+       uint8_t depth;
+       uint32_t next_hop_add = 100;
        int32_t status = 0;
 
        config.max_rules = 2;
@@ -702,7 +680,8 @@ test14(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t depth = 25, next_hop_add = 100;
+       uint8_t depth = 25;
+       uint32_t next_hop_add = 100;
        int32_t status = 0;
        int i;
 
@@ -748,7 +727,8 @@ test15(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t depth = 24, next_hop_add = 100, next_hop_return = 0;
+       uint8_t depth = 24;
+       uint32_t next_hop_add = 100, next_hop_return = 0;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -784,7 +764,8 @@ test16(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[] = {12,12,1,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t depth = 128, next_hop_add = 100, next_hop_return = 0;
+       uint8_t depth = 128;
+       uint32_t next_hop_add = 100, next_hop_return = 0;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -828,7 +809,8 @@ test17(void)
        uint8_t ip1[] = {127,255,255,255,255,255,255,255,255,
                        255,255,255,255,255,255,255};
        uint8_t ip2[] = {128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-       uint8_t depth, next_hop_add, next_hop_return;
+       uint8_t depth;
+       uint32_t next_hop_add, next_hop_return;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -857,7 +839,7 @@ test17(void)
 
        /* Loop with rte_lpm6_delete. */
        for (depth = 16; depth >= 1; depth--) {
-               next_hop_add = (uint8_t) (depth - 1);
+               next_hop_add = (depth - 1);
 
                status = rte_lpm6_delete(lpm, ip2, depth);
                TEST_LPM_ASSERT(status == 0);
@@ -893,8 +875,9 @@ test18(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[16], ip_1[16], ip_2[16];
-       uint8_t depth, depth_1, depth_2, next_hop_add, next_hop_add_1,
-               next_hop_add_2, next_hop_return;
+       uint8_t depth, depth_1, depth_2;
+       uint32_t next_hop_add, next_hop_add_1,
+                       next_hop_add_2, next_hop_return;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -1055,7 +1038,8 @@ test19(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[16];
-       uint8_t depth, next_hop_add, next_hop_return;
+       uint8_t depth;
+       uint32_t next_hop_add, next_hop_return;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -1253,7 +1237,8 @@ test20(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip[16];
-       uint8_t depth, next_hop_add, next_hop_return;
+       uint8_t depth;
+       uint32_t next_hop_add, next_hop_return;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -1320,8 +1305,9 @@ test21(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip_batch[4][16];
-       uint8_t depth, next_hop_add;
-       int16_t next_hop_return[4];
+       uint8_t depth;
+       uint32_t next_hop_add;
+       int32_t next_hop_return[4];
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -1378,8 +1364,9 @@ test22(void)
        struct rte_lpm6 *lpm = NULL;
        struct rte_lpm6_config config;
        uint8_t ip_batch[5][16];
-       uint8_t depth[5], next_hop_add;
-       int16_t next_hop_return[5];
+       uint8_t depth[5];
+       uint32_t next_hop_add;
+       int32_t next_hop_return[5];
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -1495,7 +1482,8 @@ test23(void)
        struct rte_lpm6_config config;
        uint32_t i;
        uint8_t ip[16];
-       uint8_t depth, next_hop_add, next_hop_return;
+       uint8_t depth;
+       uint32_t next_hop_add, next_hop_return;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -1579,7 +1567,8 @@ test25(void)
        struct rte_lpm6_config config;
        uint8_t ip[16];
        uint32_t i;
-       uint8_t depth, next_hop_add, next_hop_return, next_hop_expected;
+       uint8_t depth;
+       uint32_t next_hop_add, next_hop_return, next_hop_expected;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -1597,6 +1586,9 @@ test25(void)
                TEST_LPM_ASSERT(status == 0);
        }
 
+       /* generate large IPS table and expected next_hops */
+       generate_large_ips_table(1);
+
        for (i = 0; i < 100000; i++) {
                memcpy(ip, large_ips_table[i].ip, 16);
                next_hop_expected = large_ips_table[i].next_hop;
@@ -1629,10 +1621,10 @@ test26(void)
        uint8_t d_ip_10_32 = 32;
        uint8_t d_ip_10_24 = 24;
        uint8_t d_ip_20_25 = 25;
-       uint8_t next_hop_ip_10_32 = 100;
-       uint8_t next_hop_ip_10_24 = 105;
-       uint8_t next_hop_ip_20_25 = 111;
-       uint8_t next_hop_return = 0;
+       uint32_t next_hop_ip_10_32 = 100;
+       uint32_t next_hop_ip_10_24 = 105;
+       uint32_t next_hop_ip_20_25 = 111;
+       uint32_t next_hop_return = 0;
        int32_t status = 0;
 
        config.max_rules = MAX_RULES;
@@ -1647,7 +1639,7 @@ test26(void)
                return -1;
 
        status = rte_lpm6_lookup(lpm, ip_10_32, &next_hop_return);
-       uint8_t test_hop_10_32 = next_hop_return;
+       uint32_t test_hop_10_32 = next_hop_return;
        TEST_LPM_ASSERT(status == 0);
        TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_32);
 
@@ -1656,7 +1648,7 @@ test26(void)
                        return -1;
 
        status = rte_lpm6_lookup(lpm, ip_10_24, &next_hop_return);
-       uint8_t test_hop_10_24 = next_hop_return;
+       uint32_t test_hop_10_24 = next_hop_return;
        TEST_LPM_ASSERT(status == 0);
        TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_24);
 
@@ -1665,7 +1657,7 @@ test26(void)
                return -1;
 
        status = rte_lpm6_lookup(lpm, ip_20_25, &next_hop_return);
-       uint8_t test_hop_20_25 = next_hop_return;
+       uint32_t test_hop_20_25 = next_hop_return;
        TEST_LPM_ASSERT(status == 0);
        TEST_LPM_ASSERT(next_hop_return == next_hop_ip_20_25);
 
@@ -1704,7 +1696,8 @@ test27(void)
                struct rte_lpm6 *lpm = NULL;
                struct rte_lpm6_config config;
                uint8_t ip[] = {128,128,128,128,128,128,128,128,128,128,128,128,128,128,0,0};
-               uint8_t depth = 128, next_hop_add = 100, next_hop_return;
+               uint8_t depth = 128;
+               uint32_t next_hop_add = 100, next_hop_return;
                int32_t status = 0;
                int i, j;
 
@@ -1742,6 +1735,42 @@ test27(void)
                return PASS;
 }
 
+/*
+ * Call add, lookup and delete for a single rule with maximum 21bit next_hop
+ * size.
+ * Check that next_hop returned from lookup is equal to provisioned value.
+ * Delete the rule and check that the same test returs a miss.
+ */
+int32_t
+test28(void)
+{
+       struct rte_lpm6 *lpm = NULL;
+       struct rte_lpm6_config config;
+       uint8_t ip[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+       uint8_t depth = 16;
+       uint32_t next_hop_add = 0x001FFFFF, next_hop_return = 0;
+       int32_t status = 0;
+
+       config.max_rules = MAX_RULES;
+       config.number_tbl8s = NUMBER_TBL8S;
+       config.flags = 0;
+
+       lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
+       TEST_LPM_ASSERT(lpm != NULL);
+
+       status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
+       TEST_LPM_ASSERT(status == 0);
+
+       status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
+       TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
+
+       status = rte_lpm6_delete(lpm, ip, depth);
+       TEST_LPM_ASSERT(status == 0);
+       rte_lpm6_free(lpm);
+
+       return PASS;
+}
+
 /*
  * Do all unit tests.
  */
@@ -1764,8 +1793,4 @@ test_lpm6(void)
        return global_status;
 }
 
-static struct test_command lpm6_cmd = {
-       .command = "lpm6_autotest",
-       .callback = test_lpm6,
-};
-REGISTER_TEST_COMMAND(lpm6_cmd);
+REGISTER_TEST_COMMAND(lpm6_autotest, test_lpm6);