tests: add test application for CongURE implementations with SFR

tests/gnrc_sixlowpan_frag_sfr_congure_impl/Makefile

@@ -0,0 +1,49 @@
+include ../Makefile.tests_common
+
+USEMODULE += auto_init_gnrc_netif
+USEMODULE += gnrc_ipv6_router_default
+USEMODULE += gnrc_sixlowpan_frag_sfr
+USEMODULE += gnrc_udp
+USEMODULE += gnrc_rpl
+USEMODULE += auto_init_gnrc_rpl
+USEMODULE += gnrc_pktdump
+USEMODULE += gnrc_icmpv6_echo
+USEMODULE += shell
+USEMODULE += shell_cmds_default
+USEMODULE += shell_cmd_gnrc_pktbuf
+USEMODULE += shell_cmd_gnrc_udp
+USEMODULE += ps
+USEMODULE += netstats_l2
+USEMODULE += netstats_ipv6
+USEMODULE += netstats_rpl
+
+ifeq (native, $(BOARD))
+  USEMODULE += socket_zep
+  USEMODULE += socket_zep_hello
+  USEMODULE += netdev
+  TERMFLAGS = -z 127.0.0.1:17754 # Murdock has no IPv6 support
+else
+  USEMODULE += netdev_default
+  # automated test only works on native
+  TESTS=
+endif
+
+CONGURE_IMPL ?= congure_sfr
+
+ifeq (congure_sfr,$(CONGURE_IMPL))
+  USEMODULE += gnrc_sixlowpan_frag_sfr_congure_sfr
+else
+  $(error "Unknown CongURE implementation `$(CONGURE_IMPL)`")
+endif
+
+.PHONY: zep_dispatch
+
+zep_dispatch:
+	$(Q)env -u CC -u CFLAGS $(MAKE) -C $(RIOTTOOLS) $@
+
+TERMDEPS += zep_dispatch
+
+include $(RIOTBASE)/Makefile.include
+
+# Set a custom channel if needed
+include $(RIOTMAKE)/default-radio-settings.inc.mk

tests/gnrc_sixlowpan_frag_sfr_congure_impl/Makefile.ci

@@ -0,0 +1,54 @@
+BOARD_INSUFFICIENT_MEMORY := \
+    airfy-beacon \
+    arduino-duemilanove \
+    arduino-leonardo \
+    arduino-mega2560 \
+    arduino-nano \
+    arduino-uno \
+    atmega1284p \
+    atmega328p \
+    atmega328p-xplained-mini \
+    atxmega-a3bu-xplained \
+    b-l072z-lrwan1 \
+    blackpill-128kib \
+    bluepill-128kib \
+    bluepill-stm32f030c8 \
+    calliope-mini \
+    derfmega128 \
+    hifive1 \
+    hifive1b \
+    i-nucleo-lrwan1 \
+    im880b \
+    lsn50 \
+    mega-xplained \
+    microbit \
+    microduino-corerf \
+    msb-430 \
+    msb-430h \
+    nrf51dongle \
+    nrf6310 \
+    nucleo-f030r8 \
+    nucleo-f031k6 \
+    nucleo-f042k6 \
+    nucleo-f070rb \
+    nucleo-f072rb \
+    nucleo-f303k8 \
+    nucleo-f334r8 \
+    nucleo-l011k4 \
+    nucleo-l031k6 \
+    nucleo-l053r8 \
+    samd10-xmini \
+    saml10-xpro \
+    saml11-xpro \
+    slstk3400a \
+    stk3200 \
+    stm32f030f4-demo \
+    stm32f0discovery \
+    stm32g0316-disco \
+    stm32l0538-disco \
+    telosb \
+    waspmote-pro \
+    yunjia-nrf51822 \
+    z1 \
+    zigduino \
+    #

tests/gnrc_sixlowpan_frag_sfr_congure_impl/README.md

@@ -0,0 +1,8 @@
+SFR CongURE implementation test
+===============================
+This test is largely based on the [`gnrc_networking`][1] example but is changed
+so SFR with different CongURE implementations can be tested. When `CONGURE_IMPL`
+is not set in the environment, `gnrc_sixlowpan_frag_sfr_congure_sfr` is used,
+other implementations can be used with `congure_<impl>`.
+
+[1]: https://github.com/RIOT-OS/RIOT/tree/master/examples/gnrc_networking

tests/gnrc_sixlowpan_frag_sfr_congure_impl/main.c

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2015-21 Freie Universität Berlin
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @ingroup     tests
+ * @{
+ *
+ * @file
+ *
+ * @author      Hauke Petersen <hauke.petersen@fu-berlin.de>
+ * @author      Martine Lenders <m.lenders@fu-berlin.de>
+ *
+ * @}
+ */
+
+#include <stdio.h>
+
+#include "fmt.h"
+#include "shell.h"
+#include "msg.h"
+
+#define MAIN_QUEUE_SIZE     (8)
+static msg_t _main_msg_queue[MAIN_QUEUE_SIZE];
+
+int main(void)
+{
+    msg_init_queue(_main_msg_queue, MAIN_QUEUE_SIZE);
+
+    char line_buf[SHELL_DEFAULT_BUFSIZE];
+    shell_run(NULL, line_buf, SHELL_DEFAULT_BUFSIZE);
+
+    /* should be never reached */
+    return 0;
+}

tests/gnrc_sixlowpan_frag_sfr_congure_impl/tests/01-run.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2021 Benjamin Valentin
+#
+# This file is subject to the terms and conditions of the GNU Lesser
+# General Public License v2.1. See the file LICENSE in the top level
+# directory for more details.
+
+import contextlib
+import subprocess
+import sys
+import time
+
+from subprocess import Popen
+from riotctrl_shell.gnrc import GNRCICMPv6Echo, GNRCICMPv6EchoParser, GNRCIPv6NIB
+from riotctrl_shell.netif import Ifconfig
+from riotctrl.ctrl import RIOTCtrlBoardFactory
+from riotctrl_ctrl import native
+from riotctrl_shell.netif import IfconfigListParser
+
+PARSERS = {
+    "ping6": GNRCICMPv6EchoParser(),
+    "ifconfig": IfconfigListParser(),
+}
+
+
+class RIOTCtrlAppFactory(RIOTCtrlBoardFactory):
+
+    def __init__(self):
+        super().__init__(board_cls={
+            'native': native.NativeRIOTCtrl,
+        })
+        self.ctrl_list = list()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        for ctrl in self.ctrl_list:
+            ctrl.stop_term()
+
+    def get_shell(self, application_directory='.', env={'BOARD': 'native'}):
+        # retrieve a RIOTCtrl Object
+        ctrl = super().get_ctrl(
+            env=env,
+            application_directory=application_directory
+        )
+        # append ctrl to list
+        self.ctrl_list.append(ctrl)
+        # start terminal
+        ctrl.start_term()
+        ctrl.term.logfile = sys.stdout
+        # return ctrl with started terminal
+        return Shell(ctrl)
+
+    def get_shells(self, num=1):
+        terms = []
+        for i in range(num):
+            terms.append(self.get_shell())
+        return terms
+
+
+class Shell(Ifconfig, GNRCICMPv6Echo, GNRCIPv6NIB):
+    pass
+
+
+def first_netif_and_addr_by_scope(ifconfig_out, scope):
+    netifs = PARSERS["ifconfig"].parse(ifconfig_out)
+    key = next(iter(netifs))
+    netif = netifs[key]
+    return (
+        key,
+        [addr["addr"] for addr in netif["ipv6_addrs"] if addr["scope"] == scope][0],
+    )
+
+
+def global_addr(ifconfig_out):
+    return first_netif_and_addr_by_scope(ifconfig_out, "global")
+
+
+@contextlib.contextmanager
+def rpl_nodes(factory, zep_dispatch):
+    # linear topology with 4 nodes
+    topology = ("A B\n"
+                "B C\n"
+                "C D\n")
+    zep_dispatch.stdin.write(topology.encode())
+    zep_dispatch.stdin.close()
+
+    # create native instances
+    nodes = factory.get_shells(4)
+    A, _, _, D = nodes
+
+    netifs = PARSERS["ifconfig"].parse(A.ifconfig_list())
+    iface = next(iter(netifs))
+    # add prefix to root node
+    A.nib_prefix_add(iface, "2001:db8::/32")
+    A.ifconfig_add(iface, "2001:db8::1/32")
+    A.cmd("rpl root 0 2001:db8::1")
+    root_addr = global_addr(A.ifconfig_list())[1]
+
+    # wait for the creation of the DODAG
+    time.sleep(10)
+    yield root_addr, D
+    for node in nodes:
+        node.stop_term()
+
+
+def assert_result(result, exp_packet_loss, exp_responses, exp_ttl):
+    assert result['stats']['packet_loss'] < exp_packet_loss
+    assert result['stats']['rx'] >= exp_responses
+    assert result['replies'][0]['ttl'] == exp_ttl
+
+
+def test_reachability(factory, zep_dispatch):
+    with rpl_nodes(factory, zep_dispatch) as (root_addr, D):
+        # ping root node from last node
+        parser = PARSERS["ping6"]
+        result = parser.parse(D.ping6(root_addr))
+        # assert packetloss is under 34%"
+        # assert at least one response
+        # 2 intermediate hops, 64 - 2
+        assert_result(result, 34, 1, 64 - 2)
+
+
+def test_fragmentation(factory, zep_dispatch):
+    with rpl_nodes(factory, zep_dispatch) as (root_addr, D):
+        # ping root node from last node
+        parser = PARSERS["ping6"]
+        result = parser.parse(D.ping6(root_addr, count=100, interval=30, packet_size=500))
+        # assert packetloss is under 70%"
+        # assert at least one response
+        # 2 intermediate hops, 64 - 2
+        assert_result(result, 70, 1, 64 - 2)
+
+
+def run_test(func, factory):
+    with Popen(['../../dist/tools/zep_dispatch/bin/zep_dispatch',
+                '-t', '-', '127.0.0.1', '17754'], stdin=subprocess.PIPE) as zep_dispatch:
+        try:
+            func(factory, zep_dispatch)
+        finally:
+            zep_dispatch.terminate()
+
+
+if __name__ == "__main__":
+    with RIOTCtrlAppFactory() as factory:
+        # run_test(test_reachability, factory)
+        run_test(test_fragmentation, factory)