aboutsummaryrefslogtreecommitdiffstats
path: root/test/test_bfd.py
diff options
context:
space:
mode:
authorKlement Sekera <ksekera@cisco.com>2017-03-07 11:39:27 +0100
committerDamjan Marion <dmarion.lists@gmail.com>2017-03-08 21:56:59 +0000
commit871349371a62f1f20b159b6afead8e84f8a2322b (patch)
tree99c0cbf5bbfcbcee36e348e6adb87f941b6f6c5a /test/test_bfd.py
parentd96bad8ceb2ca0b798434619c5c5d1a199ec6382 (diff)
make test: split into basic and extended tests
Implement plumbing to allow decorating tests as extended, e.g.: @unittest.skipUnless(running_extended_tests(), "part of extended tests") both methods and classes can be decorated this way. Change make test and make test-debug to run only non-extended tests. Introduce make test-all and make test-all-debug to run the full suite. Run full suite as part of make verify. Decorate most BFD tests as extended. Change-Id: I3bc64f59e9fe238f7f767d7e043dc165d03e9dfa Signed-off-by: Klement Sekera <ksekera@cisco.com>
Diffstat (limited to 'test/test_bfd.py')
-rw-r--r--test/test_bfd.py35
1 files changed, 33 insertions, 2 deletions
diff --git a/test/test_bfd.py b/test/test_bfd.py
index e7ebb214d9a..5460a2b5589 100644
--- a/test/test_bfd.py
+++ b/test/test_bfd.py
@@ -15,7 +15,7 @@ from scapy.layers.inet import UDP, IP
from scapy.layers.inet6 import IPv6
from bfd import VppBFDAuthKey, BFD, BFDAuthType, VppBFDUDPSession, \
BFDDiagCode, BFDState, BFD_vpp_echo
-from framework import VppTestCase, VppTestRunner
+from framework import VppTestCase, VppTestRunner, running_extended_tests
from vpp_pg_interface import CaptureTimeoutError
from util import ppp
from vpp_papi_provider import UnexpectedApiReturnValueError
@@ -40,6 +40,7 @@ class AuthKeyFactory(object):
conf_key_id=conf_key_id, key=key)
+@unittest.skipUnless(running_extended_tests(), "part of extended tests")
class BFDAPITestCase(VppTestCase):
"""Bidirectional Forwarding Detection (BFD) - API"""
@@ -692,6 +693,7 @@ class BFD4TestCase(VppTestCase):
bfd_session_up(self)
bfd_session_down(self)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_hold_up(self):
""" hold BFD session up """
bfd_session_up(self)
@@ -701,6 +703,7 @@ class BFD4TestCase(VppTestCase):
self.assert_equal(len(self.vapi.collect_events()), 0,
"number of bfd events")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_slow_timer(self):
""" verify slow periodic control frames while session down """
packet_count = 3
@@ -715,6 +718,7 @@ class BFD4TestCase(VppTestCase):
time_diff, 0.70, 1.05, "time between slow packets")
prev_packet = next_packet
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_zero_remote_min_rx(self):
""" no packets when zero remote required min rx interval """
bfd_session_up(self)
@@ -739,6 +743,7 @@ class BFD4TestCase(VppTestCase):
self.assert_equal(
len(self.vapi.collect_events()), 0, "number of bfd events")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_conn_down(self):
""" verify session goes down after inactivity """
bfd_session_up(self)
@@ -748,6 +753,7 @@ class BFD4TestCase(VppTestCase):
e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
verify_event(self, e, expected_state=BFDState.down)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_large_required_min_rx(self):
""" large remote required min rx interval """
bfd_session_up(self)
@@ -777,6 +783,7 @@ class BFD4TestCase(VppTestCase):
break
self.assert_equal(count, 0, "number of packets received")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_immediate_remote_min_rx_reduction(self):
""" immediately honor remote required min rx reduction """
self.vpp_session.remove_vpp_config()
@@ -809,6 +816,7 @@ class BFD4TestCase(VppTestCase):
"time between BFD packets")
reference_packet = p
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_modify_req_min_rx_double(self):
""" modify session - double required min rx """
bfd_session_up(self)
@@ -838,6 +846,7 @@ class BFD4TestCase(VppTestCase):
self.assert_in_range(time_to_event, .9 * timeout,
1.1 * timeout, "session timeout")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_modify_req_min_rx_halve(self):
""" modify session - halve required min rx """
self.vpp_session.modify_parameters(
@@ -878,6 +887,7 @@ class BFD4TestCase(VppTestCase):
"time before bfd session goes down")
verify_event(self, e, expected_state=BFDState.down)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_modify_detect_mult(self):
""" modify detect multiplier """
bfd_session_up(self)
@@ -901,6 +911,7 @@ class BFD4TestCase(VppTestCase):
self.assertNotIn("P", p.sprintf("%BFD.flags%"),
"Poll bit not set in BFD packet")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_queued_poll(self):
""" test poll sequence queueing """
bfd_session_up(self)
@@ -966,6 +977,7 @@ class BFD4TestCase(VppTestCase):
self.assertNotIn("P", p.sprintf("%BFD.flags%"),
"Poll bit set in BFD packet")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_poll_response(self):
""" test correct response to control frame with poll bit set """
bfd_session_up(self)
@@ -976,6 +988,7 @@ class BFD4TestCase(VppTestCase):
self, pcap_time_min=time.time() - self.vpp_clock_offset)
self.assertIn("F", final.sprintf("%BFD.flags%"))
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_no_periodic_if_remote_demand(self):
""" no periodic frames outside poll sequence if remote demand set """
bfd_session_up(self)
@@ -1093,6 +1106,7 @@ class BFD4TestCase(VppTestCase):
"number of bfd events")
self.test_session.send_packet()
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_echo_fail(self):
""" session goes down if echo function fails """
bfd_session_up(self)
@@ -1132,6 +1146,7 @@ class BFD4TestCase(VppTestCase):
self.assert_equal(events[0].state, BFDState.down, BFDState)
self.assertTrue(verified_diag, "Incorrect diagnostics code received")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_echo_stop(self):
""" echo function stops if peer sets required min echo rx zero """
bfd_session_up(self)
@@ -1162,6 +1177,7 @@ class BFD4TestCase(VppTestCase):
events = self.vapi.collect_events()
self.assert_equal(len(events), 0, "number of bfd events")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_echo_source_removed(self):
""" echo function stops if echo source is removed """
bfd_session_up(self)
@@ -1192,6 +1208,7 @@ class BFD4TestCase(VppTestCase):
events = self.vapi.collect_events()
self.assert_equal(len(events), 0, "number of bfd events")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_stale_echo(self):
""" stale echo packets don't keep a session up """
bfd_session_up(self)
@@ -1243,6 +1260,7 @@ class BFD4TestCase(VppTestCase):
self.test_session.send_packet()
self.assertTrue(timeout_ok, "Expected timeout event didn't occur")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_invalid_echo_checksum(self):
""" echo packets with invalid checksum don't keep a session up """
bfd_session_up(self)
@@ -1291,6 +1309,7 @@ class BFD4TestCase(VppTestCase):
self.test_session.send_packet()
self.assertTrue(timeout_ok, "Expected timeout event didn't occur")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_admin_up_down(self):
""" put session admin-up and admin-down """
bfd_session_up(self)
@@ -1328,6 +1347,7 @@ class BFD4TestCase(VppTestCase):
e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
verify_event(self, e, expected_state=BFDState.up)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_config_change_remote_demand(self):
""" configuration change while peer in demand mode """
bfd_session_up(self)
@@ -1445,6 +1465,7 @@ class BFD6TestCase(VppTestCase):
self.test_session.send_packet()
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_hold_up(self):
""" hold BFD session up """
bfd_session_up(self)
@@ -1502,6 +1523,7 @@ class BFD6TestCase(VppTestCase):
self.assert_equal(udp_sport_tx, udp_sport_rx, "UDP source port (== "
"ECHO packet identifier for test purposes)")
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_echo(self):
""" echo function used """
bfd_session_up(self)
@@ -1596,6 +1618,7 @@ class BFDSHA1TestCase(VppTestCase):
bfd_key_id=self.vpp_session.bfd_key_id)
bfd_session_up(self)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_hold_up(self):
""" hold BFD session up """
key = self.factory.create_random_key(self)
@@ -1614,6 +1637,7 @@ class BFDSHA1TestCase(VppTestCase):
self.test_session.send_packet()
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_hold_up_meticulous(self):
""" hold BFD session up - meticulous auth """
key = self.factory.create_random_key(
@@ -1635,6 +1659,7 @@ class BFDSHA1TestCase(VppTestCase):
self.test_session.send_packet()
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_send_bad_seq_number(self):
""" session is not kept alive by msgs with bad sequence numbers"""
key = self.factory.create_random_key(
@@ -1697,6 +1722,7 @@ class BFDSHA1TestCase(VppTestCase):
wait_for_bfd_packet(self)
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_mismatch_auth(self):
""" session is not brought down by unauthenticated msg """
key = self.factory.create_random_key(self)
@@ -1711,6 +1737,7 @@ class BFDSHA1TestCase(VppTestCase):
legitimate_test_session,
rogue_test_session)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_mismatch_bfd_key_id(self):
""" session is not brought down by msg with non-existent key-id """
key = self.factory.create_random_key(self)
@@ -1730,6 +1757,7 @@ class BFDSHA1TestCase(VppTestCase):
legitimate_test_session,
rogue_test_session)
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_mismatched_auth_type(self):
""" session is not brought down by msg with wrong auth type """
key = self.factory.create_random_key(self)
@@ -1746,6 +1774,7 @@ class BFDSHA1TestCase(VppTestCase):
vpp_session, legitimate_test_session, rogue_test_session,
{'auth_type': BFDAuthType.keyed_md5})
+ @unittest.skipUnless(running_extended_tests(), "part of extended tests")
def test_restart(self):
""" simulate remote peer restart and resynchronization """
key = self.factory.create_random_key(
@@ -1761,7 +1790,7 @@ class BFDSHA1TestCase(VppTestCase):
# don't send any packets for 2*detection_time
detection_time = self.test_session.detect_mult *\
self.vpp_session.required_min_rx / USEC_IN_SEC
- self.sleep(2*detection_time, "simulating peer restart")
+ self.sleep(2 * detection_time, "simulating peer restart")
events = self.vapi.collect_events()
self.assert_equal(len(events), 1, "number of bfd events")
verify_event(self, events[0], expected_state=BFDState.down)
@@ -1774,6 +1803,7 @@ class BFDSHA1TestCase(VppTestCase):
bfd_session_up(self)
+@unittest.skipUnless(running_extended_tests(), "part of extended tests")
class BFDAuthOnOffTestCase(VppTestCase):
"""Bidirectional Forwarding Detection (BFD) (changing auth) """
@@ -1981,6 +2011,7 @@ class BFDAuthOnOffTestCase(VppTestCase):
"number of bfd events")
+@unittest.skipUnless(running_extended_tests(), "part of extended tests")
class BFDCLITestCase(VppTestCase):
"""Bidirectional Forwarding Detection (BFD) (CLI) """
pg0 = None
0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
/*
 * Copyright (c) 2021 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdbool.h>
#include <assert.h>
#include <vlib/vlib.h>
#include <vnet/feature/feature.h>
#include <vppinfra/clib_error.h>
#include <vnet/ip/ip4_packet.h>
#include <vnet/udp/udp.h>
#include <vppinfra/bihash_16_8.h>
#include <vppinfra/bihash_template.c>
#include <vnet/fib/ip4_fib.h>
#include "../pnat.h"
#include <pnat/pnat.api_enum.h> /* For error counters */
#include <arpa/inet.h>
#include "pnat_test_stubs.h"

/*
** Buffer management in test setup
** Allocate buffers return vector of buffer indicies.
**
** Setup frame with buffers when calling function.
** Global vector of all buffers with their indicies?
** Convert buffer index to pointer?
*/
struct buffers {
    u8 data[2048];
};
struct buffers buffers[256];
struct buffers expected[256];
u32 *buffers_vector = 0;

static u32 *buffer_init(u32 *vector, int count) {
    int i;
    for (i = 0; i < count; i++) {
        vec_add1(vector, i);
    }
    return vector;
}

u32 *results_bi = 0; /* global vector of result buffers */
u16 *results_next = 0;

vlib_node_runtime_t *node;

#define log_info(M, ...)                                                       \
    fprintf(stderr, "\033[32;1m[OK] " M "\033[0m\n", ##__VA_ARGS__)
#define log_error(M, ...)                                                      \
    fprintf(stderr, "\033[31;1m[ERROR] (%s:%d:) " M "\033[0m\n", __FILE__,     \
            __LINE__, ##__VA_ARGS__)
#define test_assert_log(A, M, ...)                                             \
    if (!(A)) {                                                                \
        log_error(M, ##__VA_ARGS__);                                           \
        assert(A);                                                             \
    } else {                                                                   \
        log_info(M, ##__VA_ARGS__);                                            \
    }
#define test_assert(A, M, ...)                                                 \
    if (!(A)) {                                                                \
        log_error(M, ##__VA_ARGS__);                                           \
        assert(A);                                                             \
    }

/*
 * Always return the frame of generated packets
 */
#define vlib_frame_vector_args test_vlib_frame_vector_args
void *test_vlib_frame_vector_args(vlib_frame_t *f) { return buffers_vector; }

/* Synthetic value for vnet_feature_next  */
#define NEXT_PASSTHROUGH 4242

#define vnet_feature_next_u16 test_vnet_feature_next_u16
void vnet_feature_next_u16(u16 *next0, vlib_buffer_t *b0) {
    *next0 = NEXT_PASSTHROUGH;
}

/* Gather output packets */
#define vlib_buffer_enqueue_to_next test_vlib_buffer_enqueue_to_next
void test_vlib_buffer_enqueue_to_next(vlib_main_t *vm,
                                      vlib_node_runtime_t *node, u32 *buffers,
                                      u16 *nexts, uword count) {
    vec_add(results_next, nexts, count);
    vec_add(results_bi, buffers, count);
}

pnat_trace_t trace = {0};
#define vlib_add_trace test_vlib_add_trace
void *test_vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r,
                          vlib_buffer_t *b, u32 n_data_bytes) {
    return &trace;
}

#define vlib_get_buffers test_vlib_get_buffers
void test_vlib_get_buffers(vlib_main_t *vm, u32 *bi, vlib_buffer_t **b,
                           int count) {
    int i;
    for (i = 0; i < count; i++) {
        b[i] = (vlib_buffer_t *)&buffers[bi[i]];
    }
}

vlib_buffer_t *test_vlib_get_buffer(u32 bi) {
    return (vlib_buffer_t *)&buffers[bi];
}

/* Must be included here to allow the above functions to override */
#include "../pnat_node.h"

/*** TESTS ***/

typedef struct {
    char *name;
    int nsend;
    char *send;
    int nexpect;
    char *expect;
    u32 expect_next_index;
} test_t;
#include "test_packets.h"

/* Rules */
typedef struct {
    char *src;
    char *dst;
    u8 proto;
    u16 sport;
    u16 dport;
    u8 from_offset;
    u8 to_offset;
    u8 clear_offset;
} test_5tuple_t;

typedef struct {
    test_5tuple_t match;
    test_5tuple_t rewrite;
    bool in;
    u32 index;
} rule_t;

rule_t rules[] = {
    {
        .match = {.dst = "2.2.2.2", .proto = 17, .dport = 6871},
        .rewrite = {.dst = "1.2.3.4"},
        .in = true,
    },
    {
        .match = {.dst = "2.2.2.2", .proto = 6, .dport = 6871},
        .rewrite = {.dst = "1.2.3.4"},
        .in = true,
    },
    {
        .match = {.dst = "2.2.2.2", .proto = 6, .dport = 6872},
        .rewrite = {.dst = "1.2.3.4", .sport = 53, .dport = 8000},
        .in = true,
    },
    {
        .match = {.dst = "2.2.2.2", .proto = 6, .dport = 6873},
        .rewrite = {.dst = "1.2.3.4", .sport = 53, .dport = 8000},
        .in = true,
    },
    {
        .match = {.dst = "2.2.2.2", .proto = 17, .dport = 6874},
        .rewrite = {.from_offset = 15, .to_offset = 19},
        .in = true,
    },
    {
        .match = {.dst = "2.2.2.2", .proto = 17, .dport = 6875},
        .rewrite = {.from_offset = 15, .to_offset = 50},
        .in = true,
    },
    {
        .match = {.dst = "2.2.2.2", .proto = 17, .dport = 6877},
        .rewrite = {.dst = "1.2.3.4", .from_offset = 15, .to_offset = 35},
        .in = true,
    },
    {
        .match = {.dst = "2.2.2.2", .proto = 17, .dport = 6876},
        .rewrite = {.clear_offset = 22},
        .in = true,
    },
};

static int fill_packets(vlib_main_t *vm, vlib_buffer_t *b, int n, char *test) {
    b->flags |= VLIB_BUFFER_IS_TRACED;

    ip4_header_t *ip = (ip4_header_t *)vlib_buffer_get_current(b);

    memcpy(ip, test, n);

    /* Do the work of SVR */
    vnet_buffer(b)->ip.reass.l4_src_port = 0;
    vnet_buffer(b)->ip.reass.l4_dst_port = 0;
    b->current_length = n;

    if (ip4_is_fragment(ip))
        return 0;
    if (ip->protocol == IP_PROTOCOL_UDP) {
        udp_header_t *udp = ip4_next_header(ip);
        vnet_buffer(b)->ip.reass.l4_src_port = udp->src_port;
        vnet_buffer(b)->ip.reass.l4_dst_port = udp->dst_port;
    } else if (ip->protocol == IP_PROTOCOL_TCP) {
        tcp_header_t *tcp = ip4_next_header(ip);
        vnet_buffer(b)->ip.reass.l4_src_port = tcp->src_port;
        vnet_buffer(b)->ip.reass.l4_dst_port = tcp->dst_port;
    }
    return 0;
}

static void ruletomatch(test_5tuple_t *r, pnat_match_tuple_t *t) {
    if (r->src) {
        inet_pton(AF_INET, r->src, &t->src);
        t->mask |= PNAT_SA;
    }
    if (r->dst) {
        inet_pton(AF_INET, r->dst, &t->dst);
        t->mask |= PNAT_DA;
    }
    if (r->dport) {
        t->dport = r->dport;
        t->mask |= PNAT_DPORT;
    }
    if (r->sport) {
        t->sport = r->sport;
        t->mask |= PNAT_SPORT;
    }
    t->proto = r->proto;
}

static void ruletorewrite(test_5tuple_t *r, pnat_rewrite_tuple_t *t) {
    if (r->src) {
        inet_pton(AF_INET, r->src, &t->src);
        t->mask |= PNAT_SA;
    }
    if (r->dst) {
        inet_pton(AF_INET, r->dst, &t->dst);
        t->mask |= PNAT_DA;
    }
    if (r->dport) {
        t->dport = r->dport;
        t->mask |= PNAT_DPORT;
    }
    if (r->sport) {
        t->sport = r->sport;
        t->mask |= PNAT_SPORT;
    }
    if (r->to_offset || r->from_offset) {
        t->to_offset = r->to_offset;
        t->from_offset = r->from_offset;
        t->mask |= PNAT_COPY_BYTE;
    }
    if (r->clear_offset) {
        t->clear_offset = r->clear_offset;
        t->mask |= PNAT_CLEAR_BYTE;
    }
}

static void add_translation(rule_t *r) {
    pnat_match_tuple_t match = {0};
    pnat_rewrite_tuple_t rewrite = {0};

    ruletomatch(&r->match, &match);
    ruletorewrite(&r->rewrite, &rewrite);

    int rv = pnat_binding_add(&match, &rewrite, &r->index);
    assert(rv == 0);

    rv = pnat_binding_attach(0, PNAT_IP4_INPUT, r->index);
    assert(rv == 0);
}

static void del_translation(rule_t *r) {
    int rv = pnat_binding_detach(0, PNAT_IP4_INPUT, r->index);
    assert(rv == 0);

    rv = pnat_binding_del(r->index);
    assert(rv == 0);
}

static void validate_packet(vlib_main_t *vm, char *name, u32 bi,
                            vlib_buffer_t *expected_b) {
    vlib_buffer_t *b = test_vlib_get_buffer(bi);
    assert(b);

    ip4_header_t *ip = (ip4_header_t *)vlib_buffer_get_current(b);
    ip4_header_t *expected_ip =
        (ip4_header_t *)vlib_buffer_get_current(expected_b);

    if (ip->protocol == IP_PROTOCOL_UDP || ip->protocol == IP_PROTOCOL_TCP) {
        u32 flags = ip4_tcp_udp_validate_checksum(vm, b);
        test_assert((flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0, "%s",
                    name);
        flags = ip4_tcp_udp_validate_checksum(vm, expected_b);
        test_assert((flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0, "%s",
                    name);
    }
    test_assert(b->current_length == expected_b->current_length, "%s %d vs %d",
                name, b->current_length, expected_b->current_length);

    if (memcmp(ip, expected_ip, b->current_length) != 0) {
        if (ip->protocol == IP_PROTOCOL_UDP) {
            udp_header_t *udp = ip4_next_header(ip);
            clib_warning("Received: IP: %U UDP: %U", format_ip4_header, ip,
                         sizeof(*ip), format_udp_header, udp, sizeof(*udp));
            udp = ip4_next_header(expected_ip);
            clib_warning("%U", format_hexdump, ip, b->current_length);
            clib_warning("Expected: IP: %U UDP: %U", format_ip4_header,
                         expected_ip, sizeof(*ip), format_udp_header, udp,
                         sizeof(*udp));
            clib_warning("%U", format_hexdump, expected_ip,
                         expected_b->current_length);
        } else if (ip->protocol == IP_PROTOCOL_TCP) {
            tcp_header_t *tcp = ip4_next_header(ip);
            clib_warning("Received IP: %U TCP: %U", format_ip4_header, ip,
                         sizeof(*ip), format_tcp_header, tcp, sizeof(*tcp));
            tcp = ip4_next_header(expected_ip);
            clib_warning("Expected IP: %U TCP: %U", format_ip4_header,
                         expected_ip, sizeof(*ip), format_tcp_header, tcp,
                         sizeof(*tcp));
        } else {
            clib_warning("Received: IP: %U", format_ip4_header, ip,
                         sizeof(*ip));
            clib_warning("Expected: IP: %U", format_ip4_header, expected_ip,
                         sizeof(*ip));
        }
        test_assert_log(0, "%s", name);
    } else {
        test_assert_log(1, "%s", name);
    }
}

extern vlib_node_registration_t pnat_input_node;

static void test_table(test_t *t, int no_tests) {
    // walk through table of tests
    int i;
    vlib_main_t *vm = &vlib_global_main;

    /* Generate packet data */
    for (i = 0; i < no_tests; i++) {
        // create input buffer(s)
        fill_packets(vm, (vlib_buffer_t *)&buffers[i], t[i].nsend, t[i].send);
        fill_packets(vm, (vlib_buffer_t *)&expected[i], t[i].nexpect,
                     t[i].expect);
    }

    /* send packets through graph node */
    vlib_frame_t frame = {.n_vectors = no_tests};
    node->flags |= VLIB_NODE_FLAG_TRACE;

    pnat_node_inline(vm, node, &frame, PNAT_IP4_INPUT, VLIB_RX);

    /* verify tests */
    for (i = 0; i < no_tests; i++) {
        test_assert(t[i].expect_next_index == results_next[i], "%s", t[i].name);
        validate_packet(vm, t[i].name, results_bi[i],
                        (vlib_buffer_t *)&expected[i]);
    }
    vec_free(results_next);
    vec_free(results_bi);
}

void test_performance(void) {
    pnat_main_t *pm = &pnat_main;
    int i;
    vlib_main_t *vm = &vlib_global_main;

    for (i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
        add_translation(&rules[i]);
    }
    assert(pool_elts(pm->translations) == sizeof(rules) / sizeof(rules[0]));

    int no_tests = sizeof(tests_packets) / sizeof(tests_packets[0]);
    /* Generate packet data */
    for (i = 0; i < VLIB_FRAME_SIZE; i++) {
        // create input buffer(s)
        fill_packets(vm, (vlib_buffer_t *)&buffers[i],
                     tests_packets[i % no_tests].nsend,
                     tests_packets[i % no_tests].send);
        // fill_packets(vm, (vlib_buffer_t *)&expected[i], &tests[i %
        // no_tests].expect);
    }

    /* send packets through graph node */
    vlib_frame_t frame = {.n_vectors = VLIB_FRAME_SIZE};
    node->flags &= ~VLIB_NODE_FLAG_TRACE;

    int j;
    for (j = 0; j < 10000; j++) {
        pnat_node_inline(vm, node, &frame, PNAT_IP4_INPUT, VLIB_RX);

#if 0
    for (i = 0; i < VLIB_FRAME_SIZE; i++) {
        assert(tests[i % no_tests].expect_next_index == results_next[i]);
        validate_packet(vm, tests[i % no_tests].name, results_bi[i], (vlib_buffer_t *)&expected[i]);
    }
#endif
        vec_free(results_next);
        vec_free(results_bi);
    }

    for (i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
        del_translation(&rules[i]);
    }
    assert(pool_elts(pm->translations) == 0);
    assert(pool_elts(pm->interfaces) == 0);
}

void test_packets(void) {
    pnat_main_t *pm = &pnat_main;
    int i;
    for (i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
        add_translation(&rules[i]);
    }
    assert(pool_elts(pm->translations) == sizeof(rules) / sizeof(rules[0]));

    test_table(tests_packets, sizeof(tests_packets) / sizeof(tests_packets[0]));

    for (i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
        del_translation(&rules[i]);
    }
    assert(pool_elts(pm->translations) == 0);
    assert(pool_elts(pm->interfaces) == 0);
}

static void test_attach(void) {
    pnat_attachment_point_t attachment = PNAT_IP4_INPUT;
    u32 binding_index = 0;
    u32 sw_if_index = 0;
    int rv = pnat_binding_attach(sw_if_index, attachment, binding_index);
    test_assert(rv == -1, "binding_attach - nothing to attach");

    rv = pnat_binding_detach(sw_if_index, attachment, 1234);
    test_assert(rv == -1, "binding_detach - nothing to detach");

    pnat_match_tuple_t match = {.mask = PNAT_SA};
    pnat_rewrite_tuple_t rewrite = {.mask = PNAT_SA};
    rv = pnat_binding_add(&match, &rewrite, &binding_index);
    assert(rv == 0);

    rv = pnat_binding_attach(sw_if_index, attachment, binding_index);
    test_assert(rv == 0, "binding_attach - rule");

    rv = pnat_binding_detach(sw_if_index, attachment, binding_index);
    test_assert(rv == 0, "binding_detach - rule");

    rv = pnat_binding_del(binding_index);
    assert(rv == 0);
}

static void test_del_before_detach(void) {
    pnat_attachment_point_t attachment = PNAT_IP4_INPUT;
    u32 binding_index = 0;
    u32 sw_if_index = 0;

    /* Ensure 5-tuple here will not duplicate with other tests cause this will
     * not be removed from flow cache */
    rule_t rule = {
        .match = {.dst = "123.123.123.123", .proto = 17, .dport = 6871},
        .rewrite = {.dst = "1.2.3.4"},
        .in = true,
    };

    add_translation(&rule);

    int rv = pnat_binding_del(binding_index);
    assert(rv == 0);

    test_table(&tests_missing_rule[0], 1);

    /* For now if you have deleted before detach, can't find key */
    rv = pnat_binding_detach(sw_if_index, attachment, binding_index);
    test_assert(rv == -1, "binding_detach - failure");

    /* Re-add the rule and try again */
    pnat_match_tuple_t match = {0};
    pnat_rewrite_tuple_t rewrite = {0};
    ruletomatch(&rule.match, &match);
    ruletorewrite(&rule.rewrite, &rewrite);
    rv = pnat_binding_add(&match, &rewrite, &binding_index);
    assert(rv == 0);
    rv = pnat_binding_detach(sw_if_index, attachment, binding_index);
    test_assert(rv == 0, "binding_detach - pass");
    rv = pnat_binding_del(binding_index);
    assert(rv == 0);
}

void test_api(void) {
    test_attach();
    test_del_before_detach();
}

void test_checksum(void) {
    int i;
    vlib_main_t *vm = &vlib_global_main;
    pnat_main_t *pm = &pnat_main;

    test_t test = {
        .name = "checksum",
        .nsend = 28,
        .send =
            (char[]){0x45, 0x00, 0x00, 0x1c, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11,
                     0x74, 0xcb, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02,
                     0x00, 0x50, 0x1a, 0xd7, 0x00, 0x08, 0xde, 0xb1},
    };

    for (i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
        add_translation(&rules[i]);
    }
    assert(pool_elts(pm->translations) == sizeof(rules) / sizeof(rules[0]));

    /* send packets through graph node */
    vlib_frame_t frame = {.n_vectors = 1};
    node->flags |= VLIB_NODE_FLAG_TRACE;

    ip4_header_t *ip =
        (ip4_header_t *)vlib_buffer_get_current((vlib_buffer_t *)&buffers[0]);

    for (i = 0; i < 65535; i++) {

        /* Get a buffer. Loop through 64K variations of it to check checksum */
        memset(&buffers[0], 0, 2048);
        fill_packets(vm, (vlib_buffer_t *)&buffers[0], test.nsend, test.send);

        ip->src_address.as_u32 = i;
        ip->checksum = 0;
        ip->checksum = ip4_header_checksum(ip);
        pnat_node_inline(vm, node, &frame, PNAT_IP4_INPUT, VLIB_RX);
    }

    test_assert_log(1, "%s", test.name);

    for (i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
        del_translation(&rules[i]);
    }
}

/*
 * Unit testing:
 * 1) Table of packets and expected outcomes. Run through
 * 2) Performance tests. Measure instructions, cache behaviour etc.
 */
clib_error_t *ip_checksum_init(vlib_main_t *vm);

int main(int argc, char **argv) {

    clib_mem_init(0, 3ULL << 30);

    vlib_main_t *vm = &vlib_global_main;

    buffers_vector = buffer_init(buffers_vector, 256);

    assert(vlib_node_main_init(vm) == 0);

    ip_checksum_init(vm);

    u32 node_index = vlib_register_node(vm, &pnat_input_node);
    node = vlib_node_get_runtime(vm, node_index);
    assert(node);

    /* Test API */
    test_api();
    test_packets();
    test_checksum();
    test_performance();
}

/*
 * NEW TESTS:
 * - Chained buffers. Only do rewrite in first buffer
 * - No interface. Can that really happen?
 * - IP length shorter than buffer.
 * - IP length longer than buffer.
 */