From d0ae9f329685a19136cfd9a890b305db3bc384b9 Mon Sep 17 00:00:00 2001 From: Loic Guegan Date: Thu, 30 Jun 2022 12:11:59 +0200 Subject: Improve tests --- esds/simulator.py | 2 +- tests/api_log_5n/node.py | 7 ++++ tests/api_log_5n/out | 21 +++++++++++ tests/api_log_5n/simulator.py | 17 +++++++++ tests/api_read_clock_2n/node.py | 7 ++++ tests/api_read_clock_2n/out | 7 ++++ tests/api_read_clock_2n/simulator.py | 14 +++++++ tests/api_read_eth0_ncom_2s1r/out | 9 +++++ tests/api_read_eth0_ncom_2s1r/receiver.py | 13 +++++++ tests/api_read_eth0_ncom_2s1r/sender.py | 9 +++++ tests/api_read_eth0_ncom_2s1r/simulator.py | 15 ++++++++ tests/api_read_order_ncom_1s2r/out | 6 +++ tests/api_read_order_ncom_1s2r/receiver.py | 4 ++ tests/api_read_order_ncom_1s2r/sender.py | 4 ++ tests/api_read_order_ncom_1s2r/simulator.py | 17 +++++++++ tests/api_read_wlan0_ncom_2s1r/out | 11 ++++++ tests/api_read_wlan0_ncom_2s1r/receiver.py | 13 +++++++ tests/api_read_wlan0_ncom_2s1r/sender.py | 9 +++++ tests/api_read_wlan0_ncom_2s1r/simulator.py | 15 ++++++++ tests/api_receivet0_eth0_1s1r/out | 5 +++ tests/api_receivet0_eth0_1s1r/receiver.py | 14 +++++++ tests/api_receivet0_eth0_1s1r/sender.py | 5 +++ tests/api_receivet0_eth0_1s1r/simulator.py | 14 +++++++ tests/api_receivet0_eth0_1s1r/yoctosim.debug | 43 ++++++++++++++++++++++ tests/api_receivet_eth0_1s1r/out | 8 ++++ tests/api_receivet_eth0_1s1r/receiver.py | 15 ++++++++ tests/api_receivet_eth0_1s1r/sender.py | 6 +++ tests/api_receivet_eth0_1s1r/simulator.py | 14 +++++++ tests/api_receivet_eth0_1s1r/yoctosim.debug | 43 ++++++++++++++++++++++ tests/api_send0_eth0_1s1r/out | 16 ++++++++ tests/api_send0_eth0_1s1r/receiver.py | 23 ++++++++++++ tests/api_send0_eth0_1s1r/sender.py | 12 ++++++ tests/api_send0_eth0_1s1r/simulator.py | 14 +++++++ tests/api_send_4interfaces_1s2r/out | 14 +++++++ tests/api_send_4interfaces_1s2r/receiver.py | 5 +++ tests/api_send_4interfaces_1s2r/sender.py | 12 ++++++ tests/api_send_4interfaces_1s2r/simulator.py | 24 ++++++++++++ tests/api_send_eth0_1s1r/out | 11 ++++++ tests/api_send_eth0_1s1r/receiver.py | 20 ++++++++++ tests/api_send_eth0_1s1r/sender.py | 7 ++++ tests/api_send_eth0_1s1r/simulator.py | 14 +++++++ tests/api_send_eth0_2s1r/out | 7 ++++ tests/api_send_eth0_2s1r/receiver.py | 13 +++++++ tests/api_send_eth0_2s1r/sender.py | 5 +++ tests/api_send_eth0_2s1r/simulator.py | 15 ++++++++ tests/api_send_eth0_3s1r/out | 40 ++++++++++++++++++++ tests/api_send_eth0_3s1r/receiver.py | 19 ++++++++++ tests/api_send_eth0_3s1r/sender.py | 37 +++++++++++++++++++ tests/api_send_eth0_3s1r/simulator.py | 16 ++++++++ tests/api_send_wlan0_1s2r/out | 16 ++++++++ tests/api_send_wlan0_1s2r/receiver.py | 29 +++++++++++++++ tests/api_send_wlan0_1s2r/sender.py | 6 +++ tests/api_send_wlan0_1s2r/simulator.py | 15 ++++++++ tests/api_send_wlan0_2s1r/out | 6 +++ tests/api_send_wlan0_2s1r/receiver.py | 5 +++ tests/api_send_wlan0_2s1r/sender.py | 4 ++ tests/api_send_wlan0_2s1r/simulator.py | 15 ++++++++ tests/api_sendt_eth0_1s1r/out | 11 ++++++ tests/api_sendt_eth0_1s1r/receiver.py | 11 ++++++ tests/api_sendt_eth0_1s1r/sender.py | 14 +++++++ tests/api_sendt_eth0_1s1r/simulator.py | 14 +++++++ tests/api_sendt_wlan0_1s2r/out | 7 ++++ tests/api_sendt_wlan0_1s2r/receiver.py | 13 +++++++ tests/api_sendt_wlan0_1s2r/sender.py | 8 ++++ tests/api_sendt_wlan0_1s2r/simulator.py | 15 ++++++++ tests/api_wait_2n/node.py | 9 +++++ tests/api_wait_2n/out | 9 +++++ tests/api_wait_2n/simulator.py | 14 +++++++ tests/api_wait_end_3n/node.py | 10 +++++ tests/api_wait_end_3n/out | 7 ++++ tests/api_wait_end_3n/simulator.py | 15 ++++++++ tests/breakpoints_auto_1n/node.py | 8 ++++ tests/breakpoints_auto_1n/out | 9 +++++ tests/breakpoints_auto_1n/simulator.py | 18 +++++++++ tests/breakpoints_manual_1n/node.py | 4 ++ tests/breakpoints_manual_1n/out | 7 ++++ tests/breakpoints_manual_1n/simulator.py | 18 +++++++++ tests/breakpoints_manual_no_callback_1n/node.py | 4 ++ tests/breakpoints_manual_no_callback_1n/out | 3 ++ .../breakpoints_manual_no_callback_1n/simulator.py | 15 ++++++++ tests/mobility_eth0_bandwidth_2s1r/simulator.py | 2 +- tests/mobility_eth0_latency_2s1r/simulator.py | 2 +- tests/simple_breakpoints_auto_1n/node.py | 8 ---- tests/simple_breakpoints_auto_1n/out | 9 ----- tests/simple_breakpoints_auto_1n/simulator.py | 18 --------- tests/simple_breakpoints_manual_1n/node.py | 4 -- tests/simple_breakpoints_manual_1n/out | 7 ---- tests/simple_breakpoints_manual_1n/simulator.py | 18 --------- .../node.py | 4 -- tests/simple_breakpoints_manual_no_callback_1n/out | 3 -- .../simulator.py | 15 -------- tests/simple_log_5n/node.py | 7 ---- tests/simple_log_5n/out | 21 ----------- tests/simple_log_5n/simulator.py | 17 --------- tests/simple_read_clock_2n/node.py | 7 ---- tests/simple_read_clock_2n/out | 7 ---- tests/simple_read_clock_2n/simulator.py | 14 ------- tests/simple_read_eth0_ncom_2s1r/out | 9 ----- tests/simple_read_eth0_ncom_2s1r/receiver.py | 12 ------ tests/simple_read_eth0_ncom_2s1r/sender.py | 9 ----- tests/simple_read_eth0_ncom_2s1r/simulator.py | 15 -------- tests/simple_read_wlan0_ncom_2s1r/out | 11 ------ tests/simple_read_wlan0_ncom_2s1r/receiver.py | 12 ------ tests/simple_read_wlan0_ncom_2s1r/sender.py | 9 ----- tests/simple_read_wlan0_ncom_2s1r/simulator.py | 15 -------- tests/simple_receivet0_eth0_1s1r/out | 5 --- tests/simple_receivet0_eth0_1s1r/receiver.py | 14 ------- tests/simple_receivet0_eth0_1s1r/sender.py | 5 --- tests/simple_receivet0_eth0_1s1r/simulator.py | 14 ------- tests/simple_receivet0_eth0_1s1r/yoctosim.debug | 43 ---------------------- tests/simple_receivet_eth0_1s1r/out | 8 ---- tests/simple_receivet_eth0_1s1r/receiver.py | 15 -------- tests/simple_receivet_eth0_1s1r/sender.py | 6 --- tests/simple_receivet_eth0_1s1r/simulator.py | 14 ------- tests/simple_receivet_eth0_1s1r/yoctosim.debug | 43 ---------------------- tests/simple_send0_eth0_1s1r/out | 16 -------- tests/simple_send0_eth0_1s1r/receiver.py | 23 ------------ tests/simple_send0_eth0_1s1r/sender.py | 12 ------ tests/simple_send0_eth0_1s1r/simulator.py | 14 ------- tests/simple_send_4interfaces_1s2r/out | 14 ------- tests/simple_send_4interfaces_1s2r/receiver.py | 5 --- tests/simple_send_4interfaces_1s2r/sender.py | 12 ------ tests/simple_send_4interfaces_1s2r/simulator.py | 24 ------------ tests/simple_send_eth0_1s1r/out | 11 ------ tests/simple_send_eth0_1s1r/receiver.py | 20 ---------- tests/simple_send_eth0_1s1r/sender.py | 7 ---- tests/simple_send_eth0_1s1r/simulator.py | 14 ------- tests/simple_send_eth0_2s1r/out | 7 ---- tests/simple_send_eth0_2s1r/receiver.py | 13 ------- tests/simple_send_eth0_2s1r/sender.py | 5 --- tests/simple_send_eth0_2s1r/simulator.py | 15 -------- tests/simple_send_eth0_3s1r/out | 40 -------------------- tests/simple_send_eth0_3s1r/receiver.py | 19 ---------- tests/simple_send_eth0_3s1r/sender.py | 37 ------------------- tests/simple_send_eth0_3s1r/simulator.py | 16 -------- tests/simple_send_wlan0_1s2r/out | 16 -------- tests/simple_send_wlan0_1s2r/receiver.py | 29 --------------- tests/simple_send_wlan0_1s2r/sender.py | 6 --- tests/simple_send_wlan0_1s2r/simulator.py | 15 -------- tests/simple_send_wlan0_2s1r/out | 6 --- tests/simple_send_wlan0_2s1r/receiver.py | 5 --- tests/simple_send_wlan0_2s1r/sender.py | 4 -- tests/simple_send_wlan0_2s1r/simulator.py | 15 -------- tests/simple_sendt_eth0_1s1r/out | 11 ------ tests/simple_sendt_eth0_1s1r/receiver.py | 11 ------ tests/simple_sendt_eth0_1s1r/sender.py | 14 ------- tests/simple_sendt_eth0_1s1r/simulator.py | 14 ------- tests/simple_sendt_wlan0_1s2r/out | 7 ---- tests/simple_sendt_wlan0_1s2r/receiver.py | 13 ------- tests/simple_sendt_wlan0_1s2r/sender.py | 8 ---- tests/simple_sendt_wlan0_1s2r/simulator.py | 15 -------- tests/simple_wait_2n/node.py | 9 ----- tests/simple_wait_2n/out | 9 ----- tests/simple_wait_2n/simulator.py | 14 ------- tests/simple_wait_end_3n/node.py | 10 ----- tests/simple_wait_end_3n/out | 7 ---- tests/simple_wait_end_3n/simulator.py | 15 -------- 157 files changed, 1031 insertions(+), 998 deletions(-) create mode 100644 tests/api_log_5n/node.py create mode 100644 tests/api_log_5n/out create mode 100755 tests/api_log_5n/simulator.py create mode 100644 tests/api_read_clock_2n/node.py create mode 100644 tests/api_read_clock_2n/out create mode 100755 tests/api_read_clock_2n/simulator.py create mode 100644 tests/api_read_eth0_ncom_2s1r/out create mode 100644 tests/api_read_eth0_ncom_2s1r/receiver.py create mode 100644 tests/api_read_eth0_ncom_2s1r/sender.py create mode 100755 tests/api_read_eth0_ncom_2s1r/simulator.py create mode 100644 tests/api_read_order_ncom_1s2r/out create mode 100644 tests/api_read_order_ncom_1s2r/receiver.py create mode 100644 tests/api_read_order_ncom_1s2r/sender.py create mode 100755 tests/api_read_order_ncom_1s2r/simulator.py create mode 100644 tests/api_read_wlan0_ncom_2s1r/out create mode 100644 tests/api_read_wlan0_ncom_2s1r/receiver.py create mode 100644 tests/api_read_wlan0_ncom_2s1r/sender.py create mode 100755 tests/api_read_wlan0_ncom_2s1r/simulator.py create mode 100644 tests/api_receivet0_eth0_1s1r/out create mode 100644 tests/api_receivet0_eth0_1s1r/receiver.py create mode 100644 tests/api_receivet0_eth0_1s1r/sender.py create mode 100755 tests/api_receivet0_eth0_1s1r/simulator.py create mode 100644 tests/api_receivet0_eth0_1s1r/yoctosim.debug create mode 100644 tests/api_receivet_eth0_1s1r/out create mode 100644 tests/api_receivet_eth0_1s1r/receiver.py create mode 100644 tests/api_receivet_eth0_1s1r/sender.py create mode 100755 tests/api_receivet_eth0_1s1r/simulator.py create mode 100644 tests/api_receivet_eth0_1s1r/yoctosim.debug create mode 100644 tests/api_send0_eth0_1s1r/out create mode 100644 tests/api_send0_eth0_1s1r/receiver.py create mode 100644 tests/api_send0_eth0_1s1r/sender.py create mode 100755 tests/api_send0_eth0_1s1r/simulator.py create mode 100644 tests/api_send_4interfaces_1s2r/out create mode 100644 tests/api_send_4interfaces_1s2r/receiver.py create mode 100644 tests/api_send_4interfaces_1s2r/sender.py create mode 100755 tests/api_send_4interfaces_1s2r/simulator.py create mode 100644 tests/api_send_eth0_1s1r/out create mode 100644 tests/api_send_eth0_1s1r/receiver.py create mode 100644 tests/api_send_eth0_1s1r/sender.py create mode 100755 tests/api_send_eth0_1s1r/simulator.py create mode 100644 tests/api_send_eth0_2s1r/out create mode 100644 tests/api_send_eth0_2s1r/receiver.py create mode 100644 tests/api_send_eth0_2s1r/sender.py create mode 100755 tests/api_send_eth0_2s1r/simulator.py create mode 100644 tests/api_send_eth0_3s1r/out create mode 100644 tests/api_send_eth0_3s1r/receiver.py create mode 100644 tests/api_send_eth0_3s1r/sender.py create mode 100755 tests/api_send_eth0_3s1r/simulator.py create mode 100644 tests/api_send_wlan0_1s2r/out create mode 100644 tests/api_send_wlan0_1s2r/receiver.py create mode 100644 tests/api_send_wlan0_1s2r/sender.py create mode 100755 tests/api_send_wlan0_1s2r/simulator.py create mode 100644 tests/api_send_wlan0_2s1r/out create mode 100644 tests/api_send_wlan0_2s1r/receiver.py create mode 100644 tests/api_send_wlan0_2s1r/sender.py create mode 100755 tests/api_send_wlan0_2s1r/simulator.py create mode 100644 tests/api_sendt_eth0_1s1r/out create mode 100644 tests/api_sendt_eth0_1s1r/receiver.py create mode 100644 tests/api_sendt_eth0_1s1r/sender.py create mode 100755 tests/api_sendt_eth0_1s1r/simulator.py create mode 100644 tests/api_sendt_wlan0_1s2r/out create mode 100644 tests/api_sendt_wlan0_1s2r/receiver.py create mode 100644 tests/api_sendt_wlan0_1s2r/sender.py create mode 100755 tests/api_sendt_wlan0_1s2r/simulator.py create mode 100644 tests/api_wait_2n/node.py create mode 100644 tests/api_wait_2n/out create mode 100755 tests/api_wait_2n/simulator.py create mode 100644 tests/api_wait_end_3n/node.py create mode 100644 tests/api_wait_end_3n/out create mode 100755 tests/api_wait_end_3n/simulator.py create mode 100644 tests/breakpoints_auto_1n/node.py create mode 100644 tests/breakpoints_auto_1n/out create mode 100755 tests/breakpoints_auto_1n/simulator.py create mode 100644 tests/breakpoints_manual_1n/node.py create mode 100644 tests/breakpoints_manual_1n/out create mode 100755 tests/breakpoints_manual_1n/simulator.py create mode 100644 tests/breakpoints_manual_no_callback_1n/node.py create mode 100644 tests/breakpoints_manual_no_callback_1n/out create mode 100755 tests/breakpoints_manual_no_callback_1n/simulator.py delete mode 100644 tests/simple_breakpoints_auto_1n/node.py delete mode 100644 tests/simple_breakpoints_auto_1n/out delete mode 100755 tests/simple_breakpoints_auto_1n/simulator.py delete mode 100644 tests/simple_breakpoints_manual_1n/node.py delete mode 100644 tests/simple_breakpoints_manual_1n/out delete mode 100755 tests/simple_breakpoints_manual_1n/simulator.py delete mode 100644 tests/simple_breakpoints_manual_no_callback_1n/node.py delete mode 100644 tests/simple_breakpoints_manual_no_callback_1n/out delete mode 100755 tests/simple_breakpoints_manual_no_callback_1n/simulator.py delete mode 100644 tests/simple_log_5n/node.py delete mode 100644 tests/simple_log_5n/out delete mode 100755 tests/simple_log_5n/simulator.py delete mode 100644 tests/simple_read_clock_2n/node.py delete mode 100644 tests/simple_read_clock_2n/out delete mode 100755 tests/simple_read_clock_2n/simulator.py delete mode 100644 tests/simple_read_eth0_ncom_2s1r/out delete mode 100644 tests/simple_read_eth0_ncom_2s1r/receiver.py delete mode 100644 tests/simple_read_eth0_ncom_2s1r/sender.py delete mode 100755 tests/simple_read_eth0_ncom_2s1r/simulator.py delete mode 100644 tests/simple_read_wlan0_ncom_2s1r/out delete mode 100644 tests/simple_read_wlan0_ncom_2s1r/receiver.py delete mode 100644 tests/simple_read_wlan0_ncom_2s1r/sender.py delete mode 100755 tests/simple_read_wlan0_ncom_2s1r/simulator.py delete mode 100644 tests/simple_receivet0_eth0_1s1r/out delete mode 100644 tests/simple_receivet0_eth0_1s1r/receiver.py delete mode 100644 tests/simple_receivet0_eth0_1s1r/sender.py delete mode 100755 tests/simple_receivet0_eth0_1s1r/simulator.py delete mode 100644 tests/simple_receivet0_eth0_1s1r/yoctosim.debug delete mode 100644 tests/simple_receivet_eth0_1s1r/out delete mode 100644 tests/simple_receivet_eth0_1s1r/receiver.py delete mode 100644 tests/simple_receivet_eth0_1s1r/sender.py delete mode 100755 tests/simple_receivet_eth0_1s1r/simulator.py delete mode 100644 tests/simple_receivet_eth0_1s1r/yoctosim.debug delete mode 100644 tests/simple_send0_eth0_1s1r/out delete mode 100644 tests/simple_send0_eth0_1s1r/receiver.py delete mode 100644 tests/simple_send0_eth0_1s1r/sender.py delete mode 100755 tests/simple_send0_eth0_1s1r/simulator.py delete mode 100644 tests/simple_send_4interfaces_1s2r/out delete mode 100644 tests/simple_send_4interfaces_1s2r/receiver.py delete mode 100644 tests/simple_send_4interfaces_1s2r/sender.py delete mode 100755 tests/simple_send_4interfaces_1s2r/simulator.py delete mode 100644 tests/simple_send_eth0_1s1r/out delete mode 100644 tests/simple_send_eth0_1s1r/receiver.py delete mode 100644 tests/simple_send_eth0_1s1r/sender.py delete mode 100755 tests/simple_send_eth0_1s1r/simulator.py delete mode 100644 tests/simple_send_eth0_2s1r/out delete mode 100644 tests/simple_send_eth0_2s1r/receiver.py delete mode 100644 tests/simple_send_eth0_2s1r/sender.py delete mode 100755 tests/simple_send_eth0_2s1r/simulator.py delete mode 100644 tests/simple_send_eth0_3s1r/out delete mode 100644 tests/simple_send_eth0_3s1r/receiver.py delete mode 100644 tests/simple_send_eth0_3s1r/sender.py delete mode 100755 tests/simple_send_eth0_3s1r/simulator.py delete mode 100644 tests/simple_send_wlan0_1s2r/out delete mode 100644 tests/simple_send_wlan0_1s2r/receiver.py delete mode 100644 tests/simple_send_wlan0_1s2r/sender.py delete mode 100755 tests/simple_send_wlan0_1s2r/simulator.py delete mode 100644 tests/simple_send_wlan0_2s1r/out delete mode 100644 tests/simple_send_wlan0_2s1r/receiver.py delete mode 100644 tests/simple_send_wlan0_2s1r/sender.py delete mode 100755 tests/simple_send_wlan0_2s1r/simulator.py delete mode 100644 tests/simple_sendt_eth0_1s1r/out delete mode 100644 tests/simple_sendt_eth0_1s1r/receiver.py delete mode 100644 tests/simple_sendt_eth0_1s1r/sender.py delete mode 100755 tests/simple_sendt_eth0_1s1r/simulator.py delete mode 100644 tests/simple_sendt_wlan0_1s2r/out delete mode 100644 tests/simple_sendt_wlan0_1s2r/receiver.py delete mode 100644 tests/simple_sendt_wlan0_1s2r/sender.py delete mode 100755 tests/simple_sendt_wlan0_1s2r/simulator.py delete mode 100644 tests/simple_wait_2n/node.py delete mode 100644 tests/simple_wait_2n/out delete mode 100755 tests/simple_wait_2n/simulator.py delete mode 100644 tests/simple_wait_end_3n/node.py delete mode 100644 tests/simple_wait_end_3n/out delete mode 100755 tests/simple_wait_end_3n/simulator.py diff --git a/esds/simulator.py b/esds/simulator.py index 4217e1d..219c1d9 100644 --- a/esds/simulator.py +++ b/esds/simulator.py @@ -7,7 +7,7 @@ class Simulator: Flow-Level Discrete Event Simulator for Cyber-Physical Systems The general format for an event is (type,timestamp,event,priority) Event types: - - 0 send (0,timestamp,(src,dst,interface,data,datasize,duration,datasize_remaining), 2) + - 0 send (0,timestamp,(src,dst,interface,data,datasize,duration,datasize_remaining,start_timestamp), 2) - 1 timeout (1,timestamp,node_id,3) - 2 breakpoint_manual (3,timestamp,0,1) - 3 breakpoint_auto (4,timestamp,0,1) diff --git a/tests/api_log_5n/node.py b/tests/api_log_5n/node.py new file mode 100644 index 0000000..053c9fd --- /dev/null +++ b/tests/api_log_5n/node.py @@ -0,0 +1,7 @@ +#!/usr/bin/env python + +def execute(api): + api.log("A") + api.log("B") + api.log("C") + api.log("D") diff --git a/tests/api_log_5n/out b/tests/api_log_5n/out new file mode 100644 index 0000000..7d89c56 --- /dev/null +++ b/tests/api_log_5n/out @@ -0,0 +1,21 @@ +[t=0.000,src=n0] A +[t=0.000,src=n0] B +[t=0.000,src=n0] C +[t=0.000,src=n0] D +[t=0.000,src=n1] A +[t=0.000,src=n1] B +[t=0.000,src=n1] C +[t=0.000,src=n1] D +[t=0.000,src=n2] A +[t=0.000,src=n2] B +[t=0.000,src=n2] C +[t=0.000,src=n2] D +[t=0.000,src=n3] A +[t=0.000,src=n3] B +[t=0.000,src=n3] C +[t=0.000,src=n3] D +[t=0.000,src=n4] A +[t=0.000,src=n4] B +[t=0.000,src=n4] C +[t=0.000,src=n4] D +[t=0.000,src=esds] Simulation ends diff --git a/tests/api_log_5n/simulator.py b/tests/api_log_5n/simulator.py new file mode 100755 index 0000000..d9346cd --- /dev/null +++ b/tests/api_log_5n/simulator.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((5,5),5) +L=np.full((5,5),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("node") +s.create_node("node") +s.create_node("node") +s.create_node("node") +s.create_node("node") + +s.run() diff --git a/tests/api_read_clock_2n/node.py b/tests/api_read_clock_2n/node.py new file mode 100644 index 0000000..765c3f9 --- /dev/null +++ b/tests/api_read_clock_2n/node.py @@ -0,0 +1,7 @@ +#!/usr/bin/env python + +def execute(api): + api.log("Clock is {}s".format(api.read("clock"))) # Ensure clock is 0s for both node + api.wait(5698.1256) + api.log("Clock is {}s".format(api.read("clock"))) # Ensure clock is 5698.1256s for both node + api.log("Clock is {}s".format(api.read("clock"))) # Ensure clock did not change in between for both node diff --git a/tests/api_read_clock_2n/out b/tests/api_read_clock_2n/out new file mode 100644 index 0000000..c3cb2b9 --- /dev/null +++ b/tests/api_read_clock_2n/out @@ -0,0 +1,7 @@ +[t=0.000,src=n0] Clock is 0.0s +[t=0.000,src=n1] Clock is 0.0s +[t=5698.126,src=n0] Clock is 5698.1256s +[t=5698.126,src=n0] Clock is 5698.1256s +[t=5698.126,src=n1] Clock is 5698.1256s +[t=5698.126,src=n1] Clock is 5698.1256s +[t=5698.126,src=esds] Simulation ends diff --git a/tests/api_read_clock_2n/simulator.py b/tests/api_read_clock_2n/simulator.py new file mode 100755 index 0000000..fc0e80d --- /dev/null +++ b/tests/api_read_clock_2n/simulator.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((2,2),2) +L=np.full((2,2),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("node") +s.create_node("node") + +s.run() diff --git a/tests/api_read_eth0_ncom_2s1r/out b/tests/api_read_eth0_ncom_2s1r/out new file mode 100644 index 0000000..087e62b --- /dev/null +++ b/tests/api_read_eth0_ncom_2s1r/out @@ -0,0 +1,9 @@ +[t=0.000,src=n2] eth0 is 0 +[t=624.000,src=n2] eth0 is 0 +[t=1248.000,src=n0] Send 50 bytes to n2 on eth0 +[t=1249.000,src=n2] eth0 is 1 +[t=1249.000,src=n1] Send 50 bytes to n2 on eth0 +[t=1250.000,src=n2] eth0 is 2 +[t=1513.667,src=n2] Receive 50 bytes on eth0 +[t=1514.667,src=n2] Receive 50 bytes on eth0 +[t=1514.667,src=esds] Simulation ends diff --git a/tests/api_read_eth0_ncom_2s1r/receiver.py b/tests/api_read_eth0_ncom_2s1r/receiver.py new file mode 100644 index 0000000..286af70 --- /dev/null +++ b/tests/api_read_eth0_ncom_2s1r/receiver.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python + +def execute(api): + api.log("eth0 is {}".format(api.read("ncom_eth0"))) # Ensure no commmunications at t=0s + api.wait(624) + api.log("eth0 is {}".format(api.read("ncom_eth0"))) # Ensure still no commmunications at t=624s + api.wait(624) + # Now we are at 624*2=1248 (first sender start a communication) + api.wait(1) # Let the communication starts (otherwise value will be 0 (see api_read_order_ncom_1s2r)) + api.log("eth0 is {}".format(api.read("ncom_eth0"))) # Should print 1 + # Now second sender start a communication + api.wait(1) # Let the second communication starts + api.log("eth0 is {}".format(api.read("ncom_eth0"))) # Should print 2 diff --git a/tests/api_read_eth0_ncom_2s1r/sender.py b/tests/api_read_eth0_ncom_2s1r/sender.py new file mode 100644 index 0000000..e80db44 --- /dev/null +++ b/tests/api_read_eth0_ncom_2s1r/sender.py @@ -0,0 +1,9 @@ +#!/usr/bin/env python + +def execute(api): + api.wait(1248) # All communications start at t=1248s + if api.node_id==0: + api.send("eth0","hello",50,2) + else: + api.wait(1) # Second sender start 1s after the first + api.send("eth0","hello",50,2) diff --git a/tests/api_read_eth0_ncom_2s1r/simulator.py b/tests/api_read_eth0_ncom_2s1r/simulator.py new file mode 100755 index 0000000..85a0671 --- /dev/null +++ b/tests/api_read_eth0_ncom_2s1r/simulator.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((3,3),3) +L=np.full((3,3),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("sender") +s.create_node("receiver") + +s.run(interferences=False) diff --git a/tests/api_read_order_ncom_1s2r/out b/tests/api_read_order_ncom_1s2r/out new file mode 100644 index 0000000..9172791 --- /dev/null +++ b/tests/api_read_order_ncom_1s2r/out @@ -0,0 +1,6 @@ +[t=0.000,src=n0] wlan0 is 0 +[t=0.000,src=n2] wlan0 is 0 +[t=0.000,src=n1] Send 1 bytes on wlan0 +[t=1.000,src=n0] Receive 1 bytes on wlan0 +[t=1.000,src=n2] Receive 1 bytes on wlan0 +[t=1.000,src=esds] Simulation ends diff --git a/tests/api_read_order_ncom_1s2r/receiver.py b/tests/api_read_order_ncom_1s2r/receiver.py new file mode 100644 index 0000000..7bcf70e --- /dev/null +++ b/tests/api_read_order_ncom_1s2r/receiver.py @@ -0,0 +1,4 @@ +#!/usr/bin/env python + +def execute(api): + api.log("wlan0 is {}".format(api.read("ncom_wlan0"))) # Ensure no commmunications at t=0s diff --git a/tests/api_read_order_ncom_1s2r/sender.py b/tests/api_read_order_ncom_1s2r/sender.py new file mode 100644 index 0000000..b13bab3 --- /dev/null +++ b/tests/api_read_order_ncom_1s2r/sender.py @@ -0,0 +1,4 @@ +#!/usr/bin/env python + +def execute(api): + api.send("wlan0","hello",1,None) diff --git a/tests/api_read_order_ncom_1s2r/simulator.py b/tests/api_read_order_ncom_1s2r/simulator.py new file mode 100755 index 0000000..5c3418c --- /dev/null +++ b/tests/api_read_order_ncom_1s2r/simulator.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((3,3),8) +L=np.full((3,3),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +# Order at which receivers and senders are instanciated should not matter on the result +# both receivers should have ncom_wlan0 equals to 0 (since non-blocking calls are processed before the blocking one, it should be the case) +s.create_node("receiver") +s.create_node("sender") +s.create_node("receiver") + +s.run(interferences=False) diff --git a/tests/api_read_wlan0_ncom_2s1r/out b/tests/api_read_wlan0_ncom_2s1r/out new file mode 100644 index 0000000..93543eb --- /dev/null +++ b/tests/api_read_wlan0_ncom_2s1r/out @@ -0,0 +1,11 @@ +[t=0.000,src=n2] wlan0 is 0 +[t=624.000,src=n2] wlan0 is 0 +[t=1248.000,src=n0] Send 50 bytes on wlan0 +[t=1249.000,src=n2] wlan0 is 1 +[t=1249.000,src=n1] Send 50 bytes on wlan0 +[t=1250.000,src=n2] wlan0 is 2 +[t=1381.333,src=n1] Receive 50 bytes on wlan0 +[t=1381.333,src=n2] Receive 50 bytes on wlan0 +[t=1382.333,src=n0] Receive 50 bytes on wlan0 +[t=1382.333,src=n2] Receive 50 bytes on wlan0 +[t=1382.333,src=esds] Simulation ends diff --git a/tests/api_read_wlan0_ncom_2s1r/receiver.py b/tests/api_read_wlan0_ncom_2s1r/receiver.py new file mode 100644 index 0000000..1e133ec --- /dev/null +++ b/tests/api_read_wlan0_ncom_2s1r/receiver.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python + +def execute(api): + api.log("wlan0 is {}".format(api.read("ncom_wlan0"))) # Ensure no commmunications at t=0s + api.wait(624) + api.log("wlan0 is {}".format(api.read("ncom_wlan0"))) # Ensure still no commmunications at t=624s + api.wait(624) + # Now we are at 624*2=1248 (first sender start a communication) + api.wait(1) # Let the communication starts (otherwise value will be 0 (see api_read_order_ncom_1s2r)) + api.log("wlan0 is {}".format(api.read("ncom_wlan0"))) # Should print 1 + # Now second sender start a communication + api.wait(1) # Let the second communication starts + api.log("wlan0 is {}".format(api.read("ncom_wlan0"))) # Should print 2 diff --git a/tests/api_read_wlan0_ncom_2s1r/sender.py b/tests/api_read_wlan0_ncom_2s1r/sender.py new file mode 100644 index 0000000..aa8e227 --- /dev/null +++ b/tests/api_read_wlan0_ncom_2s1r/sender.py @@ -0,0 +1,9 @@ +#!/usr/bin/env python + +def execute(api): + api.wait(1248) # All communications start at t=1248s + if api.node_id==0: + api.send("wlan0","hello",50,None) + else: + api.wait(1) # Second sender start 1s after the first + api.send("wlan0","hello",50,None) diff --git a/tests/api_read_wlan0_ncom_2s1r/simulator.py b/tests/api_read_wlan0_ncom_2s1r/simulator.py new file mode 100755 index 0000000..85a0671 --- /dev/null +++ b/tests/api_read_wlan0_ncom_2s1r/simulator.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((3,3),3) +L=np.full((3,3),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("sender") +s.create_node("receiver") + +s.run(interferences=False) diff --git a/tests/api_receivet0_eth0_1s1r/out b/tests/api_receivet0_eth0_1s1r/out new file mode 100644 index 0000000..b9f63cd --- /dev/null +++ b/tests/api_receivet0_eth0_1s1r/out @@ -0,0 +1,5 @@ +[t=0.000,src=n0] Send 1 bytes to n1 on eth0 +[t=0.000,src=n1] Receive failed code=-1 +[t=1.000,src=n1] Receive 1 bytes on eth0 +[t=1.000,src=n1] Received: Hello World! +[t=1.000,src=esds] Simulation ends diff --git a/tests/api_receivet0_eth0_1s1r/receiver.py b/tests/api_receivet0_eth0_1s1r/receiver.py new file mode 100644 index 0000000..e57c460 --- /dev/null +++ b/tests/api_receivet0_eth0_1s1r/receiver.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +def receivet(node,timeout): + ##### Simple receive + code, data=node.receivet("eth0",timeout) + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + node.log(msg) + +def execute(api): + # Should not works since communication start at t=0s + receivet(api,0) + api.wait(1) + # Now communication started + receivet(api,0) # Should work (no timeout error) diff --git a/tests/api_receivet0_eth0_1s1r/sender.py b/tests/api_receivet0_eth0_1s1r/sender.py new file mode 100644 index 0000000..45d0460 --- /dev/null +++ b/tests/api_receivet0_eth0_1s1r/sender.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python + +def execute(api): + api.send("eth0","Hello World!",1,1) + diff --git a/tests/api_receivet0_eth0_1s1r/simulator.py b/tests/api_receivet0_eth0_1s1r/simulator.py new file mode 100755 index 0000000..ae5bbea --- /dev/null +++ b/tests/api_receivet0_eth0_1s1r/simulator.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((2,2),8) +L=np.full((2,2),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("receiver") + +s.run() diff --git a/tests/api_receivet0_eth0_1s1r/yoctosim.debug b/tests/api_receivet0_eth0_1s1r/yoctosim.debug new file mode 100644 index 0000000..9d879f4 --- /dev/null +++ b/tests/api_receivet0_eth0_1s1r/yoctosim.debug @@ -0,0 +1,43 @@ +Python version 3.10.5 (main, Jun 6 2022, 18:49:26) [GCC 12.1.0] +Simulation started at 1654802960.7880125 +Number of nodes is 2 +Manual breakpoints list: [] +Breakpoints every Nones +----------------------------------------------- +Started since 0.02s +Simulated time 0.000s (or more precisely 0s) +Node number per state: pending=1 request=1 +Node sharing: n1=1 +Ids of node in timeout mode: +Sorted events list: +[[0 1.0 array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 0], dtype=object) + 1] + [1 2 array(1, dtype=object) 3]] +----------------------------------------------- +Started since 0.04s +Simulated time 1.000s (or more precisely 1.0s) +Node number per state: pending=1 request=1 +Node sharing: n1=1 +Ids of node in timeout mode: +Sorted events list: +[[1 1.5 array(1, dtype=object) 3] + [0 2.0 + array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 1.0], dtype=object) 1]] +----------------------------------------------- +Started since 0.06s +Simulated time 1.500s (or more precisely 1.5s) +Node number per state: pending=1 request=1 +Node sharing: n1=1 +Ids of node in timeout mode: +Sorted events list: +[[0 2.0 + array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 1.0], dtype=object) 1] + [1 2.0 array(1, dtype=object) 3]] +----------------------------------------------- +Started since 0.08s +Simulated time 2.000s (or more precisely 2.0s) +Node number per state: terminated=2 +Node sharing: +Ids of node in timeout mode: +Sorted events list: +[] diff --git a/tests/api_receivet_eth0_1s1r/out b/tests/api_receivet_eth0_1s1r/out new file mode 100644 index 0000000..98756b5 --- /dev/null +++ b/tests/api_receivet_eth0_1s1r/out @@ -0,0 +1,8 @@ +[t=0.000,src=n0] Send 1 bytes to n1 on eth0 +[t=1.000,src=n1] Receive 1 bytes on eth0 +[t=1.000,src=n1] Received: Hello World! +[t=1.000,src=n0] Send 1 bytes to n1 on eth0 +[t=1.500,src=n1] Receive failed code=-1 +[t=2.000,src=n1] Receive 1 bytes on eth0 +[t=2.000,src=n1] Received: Hello World! +[t=2.000,src=esds] Simulation ends diff --git a/tests/api_receivet_eth0_1s1r/receiver.py b/tests/api_receivet_eth0_1s1r/receiver.py new file mode 100644 index 0000000..515ff6a --- /dev/null +++ b/tests/api_receivet_eth0_1s1r/receiver.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +def receivet(node,timeout): + ##### Simple receive + code, data=node.receivet("eth0",timeout) + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + node.log(msg) + +def execute(api): + # Should works + receivet(api,2) + # Should failed + receivet(api,0.5) # At t=1.5s + # Should works (priorities says that communications should occurs before timeout) + receivet(api,0.5) # At t=2s (timeout+receive should occur) diff --git a/tests/api_receivet_eth0_1s1r/sender.py b/tests/api_receivet_eth0_1s1r/sender.py new file mode 100644 index 0000000..0b6bdb6 --- /dev/null +++ b/tests/api_receivet_eth0_1s1r/sender.py @@ -0,0 +1,6 @@ +#!/usr/bin/env python + +def execute(api): + api.send("eth0","Hello World!",1,1) + api.send("eth0","Hello World!",1,1) + diff --git a/tests/api_receivet_eth0_1s1r/simulator.py b/tests/api_receivet_eth0_1s1r/simulator.py new file mode 100755 index 0000000..ae5bbea --- /dev/null +++ b/tests/api_receivet_eth0_1s1r/simulator.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((2,2),8) +L=np.full((2,2),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("receiver") + +s.run() diff --git a/tests/api_receivet_eth0_1s1r/yoctosim.debug b/tests/api_receivet_eth0_1s1r/yoctosim.debug new file mode 100644 index 0000000..9d879f4 --- /dev/null +++ b/tests/api_receivet_eth0_1s1r/yoctosim.debug @@ -0,0 +1,43 @@ +Python version 3.10.5 (main, Jun 6 2022, 18:49:26) [GCC 12.1.0] +Simulation started at 1654802960.7880125 +Number of nodes is 2 +Manual breakpoints list: [] +Breakpoints every Nones +----------------------------------------------- +Started since 0.02s +Simulated time 0.000s (or more precisely 0s) +Node number per state: pending=1 request=1 +Node sharing: n1=1 +Ids of node in timeout mode: +Sorted events list: +[[0 1.0 array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 0], dtype=object) + 1] + [1 2 array(1, dtype=object) 3]] +----------------------------------------------- +Started since 0.04s +Simulated time 1.000s (or more precisely 1.0s) +Node number per state: pending=1 request=1 +Node sharing: n1=1 +Ids of node in timeout mode: +Sorted events list: +[[1 1.5 array(1, dtype=object) 3] + [0 2.0 + array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 1.0], dtype=object) 1]] +----------------------------------------------- +Started since 0.06s +Simulated time 1.500s (or more precisely 1.5s) +Node number per state: pending=1 request=1 +Node sharing: n1=1 +Ids of node in timeout mode: +Sorted events list: +[[0 2.0 + array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 1.0], dtype=object) 1] + [1 2.0 array(1, dtype=object) 3]] +----------------------------------------------- +Started since 0.08s +Simulated time 2.000s (or more precisely 2.0s) +Node number per state: terminated=2 +Node sharing: +Ids of node in timeout mode: +Sorted events list: +[] diff --git a/tests/api_send0_eth0_1s1r/out b/tests/api_send0_eth0_1s1r/out new file mode 100644 index 0000000..3ffee9f --- /dev/null +++ b/tests/api_send0_eth0_1s1r/out @@ -0,0 +1,16 @@ +[t=0.000,src=n0] Send 0 bytes to n1 on eth0 +[t=0.000,src=n1] Receive 0 bytes on eth0 +[t=0.000,src=n1] Received: Hello World! +[t=0.000,src=n0] Send 0 bytes to n1 on eth0 +[t=0.000,src=n1] Receive 0 bytes on eth0 +[t=0.000,src=n1] Received: Hello World! +[t=1.000,src=n0] Send 0 bytes to n1 on eth0 +[t=1.000,src=n1] Receive 0 bytes on eth0 +[t=1.000,src=n1] Received: Hello World! +[t=3.000,src=n0] Send 0 bytes to n1 on eth0 +[t=3.000,src=n1] Receive 0 bytes on eth0 +[t=3.000,src=n1] Received: Hello World! +[t=3.000,src=n0] Send 0 bytes to n1 on eth0 +[t=3.000,src=n1] Receive 0 bytes on eth0 +[t=3.000,src=n1] Received: Hello World! +[t=3.000,src=esds] Simulation ends diff --git a/tests/api_send0_eth0_1s1r/receiver.py b/tests/api_send0_eth0_1s1r/receiver.py new file mode 100644 index 0000000..3f7a7db --- /dev/null +++ b/tests/api_send0_eth0_1s1r/receiver.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python + +def receive(api): + ##### Simple receive + code, data=api.receive("eth0") + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + api.log(msg) + +def execute(api): + receive(api) + # Simulated time t=0s here + receive(api) + # Simulated time t=0s here + receive(api) + # Simulated time t=1s here + receive(api) + # Simulated time t=3s here + code, data=api.receivet("eth0",0) + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + api.log(msg) + # Simulated time t=3s here + + diff --git a/tests/api_send0_eth0_1s1r/sender.py b/tests/api_send0_eth0_1s1r/sender.py new file mode 100644 index 0000000..25472ac --- /dev/null +++ b/tests/api_send0_eth0_1s1r/sender.py @@ -0,0 +1,12 @@ +#!/usr/bin/env python + +def execute(api): + api.send("eth0","Hello World!",0,1) + api.wait(0) + api.send("eth0","Hello World!",0,1) + api.wait(1) + api.send("eth0","Hello World!",0,1) + api.wait(1) + api.wait(1) + api.send("eth0","Hello World!",0,1) + api.send("eth0","Hello World!",0,1) diff --git a/tests/api_send0_eth0_1s1r/simulator.py b/tests/api_send0_eth0_1s1r/simulator.py new file mode 100755 index 0000000..ae5bbea --- /dev/null +++ b/tests/api_send0_eth0_1s1r/simulator.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((2,2),8) +L=np.full((2,2),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("receiver") + +s.run() diff --git a/tests/api_send_4interfaces_1s2r/out b/tests/api_send_4interfaces_1s2r/out new file mode 100644 index 0000000..1d40d0a --- /dev/null +++ b/tests/api_send_4interfaces_1s2r/out @@ -0,0 +1,14 @@ +[t=0.000,src=n0] Send 1 bytes on wlan0 +[t=1.000,src=n1] Receive 1 bytes on wlan0 +[t=1.000,src=n0] Send 1 bytes on wlan1 +[t=2.000,src=n1] Receive 1 bytes on wlan1 +[t=2.000,src=n2] Receive 1 bytes on wlan1 +[t=2.000,src=n0] Send 1 bytes to n1 on eth0 +[t=3.000,src=n1] Receive 1 bytes on eth0 +[t=3.000,src=n0] Send 1 bytes to n2 on eth0 +[t=4.000,src=n2] Receive 1 bytes on eth0 +[t=4.000,src=n0] Send 1 bytes to n1 on eth1 +[t=4.500,src=n1] Receive 1 bytes on eth1 +[t=4.500,src=n0] Send 1 bytes to n2 on eth1 +[t=5.000,src=n2] Receive 1 bytes on eth1 +[t=5.000,src=esds] Simulation ends diff --git a/tests/api_send_4interfaces_1s2r/receiver.py b/tests/api_send_4interfaces_1s2r/receiver.py new file mode 100644 index 0000000..0b48f12 --- /dev/null +++ b/tests/api_send_4interfaces_1s2r/receiver.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python + +def execute(api): + pass + diff --git a/tests/api_send_4interfaces_1s2r/sender.py b/tests/api_send_4interfaces_1s2r/sender.py new file mode 100644 index 0000000..aeef4cd --- /dev/null +++ b/tests/api_send_4interfaces_1s2r/sender.py @@ -0,0 +1,12 @@ +#!/usr/bin/env python + +def execute(api): + # Wireless + api.send("wlan0","Hello World!",1,1) + api.send("wlan1","Hello World!",1,1) + # Wired + api.send("eth0","Hello World!",1,1) + api.send("eth0","Hello World!",1,2) + api.send("eth1","Hello World!",1,1) + api.send("eth1","Hello World!",1,2) + diff --git a/tests/api_send_4interfaces_1s2r/simulator.py b/tests/api_send_4interfaces_1s2r/simulator.py new file mode 100755 index 0000000..f7ebbf6 --- /dev/null +++ b/tests/api_send_4interfaces_1s2r/simulator.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B_wlan0=np.full((3,3),8) +B_wlan0[0,2]=0 # Sender cannot reach n2 on wlan0 +B_wlan1=np.full((3,3),8) # Sender can reach n1 AND n2 on wlan1 + +B_eth0=np.full((3,3),8) +B_eth1=np.full((3,3),16) # On eth1 sender can reach receiver twice faster than eth0 + +L=np.full((3,3),0) +s=esds.Simulator({"wlan0":{"bandwidth":B_wlan0, "latency":L, "is_wired":False}, + "wlan1":{"bandwidth":B_wlan1, "latency":L, "is_wired":False}, + "eth0":{"bandwidth":B_eth0, "latency":L, "is_wired":True}, + "eth1":{"bandwidth":B_eth1, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("receiver") +s.create_node("receiver") + +s.run() diff --git a/tests/api_send_eth0_1s1r/out b/tests/api_send_eth0_1s1r/out new file mode 100644 index 0000000..1634d95 --- /dev/null +++ b/tests/api_send_eth0_1s1r/out @@ -0,0 +1,11 @@ +[t=0.000,src=n0] Send 1 bytes to n1 on eth0 +[t=1.000,src=n1] Receive 1 bytes on eth0 +[t=1.000,src=n1] Received: Hello World! +[t=1.000,src=n0] Send 1 bytes to n1 on eth0 +[t=2.000,src=n1] Receive 1 bytes on eth0 +[t=3.000,src=n0] Send 1 bytes to n1 on eth0 +[t=3.000,src=n1] Received: Hello World! +[t=3.000,src=n1] Turned off +[t=4.000,src=n1] Turned on +[t=5.000,src=n1] Receive failed code=-1 +[t=5.000,src=esds] Simulation ends diff --git a/tests/api_send_eth0_1s1r/receiver.py b/tests/api_send_eth0_1s1r/receiver.py new file mode 100644 index 0000000..96305bf --- /dev/null +++ b/tests/api_send_eth0_1s1r/receiver.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python + +def execute(api): + ##### Simple receive + code, data=api.receive("eth0") + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + api.log(msg) + ##### Test if we still receive the data when we are not receiving + api.wait(2) + code, data=api.receive("eth0") + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + api.log(msg) + ##### Ensure data is not receive when turned off + api.turn_off() + api.wait(1) + api.turn_on() + code, data=api.receivet("eth0",1) + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + api.log(msg) + diff --git a/tests/api_send_eth0_1s1r/sender.py b/tests/api_send_eth0_1s1r/sender.py new file mode 100644 index 0000000..9f4aa85 --- /dev/null +++ b/tests/api_send_eth0_1s1r/sender.py @@ -0,0 +1,7 @@ +#!/usr/bin/env python + +def execute(api): + api.send("eth0","Hello World!",1,1) + api.send("eth0","Hello World!",1,1) + api.wait(1) # Goto 3 seconds + api.send("eth0","Hello World!",1,1) diff --git a/tests/api_send_eth0_1s1r/simulator.py b/tests/api_send_eth0_1s1r/simulator.py new file mode 100755 index 0000000..ae5bbea --- /dev/null +++ b/tests/api_send_eth0_1s1r/simulator.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((2,2),8) +L=np.full((2,2),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("receiver") + +s.run() diff --git a/tests/api_send_eth0_2s1r/out b/tests/api_send_eth0_2s1r/out new file mode 100644 index 0000000..663e5cf --- /dev/null +++ b/tests/api_send_eth0_2s1r/out @@ -0,0 +1,7 @@ +[t=0.000,src=n0] Send 1 bytes to n2 on eth0 +[t=0.000,src=n1] Send 1 bytes to n2 on eth0 +[t=2.000,src=n2] Receive 1 bytes on eth0 +[t=2.000,src=n2] Receive 1 bytes on eth0 +[t=2.000,src=n2] Received: Hello World from 0! +[t=2.000,src=n2] Received: Hello World from 1! +[t=2.000,src=esds] Simulation ends diff --git a/tests/api_send_eth0_2s1r/receiver.py b/tests/api_send_eth0_2s1r/receiver.py new file mode 100644 index 0000000..2f268fd --- /dev/null +++ b/tests/api_send_eth0_2s1r/receiver.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python + +def execute(api): + ##### Simple receive from node 0 + code, data=api.receive("eth0") + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + api.log(msg) + + ##### Simple receive from node 1 + code, data=api.receive("eth0") + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + api.log(msg) + diff --git a/tests/api_send_eth0_2s1r/sender.py b/tests/api_send_eth0_2s1r/sender.py new file mode 100644 index 0000000..90daae5 --- /dev/null +++ b/tests/api_send_eth0_2s1r/sender.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python + +def execute(api): + api.send("eth0","Hello World from {}!".format(api.node_id),1,2) + diff --git a/tests/api_send_eth0_2s1r/simulator.py b/tests/api_send_eth0_2s1r/simulator.py new file mode 100755 index 0000000..4cce1d0 --- /dev/null +++ b/tests/api_send_eth0_2s1r/simulator.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((3,3),8) +L=np.full((3,3),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("sender") +s.create_node("receiver") + +s.run() diff --git a/tests/api_send_eth0_3s1r/out b/tests/api_send_eth0_3s1r/out new file mode 100644 index 0000000..714a4c8 --- /dev/null +++ b/tests/api_send_eth0_3s1r/out @@ -0,0 +1,40 @@ +[t=0.000,src=n0] Send 1 bytes to n3 on eth0 +[t=0.000,src=n1] Send 1 bytes to n3 on eth0 +[t=0.000,src=n2] Send 1 bytes to n3 on eth0 +[t=3.000,src=n3] Receive 1 bytes on eth0 +[t=3.000,src=n3] Receive 1 bytes on eth0 +[t=3.000,src=n3] Receive 1 bytes on eth0 +[t=3.000,src=n3] Received: Hello World from 0! +[t=3.000,src=n0] Send 2 bytes to n3 on eth0 +[t=3.000,src=n1] Send 1 bytes to n3 on eth0 +[t=3.000,src=n2] Send 1 bytes to n3 on eth0 +[t=3.000,src=n3] Received: Hello World from 1! +[t=3.000,src=n3] Received: Hello World from 2! +[t=6.000,src=n3] Receive 1 bytes on eth0 +[t=6.000,src=n3] Receive 1 bytes on eth0 +[t=6.000,src=n3] Received: Hello World from 1! +[t=6.000,src=n3] Received: Hello World from 2! +[t=7.000,src=n3] Receive 2 bytes on eth0 +[t=7.000,src=n3] Received: Hello World (2bytes) from 0! +[t=7.000,src=n0] Send 2 bytes to n3 on eth0 +[t=7.000,src=n1] Send 2 bytes to n3 on eth0 +[t=7.000,src=n2] Send 1 bytes to n3 on eth0 +[t=10.000,src=n3] Receive 1 bytes on eth0 +[t=10.000,src=n3] Received: Hello World from 2! +[t=12.000,src=n3] Receive 2 bytes on eth0 +[t=12.000,src=n3] Receive 2 bytes on eth0 +[t=12.000,src=n3] Received: Hello World (2bytes) from 0! +[t=12.000,src=n0] Send 1 bytes to n3 on eth0 +[t=12.000,src=n1] Send 2 bytes to n3 on eth0 +[t=12.000,src=n2] Send 3 bytes to n3 on eth0 +[t=12.000,src=n3] Received: Hello World (2bytes) from 1! +[t=15.000,src=n3] Receive 1 bytes on eth0 +[t=15.000,src=n3] Received: Hello World from 0! +[t=17.000,src=n3] Receive 2 bytes on eth0 +[t=17.000,src=n3] Received: Hello World from 1! +[t=18.000,src=n3] Receive 3 bytes on eth0 +[t=18.000,src=n3] Received: Hello World from 2! +[t=18.000,src=n0] Send 5 bytes to n3 on eth0 +[t=23.000,src=n3] Receive 5 bytes on eth0 +[t=23.000,src=n3] Received: Hello World from 0! +[t=23.000,src=esds] Simulation ends diff --git a/tests/api_send_eth0_3s1r/receiver.py b/tests/api_send_eth0_3s1r/receiver.py new file mode 100644 index 0000000..4516d7a --- /dev/null +++ b/tests/api_send_eth0_3s1r/receiver.py @@ -0,0 +1,19 @@ +#!/usr/bin/env python + +def receive(node, n): + for i in range(0,n): + code, data=node.receive("eth0") + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + node.log(msg) + +def execute(api): + # Receive the first 3 send that should end at 3s + receive(api,3) + # Receive the first 3 send that should end at 7s + receive(api,3) + # Receive the first 3 send that should end at 12s + receive(api,3) + # Receive the first 3 send that should end at 18s + receive(api,3) + # Should ends at 23s + receive(api,1) diff --git a/tests/api_send_eth0_3s1r/sender.py b/tests/api_send_eth0_3s1r/sender.py new file mode 100644 index 0000000..6b8312b --- /dev/null +++ b/tests/api_send_eth0_3s1r/sender.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python + +# Node that bandwidths at setup in a way that 1 byte is send in 1 seconds with no sharing + +def execute(api): + # Should be completed at 3s (bandwidth divided by 3) + api.send("eth0","Hello World from {}!".format(api.node_id),1,3) # Shoud lasts 3s + + # These send should start at 3s and be completed at 7s + if api.node_id==0: + api.send("eth0","Hello World (2bytes) from {}!".format(api.node_id),2,3) # Should lasts 3s + 1s = 4s + else: + api.send("eth0","Hello World from {}!".format(api.node_id),1,3) # Should lasts 3s + api.wait(1) # Sync with node 0 at 7s + + # Those sends should start at 7s and be completed at 12s + if api.node_id<=1: + api.send("eth0","Hello World (2bytes) from {}!".format(api.node_id),2,3) # Should last 3s + 2s = 5s + # Completed at 12s since 3 nodes are sharing the bandwidth up to 10s + # then the 2 two remaining node send their last byte up to 12s + else: + api.send("eth0","Hello World from {}!".format(api.node_id),1,3) # Should last 3s + # Completed at 10s (3 nodes are sharing the bandwidth) + api.wait(2) # Sync with node 0-1 at 12s + + # Should start at 12s + # Node 0 sends 1 byte, node 1 sends 2 byte and node 2 sends 3 + # These send should end at 18s + api.send("eth0","Hello World from {}!".format(api.node_id),api.node_id+1,3) # Should lasts 3s, 5s and 6s + + # Finally a single send from node 0 + if api.node_id==0: + api.wait(3) # Since node 0 send ends at 15s we sync it to 18s + api.send("eth0","Hello World from {}!".format(api.node_id),5,3) # Should takes 5 seconds (ends at 23s) + + + diff --git a/tests/api_send_eth0_3s1r/simulator.py b/tests/api_send_eth0_3s1r/simulator.py new file mode 100755 index 0000000..84c0de0 --- /dev/null +++ b/tests/api_send_eth0_3s1r/simulator.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((4,4),8) +L=np.full((4,4),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("sender") +s.create_node("sender") +s.create_node("receiver") + +s.run() diff --git a/tests/api_send_wlan0_1s2r/out b/tests/api_send_wlan0_1s2r/out new file mode 100644 index 0000000..bb052dd --- /dev/null +++ b/tests/api_send_wlan0_1s2r/out @@ -0,0 +1,16 @@ +[t=0.000,src=n0] Send 1 bytes on wlan0 +[t=1.000,src=n1] Receive 1 bytes on wlan0 +[t=1.000,src=n2] Receive 1 bytes on wlan0 +[t=1.000,src=n1] Received: Hello World! +[t=1.000,src=n2] Received: Hello World! +[t=1.000,src=n2] Turned off +[t=1.000,src=n0] Send 1 bytes on wlan0 +[t=2.000,src=n1] Receive 1 bytes on wlan0 +[t=2.000,src=n1] Received: Hello World! +[t=2.000,src=n2] Turned on +[t=2.000,src=n0] Send 1 bytes on wlan0 +[t=2.500,src=n2] Turned off +[t=3.000,src=n1] Receive 1 bytes on wlan0 +[t=3.000,src=n1] Received: Hello World! +[t=3.000,src=n2] Turned on +[t=3.000,src=esds] Simulation ends diff --git a/tests/api_send_wlan0_1s2r/receiver.py b/tests/api_send_wlan0_1s2r/receiver.py new file mode 100644 index 0000000..5b86500 --- /dev/null +++ b/tests/api_send_wlan0_1s2r/receiver.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python + +def receive(node): + ##### Simple receive + code, data=node.receive("wlan0") + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + node.log(msg) + + +def execute(api): + # Should works for all receivers + receive(api) + + if api.node_id == 1: + receive(api) # Should works + else: + api.turn_off() + api.wait(1) # Node 2 should not receive anything during 1s + api.turn_on() + + + if api.node_id == 1: + receive(api) # Should works + else: + api.wait(0.5) # Check if started communication get cancelled on turning off + api.turn_off() # Node 2 should not receive anything + api.wait(0.5) # Node 2 should not receive anything during 0.5s + api.turn_on() + diff --git a/tests/api_send_wlan0_1s2r/sender.py b/tests/api_send_wlan0_1s2r/sender.py new file mode 100644 index 0000000..ef1517b --- /dev/null +++ b/tests/api_send_wlan0_1s2r/sender.py @@ -0,0 +1,6 @@ +#!/usr/bin/env python + +def execute(api): + api.send("wlan0","Hello World!",1,1) + api.send("wlan0","Hello World!",1,1) + api.send("wlan0","Hello World!",1,1) diff --git a/tests/api_send_wlan0_1s2r/simulator.py b/tests/api_send_wlan0_1s2r/simulator.py new file mode 100755 index 0000000..e721a93 --- /dev/null +++ b/tests/api_send_wlan0_1s2r/simulator.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((3,3),8) +L=np.full((3,3),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("receiver") +s.create_node("receiver") + +s.run() diff --git a/tests/api_send_wlan0_2s1r/out b/tests/api_send_wlan0_2s1r/out new file mode 100644 index 0000000..788ee42 --- /dev/null +++ b/tests/api_send_wlan0_2s1r/out @@ -0,0 +1,6 @@ +[t=0.000,src=n0] Send 1 bytes on wlan0 +[t=0.000,src=n1] Send 1 bytes on wlan0 +[t=0.000,src=n0] Interferences on wlan0 +[t=0.000,src=n1] Interferences on wlan0 +[t=0.000,src=n2] Interferences on wlan0 +[t=1.000,src=esds] Simulation ends diff --git a/tests/api_send_wlan0_2s1r/receiver.py b/tests/api_send_wlan0_2s1r/receiver.py new file mode 100644 index 0000000..0b48f12 --- /dev/null +++ b/tests/api_send_wlan0_2s1r/receiver.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python + +def execute(api): + pass + diff --git a/tests/api_send_wlan0_2s1r/sender.py b/tests/api_send_wlan0_2s1r/sender.py new file mode 100644 index 0000000..80f0fc2 --- /dev/null +++ b/tests/api_send_wlan0_2s1r/sender.py @@ -0,0 +1,4 @@ +#!/usr/bin/env python + +def execute(api): + api.send("wlan0","Hello World!",1,1) diff --git a/tests/api_send_wlan0_2s1r/simulator.py b/tests/api_send_wlan0_2s1r/simulator.py new file mode 100755 index 0000000..4cce1d0 --- /dev/null +++ b/tests/api_send_wlan0_2s1r/simulator.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((3,3),8) +L=np.full((3,3),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("sender") +s.create_node("receiver") + +s.run() diff --git a/tests/api_sendt_eth0_1s1r/out b/tests/api_sendt_eth0_1s1r/out new file mode 100644 index 0000000..254b865 --- /dev/null +++ b/tests/api_sendt_eth0_1s1r/out @@ -0,0 +1,11 @@ +[t=0.000,src=n0] Send 1 bytes to n1 on eth0 +[t=1.000,src=n1] Receive 1 bytes on eth0 +[t=1.000,src=n0] Send worked! +[t=1.000,src=n1] Received: Hello World! +[t=1.000,src=n0] Send 1 bytes to n1 on eth0 +[t=1.500,src=n0] Send failed +[t=1.500,src=n0] Send 1 bytes to n1 on eth0 +[t=2.500,src=n1] Receive 1 bytes on eth0 +[t=2.500,src=n0] Send worked! +[t=2.500,src=n1] Received: Hello World! +[t=2.500,src=esds] Simulation ends diff --git a/tests/api_sendt_eth0_1s1r/receiver.py b/tests/api_sendt_eth0_1s1r/receiver.py new file mode 100644 index 0000000..0d8561e --- /dev/null +++ b/tests/api_sendt_eth0_1s1r/receiver.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +def receive(node): + ##### Simple receive + code, data=node.receive("eth0") + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + node.log(msg) + +def execute(api): + receive(api) + receive(api) diff --git a/tests/api_sendt_eth0_1s1r/sender.py b/tests/api_sendt_eth0_1s1r/sender.py new file mode 100644 index 0000000..ee2ea9d --- /dev/null +++ b/tests/api_sendt_eth0_1s1r/sender.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +def sendt(node,timeout): + code=node.sendt("eth0","Hello World!",1,1,timeout) + msg="Send worked!" if code == 0 else "Send failed" + node.log(msg) + +def execute(api): + # Should work + sendt(api,2) + # Should not work + sendt(api,0.5) + # Should work + sendt(api,2) diff --git a/tests/api_sendt_eth0_1s1r/simulator.py b/tests/api_sendt_eth0_1s1r/simulator.py new file mode 100755 index 0000000..ae5bbea --- /dev/null +++ b/tests/api_sendt_eth0_1s1r/simulator.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((2,2),8) +L=np.full((2,2),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("receiver") + +s.run() diff --git a/tests/api_sendt_wlan0_1s2r/out b/tests/api_sendt_wlan0_1s2r/out new file mode 100644 index 0000000..9428958 --- /dev/null +++ b/tests/api_sendt_wlan0_1s2r/out @@ -0,0 +1,7 @@ +[t=0.000,src=n0] Send 1 bytes on wlan0 +[t=1.000,src=n1] Receive 1 bytes on wlan0 +[t=1.000,src=n2] Receive 1 bytes on wlan0 +[t=1.000,src=n1] Received: Hello World! +[t=1.000,src=n2] Received: Hello World! +[t=1.000,src=n0] Send 1 bytes on wlan0 +[t=1.500,src=esds] Simulation ends diff --git a/tests/api_sendt_wlan0_1s2r/receiver.py b/tests/api_sendt_wlan0_1s2r/receiver.py new file mode 100644 index 0000000..eca49ad --- /dev/null +++ b/tests/api_sendt_wlan0_1s2r/receiver.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python + +def receive(node): + ##### Simple receive + code, data=node.receive("wlan0") + msg="Received: "+data if code == 0 else "Receive failed code="+str(code) + node.log(msg) + + +def execute(api): + # Should works for all receivers + receive(api) + diff --git a/tests/api_sendt_wlan0_1s2r/sender.py b/tests/api_sendt_wlan0_1s2r/sender.py new file mode 100644 index 0000000..fe2dc1a --- /dev/null +++ b/tests/api_sendt_wlan0_1s2r/sender.py @@ -0,0 +1,8 @@ +#!/usr/bin/env python + +def execute(api): + # Should works + api.sendt("wlan0","Hello World!",1,1,2) + # Should not work + api.sendt("wlan0","Hello World!",1,1,0.5) + diff --git a/tests/api_sendt_wlan0_1s2r/simulator.py b/tests/api_sendt_wlan0_1s2r/simulator.py new file mode 100755 index 0000000..e721a93 --- /dev/null +++ b/tests/api_sendt_wlan0_1s2r/simulator.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((3,3),8) +L=np.full((3,3),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("sender") +s.create_node("receiver") +s.create_node("receiver") + +s.run() diff --git a/tests/api_wait_2n/node.py b/tests/api_wait_2n/node.py new file mode 100644 index 0000000..86b06de --- /dev/null +++ b/tests/api_wait_2n/node.py @@ -0,0 +1,9 @@ +#!/usr/bin/env python + +def execute(api): + api.log("Before wait") + api.wait(2) + api.log("After wait") + api.log("Before wait") + api.wait(3) + api.log("After wait") diff --git a/tests/api_wait_2n/out b/tests/api_wait_2n/out new file mode 100644 index 0000000..8a694cc --- /dev/null +++ b/tests/api_wait_2n/out @@ -0,0 +1,9 @@ +[t=0.000,src=n0] Before wait +[t=0.000,src=n1] Before wait +[t=2.000,src=n0] After wait +[t=2.000,src=n0] Before wait +[t=2.000,src=n1] After wait +[t=2.000,src=n1] Before wait +[t=5.000,src=n0] After wait +[t=5.000,src=n1] After wait +[t=5.000,src=esds] Simulation ends diff --git a/tests/api_wait_2n/simulator.py b/tests/api_wait_2n/simulator.py new file mode 100755 index 0000000..fc0e80d --- /dev/null +++ b/tests/api_wait_2n/simulator.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((2,2),2) +L=np.full((2,2),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("node") +s.create_node("node") + +s.run() diff --git a/tests/api_wait_end_3n/node.py b/tests/api_wait_end_3n/node.py new file mode 100644 index 0000000..a8fbcd7 --- /dev/null +++ b/tests/api_wait_end_3n/node.py @@ -0,0 +1,10 @@ +#!/usr/bin/env python + +def execute(api): + wait=api.node_id + api.log("Before wait for "+str(wait)+"s") + api.wait(wait) # Since 3 nodes max(wait)==2 + + # Ensure that wait end return back when simulation ends + api.wait_end() + api.log("Terminated") diff --git a/tests/api_wait_end_3n/out b/tests/api_wait_end_3n/out new file mode 100644 index 0000000..321b0c2 --- /dev/null +++ b/tests/api_wait_end_3n/out @@ -0,0 +1,7 @@ +[t=0.000,src=n0] Before wait for 0s +[t=0.000,src=n1] Before wait for 1s +[t=0.000,src=n2] Before wait for 2s +[t=2.000,src=n0] Terminated +[t=2.000,src=n1] Terminated +[t=2.000,src=n2] Terminated +[t=2.000,src=esds] Simulation ends diff --git a/tests/api_wait_end_3n/simulator.py b/tests/api_wait_end_3n/simulator.py new file mode 100755 index 0000000..4d1763e --- /dev/null +++ b/tests/api_wait_end_3n/simulator.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +B=np.full((3,3),2) +L=np.full((3,3),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("node") +s.create_node("node") +s.create_node("node") + +s.run() diff --git a/tests/breakpoints_auto_1n/node.py b/tests/breakpoints_auto_1n/node.py new file mode 100644 index 0000000..e812c01 --- /dev/null +++ b/tests/breakpoints_auto_1n/node.py @@ -0,0 +1,8 @@ +#!/usr/bin/env python + +def execute(api): + if api.node_id == 0: + api.send("eth0","Hello",5,1) + else: + api.receive("eth0") + diff --git a/tests/breakpoints_auto_1n/out b/tests/breakpoints_auto_1n/out new file mode 100644 index 0000000..e8fce88 --- /dev/null +++ b/tests/breakpoints_auto_1n/out @@ -0,0 +1,9 @@ +[t=0.000,src=n0] Send 5 bytes to n1 on eth0 +[t=3.300,src=esds] Hello Callback! +[t=6.600,src=esds] Hello Callback! +[t=9.900,src=esds] Hello Callback! +[t=13.200,src=esds] Hello Callback! +[t=16.500,src=esds] Hello Callback! +[t=19.800,src=esds] Hello Callback! +[t=20.000,src=n1] Receive 5 bytes on eth0 +[t=20.000,src=esds] Simulation ends diff --git a/tests/breakpoints_auto_1n/simulator.py b/tests/breakpoints_auto_1n/simulator.py new file mode 100755 index 0000000..ac24a03 --- /dev/null +++ b/tests/breakpoints_auto_1n/simulator.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +n=2 +B=np.full((2,2),n) +L=np.full((2,2),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("node") +s.create_node("node") + +def callback(simulator): + simulator.log("Hello Callback!") + +s.run(breakpoints_every=3.3,breakpoint_callback=callback) diff --git a/tests/breakpoints_manual_1n/node.py b/tests/breakpoints_manual_1n/node.py new file mode 100644 index 0000000..f8c5633 --- /dev/null +++ b/tests/breakpoints_manual_1n/node.py @@ -0,0 +1,4 @@ +#!/usr/bin/env python + +def execute(api): + api.log("Running") diff --git a/tests/breakpoints_manual_1n/out b/tests/breakpoints_manual_1n/out new file mode 100644 index 0000000..40c44b7 --- /dev/null +++ b/tests/breakpoints_manual_1n/out @@ -0,0 +1,7 @@ +[t=0.000,src=n0] Running +[t=0.000,src=n1] Running +[t=1.000,src=esds] Hello Callback! +[t=2.000,src=esds] Hello Callback! +[t=3.000,src=esds] Hello Callback! +[t=10.000,src=esds] Hello Callback! +[t=10.000,src=esds] Simulation ends diff --git a/tests/breakpoints_manual_1n/simulator.py b/tests/breakpoints_manual_1n/simulator.py new file mode 100755 index 0000000..dd12ed3 --- /dev/null +++ b/tests/breakpoints_manual_1n/simulator.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +n=2 +B=np.full((n,n),n) +L=np.full((n,n),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("node") +s.create_node("node") + +def callback(simulator): + simulator.log("Hello Callback!") + +s.run(breakpoints=[1,2,3,10],breakpoint_callback=callback) diff --git a/tests/breakpoints_manual_no_callback_1n/node.py b/tests/breakpoints_manual_no_callback_1n/node.py new file mode 100644 index 0000000..f8c5633 --- /dev/null +++ b/tests/breakpoints_manual_no_callback_1n/node.py @@ -0,0 +1,4 @@ +#!/usr/bin/env python + +def execute(api): + api.log("Running") diff --git a/tests/breakpoints_manual_no_callback_1n/out b/tests/breakpoints_manual_no_callback_1n/out new file mode 100644 index 0000000..defce2c --- /dev/null +++ b/tests/breakpoints_manual_no_callback_1n/out @@ -0,0 +1,3 @@ +[t=0.000,src=n0] Running +[t=0.000,src=n1] Running +[t=10.000,src=esds] Simulation ends diff --git a/tests/breakpoints_manual_no_callback_1n/simulator.py b/tests/breakpoints_manual_no_callback_1n/simulator.py new file mode 100755 index 0000000..fe4b491 --- /dev/null +++ b/tests/breakpoints_manual_no_callback_1n/simulator.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +# Load ESDS +import esds +import numpy as np + +n=2 +B=np.full((n,n),n) +L=np.full((n,n),0) +s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) + +s.create_node("node") +s.create_node("node") + +s.run(breakpoints=[1,2,3,10]) diff --git a/tests/mobility_eth0_bandwidth_2s1r/simulator.py b/tests/mobility_eth0_bandwidth_2s1r/simulator.py index ed58854..e1e6636 100755 --- a/tests/mobility_eth0_bandwidth_2s1r/simulator.py +++ b/tests/mobility_eth0_bandwidth_2s1r/simulator.py @@ -38,4 +38,4 @@ def callback(simulator): new_bw_eth0=simulator.netmat["eth0"]["bandwidth"]*2 simulator.update_network({"wlan0":{"bandwidth":new_bw_wlan0, "latency":L, "is_wired":False}, "eth0":{"bandwidth":new_bw_eth0, "latency":L, "is_wired":True}}) -s.run(breakpoints_every=1,breakpoint_callback=callback,debug=True) +s.run(breakpoints_every=1,breakpoint_callback=callback) diff --git a/tests/mobility_eth0_latency_2s1r/simulator.py b/tests/mobility_eth0_latency_2s1r/simulator.py index 05dfee8..cb4a8bb 100755 --- a/tests/mobility_eth0_latency_2s1r/simulator.py +++ b/tests/mobility_eth0_latency_2s1r/simulator.py @@ -39,4 +39,4 @@ def callback(simulator): new_lat_eth0=simulator.netmat["eth0"]["latency"]+1/2 simulator.update_network({"wlan0":{"bandwidth":B, "latency":new_lat_wlan0, "is_wired":False},"eth0":{"bandwidth":B, "latency":new_lat_eth0, "is_wired":True}}) -s.run(breakpoints_every=1,breakpoint_callback=callback,debug=True) +s.run(breakpoints_every=1,breakpoint_callback=callback) diff --git a/tests/simple_breakpoints_auto_1n/node.py b/tests/simple_breakpoints_auto_1n/node.py deleted file mode 100644 index e812c01..0000000 --- a/tests/simple_breakpoints_auto_1n/node.py +++ /dev/null @@ -1,8 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - if api.node_id == 0: - api.send("eth0","Hello",5,1) - else: - api.receive("eth0") - diff --git a/tests/simple_breakpoints_auto_1n/out b/tests/simple_breakpoints_auto_1n/out deleted file mode 100644 index e8fce88..0000000 --- a/tests/simple_breakpoints_auto_1n/out +++ /dev/null @@ -1,9 +0,0 @@ -[t=0.000,src=n0] Send 5 bytes to n1 on eth0 -[t=3.300,src=esds] Hello Callback! -[t=6.600,src=esds] Hello Callback! -[t=9.900,src=esds] Hello Callback! -[t=13.200,src=esds] Hello Callback! -[t=16.500,src=esds] Hello Callback! -[t=19.800,src=esds] Hello Callback! -[t=20.000,src=n1] Receive 5 bytes on eth0 -[t=20.000,src=esds] Simulation ends diff --git a/tests/simple_breakpoints_auto_1n/simulator.py b/tests/simple_breakpoints_auto_1n/simulator.py deleted file mode 100755 index ac24a03..0000000 --- a/tests/simple_breakpoints_auto_1n/simulator.py +++ /dev/null @@ -1,18 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -n=2 -B=np.full((2,2),n) -L=np.full((2,2),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("node") -s.create_node("node") - -def callback(simulator): - simulator.log("Hello Callback!") - -s.run(breakpoints_every=3.3,breakpoint_callback=callback) diff --git a/tests/simple_breakpoints_manual_1n/node.py b/tests/simple_breakpoints_manual_1n/node.py deleted file mode 100644 index f8c5633..0000000 --- a/tests/simple_breakpoints_manual_1n/node.py +++ /dev/null @@ -1,4 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.log("Running") diff --git a/tests/simple_breakpoints_manual_1n/out b/tests/simple_breakpoints_manual_1n/out deleted file mode 100644 index 40c44b7..0000000 --- a/tests/simple_breakpoints_manual_1n/out +++ /dev/null @@ -1,7 +0,0 @@ -[t=0.000,src=n0] Running -[t=0.000,src=n1] Running -[t=1.000,src=esds] Hello Callback! -[t=2.000,src=esds] Hello Callback! -[t=3.000,src=esds] Hello Callback! -[t=10.000,src=esds] Hello Callback! -[t=10.000,src=esds] Simulation ends diff --git a/tests/simple_breakpoints_manual_1n/simulator.py b/tests/simple_breakpoints_manual_1n/simulator.py deleted file mode 100755 index dd12ed3..0000000 --- a/tests/simple_breakpoints_manual_1n/simulator.py +++ /dev/null @@ -1,18 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -n=2 -B=np.full((n,n),n) -L=np.full((n,n),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("node") -s.create_node("node") - -def callback(simulator): - simulator.log("Hello Callback!") - -s.run(breakpoints=[1,2,3,10],breakpoint_callback=callback) diff --git a/tests/simple_breakpoints_manual_no_callback_1n/node.py b/tests/simple_breakpoints_manual_no_callback_1n/node.py deleted file mode 100644 index f8c5633..0000000 --- a/tests/simple_breakpoints_manual_no_callback_1n/node.py +++ /dev/null @@ -1,4 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.log("Running") diff --git a/tests/simple_breakpoints_manual_no_callback_1n/out b/tests/simple_breakpoints_manual_no_callback_1n/out deleted file mode 100644 index defce2c..0000000 --- a/tests/simple_breakpoints_manual_no_callback_1n/out +++ /dev/null @@ -1,3 +0,0 @@ -[t=0.000,src=n0] Running -[t=0.000,src=n1] Running -[t=10.000,src=esds] Simulation ends diff --git a/tests/simple_breakpoints_manual_no_callback_1n/simulator.py b/tests/simple_breakpoints_manual_no_callback_1n/simulator.py deleted file mode 100755 index fe4b491..0000000 --- a/tests/simple_breakpoints_manual_no_callback_1n/simulator.py +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -n=2 -B=np.full((n,n),n) -L=np.full((n,n),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("node") -s.create_node("node") - -s.run(breakpoints=[1,2,3,10]) diff --git a/tests/simple_log_5n/node.py b/tests/simple_log_5n/node.py deleted file mode 100644 index 053c9fd..0000000 --- a/tests/simple_log_5n/node.py +++ /dev/null @@ -1,7 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.log("A") - api.log("B") - api.log("C") - api.log("D") diff --git a/tests/simple_log_5n/out b/tests/simple_log_5n/out deleted file mode 100644 index 7d89c56..0000000 --- a/tests/simple_log_5n/out +++ /dev/null @@ -1,21 +0,0 @@ -[t=0.000,src=n0] A -[t=0.000,src=n0] B -[t=0.000,src=n0] C -[t=0.000,src=n0] D -[t=0.000,src=n1] A -[t=0.000,src=n1] B -[t=0.000,src=n1] C -[t=0.000,src=n1] D -[t=0.000,src=n2] A -[t=0.000,src=n2] B -[t=0.000,src=n2] C -[t=0.000,src=n2] D -[t=0.000,src=n3] A -[t=0.000,src=n3] B -[t=0.000,src=n3] C -[t=0.000,src=n3] D -[t=0.000,src=n4] A -[t=0.000,src=n4] B -[t=0.000,src=n4] C -[t=0.000,src=n4] D -[t=0.000,src=esds] Simulation ends diff --git a/tests/simple_log_5n/simulator.py b/tests/simple_log_5n/simulator.py deleted file mode 100755 index d9346cd..0000000 --- a/tests/simple_log_5n/simulator.py +++ /dev/null @@ -1,17 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((5,5),5) -L=np.full((5,5),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("node") -s.create_node("node") -s.create_node("node") -s.create_node("node") -s.create_node("node") - -s.run() diff --git a/tests/simple_read_clock_2n/node.py b/tests/simple_read_clock_2n/node.py deleted file mode 100644 index 79a0b78..0000000 --- a/tests/simple_read_clock_2n/node.py +++ /dev/null @@ -1,7 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.log("Clock is {}s".format(api.read("clock"))) - api.wait(5698.1256) - api.log("Clock is {}s".format(api.read("clock"))) - api.log("Clock is {}s".format(api.read("clock"))) diff --git a/tests/simple_read_clock_2n/out b/tests/simple_read_clock_2n/out deleted file mode 100644 index c3cb2b9..0000000 --- a/tests/simple_read_clock_2n/out +++ /dev/null @@ -1,7 +0,0 @@ -[t=0.000,src=n0] Clock is 0.0s -[t=0.000,src=n1] Clock is 0.0s -[t=5698.126,src=n0] Clock is 5698.1256s -[t=5698.126,src=n0] Clock is 5698.1256s -[t=5698.126,src=n1] Clock is 5698.1256s -[t=5698.126,src=n1] Clock is 5698.1256s -[t=5698.126,src=esds] Simulation ends diff --git a/tests/simple_read_clock_2n/simulator.py b/tests/simple_read_clock_2n/simulator.py deleted file mode 100755 index fc0e80d..0000000 --- a/tests/simple_read_clock_2n/simulator.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((2,2),2) -L=np.full((2,2),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("node") -s.create_node("node") - -s.run() diff --git a/tests/simple_read_eth0_ncom_2s1r/out b/tests/simple_read_eth0_ncom_2s1r/out deleted file mode 100644 index 087e62b..0000000 --- a/tests/simple_read_eth0_ncom_2s1r/out +++ /dev/null @@ -1,9 +0,0 @@ -[t=0.000,src=n2] eth0 is 0 -[t=624.000,src=n2] eth0 is 0 -[t=1248.000,src=n0] Send 50 bytes to n2 on eth0 -[t=1249.000,src=n2] eth0 is 1 -[t=1249.000,src=n1] Send 50 bytes to n2 on eth0 -[t=1250.000,src=n2] eth0 is 2 -[t=1513.667,src=n2] Receive 50 bytes on eth0 -[t=1514.667,src=n2] Receive 50 bytes on eth0 -[t=1514.667,src=esds] Simulation ends diff --git a/tests/simple_read_eth0_ncom_2s1r/receiver.py b/tests/simple_read_eth0_ncom_2s1r/receiver.py deleted file mode 100644 index e2d317b..0000000 --- a/tests/simple_read_eth0_ncom_2s1r/receiver.py +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.log("eth0 is {}".format(api.read("ncom_eth0"))) - api.wait(624) - api.log("eth0 is {}".format(api.read("ncom_eth0"))) - api.wait(624) - # Now we are at 624*2=1248 (first sender start a communication) - api.wait(1) # Let the communication starts - api.log("eth0 is {}".format(api.read("ncom_eth0"))) # Should print 1 - api.wait(1) # Now second sender start a communication - api.log("eth0 is {}".format(api.read("ncom_eth0"))) # Should print 2 diff --git a/tests/simple_read_eth0_ncom_2s1r/sender.py b/tests/simple_read_eth0_ncom_2s1r/sender.py deleted file mode 100644 index 7c9259a..0000000 --- a/tests/simple_read_eth0_ncom_2s1r/sender.py +++ /dev/null @@ -1,9 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.wait(1248) - if api.node_id==0: - api.send("eth0","hello",50,2) - else: - api.wait(1) - api.send("eth0","hello",50,2) diff --git a/tests/simple_read_eth0_ncom_2s1r/simulator.py b/tests/simple_read_eth0_ncom_2s1r/simulator.py deleted file mode 100755 index 85a0671..0000000 --- a/tests/simple_read_eth0_ncom_2s1r/simulator.py +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((3,3),3) -L=np.full((3,3),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("sender") -s.create_node("receiver") - -s.run(interferences=False) diff --git a/tests/simple_read_wlan0_ncom_2s1r/out b/tests/simple_read_wlan0_ncom_2s1r/out deleted file mode 100644 index 93543eb..0000000 --- a/tests/simple_read_wlan0_ncom_2s1r/out +++ /dev/null @@ -1,11 +0,0 @@ -[t=0.000,src=n2] wlan0 is 0 -[t=624.000,src=n2] wlan0 is 0 -[t=1248.000,src=n0] Send 50 bytes on wlan0 -[t=1249.000,src=n2] wlan0 is 1 -[t=1249.000,src=n1] Send 50 bytes on wlan0 -[t=1250.000,src=n2] wlan0 is 2 -[t=1381.333,src=n1] Receive 50 bytes on wlan0 -[t=1381.333,src=n2] Receive 50 bytes on wlan0 -[t=1382.333,src=n0] Receive 50 bytes on wlan0 -[t=1382.333,src=n2] Receive 50 bytes on wlan0 -[t=1382.333,src=esds] Simulation ends diff --git a/tests/simple_read_wlan0_ncom_2s1r/receiver.py b/tests/simple_read_wlan0_ncom_2s1r/receiver.py deleted file mode 100644 index d41304e..0000000 --- a/tests/simple_read_wlan0_ncom_2s1r/receiver.py +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.log("wlan0 is {}".format(api.read("ncom_wlan0"))) - api.wait(624) - api.log("wlan0 is {}".format(api.read("ncom_wlan0"))) - api.wait(624) - # Now we are at 624*2=1248 (first sender start a communication) - api.wait(1) # Let the communication starts - api.log("wlan0 is {}".format(api.read("ncom_wlan0"))) # Should print 1 - api.wait(1) # Second sender start a communication - api.log("wlan0 is {}".format(api.read("ncom_wlan0"))) # Should print 2 diff --git a/tests/simple_read_wlan0_ncom_2s1r/sender.py b/tests/simple_read_wlan0_ncom_2s1r/sender.py deleted file mode 100644 index b89e5e2..0000000 --- a/tests/simple_read_wlan0_ncom_2s1r/sender.py +++ /dev/null @@ -1,9 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.wait(1248) - if api.node_id==0: - api.send("wlan0","hello",50,None) - else: - api.wait(1) - api.send("wlan0","hello",50,None) diff --git a/tests/simple_read_wlan0_ncom_2s1r/simulator.py b/tests/simple_read_wlan0_ncom_2s1r/simulator.py deleted file mode 100755 index 85a0671..0000000 --- a/tests/simple_read_wlan0_ncom_2s1r/simulator.py +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((3,3),3) -L=np.full((3,3),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("sender") -s.create_node("receiver") - -s.run(interferences=False) diff --git a/tests/simple_receivet0_eth0_1s1r/out b/tests/simple_receivet0_eth0_1s1r/out deleted file mode 100644 index b9f63cd..0000000 --- a/tests/simple_receivet0_eth0_1s1r/out +++ /dev/null @@ -1,5 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes to n1 on eth0 -[t=0.000,src=n1] Receive failed code=-1 -[t=1.000,src=n1] Receive 1 bytes on eth0 -[t=1.000,src=n1] Received: Hello World! -[t=1.000,src=esds] Simulation ends diff --git a/tests/simple_receivet0_eth0_1s1r/receiver.py b/tests/simple_receivet0_eth0_1s1r/receiver.py deleted file mode 100644 index bbb7ff7..0000000 --- a/tests/simple_receivet0_eth0_1s1r/receiver.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env python - -def receivet(node,timeout): - ##### Simple receive - code, data=node.receivet("eth0",timeout) - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - node.log(msg) - -def execute(api): - # Should not works - receivet(api,0) - api.wait(1) - # Should works - receivet(api,0) diff --git a/tests/simple_receivet0_eth0_1s1r/sender.py b/tests/simple_receivet0_eth0_1s1r/sender.py deleted file mode 100644 index 45d0460..0000000 --- a/tests/simple_receivet0_eth0_1s1r/sender.py +++ /dev/null @@ -1,5 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.send("eth0","Hello World!",1,1) - diff --git a/tests/simple_receivet0_eth0_1s1r/simulator.py b/tests/simple_receivet0_eth0_1s1r/simulator.py deleted file mode 100755 index 7c3e389..0000000 --- a/tests/simple_receivet0_eth0_1s1r/simulator.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((2,2),8) -L=np.full((2,2),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("receiver") - -s.run(debug=True) diff --git a/tests/simple_receivet0_eth0_1s1r/yoctosim.debug b/tests/simple_receivet0_eth0_1s1r/yoctosim.debug deleted file mode 100644 index 9d879f4..0000000 --- a/tests/simple_receivet0_eth0_1s1r/yoctosim.debug +++ /dev/null @@ -1,43 +0,0 @@ -Python version 3.10.5 (main, Jun 6 2022, 18:49:26) [GCC 12.1.0] -Simulation started at 1654802960.7880125 -Number of nodes is 2 -Manual breakpoints list: [] -Breakpoints every Nones ------------------------------------------------ -Started since 0.02s -Simulated time 0.000s (or more precisely 0s) -Node number per state: pending=1 request=1 -Node sharing: n1=1 -Ids of node in timeout mode: -Sorted events list: -[[0 1.0 array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 0], dtype=object) - 1] - [1 2 array(1, dtype=object) 3]] ------------------------------------------------ -Started since 0.04s -Simulated time 1.000s (or more precisely 1.0s) -Node number per state: pending=1 request=1 -Node sharing: n1=1 -Ids of node in timeout mode: -Sorted events list: -[[1 1.5 array(1, dtype=object) 3] - [0 2.0 - array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 1.0], dtype=object) 1]] ------------------------------------------------ -Started since 0.06s -Simulated time 1.500s (or more precisely 1.5s) -Node number per state: pending=1 request=1 -Node sharing: n1=1 -Ids of node in timeout mode: -Sorted events list: -[[0 2.0 - array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 1.0], dtype=object) 1] - [1 2.0 array(1, dtype=object) 3]] ------------------------------------------------ -Started since 0.08s -Simulated time 2.000s (or more precisely 2.0s) -Node number per state: terminated=2 -Node sharing: -Ids of node in timeout mode: -Sorted events list: -[] diff --git a/tests/simple_receivet_eth0_1s1r/out b/tests/simple_receivet_eth0_1s1r/out deleted file mode 100644 index 98756b5..0000000 --- a/tests/simple_receivet_eth0_1s1r/out +++ /dev/null @@ -1,8 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes to n1 on eth0 -[t=1.000,src=n1] Receive 1 bytes on eth0 -[t=1.000,src=n1] Received: Hello World! -[t=1.000,src=n0] Send 1 bytes to n1 on eth0 -[t=1.500,src=n1] Receive failed code=-1 -[t=2.000,src=n1] Receive 1 bytes on eth0 -[t=2.000,src=n1] Received: Hello World! -[t=2.000,src=esds] Simulation ends diff --git a/tests/simple_receivet_eth0_1s1r/receiver.py b/tests/simple_receivet_eth0_1s1r/receiver.py deleted file mode 100644 index 515ff6a..0000000 --- a/tests/simple_receivet_eth0_1s1r/receiver.py +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env python - -def receivet(node,timeout): - ##### Simple receive - code, data=node.receivet("eth0",timeout) - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - node.log(msg) - -def execute(api): - # Should works - receivet(api,2) - # Should failed - receivet(api,0.5) # At t=1.5s - # Should works (priorities says that communications should occurs before timeout) - receivet(api,0.5) # At t=2s (timeout+receive should occur) diff --git a/tests/simple_receivet_eth0_1s1r/sender.py b/tests/simple_receivet_eth0_1s1r/sender.py deleted file mode 100644 index 0b6bdb6..0000000 --- a/tests/simple_receivet_eth0_1s1r/sender.py +++ /dev/null @@ -1,6 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.send("eth0","Hello World!",1,1) - api.send("eth0","Hello World!",1,1) - diff --git a/tests/simple_receivet_eth0_1s1r/simulator.py b/tests/simple_receivet_eth0_1s1r/simulator.py deleted file mode 100755 index 7c3e389..0000000 --- a/tests/simple_receivet_eth0_1s1r/simulator.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((2,2),8) -L=np.full((2,2),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("receiver") - -s.run(debug=True) diff --git a/tests/simple_receivet_eth0_1s1r/yoctosim.debug b/tests/simple_receivet_eth0_1s1r/yoctosim.debug deleted file mode 100644 index 9d879f4..0000000 --- a/tests/simple_receivet_eth0_1s1r/yoctosim.debug +++ /dev/null @@ -1,43 +0,0 @@ -Python version 3.10.5 (main, Jun 6 2022, 18:49:26) [GCC 12.1.0] -Simulation started at 1654802960.7880125 -Number of nodes is 2 -Manual breakpoints list: [] -Breakpoints every Nones ------------------------------------------------ -Started since 0.02s -Simulated time 0.000s (or more precisely 0s) -Node number per state: pending=1 request=1 -Node sharing: n1=1 -Ids of node in timeout mode: -Sorted events list: -[[0 1.0 array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 0], dtype=object) - 1] - [1 2 array(1, dtype=object) 3]] ------------------------------------------------ -Started since 0.04s -Simulated time 1.000s (or more precisely 1.0s) -Node number per state: pending=1 request=1 -Node sharing: n1=1 -Ids of node in timeout mode: -Sorted events list: -[[1 1.5 array(1, dtype=object) 3] - [0 2.0 - array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 1.0], dtype=object) 1]] ------------------------------------------------ -Started since 0.06s -Simulated time 1.500s (or more precisely 1.5s) -Node number per state: pending=1 request=1 -Node sharing: n1=1 -Ids of node in timeout mode: -Sorted events list: -[[0 2.0 - array([0, 1, 'eth0', 'Hello World!', 1, 1.0, 1, 1.0], dtype=object) 1] - [1 2.0 array(1, dtype=object) 3]] ------------------------------------------------ -Started since 0.08s -Simulated time 2.000s (or more precisely 2.0s) -Node number per state: terminated=2 -Node sharing: -Ids of node in timeout mode: -Sorted events list: -[] diff --git a/tests/simple_send0_eth0_1s1r/out b/tests/simple_send0_eth0_1s1r/out deleted file mode 100644 index 3ffee9f..0000000 --- a/tests/simple_send0_eth0_1s1r/out +++ /dev/null @@ -1,16 +0,0 @@ -[t=0.000,src=n0] Send 0 bytes to n1 on eth0 -[t=0.000,src=n1] Receive 0 bytes on eth0 -[t=0.000,src=n1] Received: Hello World! -[t=0.000,src=n0] Send 0 bytes to n1 on eth0 -[t=0.000,src=n1] Receive 0 bytes on eth0 -[t=0.000,src=n1] Received: Hello World! -[t=1.000,src=n0] Send 0 bytes to n1 on eth0 -[t=1.000,src=n1] Receive 0 bytes on eth0 -[t=1.000,src=n1] Received: Hello World! -[t=3.000,src=n0] Send 0 bytes to n1 on eth0 -[t=3.000,src=n1] Receive 0 bytes on eth0 -[t=3.000,src=n1] Received: Hello World! -[t=3.000,src=n0] Send 0 bytes to n1 on eth0 -[t=3.000,src=n1] Receive 0 bytes on eth0 -[t=3.000,src=n1] Received: Hello World! -[t=3.000,src=esds] Simulation ends diff --git a/tests/simple_send0_eth0_1s1r/receiver.py b/tests/simple_send0_eth0_1s1r/receiver.py deleted file mode 100644 index 3f7a7db..0000000 --- a/tests/simple_send0_eth0_1s1r/receiver.py +++ /dev/null @@ -1,23 +0,0 @@ -#!/usr/bin/env python - -def receive(api): - ##### Simple receive - code, data=api.receive("eth0") - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - api.log(msg) - -def execute(api): - receive(api) - # Simulated time t=0s here - receive(api) - # Simulated time t=0s here - receive(api) - # Simulated time t=1s here - receive(api) - # Simulated time t=3s here - code, data=api.receivet("eth0",0) - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - api.log(msg) - # Simulated time t=3s here - - diff --git a/tests/simple_send0_eth0_1s1r/sender.py b/tests/simple_send0_eth0_1s1r/sender.py deleted file mode 100644 index 25472ac..0000000 --- a/tests/simple_send0_eth0_1s1r/sender.py +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.send("eth0","Hello World!",0,1) - api.wait(0) - api.send("eth0","Hello World!",0,1) - api.wait(1) - api.send("eth0","Hello World!",0,1) - api.wait(1) - api.wait(1) - api.send("eth0","Hello World!",0,1) - api.send("eth0","Hello World!",0,1) diff --git a/tests/simple_send0_eth0_1s1r/simulator.py b/tests/simple_send0_eth0_1s1r/simulator.py deleted file mode 100755 index 7c3e389..0000000 --- a/tests/simple_send0_eth0_1s1r/simulator.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((2,2),8) -L=np.full((2,2),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("receiver") - -s.run(debug=True) diff --git a/tests/simple_send_4interfaces_1s2r/out b/tests/simple_send_4interfaces_1s2r/out deleted file mode 100644 index 1d40d0a..0000000 --- a/tests/simple_send_4interfaces_1s2r/out +++ /dev/null @@ -1,14 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes on wlan0 -[t=1.000,src=n1] Receive 1 bytes on wlan0 -[t=1.000,src=n0] Send 1 bytes on wlan1 -[t=2.000,src=n1] Receive 1 bytes on wlan1 -[t=2.000,src=n2] Receive 1 bytes on wlan1 -[t=2.000,src=n0] Send 1 bytes to n1 on eth0 -[t=3.000,src=n1] Receive 1 bytes on eth0 -[t=3.000,src=n0] Send 1 bytes to n2 on eth0 -[t=4.000,src=n2] Receive 1 bytes on eth0 -[t=4.000,src=n0] Send 1 bytes to n1 on eth1 -[t=4.500,src=n1] Receive 1 bytes on eth1 -[t=4.500,src=n0] Send 1 bytes to n2 on eth1 -[t=5.000,src=n2] Receive 1 bytes on eth1 -[t=5.000,src=esds] Simulation ends diff --git a/tests/simple_send_4interfaces_1s2r/receiver.py b/tests/simple_send_4interfaces_1s2r/receiver.py deleted file mode 100644 index 0b48f12..0000000 --- a/tests/simple_send_4interfaces_1s2r/receiver.py +++ /dev/null @@ -1,5 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - pass - diff --git a/tests/simple_send_4interfaces_1s2r/sender.py b/tests/simple_send_4interfaces_1s2r/sender.py deleted file mode 100644 index aeef4cd..0000000 --- a/tests/simple_send_4interfaces_1s2r/sender.py +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - # Wireless - api.send("wlan0","Hello World!",1,1) - api.send("wlan1","Hello World!",1,1) - # Wired - api.send("eth0","Hello World!",1,1) - api.send("eth0","Hello World!",1,2) - api.send("eth1","Hello World!",1,1) - api.send("eth1","Hello World!",1,2) - diff --git a/tests/simple_send_4interfaces_1s2r/simulator.py b/tests/simple_send_4interfaces_1s2r/simulator.py deleted file mode 100755 index f7ebbf6..0000000 --- a/tests/simple_send_4interfaces_1s2r/simulator.py +++ /dev/null @@ -1,24 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B_wlan0=np.full((3,3),8) -B_wlan0[0,2]=0 # Sender cannot reach n2 on wlan0 -B_wlan1=np.full((3,3),8) # Sender can reach n1 AND n2 on wlan1 - -B_eth0=np.full((3,3),8) -B_eth1=np.full((3,3),16) # On eth1 sender can reach receiver twice faster than eth0 - -L=np.full((3,3),0) -s=esds.Simulator({"wlan0":{"bandwidth":B_wlan0, "latency":L, "is_wired":False}, - "wlan1":{"bandwidth":B_wlan1, "latency":L, "is_wired":False}, - "eth0":{"bandwidth":B_eth0, "latency":L, "is_wired":True}, - "eth1":{"bandwidth":B_eth1, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("receiver") -s.create_node("receiver") - -s.run() diff --git a/tests/simple_send_eth0_1s1r/out b/tests/simple_send_eth0_1s1r/out deleted file mode 100644 index 1634d95..0000000 --- a/tests/simple_send_eth0_1s1r/out +++ /dev/null @@ -1,11 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes to n1 on eth0 -[t=1.000,src=n1] Receive 1 bytes on eth0 -[t=1.000,src=n1] Received: Hello World! -[t=1.000,src=n0] Send 1 bytes to n1 on eth0 -[t=2.000,src=n1] Receive 1 bytes on eth0 -[t=3.000,src=n0] Send 1 bytes to n1 on eth0 -[t=3.000,src=n1] Received: Hello World! -[t=3.000,src=n1] Turned off -[t=4.000,src=n1] Turned on -[t=5.000,src=n1] Receive failed code=-1 -[t=5.000,src=esds] Simulation ends diff --git a/tests/simple_send_eth0_1s1r/receiver.py b/tests/simple_send_eth0_1s1r/receiver.py deleted file mode 100644 index 96305bf..0000000 --- a/tests/simple_send_eth0_1s1r/receiver.py +++ /dev/null @@ -1,20 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - ##### Simple receive - code, data=api.receive("eth0") - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - api.log(msg) - ##### Test if we still receive the data when we are not receiving - api.wait(2) - code, data=api.receive("eth0") - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - api.log(msg) - ##### Ensure data is not receive when turned off - api.turn_off() - api.wait(1) - api.turn_on() - code, data=api.receivet("eth0",1) - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - api.log(msg) - diff --git a/tests/simple_send_eth0_1s1r/sender.py b/tests/simple_send_eth0_1s1r/sender.py deleted file mode 100644 index 9f4aa85..0000000 --- a/tests/simple_send_eth0_1s1r/sender.py +++ /dev/null @@ -1,7 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.send("eth0","Hello World!",1,1) - api.send("eth0","Hello World!",1,1) - api.wait(1) # Goto 3 seconds - api.send("eth0","Hello World!",1,1) diff --git a/tests/simple_send_eth0_1s1r/simulator.py b/tests/simple_send_eth0_1s1r/simulator.py deleted file mode 100755 index ae5bbea..0000000 --- a/tests/simple_send_eth0_1s1r/simulator.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((2,2),8) -L=np.full((2,2),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("receiver") - -s.run() diff --git a/tests/simple_send_eth0_2s1r/out b/tests/simple_send_eth0_2s1r/out deleted file mode 100644 index 663e5cf..0000000 --- a/tests/simple_send_eth0_2s1r/out +++ /dev/null @@ -1,7 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes to n2 on eth0 -[t=0.000,src=n1] Send 1 bytes to n2 on eth0 -[t=2.000,src=n2] Receive 1 bytes on eth0 -[t=2.000,src=n2] Receive 1 bytes on eth0 -[t=2.000,src=n2] Received: Hello World from 0! -[t=2.000,src=n2] Received: Hello World from 1! -[t=2.000,src=esds] Simulation ends diff --git a/tests/simple_send_eth0_2s1r/receiver.py b/tests/simple_send_eth0_2s1r/receiver.py deleted file mode 100644 index 2f268fd..0000000 --- a/tests/simple_send_eth0_2s1r/receiver.py +++ /dev/null @@ -1,13 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - ##### Simple receive from node 0 - code, data=api.receive("eth0") - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - api.log(msg) - - ##### Simple receive from node 1 - code, data=api.receive("eth0") - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - api.log(msg) - diff --git a/tests/simple_send_eth0_2s1r/sender.py b/tests/simple_send_eth0_2s1r/sender.py deleted file mode 100644 index 90daae5..0000000 --- a/tests/simple_send_eth0_2s1r/sender.py +++ /dev/null @@ -1,5 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.send("eth0","Hello World from {}!".format(api.node_id),1,2) - diff --git a/tests/simple_send_eth0_2s1r/simulator.py b/tests/simple_send_eth0_2s1r/simulator.py deleted file mode 100755 index 4cce1d0..0000000 --- a/tests/simple_send_eth0_2s1r/simulator.py +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((3,3),8) -L=np.full((3,3),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("sender") -s.create_node("receiver") - -s.run() diff --git a/tests/simple_send_eth0_3s1r/out b/tests/simple_send_eth0_3s1r/out deleted file mode 100644 index 714a4c8..0000000 --- a/tests/simple_send_eth0_3s1r/out +++ /dev/null @@ -1,40 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes to n3 on eth0 -[t=0.000,src=n1] Send 1 bytes to n3 on eth0 -[t=0.000,src=n2] Send 1 bytes to n3 on eth0 -[t=3.000,src=n3] Receive 1 bytes on eth0 -[t=3.000,src=n3] Receive 1 bytes on eth0 -[t=3.000,src=n3] Receive 1 bytes on eth0 -[t=3.000,src=n3] Received: Hello World from 0! -[t=3.000,src=n0] Send 2 bytes to n3 on eth0 -[t=3.000,src=n1] Send 1 bytes to n3 on eth0 -[t=3.000,src=n2] Send 1 bytes to n3 on eth0 -[t=3.000,src=n3] Received: Hello World from 1! -[t=3.000,src=n3] Received: Hello World from 2! -[t=6.000,src=n3] Receive 1 bytes on eth0 -[t=6.000,src=n3] Receive 1 bytes on eth0 -[t=6.000,src=n3] Received: Hello World from 1! -[t=6.000,src=n3] Received: Hello World from 2! -[t=7.000,src=n3] Receive 2 bytes on eth0 -[t=7.000,src=n3] Received: Hello World (2bytes) from 0! -[t=7.000,src=n0] Send 2 bytes to n3 on eth0 -[t=7.000,src=n1] Send 2 bytes to n3 on eth0 -[t=7.000,src=n2] Send 1 bytes to n3 on eth0 -[t=10.000,src=n3] Receive 1 bytes on eth0 -[t=10.000,src=n3] Received: Hello World from 2! -[t=12.000,src=n3] Receive 2 bytes on eth0 -[t=12.000,src=n3] Receive 2 bytes on eth0 -[t=12.000,src=n3] Received: Hello World (2bytes) from 0! -[t=12.000,src=n0] Send 1 bytes to n3 on eth0 -[t=12.000,src=n1] Send 2 bytes to n3 on eth0 -[t=12.000,src=n2] Send 3 bytes to n3 on eth0 -[t=12.000,src=n3] Received: Hello World (2bytes) from 1! -[t=15.000,src=n3] Receive 1 bytes on eth0 -[t=15.000,src=n3] Received: Hello World from 0! -[t=17.000,src=n3] Receive 2 bytes on eth0 -[t=17.000,src=n3] Received: Hello World from 1! -[t=18.000,src=n3] Receive 3 bytes on eth0 -[t=18.000,src=n3] Received: Hello World from 2! -[t=18.000,src=n0] Send 5 bytes to n3 on eth0 -[t=23.000,src=n3] Receive 5 bytes on eth0 -[t=23.000,src=n3] Received: Hello World from 0! -[t=23.000,src=esds] Simulation ends diff --git a/tests/simple_send_eth0_3s1r/receiver.py b/tests/simple_send_eth0_3s1r/receiver.py deleted file mode 100644 index 4516d7a..0000000 --- a/tests/simple_send_eth0_3s1r/receiver.py +++ /dev/null @@ -1,19 +0,0 @@ -#!/usr/bin/env python - -def receive(node, n): - for i in range(0,n): - code, data=node.receive("eth0") - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - node.log(msg) - -def execute(api): - # Receive the first 3 send that should end at 3s - receive(api,3) - # Receive the first 3 send that should end at 7s - receive(api,3) - # Receive the first 3 send that should end at 12s - receive(api,3) - # Receive the first 3 send that should end at 18s - receive(api,3) - # Should ends at 23s - receive(api,1) diff --git a/tests/simple_send_eth0_3s1r/sender.py b/tests/simple_send_eth0_3s1r/sender.py deleted file mode 100644 index 6b8312b..0000000 --- a/tests/simple_send_eth0_3s1r/sender.py +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env python - -# Node that bandwidths at setup in a way that 1 byte is send in 1 seconds with no sharing - -def execute(api): - # Should be completed at 3s (bandwidth divided by 3) - api.send("eth0","Hello World from {}!".format(api.node_id),1,3) # Shoud lasts 3s - - # These send should start at 3s and be completed at 7s - if api.node_id==0: - api.send("eth0","Hello World (2bytes) from {}!".format(api.node_id),2,3) # Should lasts 3s + 1s = 4s - else: - api.send("eth0","Hello World from {}!".format(api.node_id),1,3) # Should lasts 3s - api.wait(1) # Sync with node 0 at 7s - - # Those sends should start at 7s and be completed at 12s - if api.node_id<=1: - api.send("eth0","Hello World (2bytes) from {}!".format(api.node_id),2,3) # Should last 3s + 2s = 5s - # Completed at 12s since 3 nodes are sharing the bandwidth up to 10s - # then the 2 two remaining node send their last byte up to 12s - else: - api.send("eth0","Hello World from {}!".format(api.node_id),1,3) # Should last 3s - # Completed at 10s (3 nodes are sharing the bandwidth) - api.wait(2) # Sync with node 0-1 at 12s - - # Should start at 12s - # Node 0 sends 1 byte, node 1 sends 2 byte and node 2 sends 3 - # These send should end at 18s - api.send("eth0","Hello World from {}!".format(api.node_id),api.node_id+1,3) # Should lasts 3s, 5s and 6s - - # Finally a single send from node 0 - if api.node_id==0: - api.wait(3) # Since node 0 send ends at 15s we sync it to 18s - api.send("eth0","Hello World from {}!".format(api.node_id),5,3) # Should takes 5 seconds (ends at 23s) - - - diff --git a/tests/simple_send_eth0_3s1r/simulator.py b/tests/simple_send_eth0_3s1r/simulator.py deleted file mode 100755 index 84c0de0..0000000 --- a/tests/simple_send_eth0_3s1r/simulator.py +++ /dev/null @@ -1,16 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((4,4),8) -L=np.full((4,4),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("sender") -s.create_node("sender") -s.create_node("receiver") - -s.run() diff --git a/tests/simple_send_wlan0_1s2r/out b/tests/simple_send_wlan0_1s2r/out deleted file mode 100644 index bb052dd..0000000 --- a/tests/simple_send_wlan0_1s2r/out +++ /dev/null @@ -1,16 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes on wlan0 -[t=1.000,src=n1] Receive 1 bytes on wlan0 -[t=1.000,src=n2] Receive 1 bytes on wlan0 -[t=1.000,src=n1] Received: Hello World! -[t=1.000,src=n2] Received: Hello World! -[t=1.000,src=n2] Turned off -[t=1.000,src=n0] Send 1 bytes on wlan0 -[t=2.000,src=n1] Receive 1 bytes on wlan0 -[t=2.000,src=n1] Received: Hello World! -[t=2.000,src=n2] Turned on -[t=2.000,src=n0] Send 1 bytes on wlan0 -[t=2.500,src=n2] Turned off -[t=3.000,src=n1] Receive 1 bytes on wlan0 -[t=3.000,src=n1] Received: Hello World! -[t=3.000,src=n2] Turned on -[t=3.000,src=esds] Simulation ends diff --git a/tests/simple_send_wlan0_1s2r/receiver.py b/tests/simple_send_wlan0_1s2r/receiver.py deleted file mode 100644 index 5b86500..0000000 --- a/tests/simple_send_wlan0_1s2r/receiver.py +++ /dev/null @@ -1,29 +0,0 @@ -#!/usr/bin/env python - -def receive(node): - ##### Simple receive - code, data=node.receive("wlan0") - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - node.log(msg) - - -def execute(api): - # Should works for all receivers - receive(api) - - if api.node_id == 1: - receive(api) # Should works - else: - api.turn_off() - api.wait(1) # Node 2 should not receive anything during 1s - api.turn_on() - - - if api.node_id == 1: - receive(api) # Should works - else: - api.wait(0.5) # Check if started communication get cancelled on turning off - api.turn_off() # Node 2 should not receive anything - api.wait(0.5) # Node 2 should not receive anything during 0.5s - api.turn_on() - diff --git a/tests/simple_send_wlan0_1s2r/sender.py b/tests/simple_send_wlan0_1s2r/sender.py deleted file mode 100644 index ef1517b..0000000 --- a/tests/simple_send_wlan0_1s2r/sender.py +++ /dev/null @@ -1,6 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.send("wlan0","Hello World!",1,1) - api.send("wlan0","Hello World!",1,1) - api.send("wlan0","Hello World!",1,1) diff --git a/tests/simple_send_wlan0_1s2r/simulator.py b/tests/simple_send_wlan0_1s2r/simulator.py deleted file mode 100755 index e721a93..0000000 --- a/tests/simple_send_wlan0_1s2r/simulator.py +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((3,3),8) -L=np.full((3,3),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("receiver") -s.create_node("receiver") - -s.run() diff --git a/tests/simple_send_wlan0_2s1r/out b/tests/simple_send_wlan0_2s1r/out deleted file mode 100644 index 788ee42..0000000 --- a/tests/simple_send_wlan0_2s1r/out +++ /dev/null @@ -1,6 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes on wlan0 -[t=0.000,src=n1] Send 1 bytes on wlan0 -[t=0.000,src=n0] Interferences on wlan0 -[t=0.000,src=n1] Interferences on wlan0 -[t=0.000,src=n2] Interferences on wlan0 -[t=1.000,src=esds] Simulation ends diff --git a/tests/simple_send_wlan0_2s1r/receiver.py b/tests/simple_send_wlan0_2s1r/receiver.py deleted file mode 100644 index 0b48f12..0000000 --- a/tests/simple_send_wlan0_2s1r/receiver.py +++ /dev/null @@ -1,5 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - pass - diff --git a/tests/simple_send_wlan0_2s1r/sender.py b/tests/simple_send_wlan0_2s1r/sender.py deleted file mode 100644 index 80f0fc2..0000000 --- a/tests/simple_send_wlan0_2s1r/sender.py +++ /dev/null @@ -1,4 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.send("wlan0","Hello World!",1,1) diff --git a/tests/simple_send_wlan0_2s1r/simulator.py b/tests/simple_send_wlan0_2s1r/simulator.py deleted file mode 100755 index 4cce1d0..0000000 --- a/tests/simple_send_wlan0_2s1r/simulator.py +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((3,3),8) -L=np.full((3,3),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("sender") -s.create_node("receiver") - -s.run() diff --git a/tests/simple_sendt_eth0_1s1r/out b/tests/simple_sendt_eth0_1s1r/out deleted file mode 100644 index 254b865..0000000 --- a/tests/simple_sendt_eth0_1s1r/out +++ /dev/null @@ -1,11 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes to n1 on eth0 -[t=1.000,src=n1] Receive 1 bytes on eth0 -[t=1.000,src=n0] Send worked! -[t=1.000,src=n1] Received: Hello World! -[t=1.000,src=n0] Send 1 bytes to n1 on eth0 -[t=1.500,src=n0] Send failed -[t=1.500,src=n0] Send 1 bytes to n1 on eth0 -[t=2.500,src=n1] Receive 1 bytes on eth0 -[t=2.500,src=n0] Send worked! -[t=2.500,src=n1] Received: Hello World! -[t=2.500,src=esds] Simulation ends diff --git a/tests/simple_sendt_eth0_1s1r/receiver.py b/tests/simple_sendt_eth0_1s1r/receiver.py deleted file mode 100644 index 0d8561e..0000000 --- a/tests/simple_sendt_eth0_1s1r/receiver.py +++ /dev/null @@ -1,11 +0,0 @@ -#!/usr/bin/env python - -def receive(node): - ##### Simple receive - code, data=node.receive("eth0") - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - node.log(msg) - -def execute(api): - receive(api) - receive(api) diff --git a/tests/simple_sendt_eth0_1s1r/sender.py b/tests/simple_sendt_eth0_1s1r/sender.py deleted file mode 100644 index ee2ea9d..0000000 --- a/tests/simple_sendt_eth0_1s1r/sender.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env python - -def sendt(node,timeout): - code=node.sendt("eth0","Hello World!",1,1,timeout) - msg="Send worked!" if code == 0 else "Send failed" - node.log(msg) - -def execute(api): - # Should work - sendt(api,2) - # Should not work - sendt(api,0.5) - # Should work - sendt(api,2) diff --git a/tests/simple_sendt_eth0_1s1r/simulator.py b/tests/simple_sendt_eth0_1s1r/simulator.py deleted file mode 100755 index ae5bbea..0000000 --- a/tests/simple_sendt_eth0_1s1r/simulator.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((2,2),8) -L=np.full((2,2),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("receiver") - -s.run() diff --git a/tests/simple_sendt_wlan0_1s2r/out b/tests/simple_sendt_wlan0_1s2r/out deleted file mode 100644 index 9428958..0000000 --- a/tests/simple_sendt_wlan0_1s2r/out +++ /dev/null @@ -1,7 +0,0 @@ -[t=0.000,src=n0] Send 1 bytes on wlan0 -[t=1.000,src=n1] Receive 1 bytes on wlan0 -[t=1.000,src=n2] Receive 1 bytes on wlan0 -[t=1.000,src=n1] Received: Hello World! -[t=1.000,src=n2] Received: Hello World! -[t=1.000,src=n0] Send 1 bytes on wlan0 -[t=1.500,src=esds] Simulation ends diff --git a/tests/simple_sendt_wlan0_1s2r/receiver.py b/tests/simple_sendt_wlan0_1s2r/receiver.py deleted file mode 100644 index eca49ad..0000000 --- a/tests/simple_sendt_wlan0_1s2r/receiver.py +++ /dev/null @@ -1,13 +0,0 @@ -#!/usr/bin/env python - -def receive(node): - ##### Simple receive - code, data=node.receive("wlan0") - msg="Received: "+data if code == 0 else "Receive failed code="+str(code) - node.log(msg) - - -def execute(api): - # Should works for all receivers - receive(api) - diff --git a/tests/simple_sendt_wlan0_1s2r/sender.py b/tests/simple_sendt_wlan0_1s2r/sender.py deleted file mode 100644 index fe2dc1a..0000000 --- a/tests/simple_sendt_wlan0_1s2r/sender.py +++ /dev/null @@ -1,8 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - # Should works - api.sendt("wlan0","Hello World!",1,1,2) - # Should not work - api.sendt("wlan0","Hello World!",1,1,0.5) - diff --git a/tests/simple_sendt_wlan0_1s2r/simulator.py b/tests/simple_sendt_wlan0_1s2r/simulator.py deleted file mode 100755 index e721a93..0000000 --- a/tests/simple_sendt_wlan0_1s2r/simulator.py +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((3,3),8) -L=np.full((3,3),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("sender") -s.create_node("receiver") -s.create_node("receiver") - -s.run() diff --git a/tests/simple_wait_2n/node.py b/tests/simple_wait_2n/node.py deleted file mode 100644 index 86b06de..0000000 --- a/tests/simple_wait_2n/node.py +++ /dev/null @@ -1,9 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - api.log("Before wait") - api.wait(2) - api.log("After wait") - api.log("Before wait") - api.wait(3) - api.log("After wait") diff --git a/tests/simple_wait_2n/out b/tests/simple_wait_2n/out deleted file mode 100644 index 8a694cc..0000000 --- a/tests/simple_wait_2n/out +++ /dev/null @@ -1,9 +0,0 @@ -[t=0.000,src=n0] Before wait -[t=0.000,src=n1] Before wait -[t=2.000,src=n0] After wait -[t=2.000,src=n0] Before wait -[t=2.000,src=n1] After wait -[t=2.000,src=n1] Before wait -[t=5.000,src=n0] After wait -[t=5.000,src=n1] After wait -[t=5.000,src=esds] Simulation ends diff --git a/tests/simple_wait_2n/simulator.py b/tests/simple_wait_2n/simulator.py deleted file mode 100755 index fc0e80d..0000000 --- a/tests/simple_wait_2n/simulator.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((2,2),2) -L=np.full((2,2),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("node") -s.create_node("node") - -s.run() diff --git a/tests/simple_wait_end_3n/node.py b/tests/simple_wait_end_3n/node.py deleted file mode 100644 index a8fbcd7..0000000 --- a/tests/simple_wait_end_3n/node.py +++ /dev/null @@ -1,10 +0,0 @@ -#!/usr/bin/env python - -def execute(api): - wait=api.node_id - api.log("Before wait for "+str(wait)+"s") - api.wait(wait) # Since 3 nodes max(wait)==2 - - # Ensure that wait end return back when simulation ends - api.wait_end() - api.log("Terminated") diff --git a/tests/simple_wait_end_3n/out b/tests/simple_wait_end_3n/out deleted file mode 100644 index 321b0c2..0000000 --- a/tests/simple_wait_end_3n/out +++ /dev/null @@ -1,7 +0,0 @@ -[t=0.000,src=n0] Before wait for 0s -[t=0.000,src=n1] Before wait for 1s -[t=0.000,src=n2] Before wait for 2s -[t=2.000,src=n0] Terminated -[t=2.000,src=n1] Terminated -[t=2.000,src=n2] Terminated -[t=2.000,src=esds] Simulation ends diff --git a/tests/simple_wait_end_3n/simulator.py b/tests/simple_wait_end_3n/simulator.py deleted file mode 100755 index 4d1763e..0000000 --- a/tests/simple_wait_end_3n/simulator.py +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env python - -# Load ESDS -import esds -import numpy as np - -B=np.full((3,3),2) -L=np.full((3,3),0) -s=esds.Simulator({"wlan0":{"bandwidth":B, "latency":L, "is_wired":False}, "eth0":{"bandwidth":B, "latency":L, "is_wired":True}}) - -s.create_node("node") -s.create_node("node") -s.create_node("node") - -s.run() -- cgit v1.2.3