From d426d7cfbde61decc40c64ea4419c1a7e49e1e45 Mon Sep 17 00:00:00 2001 From: Jonathan Hui Date: Mon, 29 Jan 2018 19:30:46 +0000 Subject: [PATCH] [posix] implement virtual time and update tests to utilize virtual time (#2508) This commit adds the following features: - Example posix drivers to support virtual time simulation, allowing tests to run faster than real time. - A python-based simulation driver that coordinates the virtual time simulations. Each alarm event and message transmission across all nodes are scheduled in a single discrete time event queue. As a result, only a single node is making forward progress at a time. - Updated tests to utilize new virtual-time simulator, allowing them to run faster than real time. - To enable virtual time feature, define VIRTUAL_TIME=1 env var and set CPPFLAGS=-DOPENTHREAD_POSIX_VIRTUAL_TIME=1. --- .travis.yml | 8 +- .travis/script.sh | 1 + examples/Makefile-posix | 4 + examples/platforms/posix/Makefile.am | 3 + examples/platforms/posix/alarm.c | 4 + examples/platforms/posix/misc.c | 3 +- examples/platforms/posix/platform-posix.h | 52 +- examples/platforms/posix/platform.c | 9 + examples/platforms/posix/radio.c | 4 + examples/platforms/posix/sim/alarm-sim.c | 173 ++++ examples/platforms/posix/sim/platform-sim.c | 241 ++++++ examples/platforms/posix/sim/radio-sim.c | 810 ++++++++++++++++++ src/core/coap/coap.hpp | 4 +- .../thread-cert/Cert_5_1_01_RouterAttach.py | 22 +- .../Cert_5_1_02_ChildAddressTimeout.py | 33 +- .../Cert_5_1_03_RouterAddressReallocation.py | 27 +- .../Cert_5_1_04_RouterAddressReallocation.py | 27 +- .../Cert_5_1_05_RouterAddressTimeout.py | 29 +- .../thread-cert/Cert_5_1_06_RemoveRouterId.py | 23 +- .../thread-cert/Cert_5_1_07_MaxChildCount.py | 13 +- .../Cert_5_1_08_RouterAttachConnectivity.py | 27 +- .../Cert_5_1_09_REEDAttachConnectivity.py | 35 +- .../Cert_5_1_10_RouterAttachLinkQuality.py | 29 +- .../Cert_5_1_11_REEDAttachLinkQuality.py | 29 +- .../Cert_5_1_12_NewRouterNeighborSync.py | 35 +- .../thread-cert/Cert_5_1_13_RouterReset.py | 25 +- .../thread-cert/Cert_5_2_01_REEDAttach.py | 27 +- .../Cert_5_2_03_LeaderReject2Hops.py | 30 +- .../thread-cert/Cert_5_2_04_REEDUpgrade.py | 30 +- .../thread-cert/Cert_5_2_05_AddressQuery.py | 29 +- .../Cert_5_2_06_RouterDowngrade.py | 23 +- .../Cert_5_2_07_REEDSynchronization.py | 23 +- .../thread-cert/Cert_5_3_01_LinkLocal.py | 9 +- .../thread-cert/Cert_5_3_02_RealmLocal.py | 35 +- .../thread-cert/Cert_5_3_03_AddressQuery.py | 43 +- .../Cert_5_3_04_AddressMapCache.py | 27 +- .../Cert_5_3_05_RoutingLinkQuality.py | 29 +- .../thread-cert/Cert_5_3_06_RouterIdMask.py | 49 +- .../thread-cert/Cert_5_3_06b_RouterIdMask.py | 14 +- .../Cert_5_3_07_DuplicateAddress.py | 27 +- .../Cert_5_3_08_ChildAddressSet.py | 48 +- .../thread-cert/Cert_5_3_09_AddressQuery.py | 23 +- .../thread-cert/Cert_5_3_10_AddressQuery.py | 45 +- .../thread-cert/Cert_5_5_01_LeaderReset.py | 14 +- .../thread-cert/Cert_5_5_02_LeaderReboot.py | 16 +- .../Cert_5_5_03_SplitMergeChildren.py | 24 +- .../Cert_5_5_04_SplitMergeRouters.py | 20 +- .../thread-cert/Cert_5_5_05_SplitMergeREED.py | 16 +- .../Cert_5_5_07_SplitMergeThreeWay.py | 18 +- .../Cert_5_5_08_SplitRoutersLostLeader.py | 19 +- ...1_NetworkDataRegisterBeforeAttachLeader.py | 14 +- ...2_NetworkDataRegisterBeforeAttachRouter.py | 14 +- ...03_NetworkDataRegisterAfterAttachLeader.py | 16 +- ...04_NetworkDataRegisterAfterAttachRouter.py | 16 +- ...05_NetworkDataRegisterAfterAttachRouter.py | 18 +- .../Cert_5_6_06_NetworkDataExpiration.py | 20 +- .../Cert_5_6_07_NetworkDataRequestREED.py | 16 +- .../Cert_5_6_08_ContextManagement.py | 22 +- .../Cert_5_6_09_NetworkDataForwarding.py | 24 +- .../Cert_5_8_01_KeySynchronization.py | 10 +- .../thread-cert/Cert_5_8_02_KeyIncrement.py | 11 +- .../Cert_5_8_03_KeyIncrementRollOver.py | 10 +- .../thread-cert/Cert_6_1_01_RouterAttach.py | 20 +- .../thread-cert/Cert_6_1_02_REEDAttach.py | 12 +- .../Cert_6_1_03_RouterAttachConnectivity.py | 12 +- .../Cert_6_1_04_REEDAttachConnectivity.py | 18 +- .../Cert_6_1_05_RouterAttachLinkQuality.py | 14 +- .../Cert_6_1_06_REEDAttachLinkQuality.py | 14 +- .../Cert_6_1_07_EDSynchronization.py | 16 +- .../thread-cert/Cert_6_2_01_NewPartition.py | 14 +- .../thread-cert/Cert_6_2_02_NewPartition.py | 16 +- .../thread-cert/Cert_6_3_01_OrphanReattach.py | 14 +- .../Cert_6_3_02_NetworkDataUpdate.py | 16 +- .../thread-cert/Cert_6_4_01_LinkLocal.py | 10 +- .../thread-cert/Cert_6_4_02_RealmLocal.py | 12 +- .../Cert_6_5_01_ChildResetSynchronize.py | 18 +- .../Cert_6_5_02_ChildResetReattach.py | 16 +- .../thread-cert/Cert_6_6_01_KeyIncrement.py | 11 +- .../Cert_6_6_02_KeyIncrementRollOver.py | 10 +- .../Cert_7_1_01_BorderRouterAsLeader.py | 14 +- .../Cert_7_1_02_BorderRouterAsRouter.py | 14 +- .../Cert_7_1_03_BorderRouterAsLeader.py | 16 +- .../Cert_7_1_04_BorderRouterAsRouter.py | 16 +- .../Cert_7_1_05_BorderRouterAsRouter.py | 18 +- .../thread-cert/Cert_8_1_01_Commissioning.py | 14 +- .../thread-cert/Cert_8_1_02_Commissioning.py | 10 +- .../thread-cert/Cert_8_2_01_JoinerRouter.py | 18 +- .../thread-cert/Cert_8_2_02_JoinerRouter.py | 18 +- .../thread-cert/Cert_9_2_04_ActiveDataset.py | 30 +- .../thread-cert/Cert_9_2_07_DelayTimer.py | 18 +- .../Cert_9_2_08_PersistentDatasets.py | 25 +- .../Cert_9_2_09_PendingPartition.py | 24 +- .../Cert_9_2_10_PendingPartition.py | 24 +- .../thread-cert/Cert_9_2_11_MasterKey.py | 22 +- .../thread-cert/Cert_9_2_12_Announce.py | 18 +- .../thread-cert/Cert_9_2_13_EnergyScan.py | 16 +- .../thread-cert/Cert_9_2_14_PanIdQuery.py | 16 +- .../Cert_9_2_15_PendingPartition.py | 24 +- .../Cert_9_2_16_ActivePendingPartition.py | 26 +- .../scripts/thread-cert/Cert_9_2_17_Orphan.py | 12 +- .../Cert_9_2_18_RollBackActiveTimestamp.py | 25 +- tests/scripts/thread-cert/Makefile.am | 1 + tests/scripts/thread-cert/config.py | 9 + tests/scripts/thread-cert/node.py | 8 +- tests/scripts/thread-cert/node_cli.py | 41 +- tests/scripts/thread-cert/simulator.py | 240 ++++++ tests/scripts/thread-cert/test_service.py | 23 +- 107 files changed, 2600 insertions(+), 882 deletions(-) create mode 100644 examples/platforms/posix/sim/alarm-sim.c create mode 100644 examples/platforms/posix/sim/platform-sim.c create mode 100644 examples/platforms/posix/sim/radio-sim.c create mode 100644 tests/scripts/thread-cert/simulator.py diff --git a/.travis.yml b/.travis.yml index f00970dd7..9b3234148 100644 --- a/.travis.yml +++ b/.travis.yml @@ -42,16 +42,16 @@ after_success: matrix: include: - - env: BUILD_TARGET="posix-distcheck" VERBOSE=1 + - env: BUILD_TARGET="posix-distcheck" VERBOSE=1 VIRTUAL_TIME=1 os: linux compiler: clang - - env: BUILD_TARGET="posix-32-bit" VERBOSE=1 + - env: BUILD_TARGET="posix-32-bit" VERBOSE=1 VIRTUAL_TIME=1 os: linux compiler: gcc - - env: BUILD_TARGET="posix-ncp" VERBOSE=1 + - env: BUILD_TARGET="posix-ncp" VERBOSE=1 VIRTUAL_TIME=1 os: linux compiler: gcc - - env: BUILD_TARGET="posix-mtd" VERBOSE=1 + - env: BUILD_TARGET="posix-mtd" VERBOSE=1 VIRTUAL_TIME=1 os: linux compiler: gcc - env: BUILD_TARGET="pretty-check" diff --git a/.travis/script.sh b/.travis/script.sh index 5e0c71d4b..82a4da5dd 100755 --- a/.travis/script.sh +++ b/.travis/script.sh @@ -346,6 +346,7 @@ set -x [ $BUILD_TARGET != posix-distcheck ] || { export ASAN_SYMBOLIZER_PATH=`which llvm-symbolizer-3.4` || die export ASAN_OPTIONS=symbolize=1 || die + export DISTCHECK_CONFIGURE_FLAGS= CPPFLAGS=-DOPENTHREAD_POSIX_VIRTUAL_TIME=1 || die ./bootstrap || die make -f examples/Makefile-posix distcheck || die } diff --git a/examples/Makefile-posix b/examples/Makefile-posix index f4f9fe6eb..ba341b0c4 100644 --- a/examples/Makefile-posix +++ b/examples/Makefile-posix @@ -83,6 +83,10 @@ COMMONCFLAGS := \ include $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/common-switches.mk +ifeq ($(VIRTUAL_TIME),1) +COMMONCFLAGS += -DOPENTHREAD_POSIX_VIRTUAL_TIME=1 +endif + CPPFLAGS += \ $(COMMONCFLAGS) \ $(NULL) diff --git a/examples/platforms/posix/Makefile.am b/examples/platforms/posix/Makefile.am index 2bd4b9fa7..397f0f9a9 100644 --- a/examples/platforms/posix/Makefile.am +++ b/examples/platforms/posix/Makefile.am @@ -46,6 +46,9 @@ libopenthread_posix_a_SOURCES = \ random.c \ uart-posix.c \ flash.c \ + sim/alarm-sim.c \ + sim/platform-sim.c \ + sim/radio-sim.c \ $(NULL) if OPENTHREAD_ENABLE_DIAG diff --git a/examples/platforms/posix/alarm.c b/examples/platforms/posix/alarm.c index 26e113c12..8f00609c4 100644 --- a/examples/platforms/posix/alarm.c +++ b/examples/platforms/posix/alarm.c @@ -28,6 +28,8 @@ #include "platform-posix.h" +#if OPENTHREAD_POSIX_VIRTUAL_TIME == 0 + #include #include #include @@ -180,3 +182,5 @@ void platformAlarmProcess(otInstance *aInstance) #endif // OPENTHREAD_CONFIG_ENABLE_PLATFORM_USEC_TIMER } + +#endif // OPENTHREAD_POSIX_VIRTUAL_TIME == 0 diff --git a/examples/platforms/posix/misc.c b/examples/platforms/posix/misc.c index ec0b6d7e7..0dbb69d10 100644 --- a/examples/platforms/posix/misc.c +++ b/examples/platforms/posix/misc.c @@ -34,6 +34,7 @@ #include #include +#include #ifndef _WIN32 extern int gArgumentsCount; @@ -52,7 +53,7 @@ void otPlatReset(otInstance *aInstance) argv[gArgumentsCount] = NULL; - platformRadioDeinit(); + PlatformDeinit(); platformUartRestore(); alarm(0); diff --git a/examples/platforms/posix/platform-posix.h b/examples/platforms/posix/platform-posix.h index 590743b86..0d227f958 100644 --- a/examples/platforms/posix/platform-posix.h +++ b/examples/platforms/posix/platform-posix.h @@ -82,6 +82,22 @@ __forceinline void timersub(struct timeval *a, struct timeval *b, struct timeval #include "openthread-core-config.h" +enum +{ + OT_SIM_EVENT_ALARM_FIRED = 0, + OT_SIM_EVENT_RADIO_RECEIVED = 1, + OT_EVENT_DATA_MAX_SIZE = 1024, +}; + +OT_TOOL_PACKED_BEGIN +struct Event +{ + uint64_t mDelay; + uint8_t mEvent; + uint16_t mDataLength; + uint8_t mData[OT_EVENT_DATA_MAX_SIZE]; +} OT_TOOL_PACKED_END; + /** * Unique node ID. * @@ -116,6 +132,30 @@ void platformAlarmUpdateTimeout(struct timeval *tv); */ void platformAlarmProcess(otInstance *aInstance); +/** + * This function returns the next alarm event time. + * + * @returns The next alarm fire time. + * + */ +int32_t platformAlarmGetNext(void); + +/** + * This function returns the current alarm time. + * + * @returns The current alarm time. + * + */ +uint64_t platformAlarmGetNow(void); + +/** + * This function advances the alarm time by @p aDelta. + * + * @param[in] aDelta The amount of time to advance. + * + */ +void platformAlarmAdvanceNow(uint64_t aDelta); + /** * This function initializes the radio service used by OpenThread. * @@ -123,11 +163,21 @@ void platformAlarmProcess(otInstance *aInstance); void platformRadioInit(void); /** - * This function deinitializes the radio service used by OpenThread. + * This function shuts down the radio service used by OpenThread. * */ void platformRadioDeinit(void); +/** + * This function inputs a received radio frame. + * + * @param[in] aInstance A pointer to the OpenThread instance. + * @param[in] aBuf A pointer to the received radio frame. + * @param[in] aBufLength The size of the received radio frame. + * + */ +void platformRadioReceive(otInstance *aInstance, uint8_t *aBuf, uint16_t aBufLength); + /** * This function updates the file descriptor sets with file descriptors used by the radio driver. * diff --git a/examples/platforms/posix/platform.c b/examples/platforms/posix/platform.c index eb5cb9eef..7272aa485 100644 --- a/examples/platforms/posix/platform.c +++ b/examples/platforms/posix/platform.c @@ -34,6 +34,8 @@ #include "platform-posix.h" +#if OPENTHREAD_POSIX_VIRTUAL_TIME == 0 + #include #include #include @@ -88,6 +90,11 @@ void PlatformInit(int argc, char *argv[]) platformRandomInit(); } +void PlatformDeinit(void) +{ + platformRadioDeinit(); +} + void PlatformProcessDrivers(otInstance *aInstance) { fd_set read_fds; @@ -120,3 +127,5 @@ void PlatformProcessDrivers(otInstance *aInstance) platformRadioProcess(aInstance); platformAlarmProcess(aInstance); } + +#endif // OPENTHREAD_POSIX_VIRTUAL_TIME == 0 diff --git a/examples/platforms/posix/radio.c b/examples/platforms/posix/radio.c index de8bed135..bc0976a81 100644 --- a/examples/platforms/posix/radio.c +++ b/examples/platforms/posix/radio.c @@ -28,6 +28,8 @@ #include "platform-posix.h" +#if OPENTHREAD_POSIX_VIRTUAL_TIME == 0 + #include #include #include @@ -876,3 +878,5 @@ int8_t otPlatRadioGetReceiveSensitivity(otInstance *aInstance) (void)aInstance; return POSIX_RECEIVE_SENSITIVITY; } + +#endif // OPENTHREAD_POSIX_VIRTUAL_TIME == 0 diff --git a/examples/platforms/posix/sim/alarm-sim.c b/examples/platforms/posix/sim/alarm-sim.c new file mode 100644 index 000000000..d27c61ec0 --- /dev/null +++ b/examples/platforms/posix/sim/alarm-sim.c @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2018, The OpenThread Authors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holder nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "platform-posix.h" + +#if OPENTHREAD_POSIX_VIRTUAL_TIME + +#include +#include +#include + +#include +#include +#include + +#define US_PER_MS 1000 + +static uint64_t sNow = 0; // microseconds + +static bool sIsMsRunning = false; +static uint32_t sMsAlarm = 0; + +static bool sIsUsRunning = false; +static uint32_t sUsAlarm = 0; + +void platformAlarmInit(void) +{ + sNow = 0; +} + +uint64_t platformAlarmGetNow(void) +{ + return sNow; +} + +void platformAlarmAdvanceNow(uint64_t aDelta) +{ + sNow += aDelta; +} + +uint32_t otPlatAlarmMilliGetNow(void) +{ + return (uint32_t)(sNow / US_PER_MS); +} + +void otPlatAlarmMilliStartAt(otInstance *aInstance, uint32_t aT0, uint32_t aDt) +{ + (void)aInstance; + sMsAlarm = aT0 + aDt; + sIsMsRunning = true; +} + +void otPlatAlarmMilliStop(otInstance *aInstance) +{ + (void)aInstance; + sIsMsRunning = false; +} + +uint32_t otPlatAlarmMicroGetNow(void) +{ + return (uint32_t)sNow; +} + +void otPlatAlarmMicroStartAt(otInstance *aInstance, uint32_t aT0, uint32_t aDt) +{ + (void)aInstance; + sUsAlarm = aT0 + aDt; + sIsUsRunning = true; +} + +void otPlatAlarmMicroStop(otInstance *aInstance) +{ + (void)aInstance; + sIsUsRunning = false; +} + +int32_t platformAlarmGetNext(void) +{ + int32_t remaining = INT32_MAX; + + if (sIsMsRunning) + { + int32_t milli = (int32_t)(sMsAlarm - otPlatAlarmMilliGetNow()); + + remaining = milli * US_PER_MS; + } + +#if OPENTHREAD_CONFIG_ENABLE_PLATFORM_USEC_TIMER + + if (sIsUsRunning) + { + int32_t micro = (int32_t)(sUsAlarm - otPlatAlarmMicroGetNow()); + + if (remaining > micro) + { + remaining = micro; + } + } + +#endif // OPENTHREAD_CONFIG_ENABLE_PLATFORM_USEC_TIMER + + return remaining; +} + +void platformAlarmProcess(otInstance *aInstance) +{ + int32_t remaining; + + if (sIsMsRunning) + { + remaining = (int32_t)(sMsAlarm - otPlatAlarmMilliGetNow()); + + if (remaining <= 0) + { + sIsMsRunning = false; + +#if OPENTHREAD_ENABLE_DIAG + + if (otPlatDiagModeGet()) + { + otPlatDiagAlarmFired(aInstance); + } + else +#endif + { + otPlatAlarmMilliFired(aInstance); + } + } + } + +#if OPENTHREAD_CONFIG_ENABLE_PLATFORM_USEC_TIMER + + if (sIsUsRunning) + { + remaining = (int32_t)(sUsAlarm - otPlatAlarmMicroGetNow()); + + if (remaining <= 0) + { + sIsUsRunning = false; + + otPlatAlarmMicroFired(aInstance); + } + } + +#endif // OPENTHREAD_CONFIG_ENABLE_PLATFORM_USEC_TIMER +} + +#endif // OPENTHREAD_POSIX_VIRTUAL_TIME diff --git a/examples/platforms/posix/sim/platform-sim.c b/examples/platforms/posix/sim/platform-sim.c new file mode 100644 index 000000000..780fea2b7 --- /dev/null +++ b/examples/platforms/posix/sim/platform-sim.c @@ -0,0 +1,241 @@ +/* + * Copyright (c) 2018, The OpenThread Authors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holder nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @file + * @brief + * This file includes the platform-specific initializers. + */ + +#include "platform-posix.h" + +#if OPENTHREAD_POSIX_VIRTUAL_TIME + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +uint32_t NODE_ID = 1; +uint32_t WELLKNOWN_NODE_ID = 34; + +int gArgumentsCount = 0; +char **gArguments = NULL; + +int sSockFd; +uint16_t sPortOffset; + +static void receiveEvent(otInstance *aInstance) +{ + struct Event event; + ssize_t rval = recvfrom(sSockFd, (char *)&event, sizeof(event), 0, NULL, NULL); + + if (rval < 0 || (uint16_t)rval < offsetof(struct Event, mData)) + { + perror("recvfrom"); + exit(EXIT_FAILURE); + } + + platformAlarmAdvanceNow(event.mDelay); + + switch (event.mEvent) + { + case OT_SIM_EVENT_ALARM_FIRED: + break; + + case OT_SIM_EVENT_RADIO_RECEIVED: + platformRadioReceive(aInstance, event.mData, event.mDataLength); + break; + } +} + +static bool processEvent(otInstance *aInstance) +{ + const int flags = POLLIN | POLLRDNORM | POLLERR | POLLNVAL | POLLHUP; + struct pollfd pollfd = { sSockFd, flags, 0 }; + bool rval = false; + + if (POLL(&pollfd, 1, 0) > 0 && (pollfd.revents & flags) != 0) + { + receiveEvent(aInstance); + rval = true; + } + + return rval; +} + +static void platformSendSleepEvent(void) +{ + struct sockaddr_in sockaddr; + struct Event event; + ssize_t rval; + + assert(platformAlarmGetNext() > 0); + + event.mDelay = (uint64_t)platformAlarmGetNext(); + event.mEvent = OT_SIM_EVENT_ALARM_FIRED; + event.mDataLength = 0; + + memset(&sockaddr, 0, sizeof(sockaddr)); + sockaddr.sin_family = AF_INET; + inet_pton(AF_INET, "127.0.0.1", &sockaddr.sin_addr); + sockaddr.sin_port = htons(9000 + sPortOffset); + + rval = sendto(sSockFd, (const char *)&event, offsetof(struct Event, mData), + 0, (struct sockaddr *)&sockaddr, sizeof(sockaddr)); + + if (rval < 0) + { + perror("sendto"); + exit(EXIT_FAILURE); + } +} + +static void socket_init(void) +{ + struct sockaddr_in sockaddr; + char *offset; + memset(&sockaddr, 0, sizeof(sockaddr)); + sockaddr.sin_family = AF_INET; + + offset = getenv("PORT_OFFSET"); + + if (offset) + { + char *endptr; + + sPortOffset = (uint16_t)strtol(offset, &endptr, 0); + + if (*endptr != '\0') + { + fprintf(stderr, "Invalid PORT_OFFSET: %s\n", offset); + exit(EXIT_FAILURE); + } + + sPortOffset *= WELLKNOWN_NODE_ID; + } + + sockaddr.sin_port = htons(9000 + sPortOffset + NODE_ID); + sockaddr.sin_addr.s_addr = INADDR_ANY; + + sSockFd = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + + if (sSockFd == -1) + { + perror("socket"); + exit(EXIT_FAILURE); + } + + if (bind(sSockFd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)) == -1) + { + perror("bind"); + exit(EXIT_FAILURE); + } +} + +void PlatformInit(int argc, char *argv[]) +{ + char *endptr; + + if (argc != 2) + { + exit(EXIT_FAILURE); + } + + openlog(basename(argv[0]), LOG_PID, LOG_USER); + setlogmask(setlogmask(0) & LOG_UPTO(LOG_NOTICE)); + + gArgumentsCount = argc; + gArguments = argv; + + NODE_ID = (uint32_t)strtol(argv[1], &endptr, 0); + + if (*endptr != '\0' || NODE_ID < 1 || NODE_ID >= WELLKNOWN_NODE_ID) + { + fprintf(stderr, "Invalid NODE_ID: %s\n", argv[1]); + exit(EXIT_FAILURE); + } + + socket_init(); + + platformAlarmInit(); + platformRadioInit(); + platformRandomInit(); +} + +void PlatformDeinit(void) +{ + close(sSockFd); +} + +void PlatformProcessDrivers(otInstance *aInstance) +{ + fd_set read_fds; + fd_set write_fds; + fd_set error_fds; + int max_fd = -1; + int rval; + + FD_ZERO(&read_fds); + FD_ZERO(&write_fds); + FD_ZERO(&error_fds); + + FD_SET(sSockFd, &read_fds); + max_fd = sSockFd; + + platformUartUpdateFdSet(&read_fds, &write_fds, &error_fds, &max_fd); + + if (!otTaskletsArePending(aInstance) && platformAlarmGetNext() > 0) + { + platformSendSleepEvent(); + + rval = select(max_fd + 1, &read_fds, &write_fds, &error_fds, NULL); + + if ((rval < 0) && (errno != EINTR)) + { + perror("select"); + exit(EXIT_FAILURE); + } + + processEvent(aInstance); + } + + platformAlarmProcess(aInstance); + platformRadioProcess(aInstance); + platformUartProcess(); +} + +#endif // OPENTHREAD_POSIX_VIRTUAL_TIME diff --git a/examples/platforms/posix/sim/radio-sim.c b/examples/platforms/posix/sim/radio-sim.c new file mode 100644 index 000000000..f8b8ed3e1 --- /dev/null +++ b/examples/platforms/posix/sim/radio-sim.c @@ -0,0 +1,810 @@ +/* + * Copyright (c) 2018, The OpenThread Authors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holder nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "platform-posix.h" + +#if OPENTHREAD_POSIX_VIRTUAL_TIME + +#include +#include +#include + +#include "utils/code_utils.h" + +enum +{ + IEEE802154_MIN_LENGTH = 5, + IEEE802154_MAX_LENGTH = 127, + IEEE802154_ACK_LENGTH = 5, + + IEEE802154_BROADCAST = 0xffff, + + IEEE802154_FRAME_TYPE_ACK = 2 << 0, + IEEE802154_FRAME_TYPE_MACCMD = 3 << 0, + IEEE802154_FRAME_TYPE_MASK = 7 << 0, + + IEEE802154_SECURITY_ENABLED = 1 << 3, + IEEE802154_FRAME_PENDING = 1 << 4, + IEEE802154_ACK_REQUEST = 1 << 5, + IEEE802154_PANID_COMPRESSION = 1 << 6, + + IEEE802154_DST_ADDR_NONE = 0 << 2, + IEEE802154_DST_ADDR_SHORT = 2 << 2, + IEEE802154_DST_ADDR_EXT = 3 << 2, + IEEE802154_DST_ADDR_MASK = 3 << 2, + + IEEE802154_SRC_ADDR_NONE = 0 << 6, + IEEE802154_SRC_ADDR_SHORT = 2 << 6, + IEEE802154_SRC_ADDR_EXT = 3 << 6, + IEEE802154_SRC_ADDR_MASK = 3 << 6, + + IEEE802154_DSN_OFFSET = 2, + IEEE802154_DSTPAN_OFFSET = 3, + IEEE802154_DSTADDR_OFFSET = 5, + + IEEE802154_SEC_LEVEL_MASK = 7 << 0, + + IEEE802154_KEY_ID_MODE_0 = 0 << 3, + IEEE802154_KEY_ID_MODE_1 = 1 << 3, + IEEE802154_KEY_ID_MODE_2 = 2 << 3, + IEEE802154_KEY_ID_MODE_3 = 3 << 3, + IEEE802154_KEY_ID_MODE_MASK = 3 << 3, + + IEEE802154_MACCMD_DATA_REQ = 4, +}; + +enum +{ + POSIX_RECEIVE_SENSITIVITY = -100, // dBm + POSIX_MAX_SRC_MATCH_ENTRIES = OPENTHREAD_CONFIG_MAX_CHILDREN, +}; + +extern int sSockFd; +extern uint16_t sPortOffset; + +OT_TOOL_PACKED_BEGIN +struct RadioMessage +{ + uint8_t mChannel; + uint8_t mPsdu[OT_RADIO_FRAME_MAX_SIZE]; +} OT_TOOL_PACKED_END; + +static void radioTransmit(struct RadioMessage *msg, const struct otRadioFrame *pkt); +static void radioSendMessage(otInstance *aInstance); +static void radioSendAck(void); +static void radioProcessFrame(otInstance *aInstance); + +static otRadioState sState = OT_RADIO_STATE_DISABLED; +static struct RadioMessage sReceiveMessage; +static struct RadioMessage sTransmitMessage; +static struct RadioMessage sAckMessage; +static otRadioFrame sReceiveFrame; +static otRadioFrame sTransmitFrame; +static otRadioFrame sAckFrame; + +static uint8_t sExtendedAddress[OT_EXT_ADDRESS_SIZE]; +static uint16_t sShortAddress; +static uint16_t sPanid; +static bool sPromiscuous = false; +static bool sAckWait = false; + +static uint8_t sShortAddressMatchTableCount = 0; +static uint8_t sExtAddressMatchTableCount = 0; +static uint16_t sShortAddressMatchTable[POSIX_MAX_SRC_MATCH_ENTRIES]; +static otExtAddress sExtAddressMatchTable[POSIX_MAX_SRC_MATCH_ENTRIES]; +static bool sSrcMatchEnabled = false; + +static bool findShortAddress(uint16_t aShortAddress) +{ + uint8_t i; + + for (i = 0; i < sShortAddressMatchTableCount; ++i) + { + if (sShortAddressMatchTable[i] == aShortAddress) + { + break; + } + } + + return i < sShortAddressMatchTableCount; +} + +static bool findExtAddress(const otExtAddress *aExtAddress) +{ + uint8_t i; + + for (i = 0; i < sExtAddressMatchTableCount; ++i) + { + if (!memcmp(&sExtAddressMatchTable[i], aExtAddress, sizeof(otExtAddress))) + { + break; + } + } + + return i < sExtAddressMatchTableCount; +} + +static inline bool isFrameTypeAck(const uint8_t *frame) +{ + return (frame[0] & IEEE802154_FRAME_TYPE_MASK) == IEEE802154_FRAME_TYPE_ACK; +} + +static inline bool isFrameTypeMacCmd(const uint8_t *frame) +{ + return (frame[0] & IEEE802154_FRAME_TYPE_MASK) == IEEE802154_FRAME_TYPE_MACCMD; +} + +static inline bool isSecurityEnabled(const uint8_t *frame) +{ + return (frame[0] & IEEE802154_SECURITY_ENABLED) != 0; +} + +static inline bool isAckRequested(const uint8_t *frame) +{ + return (frame[0] & IEEE802154_ACK_REQUEST) != 0; +} + +static inline bool isPanIdCompressed(const uint8_t *frame) +{ + return (frame[0] & IEEE802154_PANID_COMPRESSION) != 0; +} + +static inline bool isDataRequestAndHasFramePending(const uint8_t *frame) +{ + const uint8_t *cur = frame; + uint8_t securityControl; + bool isDataRequest = false; + bool hasFramePending = false; + + // FCF + DSN + cur += 2 + 1; + + otEXPECT(isFrameTypeMacCmd(frame)); + + // Destination PAN + Address + switch (frame[1] & IEEE802154_DST_ADDR_MASK) + { + case IEEE802154_DST_ADDR_SHORT: + cur += sizeof(otPanId) + sizeof(otShortAddress); + break; + + case IEEE802154_DST_ADDR_EXT: + cur += sizeof(otPanId) + sizeof(otExtAddress); + break; + + default: + goto exit; + } + + // Source PAN + Address + switch (frame[1] & IEEE802154_SRC_ADDR_MASK) + { + case IEEE802154_SRC_ADDR_SHORT: + if (!isPanIdCompressed(frame)) + { + cur += sizeof(otPanId); + } + + if (sSrcMatchEnabled) + { + hasFramePending = findShortAddress((uint16_t)(cur[1] << 8 | cur[0])); + } + + cur += sizeof(otShortAddress); + break; + + case IEEE802154_SRC_ADDR_EXT: + if (!isPanIdCompressed(frame)) + { + cur += sizeof(otPanId); + } + + if (sSrcMatchEnabled) + { + hasFramePending = findExtAddress((const otExtAddress *)cur); + } + + cur += sizeof(otExtAddress); + break; + + default: + goto exit; + } + + // Security Control + Frame Counter + Key Identifier + if (isSecurityEnabled(frame)) + { + securityControl = *cur; + + if (securityControl & IEEE802154_SEC_LEVEL_MASK) + { + cur += 1 + 4; + } + + switch (securityControl & IEEE802154_KEY_ID_MODE_MASK) + { + case IEEE802154_KEY_ID_MODE_0: + cur += 0; + break; + + case IEEE802154_KEY_ID_MODE_1: + cur += 1; + break; + + case IEEE802154_KEY_ID_MODE_2: + cur += 5; + break; + + case IEEE802154_KEY_ID_MODE_3: + cur += 9; + break; + } + } + + // Command ID + isDataRequest = cur[0] == IEEE802154_MACCMD_DATA_REQ; + +exit: + return isDataRequest && hasFramePending; +} + +static inline uint8_t getDsn(const uint8_t *frame) +{ + return frame[IEEE802154_DSN_OFFSET]; +} + +static inline otPanId getDstPan(const uint8_t *frame) +{ + return (otPanId)((frame[IEEE802154_DSTPAN_OFFSET + 1] << 8) | frame[IEEE802154_DSTPAN_OFFSET]); +} + +static inline otShortAddress getShortAddress(const uint8_t *frame) +{ + return (otShortAddress)((frame[IEEE802154_DSTADDR_OFFSET + 1] << 8) | frame[IEEE802154_DSTADDR_OFFSET]); +} + +static inline void getExtAddress(const uint8_t *frame, otExtAddress *address) +{ + size_t i; + + for (i = 0; i < sizeof(otExtAddress); i++) + { + address->m8[i] = frame[IEEE802154_DSTADDR_OFFSET + (sizeof(otExtAddress) - 1 - i)]; + } +} + +static uint16_t crc16_citt(uint16_t aFcs, uint8_t aByte) +{ + // CRC-16/CCITT, CRC-16/CCITT-TRUE, CRC-CCITT + // width=16 poly=0x1021 init=0x0000 refin=true refout=true xorout=0x0000 check=0x2189 name="KERMIT" + // http://reveng.sourceforge.net/crc-catalogue/16.htm#crc.cat.kermit + static const uint16_t sFcsTable[256] = + { + 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, + 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, + 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, + 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, + 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, + 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, + 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, + 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, + 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, + 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, + 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, + 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, + 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, + 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, + 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, + 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, + 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, + 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, + 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, + 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, + 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, + 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, + 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, + 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, + 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, + 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, + 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, + 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, + 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, + 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, + 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, + 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 + }; + return (aFcs >> 8) ^ sFcsTable[(aFcs ^ aByte) & 0xff]; +} + +void otPlatRadioGetIeeeEui64(otInstance *aInstance, uint8_t *aIeeeEui64) +{ + (void)aInstance; + aIeeeEui64[0] = 0x18; + aIeeeEui64[1] = 0xb4; + aIeeeEui64[2] = 0x30; + aIeeeEui64[3] = 0x00; + aIeeeEui64[4] = (NODE_ID >> 24) & 0xff; + aIeeeEui64[5] = (NODE_ID >> 16) & 0xff; + aIeeeEui64[6] = (NODE_ID >> 8) & 0xff; + aIeeeEui64[7] = NODE_ID & 0xff; +} + +void otPlatRadioSetPanId(otInstance *aInstance, uint16_t panid) +{ + (void)aInstance; + sPanid = panid; +} + +void otPlatRadioSetExtendedAddress(otInstance *aInstance, const otExtAddress *aExtAddress) +{ + (void)aInstance; + + for (size_t i = 0; i < sizeof(sExtendedAddress); i++) + { + sExtendedAddress[i] = aExtAddress->m8[sizeof(sExtendedAddress) - 1 - i]; + } +} + +void otPlatRadioSetShortAddress(otInstance *aInstance, uint16_t address) +{ + (void)aInstance; + sShortAddress = address; +} + +void otPlatRadioSetPromiscuous(otInstance *aInstance, bool aEnable) +{ + (void)aInstance; + sPromiscuous = aEnable; +} + +void platformRadioInit(void) +{ + sReceiveFrame.mPsdu = sReceiveMessage.mPsdu; + sTransmitFrame.mPsdu = sTransmitMessage.mPsdu; + sAckFrame.mPsdu = sAckMessage.mPsdu; +} + +bool otPlatRadioIsEnabled(otInstance *aInstance) +{ + (void)aInstance; + return (sState != OT_RADIO_STATE_DISABLED) ? true : false; +} + +otError otPlatRadioEnable(otInstance *aInstance) +{ + if (!otPlatRadioIsEnabled(aInstance)) + { + sState = OT_RADIO_STATE_SLEEP; + } + + return OT_ERROR_NONE; +} + +otError otPlatRadioDisable(otInstance *aInstance) +{ + if (otPlatRadioIsEnabled(aInstance)) + { + sState = OT_RADIO_STATE_DISABLED; + } + + return OT_ERROR_NONE; +} + +otError otPlatRadioSleep(otInstance *aInstance) +{ + otError error = OT_ERROR_INVALID_STATE; + (void)aInstance; + + if (sState == OT_RADIO_STATE_SLEEP || sState == OT_RADIO_STATE_RECEIVE) + { + error = OT_ERROR_NONE; + sState = OT_RADIO_STATE_SLEEP; + } + + return error; +} + +otError otPlatRadioReceive(otInstance *aInstance, uint8_t aChannel) +{ + otError error = OT_ERROR_INVALID_STATE; + (void)aInstance; + + if (sState != OT_RADIO_STATE_DISABLED) + { + error = OT_ERROR_NONE; + sState = OT_RADIO_STATE_RECEIVE; + sAckWait = false; + sReceiveFrame.mChannel = aChannel; + } + + return error; +} + +otError otPlatRadioTransmit(otInstance *aInstance, otRadioFrame *aRadio) +{ + otError error = OT_ERROR_INVALID_STATE; + (void)aInstance; + (void)aRadio; + + if (sState == OT_RADIO_STATE_RECEIVE) + { + error = OT_ERROR_NONE; + sState = OT_RADIO_STATE_TRANSMIT; + } + + return error; +} + +otRadioFrame *otPlatRadioGetTransmitBuffer(otInstance *aInstance) +{ + (void)aInstance; + return &sTransmitFrame; +} + +int8_t otPlatRadioGetRssi(otInstance *aInstance) +{ + (void)aInstance; + return 0; +} + +otRadioCaps otPlatRadioGetCaps(otInstance *aInstance) +{ + (void)aInstance; + return OT_RADIO_CAPS_NONE; +} + +bool otPlatRadioGetPromiscuous(otInstance *aInstance) +{ + (void)aInstance; + return sPromiscuous; +} + +void platformRadioReceive(otInstance *aInstance, uint8_t *aBuf, uint16_t aBufLength) +{ + assert(sizeof(sReceiveMessage) >= aBufLength); + + memcpy(&sReceiveMessage, aBuf, aBufLength); + +#if OPENTHREAD_ENABLE_RAW_LINK_API + // Timestamp + sReceiveFrame.mMsec = otPlatAlarmMilliGetNow(); + sReceiveFrame.mUsec = 0; // Don't support microsecond timer for now. +#endif + + sReceiveFrame.mLength = (uint8_t)(aBufLength - 1); + + if (sState == OT_RADIO_STATE_TRANSMIT && + sAckWait && + !isAckRequested(sTransmitFrame.mPsdu) && + sTransmitFrame.mChannel == sReceiveMessage.mChannel && + !isFrameTypeAck(sTransmitFrame.mPsdu) && + sTransmitFrame.mLength == sReceiveFrame.mLength && + memcmp(sTransmitFrame.mPsdu, sReceiveFrame.mPsdu, sTransmitFrame.mLength) == 0) + { + sState = OT_RADIO_STATE_RECEIVE; + sAckWait = false; + +#if OPENTHREAD_ENABLE_DIAG + + if (otPlatDiagModeGet()) + { + otPlatDiagRadioTransmitDone(aInstance, &sTransmitFrame, OT_ERROR_NONE); + } + else +#endif + { + otPlatRadioTxDone(aInstance, &sTransmitFrame, NULL, OT_ERROR_NONE); + } + } + else if (sState == OT_RADIO_STATE_TRANSMIT && + sAckWait && + isAckRequested(sTransmitFrame.mPsdu) && + sTransmitFrame.mChannel == sReceiveMessage.mChannel && + isFrameTypeAck(sReceiveFrame.mPsdu) && + getDsn(sReceiveFrame.mPsdu) == getDsn(sTransmitFrame.mPsdu)) + { + sState = OT_RADIO_STATE_RECEIVE; + sAckWait = false; + +#if OPENTHREAD_ENABLE_DIAG + + if (otPlatDiagModeGet()) + { + otPlatDiagRadioTransmitDone(aInstance, &sTransmitFrame, OT_ERROR_NONE); + } + else +#endif + { + otPlatRadioTxDone(aInstance, &sTransmitFrame, &sReceiveFrame, OT_ERROR_NONE); + } + } + else if ((sState == OT_RADIO_STATE_RECEIVE || sState == OT_RADIO_STATE_TRANSMIT) && + (sReceiveFrame.mChannel == sReceiveMessage.mChannel)) + { + radioProcessFrame(aInstance); + } +} + +void radioSendMessage(otInstance *aInstance) +{ + sTransmitMessage.mChannel = sTransmitFrame.mChannel; + + otPlatRadioTxStarted(aInstance, &sTransmitFrame); + radioTransmit(&sTransmitMessage, &sTransmitFrame); + + sAckWait = true; +} + +void platformRadioProcess(otInstance *aInstance) +{ + if (sState == OT_RADIO_STATE_TRANSMIT && !sAckWait) + { + radioSendMessage(aInstance); + } +} + +void radioTransmit(struct RadioMessage *aMessage, const struct otRadioFrame *aFrame) +{ + struct sockaddr_in sockaddr; + struct Event event; + ssize_t rval; + + uint16_t crc = 0; + uint16_t crc_offset = aFrame->mLength - sizeof(uint16_t); + + for (uint32_t i = 0; i < crc_offset; i++) + { + crc = crc16_citt(crc, aMessage->mPsdu[i]); + } + + aMessage->mPsdu[crc_offset] = crc & 0xff; + aMessage->mPsdu[crc_offset + 1] = crc >> 8; + + event.mDelay = 1; // 1us for now + event.mEvent = OT_SIM_EVENT_RADIO_RECEIVED; + event.mDataLength = 1 + aFrame->mLength; // include channel in first byte + memcpy(event.mData, aMessage, event.mDataLength); + + memset(&sockaddr, 0, sizeof(sockaddr)); + sockaddr.sin_family = AF_INET; + inet_pton(AF_INET, "127.0.0.1", &sockaddr.sin_addr); + sockaddr.sin_port = htons(9000 + sPortOffset); + + rval = sendto(sSockFd, (const char *)&event, offsetof(struct Event, mData) + event.mDataLength, + 0, (struct sockaddr *)&sockaddr, sizeof(sockaddr)); + + if (rval < 0) + { + perror("sendto"); + exit(EXIT_FAILURE); + } +} + +void radioSendAck(void) +{ + sAckFrame.mLength = IEEE802154_ACK_LENGTH; + sAckMessage.mPsdu[0] = IEEE802154_FRAME_TYPE_ACK; + + if (isDataRequestAndHasFramePending(sReceiveFrame.mPsdu)) + { + sAckMessage.mPsdu[0] |= IEEE802154_FRAME_PENDING; + } + + sAckMessage.mPsdu[1] = 0; + sAckMessage.mPsdu[2] = getDsn(sReceiveFrame.mPsdu); + + sAckMessage.mChannel = sReceiveFrame.mChannel; + + radioTransmit(&sAckMessage, &sAckFrame); +} + +void radioProcessFrame(otInstance *aInstance) +{ + otError error = OT_ERROR_NONE; + otPanId dstpan; + otShortAddress short_address; + otExtAddress ext_address; + + otEXPECT_ACTION(sPromiscuous == false, error = OT_ERROR_NONE); + + switch (sReceiveFrame.mPsdu[1] & IEEE802154_DST_ADDR_MASK) + { + case IEEE802154_DST_ADDR_NONE: + break; + + case IEEE802154_DST_ADDR_SHORT: + dstpan = getDstPan(sReceiveFrame.mPsdu); + short_address = getShortAddress(sReceiveFrame.mPsdu); + otEXPECT_ACTION((dstpan == IEEE802154_BROADCAST || dstpan == sPanid) && + (short_address == IEEE802154_BROADCAST || short_address == sShortAddress), + error = OT_ERROR_ABORT); + break; + + case IEEE802154_DST_ADDR_EXT: + dstpan = getDstPan(sReceiveFrame.mPsdu); + getExtAddress(sReceiveFrame.mPsdu, &ext_address); + otEXPECT_ACTION((dstpan == IEEE802154_BROADCAST || dstpan == sPanid) && + memcmp(&ext_address, sExtendedAddress, sizeof(ext_address)) == 0, + error = OT_ERROR_ABORT); + break; + + default: + error = OT_ERROR_ABORT; + goto exit; + } + + sReceiveFrame.mRssi = -20; + sReceiveFrame.mLqi = OT_RADIO_LQI_NONE; + + // generate acknowledgment + if (isAckRequested(sReceiveFrame.mPsdu)) + { + radioSendAck(); + } + +exit: + +#if OPENTHREAD_ENABLE_DIAG + + if (otPlatDiagModeGet()) + { + otPlatDiagRadioReceiveDone(aInstance, error == OT_ERROR_NONE ? &sReceiveFrame : NULL, error); + } + else +#endif + { + otPlatRadioReceiveDone(aInstance, error == OT_ERROR_NONE ? &sReceiveFrame : NULL, error); + } +} + +void otPlatRadioEnableSrcMatch(otInstance *aInstance, bool aEnable) +{ + sSrcMatchEnabled = aEnable; + (void)aInstance; +} + +otError otPlatRadioAddSrcMatchShortEntry(otInstance *aInstance, const uint16_t aShortAddress) +{ + otError error = OT_ERROR_NONE; + otEXPECT_ACTION(sShortAddressMatchTableCount < sizeof(sShortAddressMatchTable) / sizeof(uint16_t), + error = OT_ERROR_NO_BUFS); + + for (uint8_t i = 0; i < sShortAddressMatchTableCount; ++i) + { + otEXPECT_ACTION(sShortAddressMatchTable[i] != aShortAddress, error = OT_ERROR_DUPLICATED); + } + + sShortAddressMatchTable[sShortAddressMatchTableCount++] = aShortAddress; + +exit: + (void)aInstance; + return error; +} + +otError otPlatRadioAddSrcMatchExtEntry(otInstance *aInstance, const otExtAddress *aExtAddress) +{ + otError error = OT_ERROR_NONE; + + otEXPECT_ACTION(sExtAddressMatchTableCount < sizeof(sExtAddressMatchTable) / sizeof(otExtAddress), + error = OT_ERROR_NO_BUFS); + + for (uint8_t i = 0; i < sExtAddressMatchTableCount; ++i) + { + otEXPECT_ACTION(memcmp(&sExtAddressMatchTable[i], aExtAddress, sizeof(otExtAddress)), + error = OT_ERROR_DUPLICATED); + } + + sExtAddressMatchTable[sExtAddressMatchTableCount++] = *aExtAddress; + +exit: + (void)aInstance; + return error; +} + +otError otPlatRadioClearSrcMatchShortEntry(otInstance *aInstance, const uint16_t aShortAddress) +{ + otError error = OT_ERROR_NOT_FOUND; + otEXPECT(sShortAddressMatchTableCount > 0); + + for (uint8_t i = 0; i < sShortAddressMatchTableCount; ++i) + { + if (sShortAddressMatchTable[i] == aShortAddress) + { + sShortAddressMatchTable[i] = sShortAddressMatchTable[--sShortAddressMatchTableCount]; + error = OT_ERROR_NONE; + goto exit; + } + } + +exit: + (void)aInstance; + return error; +} + +otError otPlatRadioClearSrcMatchExtEntry(otInstance *aInstance, const otExtAddress *aExtAddress) +{ + otError error = OT_ERROR_NOT_FOUND; + + otEXPECT(sExtAddressMatchTableCount > 0); + + for (uint8_t i = 0; i < sExtAddressMatchTableCount; ++i) + { + if (!memcmp(&sExtAddressMatchTable[i], aExtAddress, sizeof(otExtAddress))) + { + sExtAddressMatchTable[i] = sExtAddressMatchTable[--sExtAddressMatchTableCount]; + error = OT_ERROR_NONE; + goto exit; + } + } + +exit: + (void)aInstance; + return error; +} + +void otPlatRadioClearSrcMatchShortEntries(otInstance *aInstance) +{ + sShortAddressMatchTableCount = 0; + (void)aInstance; +} + +void otPlatRadioClearSrcMatchExtEntries(otInstance *aInstance) +{ + sExtAddressMatchTableCount = 0; + (void)aInstance; +} + +otError otPlatRadioEnergyScan(otInstance *aInstance, uint8_t aScanChannel, uint16_t aScanDuration) +{ + (void)aInstance; + (void)aScanChannel; + (void)aScanDuration; + return OT_ERROR_NOT_IMPLEMENTED; +} + +otError otPlatRadioGetTransmitPower(otInstance *aInstance, int8_t *aPower) +{ + (void)aInstance; + (void)aPower; + return OT_ERROR_NOT_IMPLEMENTED; +} + +otError otPlatRadioSetTransmitPower(otInstance *aInstance, int8_t aPower) +{ + (void)aInstance; + (void)aPower; + return OT_ERROR_NOT_IMPLEMENTED; +} + +int8_t otPlatRadioGetReceiveSensitivity(otInstance *aInstance) +{ + (void)aInstance; + return POSIX_RECEIVE_SENSITIVITY; +} + +#endif // OPENTHREAD_POSIX_VIRTUAL_TIME diff --git a/src/core/coap/coap.hpp b/src/core/coap/coap.hpp index a67cd283c..78f33f40d 100644 --- a/src/core/coap/coap.hpp +++ b/src/core/coap/coap.hpp @@ -168,7 +168,7 @@ public: * @retval TRUE If the message shall be sent before the given time. * @retval FALSE Otherwise. */ - bool IsEarlier(uint32_t aTime) const { return (static_cast(aTime - mNextTimerShot) > 0); }; + bool IsEarlier(uint32_t aTime) const { return (static_cast(aTime - mNextTimerShot) >= 0); }; /** * This method checks if the message shall be sent after the given time. @@ -299,7 +299,7 @@ public: * @retval FALSE Otherwise. * */ - bool IsEarlier(uint32_t aTime) const { return (static_cast(aTime - mDequeueTime) > 0); } + bool IsEarlier(uint32_t aTime) const { return (static_cast(aTime - mDequeueTime) >= 0); } /** * This method returns number of milliseconds in which the message should be sent. diff --git a/tests/scripts/thread-cert/Cert_5_1_01_RouterAttach.py b/tests/scripts/thread-cert/Cert_5_1_01_RouterAttach.py index dfae6b0f9..e9acf810b 100755 --- a/tests/scripts/thread-cert/Cert_5_1_01_RouterAttach.py +++ b/tests/scripts/thread-cert/Cert_5_1_01_RouterAttach.py @@ -37,15 +37,16 @@ import node LEADER = 1 ROUTER = 2 -SNIFFER = 3 class Cert_5_1_01_RouterAttach(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -58,29 +59,23 @@ class Cert_5_1_01_RouterAttach(unittest.TestCase): self.nodes[ROUTER].enable_whitelist() self.nodes[ROUTER].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER].start() - time.sleep(7) + self.simulator.go(7) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router_messages = self.sniffer.get_messages_sent_by(ROUTER) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router_messages = self.simulator.get_messages_sent_by(ROUTER) # 1 - Leader msg = leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) @@ -186,6 +181,5 @@ class Cert_5_1_01_RouterAttach(unittest.TestCase): for addr in self.nodes[LEADER].get_addrs(): self.assertTrue(self.nodes[ROUTER].ping(addr)) - if __name__ == '__main__': unittest.main() diff --git a/tests/scripts/thread-cert/Cert_5_1_02_ChildAddressTimeout.py b/tests/scripts/thread-cert/Cert_5_1_02_ChildAddressTimeout.py index 933016688..0c7fba037 100755 --- a/tests/scripts/thread-cert/Cert_5_1_02_ChildAddressTimeout.py +++ b/tests/scripts/thread-cert/Cert_5_1_02_ChildAddressTimeout.py @@ -38,16 +38,17 @@ LEADER = 1 ROUTER = 2 ED = 3 SED = 4 -SNIFFER = 5 MTDS = [ED, SED] class Cert_5_1_02_ChildAddressTimeout(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -74,54 +75,48 @@ class Cert_5_1_02_ChildAddressTimeout(unittest.TestCase): self.nodes[SED].add_whitelist(self.nodes[ROUTER].get_addr64()) self.nodes[SED].enable_whitelist() - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[SED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED].get_state(), 'child') ed_addrs = self.nodes[ED].get_addrs() sed_addrs = self.nodes[SED].get_addrs() self.nodes[ED].stop() - time.sleep(5) + self.simulator.go(5) for addr in ed_addrs: if addr[0:4] != 'fe80': self.assertFalse(self.nodes[LEADER].ping(addr)) self.nodes[SED].stop() - time.sleep(5) + self.simulator.go(5) for addr in sed_addrs: if addr[0:4] != 'fe80': self.assertFalse(self.nodes[LEADER].ping(addr)) - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER) - ed_messages = self.sniffer.get_messages_sent_by(ED) - sed_messages = self.sniffer.get_messages_sent_by(SED) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER) + ed_messages = self.simulator.get_messages_sent_by(ED) + sed_messages = self.simulator.get_messages_sent_by(SED) # 1 - All leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_1_03_RouterAddressReallocation.py b/tests/scripts/thread-cert/Cert_5_1_03_RouterAddressReallocation.py index d068bbb76..fcf96520a 100755 --- a/tests/scripts/thread-cert/Cert_5_1_03_RouterAddressReallocation.py +++ b/tests/scripts/thread-cert/Cert_5_1_03_RouterAddressReallocation.py @@ -38,15 +38,16 @@ import node LEADER = 1 ROUTER1 = 2 ROUTER2 = 3 -SNIFFER = 4 class Cert_5_1_03_RouterAddressReallocation(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 4): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -68,44 +69,38 @@ class Cert_5_1_03_RouterAddressReallocation(unittest.TestCase): self.nodes[ROUTER2].enable_whitelist() self.nodes[ROUTER2].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') rloc16 = self.nodes[ROUTER1].get_addr16() self.nodes[ROUTER2].set_network_id_timeout(110) self.nodes[LEADER].stop() - time.sleep(140) + self.simulator.go(140) self.assertEqual(self.nodes[ROUTER2].get_state(), 'leader') self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.assertEqual(self.nodes[ROUTER1].get_addr16(), rloc16) - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) - router2_messages = self.sniffer.get_messages_sent_by(ROUTER2) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) + router2_messages = self.simulator.get_messages_sent_by(ROUTER2) # 2 - All leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_1_04_RouterAddressReallocation.py b/tests/scripts/thread-cert/Cert_5_1_04_RouterAddressReallocation.py index de5fadb15..e1318d432 100755 --- a/tests/scripts/thread-cert/Cert_5_1_04_RouterAddressReallocation.py +++ b/tests/scripts/thread-cert/Cert_5_1_04_RouterAddressReallocation.py @@ -38,15 +38,16 @@ import node LEADER = 1 ROUTER1 = 2 ROUTER2 = 3 -SNIFFER = 4 class Cert_5_1_04_RouterAddressReallocation(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 4): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -68,43 +69,37 @@ class Cert_5_1_04_RouterAddressReallocation(unittest.TestCase): self.nodes[ROUTER2].enable_whitelist() self.nodes[ROUTER2].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') rloc16 = self.nodes[ROUTER1].get_addr16() self.nodes[ROUTER2].set_network_id_timeout(200) self.nodes[LEADER].stop() - time.sleep(220) + self.simulator.go(220) self.assertEqual(self.nodes[ROUTER1].get_state(), 'leader') self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.assertEqual(self.nodes[ROUTER1].get_addr16(), rloc16) - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) - router2_messages = self.sniffer.get_messages_sent_by(ROUTER2) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) + router2_messages = self.simulator.get_messages_sent_by(ROUTER2) # 2 - All leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_1_05_RouterAddressTimeout.py b/tests/scripts/thread-cert/Cert_5_1_05_RouterAddressTimeout.py index e3c4873f4..ddf4adc62 100755 --- a/tests/scripts/thread-cert/Cert_5_1_05_RouterAddressTimeout.py +++ b/tests/scripts/thread-cert/Cert_5_1_05_RouterAddressTimeout.py @@ -37,15 +37,16 @@ import node LEADER = 1 ROUTER1 = 2 -SNIFFER = 3 class Cert_5_1_05_RouterAddressTimeout(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -56,53 +57,47 @@ class Cert_5_1_05_RouterAddressTimeout(unittest.TestCase): self.nodes[ROUTER1].set_mode('rsdn') self._setUpRouter1() - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def _setUpRouter1(self): self.nodes[ROUTER1].add_whitelist(self.nodes[LEADER].get_addr64()) self.nodes[ROUTER1].enable_whitelist() self.nodes[ROUTER1].set_router_selection_jitter(1) def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') rloc16 = self.nodes[ROUTER1].get_addr16() self.nodes[ROUTER1].reset() self._setUpRouter1() - time.sleep(200) + self.simulator.go(200) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.assertNotEqual(self.nodes[ROUTER1].get_addr16(), rloc16) rloc16 = self.nodes[ROUTER1].get_addr16() self.nodes[ROUTER1].reset() self._setUpRouter1() - time.sleep(300) + self.simulator.go(300) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.assertEqual(self.nodes[ROUTER1].get_addr16(), rloc16) - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) # 2 - All leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_1_06_RemoveRouterId.py b/tests/scripts/thread-cert/Cert_5_1_06_RemoveRouterId.py index 2599af520..663d8b264 100755 --- a/tests/scripts/thread-cert/Cert_5_1_06_RemoveRouterId.py +++ b/tests/scripts/thread-cert/Cert_5_1_06_RemoveRouterId.py @@ -37,15 +37,16 @@ import node LEADER = 1 ROUTER1 = 2 -SNIFFER = 3 class Cert_5_1_06_RemoveRouterId(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -58,25 +59,19 @@ class Cert_5_1_06_RemoveRouterId(unittest.TestCase): self.nodes[ROUTER1].enable_whitelist() self.nodes[ROUTER1].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') rloc16 = self.nodes[ROUTER1].get_addr16() @@ -84,14 +79,14 @@ class Cert_5_1_06_RemoveRouterId(unittest.TestCase): self.assertTrue(self.nodes[LEADER].ping(addr)) self.nodes[LEADER].release_router_id(rloc16 >> 10) - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') for addr in self.nodes[ROUTER1].get_addrs(): self.assertTrue(self.nodes[LEADER].ping(addr)) - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) # 1 - All leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_1_07_MaxChildCount.py b/tests/scripts/thread-cert/Cert_5_1_07_MaxChildCount.py index 145adbef6..265672ca5 100755 --- a/tests/scripts/thread-cert/Cert_5_1_07_MaxChildCount.py +++ b/tests/scripts/thread-cert/Cert_5_1_07_MaxChildCount.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -38,9 +39,11 @@ SED1 = 7 class Cert_5_1_07_MaxChildCount(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 13): - self.nodes[i] = node.Node(i, (i >= 3)) + self.nodes[i] = node.Node(i, (i >= 3), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -69,20 +72,20 @@ class Cert_5_1_07_MaxChildCount(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') for i in range(3, 13): self.nodes[i].start() - time.sleep(7) + self.simulator.go(7) self.assertEqual(self.nodes[i].get_state(), 'child') ipaddrs = self.nodes[SED1].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_5_1_08_RouterAttachConnectivity.py b/tests/scripts/thread-cert/Cert_5_1_08_RouterAttachConnectivity.py index 5c1755104..fb56eb50e 100755 --- a/tests/scripts/thread-cert/Cert_5_1_08_RouterAttachConnectivity.py +++ b/tests/scripts/thread-cert/Cert_5_1_08_RouterAttachConnectivity.py @@ -39,15 +39,16 @@ ROUTER1 = 2 ROUTER2 = 3 ROUTER3 = 4 ROUTER4 = 5 -SNIFFER = 6 class Cert_5_1_08_RouterAttachConnectivity(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 6): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -85,33 +86,27 @@ class Cert_5_1_08_RouterAttachConnectivity(unittest.TestCase): self.nodes[ROUTER4].enable_whitelist() self.nodes[ROUTER4].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) for i in range(2, 6): self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[i].get_state(), 'router') - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) - router2_messages = self.sniffer.get_messages_sent_by(ROUTER2) - router3_messages = self.sniffer.get_messages_sent_by(ROUTER3) - router4_messages = self.sniffer.get_messages_sent_by(ROUTER4) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) + router2_messages = self.simulator.get_messages_sent_by(ROUTER2) + router3_messages = self.simulator.get_messages_sent_by(ROUTER3) + router4_messages = self.simulator.get_messages_sent_by(ROUTER4) # 1 - Leader, Router1, Router2, Router3 leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_1_09_REEDAttachConnectivity.py b/tests/scripts/thread-cert/Cert_5_1_09_REEDAttachConnectivity.py index 317584704..67739afdb 100755 --- a/tests/scripts/thread-cert/Cert_5_1_09_REEDAttachConnectivity.py +++ b/tests/scripts/thread-cert/Cert_5_1_09_REEDAttachConnectivity.py @@ -39,15 +39,16 @@ ROUTER1 = 2 REED0 = 3 REED1 = 4 ROUTER2 = 5 -SNIFFER = 6 class Cert_5_1_09_REEDAttachConnectivity(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 6): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -85,47 +86,41 @@ class Cert_5_1_09_REEDAttachConnectivity(unittest.TestCase): self.nodes[ROUTER2].enable_whitelist() self.nodes[ROUTER2].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[REED0].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED0].get_state(), 'child') self.nodes[REED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED1].get_state(), 'child') - time.sleep(10) + self.simulator.go(10) self.nodes[ROUTER2].start() - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.assertEqual(self.nodes[REED1].get_state(), 'router') - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) - reed0_messages = self.sniffer.get_messages_sent_by(REED0) - reed1_messages = self.sniffer.get_messages_sent_by(REED1) - router2_messages = self.sniffer.get_messages_sent_by(ROUTER2) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) + reed0_messages = self.simulator.get_messages_sent_by(REED0) + reed1_messages = self.simulator.get_messages_sent_by(REED1) + router2_messages = self.simulator.get_messages_sent_by(ROUTER2) # 1 - Leader, Router1, REED1, REED2 leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_1_10_RouterAttachLinkQuality.py b/tests/scripts/thread-cert/Cert_5_1_10_RouterAttachLinkQuality.py index 40d13f95d..0052e1e66 100755 --- a/tests/scripts/thread-cert/Cert_5_1_10_RouterAttachLinkQuality.py +++ b/tests/scripts/thread-cert/Cert_5_1_10_RouterAttachLinkQuality.py @@ -38,15 +38,16 @@ LEADER = 1 ROUTER1 = 2 ROUTER2 = 3 ROUTER3 = 4 -SNIFFER = 5 class Cert_5_1_10_RouterAttachLinkQuality(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 5): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -75,39 +76,33 @@ class Cert_5_1_10_RouterAttachLinkQuality(unittest.TestCase): self.nodes[ROUTER3].enable_whitelist() self.nodes[ROUTER3].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER3].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER3].get_state(), 'router') - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) - router2_messages = self.sniffer.get_messages_sent_by(ROUTER2) - router3_messages = self.sniffer.get_messages_sent_by(ROUTER3) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) + router2_messages = self.simulator.get_messages_sent_by(ROUTER2) + router3_messages = self.simulator.get_messages_sent_by(ROUTER3) # 1 - Leader, Router1, Router2 leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_1_11_REEDAttachLinkQuality.py b/tests/scripts/thread-cert/Cert_5_1_11_REEDAttachLinkQuality.py index 15bb5bd3c..f03be3302 100755 --- a/tests/scripts/thread-cert/Cert_5_1_11_REEDAttachLinkQuality.py +++ b/tests/scripts/thread-cert/Cert_5_1_11_REEDAttachLinkQuality.py @@ -38,15 +38,16 @@ LEADER = 1 REED = 2 ROUTER2 = 3 ROUTER1 = 4 -SNIFFER = 5 class Cert_5_1_11_REEDAttachLinkQuality(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 5): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -75,40 +76,34 @@ class Cert_5_1_11_REEDAttachLinkQuality(unittest.TestCase): self.nodes[ROUTER1].enable_whitelist() self.nodes[ROUTER1].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[REED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED].get_state(), 'child') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER1].start() - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.assertEqual(self.nodes[REED].get_state(), 'router') - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - reed_messages = self.sniffer.get_messages_sent_by(REED) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) - router2_messages = self.sniffer.get_messages_sent_by(ROUTER2) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + reed_messages = self.simulator.get_messages_sent_by(REED) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) + router2_messages = self.simulator.get_messages_sent_by(ROUTER2) # 1 - Leader. REED1, Router2 leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_1_12_NewRouterNeighborSync.py b/tests/scripts/thread-cert/Cert_5_1_12_NewRouterNeighborSync.py index ca677f392..3e2c80cf3 100755 --- a/tests/scripts/thread-cert/Cert_5_1_12_NewRouterNeighborSync.py +++ b/tests/scripts/thread-cert/Cert_5_1_12_NewRouterNeighborSync.py @@ -37,15 +37,16 @@ import node LEADER = 1 ROUTER1 = 2 ROUTER2 = 3 -SNIFFER = 4 class Cert_5_1_12_NewRouterSync(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 4): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -65,16 +66,11 @@ class Cert_5_1_12_NewRouterSync(unittest.TestCase): self.nodes[ROUTER2].enable_whitelist() self.nodes[ROUTER2].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def verify_step_4(self, router1_messages, router2_messages, req_receiver, accept_receiver): if router2_messages.contains_mle_message(mle.CommandType.LINK_REQUEST) and \ @@ -113,23 +109,22 @@ class Cert_5_1_12_NewRouterSync(unittest.TestCase): def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') - time.sleep(10) + self.simulator.go(10) - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) - router2_messages = self.sniffer.get_messages_sent_by(ROUTER2) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) + router2_messages = self.simulator.get_messages_sent_by(ROUTER2) # 2 - Router1 msg = router1_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) @@ -142,11 +137,11 @@ class Cert_5_1_12_NewRouterSync(unittest.TestCase): self.nodes[ROUTER1].add_whitelist(self.nodes[ROUTER2].get_addr64()) self.nodes[ROUTER2].add_whitelist(self.nodes[ROUTER1].get_addr64()) - time.sleep(35) + self.simulator.go(35) - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER1) - router2_messages = self.sniffer.get_messages_sent_by(ROUTER2) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER1) + router2_messages = self.simulator.get_messages_sent_by(ROUTER2) # 4 - Router1, Router2 self.assertTrue(self.verify_step_4(router1_messages, router2_messages, ROUTER1, ROUTER2) or diff --git a/tests/scripts/thread-cert/Cert_5_1_13_RouterReset.py b/tests/scripts/thread-cert/Cert_5_1_13_RouterReset.py index 1f907f1f2..7383666f7 100755 --- a/tests/scripts/thread-cert/Cert_5_1_13_RouterReset.py +++ b/tests/scripts/thread-cert/Cert_5_1_13_RouterReset.py @@ -36,15 +36,16 @@ import node LEADER = 1 ROUTER = 2 -SNIFFER = 3 class Cert_5_1_13_RouterReset(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -55,45 +56,39 @@ class Cert_5_1_13_RouterReset(unittest.TestCase): self.nodes[ROUTER].set_mode('rsdn') self._setUpRouter() - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def _setUpRouter(self): self.nodes[ROUTER].add_whitelist(self.nodes[LEADER].get_addr64()) self.nodes[ROUTER].enable_whitelist() self.nodes[ROUTER].set_router_selection_jitter(1) def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') - time.sleep(4) self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') rloc16 = self.nodes[ROUTER].get_addr16() self.nodes[ROUTER].reset() self._setUpRouter() - time.sleep(5) + self.simulator.go(5) self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.assertEqual(self.nodes[ROUTER].get_addr16(), rloc16) - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - router1_messages = self.sniffer.get_messages_sent_by(ROUTER) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + router1_messages = self.simulator.get_messages_sent_by(ROUTER) # 1 - All leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_5_2_01_REEDAttach.py b/tests/scripts/thread-cert/Cert_5_2_01_REEDAttach.py index beb11085e..43e56eb92 100755 --- a/tests/scripts/thread-cert/Cert_5_2_01_REEDAttach.py +++ b/tests/scripts/thread-cert/Cert_5_2_01_REEDAttach.py @@ -45,9 +45,11 @@ MED1 = 4 class Cert_5_2_01_REEDAttach(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 5): - self.nodes[i] = node.Node(i, i == MED1) + self.nodes[i] = node.Node(i, i == MED1, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -74,39 +76,34 @@ class Cert_5_2_01_REEDAttach(unittest.TestCase): self.nodes[MED1].add_whitelist(self.nodes[REED1].get_addr64()) self.nodes[MED1].enable_whitelist() - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') # 1 DUT_ROUTER1: Attach to LEADER self.nodes[DUT_ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[DUT_ROUTER1].get_state(), 'router') # DUT_ROUTER1: Verify MLE advertisements - router1_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + router1_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) msg = router1_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) command.check_mle_advertisement(msg) # 2 REED1: Attach to DUT_ROUTER1 self.nodes[REED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED1].get_state(), 'child') # 3 DUT_ROUTER1: Verify MLE Parent Response - router1_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + router1_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) msg = router1_messages.next_mle_message(mle.CommandType.PARENT_RESPONSE) msg.assertSentToNode(self.nodes[REED1]) command.check_parent_response(msg) @@ -120,18 +117,18 @@ class Cert_5_2_01_REEDAttach(unittest.TestCase): # 6 MED1: Attach to REED1 self.nodes[MED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[MED1].get_state(), 'child') # 7 REED1: Verify sending Address Solicit Request to DUT_ROUTER1 - reed1_messages = self.sniffer.get_messages_sent_by(REED1) + reed1_messages = self.simulator.get_messages_sent_by(REED1) msg = reed1_messages.next_coap_message('0.02') reed1_ipv6_address = msg.ipv6_packet.ipv6_header.source_address.compressed msg.assertSentToNode(self.nodes[DUT_ROUTER1]); msg.assertCoapMessageRequestUriPath('/a/as') # 8 DUT_ROUTER1: Verify forwarding REED1's Address Solicit Request to LEADER - router1_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + router1_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) msg = router1_messages.next_coap_message('0.02') msg.assertSentToNode(self.nodes[LEADER]); msg.assertCoapMessageRequestUriPath('/a/as') diff --git a/tests/scripts/thread-cert/Cert_5_2_03_LeaderReject2Hops.py b/tests/scripts/thread-cert/Cert_5_2_03_LeaderReject2Hops.py index 0cc140380..82bbfac18 100755 --- a/tests/scripts/thread-cert/Cert_5_2_03_LeaderReject2Hops.py +++ b/tests/scripts/thread-cert/Cert_5_2_03_LeaderReject2Hops.py @@ -39,13 +39,14 @@ DUT_LEADER = 1 ROUTER_1 = 2 ROUTER_31 = 32 ROUTER_32 = 33 -SNIFFER = 34 class Cert_5_2_3_LeaderReject2Hops(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} - self.nodes[DUT_LEADER] = node.Node(DUT_LEADER) + self.nodes[DUT_LEADER] = node.Node(DUT_LEADER, simulator=self.simulator) self.nodes[DUT_LEADER].set_panid(0xface) self.nodes[DUT_LEADER].set_mode('rsdn') self.nodes[DUT_LEADER].enable_whitelist() @@ -53,7 +54,7 @@ class Cert_5_2_3_LeaderReject2Hops(unittest.TestCase): self.nodes[DUT_LEADER].set_router_downgrade_threshold(33) for i in range(2, 33): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[i].set_panid(0xface) self.nodes[i].set_mode('rsdn') self.nodes[i].add_whitelist(self.nodes[DUT_LEADER].get_addr64()) @@ -63,7 +64,7 @@ class Cert_5_2_3_LeaderReject2Hops(unittest.TestCase): self.nodes[i].set_router_downgrade_threshold(33) self.nodes[i].set_router_selection_jitter(1) - self.nodes[ROUTER_32] = node.Node(ROUTER_32) + self.nodes[ROUTER_32] = node.Node(ROUTER_32, simulator=self.simulator) self.nodes[ROUTER_32].set_panid(0xface) self.nodes[ROUTER_32].set_mode('rsdn') self.nodes[ROUTER_32].add_whitelist(self.nodes[ROUTER_1].get_addr64()) @@ -73,38 +74,33 @@ class Cert_5_2_3_LeaderReject2Hops(unittest.TestCase): self.nodes[ROUTER_32].set_router_downgrade_threshold(33) self.nodes[ROUTER_32].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 self.nodes[DUT_LEADER].start() - self.nodes[DUT_LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[DUT_LEADER].get_state(), 'leader') for i in range(2, 32): self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[i].get_state(), 'router') - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) # 2 self.nodes[ROUTER_31].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER_31].get_state(), 'router') # 3 - DUT_LEADER # This method flushes the message queue so calling this method again will return only the newly logged messages. - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.next_coap_message('2.04') msg.assertCoapMessageContainsTlv(network_layer.Status) msg.assertCoapMessageContainsTlv(network_layer.RouterMask) @@ -119,10 +115,10 @@ class Cert_5_2_3_LeaderReject2Hops(unittest.TestCase): # 5 - Router_32 self.nodes[ROUTER_32].start() - time.sleep(5) + self.simulator.go(5) # 6 - DUT_LEADER - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.next_coap_message('2.04') msg.assertCoapMessageContainsTlv(network_layer.Status) diff --git a/tests/scripts/thread-cert/Cert_5_2_04_REEDUpgrade.py b/tests/scripts/thread-cert/Cert_5_2_04_REEDUpgrade.py index 8a7d25244..a4667bec1 100755 --- a/tests/scripts/thread-cert/Cert_5_2_04_REEDUpgrade.py +++ b/tests/scripts/thread-cert/Cert_5_2_04_REEDUpgrade.py @@ -39,7 +39,6 @@ LEADER = 1 ROUTER = 16 DUT_REED = 17 ED = 18 -SNIFFER = 19 MESH_LOCAL_PREFIX = 'fdde:ad00:beef:0:' ROUTING_LACATOR = ':0:ff:fe00' REED_ADVERTISEMENT_INTERVAL = 570 @@ -48,9 +47,11 @@ ROUTER_SELECTION_JITTER = 1 class Cert_5_2_4_REEDUpgrade(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 19): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -77,34 +78,29 @@ class Cert_5_2_4_REEDUpgrade(unittest.TestCase): self.nodes[ED].add_whitelist(self.nodes[DUT_REED].get_addr64()) self.nodes[ED].enable_whitelist() - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 Ensure topology is formed correctly without the DUT_REED. self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') for i in range(2, 17): self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[i].get_state(), 'router') # 2 DUT_REED: Attach to ROUTER, 2-hops from the Leader. self.nodes[DUT_REED].start() - time.sleep(5) - time.sleep(ROUTER_SELECTION_JITTER) + self.simulator.go(5) + self.simulator.go(ROUTER_SELECTION_JITTER) - reed_messages = self.sniffer.get_messages_sent_by(DUT_REED) + reed_messages = self.simulator.get_messages_sent_by(DUT_REED) # The DUT_REED must not send a coap message here. msg = reed_messages.does_not_contain_coap_message() @@ -119,18 +115,18 @@ class Cert_5_2_4_REEDUpgrade(unittest.TestCase): msg.assertMleMessageDoesNotContainTlv(mle.Route64) # 4 Wait for DUT_REED to send the second packet. - time.sleep(REED_ADVERTISEMENT_INTERVAL + REED_ADVERTISEMENT_MAX_JITTER) + self.simulator.go(REED_ADVERTISEMENT_INTERVAL + REED_ADVERTISEMENT_MAX_JITTER) # 5 DUT_REED: Verify the second MLE Advertisement. - reed_messages = self.sniffer.get_messages_sent_by(DUT_REED) + reed_messages = self.simulator.get_messages_sent_by(DUT_REED) msg = reed_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) # 6 ED self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) # 7 DUT_REED: Verify MLE Parent Response. - reed_messages = self.sniffer.get_messages_sent_by(DUT_REED) + reed_messages = self.simulator.get_messages_sent_by(DUT_REED) msg = reed_messages.next_mle_message(mle.CommandType.PARENT_RESPONSE) msg.assertSentToNode(self.nodes[ED]) msg.assertMleMessageContainsTlv(mle.SourceAddress) diff --git a/tests/scripts/thread-cert/Cert_5_2_05_AddressQuery.py b/tests/scripts/thread-cert/Cert_5_2_05_AddressQuery.py index f1ba6d6a1..96f4fea97 100755 --- a/tests/scripts/thread-cert/Cert_5_2_05_AddressQuery.py +++ b/tests/scripts/thread-cert/Cert_5_2_05_AddressQuery.py @@ -43,9 +43,11 @@ ROUTER_SELECTION_JITTER = 1 class Cert_5_2_5_AddressQuery(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 19): - self.nodes[i] = node.Node(i, (i == ED1)) + self.nodes[i] = node.Node(i, (i == ED1), simulator=self.simulator) self.nodes[LEADER].set_panid() self.nodes[LEADER].set_mode('rsdn') @@ -72,28 +74,23 @@ class Cert_5_2_5_AddressQuery(unittest.TestCase): self.nodes[DUT_REED].enable_whitelist() self.nodes[DUT_REED].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1. LEADER: DHCPv6 Server for prefix 2001::/64. self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[LEADER].add_prefix('2001::/64', 'pdros') self.nodes[LEADER].register_netdata() # 2. BR: SLAAC Server for prefix 2002::/64. self.nodes[BR].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[BR].get_state(), 'router') self.nodes[BR].add_prefix('2002::/64', 'paros') self.nodes[BR].register_netdata() @@ -103,19 +100,19 @@ class Cert_5_2_5_AddressQuery(unittest.TestCase): if i == BR: continue self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[i].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') # 4. Bring up DUT_REED. self.nodes[DUT_REED].start() - time.sleep(5) - time.sleep(ROUTER_SELECTION_JITTER) + self.simulator.go(5) + self.simulator.go(ROUTER_SELECTION_JITTER) - reed_messages = self.sniffer.get_messages_sent_by(DUT_REED) + reed_messages = self.simulator.get_messages_sent_by(DUT_REED) # Verify DUT_REED doesn't try to become router. msg = reed_messages.does_not_contain_coap_message() @@ -129,7 +126,7 @@ class Cert_5_2_5_AddressQuery(unittest.TestCase): mleid = self.nodes[DUT_REED].get_ip6_address(config.ADDRESS_TYPE.ML_EID) self.assertTrue(self.nodes[ED1].ping(mleid)) - reed_messages = self.sniffer.get_messages_sent_by(DUT_REED) + reed_messages = self.simulator.get_messages_sent_by(DUT_REED) msg = reed_messages.next_coap_message('0.02') command.check_address_notification(msg, self.nodes[DUT_REED], self.nodes[LEADER]) @@ -145,7 +142,7 @@ class Cert_5_2_5_AddressQuery(unittest.TestCase): raise "Error: Address is unexpected." self.assertTrue(self.nodes[ED1].ping(global_address)) - reed_messages = self.sniffer.get_messages_sent_by(DUT_REED) + reed_messages = self.simulator.get_messages_sent_by(DUT_REED) msg = reed_messages.next_coap_message('0.02') command.check_address_notification(msg, self.nodes[DUT_REED], self.nodes[LEADER]) diff --git a/tests/scripts/thread-cert/Cert_5_2_06_RouterDowngrade.py b/tests/scripts/thread-cert/Cert_5_2_06_RouterDowngrade.py index c3599b78b..9c56c41c5 100755 --- a/tests/scripts/thread-cert/Cert_5_2_06_RouterDowngrade.py +++ b/tests/scripts/thread-cert/Cert_5_2_06_RouterDowngrade.py @@ -42,9 +42,11 @@ ROUTER24 = 24 class Cert_5_2_06_RouterDowngrade(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 25): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[i].set_panid() self.nodes[i].set_mode('rsdn') self.nodes[i].set_router_selection_jitter(1) @@ -52,44 +54,39 @@ class Cert_5_2_06_RouterDowngrade(unittest.TestCase): self.nodes[i].set_router_upgrade_threshold(32) self.nodes[i].set_router_downgrade_threshold(32) - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 Ensure topology is formed correctly without ROUTER24. self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') for i in range(2, 24): self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[i].get_state(), 'router') # This method flushes the message queue so calling this method again will return only the newly logged messages. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) # 2 ROUTER24: Attach to network. # All reference testbed devices have been configured with downgrade threshold as 32 except DUT_ROUTER1, # so we don't need to ensure ROUTER24 has a better link quality on posix. self.nodes[ROUTER24].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER24].get_state(), 'router') # 3 DUT_ROUTER1: - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[DUT_ROUTER1].get_state(), 'child') # Verify it sent a Parent Request and Child ID Request. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) dut_messages.next_mle_message(mle.CommandType.PARENT_REQUEST) dut_messages.next_mle_message(mle.CommandType.CHILD_ID_REQUEST) diff --git a/tests/scripts/thread-cert/Cert_5_2_07_REEDSynchronization.py b/tests/scripts/thread-cert/Cert_5_2_07_REEDSynchronization.py index 3504693ae..e90e12d73 100755 --- a/tests/scripts/thread-cert/Cert_5_2_07_REEDSynchronization.py +++ b/tests/scripts/thread-cert/Cert_5_2_07_REEDSynchronization.py @@ -42,33 +42,30 @@ DUT_REED = 17 class Cert_5_2_7_REEDSynchronization(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 18): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[i].set_panid(0xface) self.nodes[i].set_mode('rsdn') self.nodes[i].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1. Ensure topology is formed correctly without DUT_ROUTER1. self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') for i in range(2, 17): self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) for i in range(2, 17): self.assertEqual(self.nodes[i].get_state(), 'router') @@ -78,11 +75,11 @@ class Cert_5_2_7_REEDSynchronization(unittest.TestCase): self.nodes[DUT_REED].add_whitelist(self.nodes[DUT_ROUTER1].get_addr64(), config.RSSI['LINK_QULITY_1']) self.nodes[DUT_REED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[DUT_REED].get_state(), 'child') # The DUT_REED must not send a coap message here. - reed_messages = self.sniffer.get_messages_sent_by(DUT_REED) + reed_messages = self.simulator.get_messages_sent_by(DUT_REED) msg = reed_messages.does_not_contain_coap_message() assert msg is True, "Error: The DUT_REED sent an Address Solicit Request" @@ -92,8 +89,8 @@ class Cert_5_2_7_REEDSynchronization(unittest.TestCase): command.check_link_request(msg) # 4. DUT_ROUTER1: Verify sent a Link Accept to DUT_REED. - time.sleep(30) - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + self.simulator.go(30) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) flag_link_accept = False while True: msg = dut_messages.next_mle_message(mle.CommandType.LINK_ACCEPT, False) diff --git a/tests/scripts/thread-cert/Cert_5_3_01_LinkLocal.py b/tests/scripts/thread-cert/Cert_5_3_01_LinkLocal.py index 6168fad46..73c316184 100755 --- a/tests/scripts/thread-cert/Cert_5_3_01_LinkLocal.py +++ b/tests/scripts/thread-cert/Cert_5_3_01_LinkLocal.py @@ -39,9 +39,11 @@ DUT_ROUTER1 = 2 class Cert_5_3_1_LinkLocal(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -54,15 +56,16 @@ class Cert_5_3_1_LinkLocal(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[DUT_ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[DUT_ROUTER1].get_state(), 'router') # 2 & 3 diff --git a/tests/scripts/thread-cert/Cert_5_3_02_RealmLocal.py b/tests/scripts/thread-cert/Cert_5_3_02_RealmLocal.py index 49886ae7e..477ff32d3 100755 --- a/tests/scripts/thread-cert/Cert_5_3_02_RealmLocal.py +++ b/tests/scripts/thread-cert/Cert_5_3_02_RealmLocal.py @@ -41,9 +41,11 @@ SED1 = 4 class Cert_5_3_2_RealmLocal(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i == SED1)) + self.nodes[i] = node.Node(i, (i == SED1), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -70,33 +72,28 @@ class Cert_5_3_2_RealmLocal(unittest.TestCase): self.nodes[SED1].enable_whitelist() self.nodes[SED1].set_timeout(3) - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[DUT_ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[DUT_ROUTER2].get_state(), 'router') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') # 2 & 3 @@ -106,31 +103,31 @@ class Cert_5_3_2_RealmLocal(unittest.TestCase): # 4 & 5 self.assertTrue(self.nodes[LEADER].ping('ff03::1', num_responses=2, size=256)) - sed_messages = self.sniffer.get_messages_sent_by(SED1) + sed_messages = self.simulator.get_messages_sent_by(SED1) self.assertFalse(sed_messages.contains_icmp_message()) self.assertTrue(self.nodes[LEADER].ping('ff03::1', num_responses=2)) - sed_messages = self.sniffer.get_messages_sent_by(SED1) + sed_messages = self.simulator.get_messages_sent_by(SED1) self.assertFalse(sed_messages.contains_icmp_message()) # 6 & 7 self.assertTrue(self.nodes[LEADER].ping('ff03::2', num_responses=2, size=256)) - sed_messages = self.sniffer.get_messages_sent_by(SED1) + sed_messages = self.simulator.get_messages_sent_by(SED1) self.assertFalse(sed_messages.contains_icmp_message()) self.assertTrue(self.nodes[LEADER].ping('ff03::2', num_responses=2)) - sed_messages = self.sniffer.get_messages_sent_by(SED1) + sed_messages = self.simulator.get_messages_sent_by(SED1) self.assertFalse(sed_messages.contains_icmp_message()) # 8 self.assertTrue(self.nodes[LEADER].ping(config.REALM_LOCAL_All_THREAD_NODES_MULTICAST_ADDRESS, num_responses=3, size=256)) - time.sleep(2) - sed_messages = self.sniffer.get_messages_sent_by(SED1) + self.simulator.go(2) + sed_messages = self.simulator.get_messages_sent_by(SED1) self.assertTrue(sed_messages.contains_icmp_message()) self.assertTrue(self.nodes[LEADER].ping(config.REALM_LOCAL_All_THREAD_NODES_MULTICAST_ADDRESS, num_responses=3)) - time.sleep(2) - sed_messages = self.sniffer.get_messages_sent_by(SED1) + self.simulator.go(2) + sed_messages = self.simulator.get_messages_sent_by(SED1) self.assertTrue(sed_messages.contains_icmp_message()) if __name__ == '__main__': diff --git a/tests/scripts/thread-cert/Cert_5_3_03_AddressQuery.py b/tests/scripts/thread-cert/Cert_5_3_03_AddressQuery.py index 5ae571a5d..7910a87d3 100755 --- a/tests/scripts/thread-cert/Cert_5_3_03_AddressQuery.py +++ b/tests/scripts/thread-cert/Cert_5_3_03_AddressQuery.py @@ -43,9 +43,11 @@ MED1_TIMEOUT = 3 class Cert_5_3_3_AddressQuery(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i == MED1)) + self.nodes[i] = node.Node(i, (i == MED1), simulator=self.simulator) self.nodes[LEADER].set_panid() self.nodes[LEADER].set_mode('rsdn') @@ -81,28 +83,23 @@ class Cert_5_3_3_AddressQuery(unittest.TestCase): self.nodes[MED1].set_timeout(MED1_TIMEOUT) self.nodes[MED1].enable_whitelist() - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() self.nodes[DUT_ROUTER2].start() self.nodes[ROUTER3].start() self.nodes[MED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.assertEqual(self.nodes[DUT_ROUTER2].get_state(), 'router') @@ -112,42 +109,42 @@ class Cert_5_3_3_AddressQuery(unittest.TestCase): # 2 # Flush the message queue to avoid possible impact on follow-up verification. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) router3_mleid = self.nodes[ROUTER3].get_ip6_address(config.ADDRESS_TYPE.ML_EID) self.assertTrue(self.nodes[MED1].ping(router3_mleid)) # Verify DUT_ROUTER2 sent an Address Query Request to the Realm local address. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) msg = dut_messages.next_coap_message('0.02', '/a/aq') command.check_address_query(msg, self.nodes[DUT_ROUTER2], config.REALM_LOCAL_ALL_ROUTERS_ADDRESS) # 3 # Wait the finish of address resolution traffic triggerred by previous ping. - time.sleep(5) + self.simulator.go(5) # Flush the message queue to avoid possible impact on follow-up verification. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) med1_mleid = self.nodes[MED1].get_ip6_address(config.ADDRESS_TYPE.ML_EID) self.assertTrue(self.nodes[ROUTER1].ping(med1_mleid)) # Verify DUT_ROUTER2 responded with an Address Notification. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) msg = dut_messages.next_coap_message('0.02', '/a/an') command.check_address_notification(msg, self.nodes[DUT_ROUTER2], self.nodes[ROUTER1]) # 4 # Wait the finish of address resolution traffic triggerred by previous ping. - time.sleep(5) + self.simulator.go(5) # Flush the message queue to avoid possible impact on follow-up verification. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) self.assertTrue(self.nodes[MED1].ping(router3_mleid)) # Verify DUT_ROUTER2 didn't send an Address Query Request. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) msg = dut_messages.next_coap_message('0.02', '/a/aq', False) assert msg is None, "The Address Query Request is not expected." @@ -156,30 +153,30 @@ class Cert_5_3_3_AddressQuery(unittest.TestCase): # Wait for the Leader to expire its Router ID. # MAX_NEIGHBOR_AGE + INFINITE_COST_TIMEOUT + ID_REUSE_DELAY + propagation time + transmission time ~ 580s. - time.sleep(580) + self.simulator.go(580) # Flush the message queue to avoid possible impact on follow-up verification. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) self.assertFalse(self.nodes[MED1].ping(router3_mleid)) # Verify DUT_ROUTER2 sent an Address Query Request to the Realm local address. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) msg = dut_messages.next_coap_message('0.02', '/a/aq') command.check_address_query(msg, self.nodes[DUT_ROUTER2], config.REALM_LOCAL_ALL_ROUTERS_ADDRESS) # 6 self.nodes[MED1].stop() - time.sleep(MED1_TIMEOUT) + self.simulator.go(MED1_TIMEOUT) # Flush the message queue to avoid possible impact on follow-up verification. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) self.assertFalse(self.nodes[ROUTER1].ping(med1_mleid)) self.assertFalse(self.nodes[ROUTER1].ping(med1_mleid)) # Verify DUT_ROUTER2 didn't respond with an Address Notification. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) msg = dut_messages.next_coap_message('0.02', '/a/an', False) assert msg is None, "The Address Notification is not expected." diff --git a/tests/scripts/thread-cert/Cert_5_3_04_AddressMapCache.py b/tests/scripts/thread-cert/Cert_5_3_04_AddressMapCache.py index 7c91125a1..e5d888857 100755 --- a/tests/scripts/thread-cert/Cert_5_3_04_AddressMapCache.py +++ b/tests/scripts/thread-cert/Cert_5_3_04_AddressMapCache.py @@ -46,9 +46,11 @@ MTDS = [SED1, ED1, ED2, ED3, ED4] class Cert_5_3_4_AddressMapCache(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,8): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -80,27 +82,22 @@ class Cert_5_3_4_AddressMapCache(unittest.TestCase): self.nodes[ED].add_whitelist(self.nodes[LEADER].get_addr64()) self.nodes[ED].enable_whitelist() - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[DUT_ROUTER1].start() for i in MTDS: self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[DUT_ROUTER1].get_state(), 'router') @@ -108,30 +105,30 @@ class Cert_5_3_4_AddressMapCache(unittest.TestCase): self.assertEqual(self.nodes[i].get_state(), 'child') # This method flushes the message queue so calling this method again will return only the newly logged messages. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) # 2 for ED in [ED1, ED2, ED3, ED4]: ed_mleid = self.nodes[ED].get_ip6_address(config.ADDRESS_TYPE.ML_EID) self.assertTrue(self.nodes[SED1].ping(ed_mleid)) - time.sleep(5) + self.simulator.go(5) # Verify DUT_ROUTER1 generated an Address Query Request to find each node's RLOC. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) msg = dut_messages.next_coap_message('0.02', '/a/aq') command.check_address_query(msg, self.nodes[DUT_ROUTER1], config.REALM_LOCAL_ALL_ROUTERS_ADDRESS) # 3 & 4 # This method flushes the message queue so calling this method again will return only the newly logged messages. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) for ED in [ED1, ED2, ED3, ED4]: ed_mleid = self.nodes[ED].get_ip6_address(config.ADDRESS_TYPE.ML_EID) self.assertTrue(self.nodes[SED1].ping(ed_mleid)) - time.sleep(5) + self.simulator.go(5) # Verify DUT_ROUTER1 didn't generate an Address Query Request. - dut_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER1) + dut_messages = self.simulator.get_messages_sent_by(DUT_ROUTER1) msg = dut_messages.next_coap_message('0.02', '/a/aq', False) assert msg is None, "Error: The DUT sent an unexpected Address Query Request" diff --git a/tests/scripts/thread-cert/Cert_5_3_05_RoutingLinkQuality.py b/tests/scripts/thread-cert/Cert_5_3_05_RoutingLinkQuality.py index d4e721a0f..587eb554e 100755 --- a/tests/scripts/thread-cert/Cert_5_3_05_RoutingLinkQuality.py +++ b/tests/scripts/thread-cert/Cert_5_3_05_RoutingLinkQuality.py @@ -41,9 +41,11 @@ ROUTER3 = 4 class Cert_5_3_5_RoutingLinkQuality(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -72,26 +74,21 @@ class Cert_5_3_5_RoutingLinkQuality(unittest.TestCase): self.nodes[ROUTER3].enable_whitelist() self.nodes[ROUTER3].set_router_selection_jitter(1) - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') for router in range(DUT_ROUTER1, ROUTER3 + 1): self.nodes[router].start() - time.sleep(10) + self.simulator.go(10) for router in range(DUT_ROUTER1, ROUTER3 + 1): self.assertEqual(self.nodes[router].get_state(), 'router') @@ -102,38 +99,38 @@ class Cert_5_3_5_RoutingLinkQuality(unittest.TestCase): # Verify the ICMPv6 Echo Request took the least cost path. self.assertTrue(self.nodes[ROUTER3].ping(leader_rloc)) path = [ROUTER3, DUT_ROUTER1, LEADER] - command.check_icmp_path(self.sniffer, path, self.nodes) + command.check_icmp_path(self.simulator, path, self.nodes) # 4 & 5 self.nodes[LEADER].add_whitelist(self.nodes[DUT_ROUTER1].get_addr64(), config.RSSI['LINK_QULITY_1']) self.nodes[DUT_ROUTER1].add_whitelist(self.nodes[LEADER].get_addr64(), config.RSSI['LINK_QULITY_1']) - time.sleep(70) + self.simulator.go(70) # Verify the ICMPv6 Echo Request took the longer path because it cost less. self.assertTrue(self.nodes[ROUTER3].ping(leader_rloc)) path = [ROUTER3, DUT_ROUTER1, ROUTER2, LEADER] - command.check_icmp_path(self.sniffer, path, self.nodes) + command.check_icmp_path(self.simulator, path, self.nodes) # 6 & 7 self.nodes[LEADER].add_whitelist(self.nodes[DUT_ROUTER1].get_addr64(), config.RSSI['LINK_QULITY_2']) self.nodes[DUT_ROUTER1].add_whitelist(self.nodes[LEADER].get_addr64(), config.RSSI['LINK_QULITY_2']) - time.sleep(70) + self.simulator.go(70) # Verify the direct neighbor would be prioritized when there are two paths with the same cost. self.assertTrue(self.nodes[ROUTER3].ping(leader_rloc)) path = [ROUTER3, DUT_ROUTER1, LEADER] - command.check_icmp_path(self.sniffer, path, self.nodes) + command.check_icmp_path(self.simulator, path, self.nodes) # 8 & 9 self.nodes[LEADER].add_whitelist(self.nodes[DUT_ROUTER1].get_addr64(), config.RSSI['LINK_QULITY_0']) self.nodes[DUT_ROUTER1].add_whitelist(self.nodes[LEADER].get_addr64(), config.RSSI['LINK_QULITY_0']) - time.sleep(70) + self.simulator.go(70) # Verify the ICMPv6 Echo Request took the longer path. leader_rloc = self.nodes[LEADER].get_ip6_address(config.ADDRESS_TYPE.RLOC) self.assertTrue(self.nodes[ROUTER3].ping(leader_rloc)) path = [ROUTER3, DUT_ROUTER1, ROUTER2, LEADER] - command.check_icmp_path(self.sniffer, path, self.nodes) + command.check_icmp_path(self.simulator, path, self.nodes) if __name__ == '__main__': unittest.main() diff --git a/tests/scripts/thread-cert/Cert_5_3_06_RouterIdMask.py b/tests/scripts/thread-cert/Cert_5_3_06_RouterIdMask.py index ec511b909..1d6c68ade 100755 --- a/tests/scripts/thread-cert/Cert_5_3_06_RouterIdMask.py +++ b/tests/scripts/thread-cert/Cert_5_3_06_RouterIdMask.py @@ -41,9 +41,11 @@ ROUTER2 = 3 class Cert_5_3_6_RouterIdMask(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[DUT_LEADER].set_panid(0xface) self.nodes[DUT_LEADER].set_mode('rsdn') @@ -61,39 +63,34 @@ class Cert_5_3_6_RouterIdMask(unittest.TestCase): self.nodes[ROUTER2].set_mode('rsdn') self._setUpRouter2() - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def _setUpRouter2(self): self.nodes[ROUTER2].add_whitelist(self.nodes[ROUTER1].get_addr64()) self.nodes[ROUTER2].enable_whitelist() self.nodes[ROUTER2].set_router_selection_jitter(1) def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 self.nodes[DUT_LEADER].start() - self.nodes[DUT_LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[DUT_LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') router2_id = self.nodes[ROUTER2].get_router_id() # Wait DUT_LEADER to establish routing to ROUTER2 via ROUTER1's MLE advertisement. - time.sleep(config.MAX_ADVERTISEMENT_INTERVAL) + self.simulator.go(config.MAX_ADVERTISEMENT_INTERVAL) # 2 self.nodes[ROUTER2].reset() @@ -101,15 +98,15 @@ class Cert_5_3_6_RouterIdMask(unittest.TestCase): # 3 & 4 # Flush the message queue to avoid possible impact on follow-up verification. - dut_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + dut_messages = self.simulator.get_messages_sent_by(DUT_LEADER) # Verify the cost from DUT_LEADER to ROUTER2 goes to infinity in 12 mins. routing_cost = 1 for i in range(0, 24): - time.sleep(30) + self.simulator.go(30) print("%ss" %((i + 1) * 30)) - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.last_mle_message(mle.CommandType.ADVERTISEMENT, False) if msg == None: continue @@ -121,37 +118,37 @@ class Cert_5_3_6_RouterIdMask(unittest.TestCase): break self.assertTrue(routing_cost == 0) - time.sleep(config.INFINITE_COST_TIMEOUT + config.MAX_ADVERTISEMENT_INTERVAL) - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + self.simulator.go(config.INFINITE_COST_TIMEOUT + config.MAX_ADVERTISEMENT_INTERVAL) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.last_mle_message(mle.CommandType.ADVERTISEMENT) self.assertFalse(command.check_id_set(msg, router2_id)) # 5 # Flush the message queue to avoid possible impact on follow-up verification. - dut_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + dut_messages = self.simulator.get_messages_sent_by(DUT_LEADER) self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') - time.sleep(config.MAX_ADVERTISEMENT_INTERVAL) - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + self.simulator.go(config.MAX_ADVERTISEMENT_INTERVAL) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) leader_messages.last_mle_message(mle.CommandType.ADVERTISEMENT) # 6 - self.nodes[ROUTER1].stop() - self.nodes[ROUTER2].stop() + self.nodes[ROUTER1].reset() + self.nodes[ROUTER2].reset() router1_id = self.nodes[ROUTER1].get_router_id() router2_id = self.nodes[ROUTER2].get_router_id() - time.sleep(config.MAX_NEIGHBOR_AGE + config.MAX_ADVERTISEMENT_INTERVAL) - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + self.simulator.go(config.MAX_NEIGHBOR_AGE + config.MAX_ADVERTISEMENT_INTERVAL) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.last_mle_message(mle.CommandType.ADVERTISEMENT) self.assertEqual(command.get_routing_cost(msg, router1_id), 0) - time.sleep(config.INFINITE_COST_TIMEOUT + config.MAX_ADVERTISEMENT_INTERVAL) - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + self.simulator.go(config.INFINITE_COST_TIMEOUT + config.MAX_ADVERTISEMENT_INTERVAL) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.last_mle_message(mle.CommandType.ADVERTISEMENT) self.assertFalse(command.check_id_set(msg, router1_id)) self.assertFalse(command.check_id_set(msg, router2_id)) diff --git a/tests/scripts/thread-cert/Cert_5_3_06b_RouterIdMask.py b/tests/scripts/thread-cert/Cert_5_3_06b_RouterIdMask.py index a6b9cbd94..b7f0aaa38 100755 --- a/tests/scripts/thread-cert/Cert_5_3_06b_RouterIdMask.py +++ b/tests/scripts/thread-cert/Cert_5_3_06b_RouterIdMask.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -38,9 +39,11 @@ ROUTER2 = 3 class Cert_5_3_6_RouterIdMask(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -64,24 +67,25 @@ class Cert_5_3_6_RouterIdMask(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER1].stop() self.nodes[ROUTER2].stop() - time.sleep(300) + self.simulator.go(300) if __name__ == '__main__': unittest.main() diff --git a/tests/scripts/thread-cert/Cert_5_3_07_DuplicateAddress.py b/tests/scripts/thread-cert/Cert_5_3_07_DuplicateAddress.py index d09591b22..58fd9831a 100755 --- a/tests/scripts/thread-cert/Cert_5_3_07_DuplicateAddress.py +++ b/tests/scripts/thread-cert/Cert_5_3_07_DuplicateAddress.py @@ -46,9 +46,11 @@ MTDS = [MED1, SED1, MED3] class Cert_5_3_7_DuplicateAddress(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,7): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[DUT_LEADER].set_panid(0xface) self.nodes[DUT_LEADER].set_mode('rsdn') @@ -86,27 +88,22 @@ class Cert_5_3_7_DuplicateAddress(unittest.TestCase): self.nodes[MED3].add_whitelist(self.nodes[DUT_LEADER].get_addr64()) self.nodes[MED3].enable_whitelist() - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 self.nodes[DUT_LEADER].start() - self.nodes[DUT_LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[DUT_LEADER].get_state(), 'leader') for i in range(ROUTER1, MED3 + 1): self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) for i in [ROUTER1, ROUTER2]: self.assertEqual(self.nodes[i].get_state(), 'router') @@ -115,7 +112,7 @@ class Cert_5_3_7_DuplicateAddress(unittest.TestCase): self.assertEqual(self.nodes[i].get_state(), 'child') # 2 - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) command.check_mle_advertisement(msg) @@ -126,23 +123,23 @@ class Cert_5_3_7_DuplicateAddress(unittest.TestCase): self.nodes[MED1].add_ipaddr('2001:2:0:1::1234') self.nodes[SED1].add_ipaddr('2001:2:0:1::1234') - time.sleep(5) + self.simulator.go(5) # 4 # Flush the message queue to avoid possible impact on follow-up verification. - self.sniffer.get_messages_sent_by(DUT_LEADER) + self.simulator.get_messages_sent_by(DUT_LEADER) self.nodes[MED3].ping('2001:2:0:1::1234') # Verify DUT_LEADER sent an Address Query Request to the Realm local address. - dut_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + dut_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = dut_messages.next_coap_message('0.02', '/a/aq') command.check_address_query(msg, self.nodes[DUT_LEADER], config.REALM_LOCAL_ALL_ROUTERS_ADDRESS) # 5 & 6 # Verify DUT_LEADER sent an Address Error Notification to the Realm local address. - time.sleep(5) - dut_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + self.simulator.go(5) + dut_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = dut_messages.next_coap_message('0.02', '/a/ae') command.check_address_error_notification(msg, self.nodes[DUT_LEADER], config.REALM_LOCAL_ALL_ROUTERS_ADDRESS) diff --git a/tests/scripts/thread-cert/Cert_5_3_08_ChildAddressSet.py b/tests/scripts/thread-cert/Cert_5_3_08_ChildAddressSet.py index 1b36db570..041665359 100755 --- a/tests/scripts/thread-cert/Cert_5_3_08_ChildAddressSet.py +++ b/tests/scripts/thread-cert/Cert_5_3_08_ChildAddressSet.py @@ -45,10 +45,11 @@ MTDS = [MED1, MED2] class Cert_5_3_8_ChildAddressSet(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() self.nodes = {} for i in range(1, 5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[DUT_LEADER].set_panid(0xface) self.nodes[DUT_LEADER].set_mode('rsdn') @@ -69,24 +70,19 @@ class Cert_5_3_8_ChildAddressSet(unittest.TestCase): self.nodes[i].add_whitelist(self.nodes[DUT_LEADER].get_addr64()) self.nodes[i].enable_whitelist() - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[DUT_LEADER].start() - self.nodes[DUT_LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[DUT_LEADER].get_state(), 'leader') self.nodes[BR].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[BR].get_state(), 'router') # 1 BR: Configure BR to be a DHCPv6 server @@ -96,19 +92,19 @@ class Cert_5_3_8_ChildAddressSet(unittest.TestCase): self.nodes[BR].register_netdata() # Set lowpan context of sniffer - self.sniffer.set_lowpan_context(1, '2001::/64') - self.sniffer.set_lowpan_context(2, '2002::/64') - self.sniffer.set_lowpan_context(3, '2003::/64') + self.simulator.set_lowpan_context(1, '2001::/64') + self.simulator.set_lowpan_context(2, '2002::/64') + self.simulator.set_lowpan_context(3, '2003::/64') # 2 DUT_LEADER: Verify LEADER sent an Advertisement - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) command.check_mle_advertisement(msg) # 3 MED1, MED2: MED1 and MED2 attach to DUT_LEADER for i in MTDS: self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[i].get_state(), 'child') # 4 MED1: MED1 send an ICMPv6 Echo Request to the MED2 ML-EID @@ -117,15 +113,15 @@ class Cert_5_3_8_ChildAddressSet(unittest.TestCase): self.assertTrue(self.nodes[MED1].ping(med2_ml_eid)) # Verify DUT_LEADER didn't generate an Address Query Request - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.next_coap_message('0.02', '/a/aq', False) assert msg is None, "Error: The DUT_LEADER sent an unexpected Address Query Request" # Wait for sniffer got packets - time.sleep(1) + self.simulator.go(1) # Verify MED2 sent an ICMPv6 Echo Reply - med2_messages = self.sniffer.get_messages_sent_by(MED2) + med2_messages = self.simulator.get_messages_sent_by(MED2) msg = med2_messages.get_icmp_message(ipv6.ICMP_ECHO_RESPONSE) assert msg is not None, "Error: The MED2 didn't send ICMPv6 Echo Reply to MED1" @@ -135,15 +131,15 @@ class Cert_5_3_8_ChildAddressSet(unittest.TestCase): self.assertTrue(self.nodes[MED1].ping(addr)) # Verify DUT_LEADER didn't generate an Address Query Request - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.next_coap_message('0.02', '/a/aq', False) assert msg is None, "Error: The DUT_LEADER sent an unexpected Address Query Request" # Wait for sniffer got packets - time.sleep(1) + self.simulator.go(1) # Verify MED2 sent an ICMPv6 Echo Reply - med2_messages = self.sniffer.get_messages_sent_by(MED2) + med2_messages = self.simulator.get_messages_sent_by(MED2) msg = med2_messages.get_icmp_message(ipv6.ICMP_ECHO_RESPONSE) assert msg is not None, "Error: The MED2 didn't send ICMPv6 Echo Reply to MED1" @@ -153,15 +149,15 @@ class Cert_5_3_8_ChildAddressSet(unittest.TestCase): self.assertTrue(self.nodes[MED1].ping(addr)) # Verify DUT_LEADER didn't generate an Address Query Request - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.next_coap_message('0.02', '/a/aq', False) assert msg is None, "Error: The DUT_LEADER sent an unexpected Address Query Request" # Wait for sniffer got packets - time.sleep(1) + self.simulator.go(1) # Verify MED2 sent an ICMPv6 Echo Reply - med2_messages = self.sniffer.get_messages_sent_by(MED2) + med2_messages = self.simulator.get_messages_sent_by(MED2) msg = med2_messages.get_icmp_message(ipv6.ICMP_ECHO_RESPONSE) assert msg is not None, "Error: The MED2 didn't send ICMPv6 Echo Reply to MED1" @@ -171,15 +167,15 @@ class Cert_5_3_8_ChildAddressSet(unittest.TestCase): self.assertTrue(self.nodes[MED1].ping(addr)) # Verify DUT_LEADER didn't generate an Address Query Request - leader_messages = self.sniffer.get_messages_sent_by(DUT_LEADER) + leader_messages = self.simulator.get_messages_sent_by(DUT_LEADER) msg = leader_messages.next_coap_message('0.02', '/a/aq', False) assert msg is None, "Error: The DUT_LEADER sent an unexpected Address Query Request" # Wait for sniffer got packets - time.sleep(1) + self.simulator.go(1) # Verify MED2 sent an ICMPv6 Echo Reply - med2_messages = self.sniffer.get_messages_sent_by(MED2) + med2_messages = self.simulator.get_messages_sent_by(MED2) msg = med2_messages.get_icmp_message(ipv6.ICMP_ECHO_RESPONSE) assert msg is not None, "Error: The MED2 didn't send ICMPv6 Echo Reply to MED1" diff --git a/tests/scripts/thread-cert/Cert_5_3_09_AddressQuery.py b/tests/scripts/thread-cert/Cert_5_3_09_AddressQuery.py index 0534b6bac..32695ad51 100755 --- a/tests/scripts/thread-cert/Cert_5_3_09_AddressQuery.py +++ b/tests/scripts/thread-cert/Cert_5_3_09_AddressQuery.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -40,9 +41,11 @@ SED1 = 5 class Cert_5_3_09_AddressQuery(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i == SED1)) + self.nodes[i] = node.Node(i, (i == SED1), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -81,34 +84,36 @@ class Cert_5_3_09_AddressQuery(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[LEADER].add_prefix('2001:2:0:1::/64', 'pdros') self.nodes[LEADER].add_prefix('2001:2:0:2::/64', 'pdro') self.nodes[LEADER].register_netdata() + self.simulator.go(5) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER3].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER3].get_state(), 'router') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') # wait for sed got replied - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[ROUTER3].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) @@ -130,7 +135,7 @@ class Cert_5_3_09_AddressQuery(unittest.TestCase): self.assertTrue(self.nodes[SED1].ping(addr)) self.nodes[ROUTER3].stop() - time.sleep(300) + self.simulator.go(300) addrs = self.nodes[ROUTER3].get_addrs() for addr in addrs: @@ -138,7 +143,7 @@ class Cert_5_3_09_AddressQuery(unittest.TestCase): self.assertFalse(self.nodes[SED1].ping(addr)) self.nodes[SED1].stop() - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[SED1].get_addrs() for addr in addrs: diff --git a/tests/scripts/thread-cert/Cert_5_3_10_AddressQuery.py b/tests/scripts/thread-cert/Cert_5_3_10_AddressQuery.py index dda0d9cc7..c23c391a1 100755 --- a/tests/scripts/thread-cert/Cert_5_3_10_AddressQuery.py +++ b/tests/scripts/thread-cert/Cert_5_3_10_AddressQuery.py @@ -46,9 +46,11 @@ MED1 = 5 class Cert_5_3_10_AddressQuery(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1, 6): - self.nodes[i] = node.Node(i, (i == MED1)) + self.nodes[i] = node.Node(i, (i == MED1), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -83,26 +85,21 @@ class Cert_5_3_10_AddressQuery(unittest.TestCase): self.nodes[MED1].add_whitelist(self.nodes[DUT_ROUTER2].get_addr64()) self.nodes[MED1].enable_whitelist() - self.sniffer = config.create_default_thread_sniffer() - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): # 1 & 2 # Build and verify the topology self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[BR].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[BR].get_state(), 'router') # Configure two On-Mesh Prefixes on the BR @@ -111,19 +108,19 @@ class Cert_5_3_10_AddressQuery(unittest.TestCase): self.nodes[BR].register_netdata() # Set lowpan context of sniffer - self.sniffer.set_lowpan_context(1, '2003::/64') - self.sniffer.set_lowpan_context(2, '2004::/64') + self.simulator.set_lowpan_context(1, '2003::/64') + self.simulator.set_lowpan_context(2, '2004::/64') self.nodes[DUT_ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[DUT_ROUTER2].get_state(), 'router') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[MED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[MED1].get_state(), 'child') # 3 MED1: MED1 sends an ICMPv6 Echo Request to Router1 using GUA 2003:: address @@ -132,10 +129,10 @@ class Cert_5_3_10_AddressQuery(unittest.TestCase): self.assertTrue(self.nodes[MED1].ping(router1_addr)) # Wait for sniffer got Address Notification messages - time.sleep(1) + self.simulator.go(1) # Verify DUT_ROUTER2 sent an Address Query Request - dut_router2_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_router2_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) msg = dut_router2_messages.next_coap_message('0.02', '/a/aq') command.check_address_query(msg, self.nodes[DUT_ROUTER2], config.REALM_LOCAL_ALL_ROUTERS_ADDRESS) @@ -150,10 +147,10 @@ class Cert_5_3_10_AddressQuery(unittest.TestCase): self.assertTrue(self.nodes[BR].ping(med1_addr)) # Wait for sniffer got Address Notification messages - time.sleep(1) + self.simulator.go(1) # Verify DUT_ROUTER2 sent an Address Notification message - dut_router2_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_router2_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) msg = dut_router2_messages.next_coap_message('0.02', '/a/an') command.check_address_notification(msg, self.nodes[DUT_ROUTER2], self.nodes[BR]) @@ -163,10 +160,10 @@ class Cert_5_3_10_AddressQuery(unittest.TestCase): self.assertTrue(self.nodes[MED1].ping(addr)) # Wait for sniffer got ICMPv6 Echo Reply - time.sleep(1) + self.simulator.go(1) # Verify DUT_ROUTER2 didn't generate an Address Query Request - dut_router2_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_router2_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) dut_router2_messages_temp = copy.deepcopy(dut_router2_messages) msg = dut_router2_messages.next_coap_message('0.02', '/a/aq', False) assert msg is None, "Error: The DUT_ROUTER2 sent an unexpected Address Query Request" @@ -179,7 +176,7 @@ class Cert_5_3_10_AddressQuery(unittest.TestCase): # 6 DUT_ROUTER2: Power off ROUTER1 and wait 580 seconds to allow the LEADER to expire its Router ID router1_id = self.nodes[ROUTER1].get_router_id() self.nodes[ROUTER1].stop() - time.sleep(580) + self.simulator.go(580) # Send an ICMPv6 Echo Request from MED1 to ROUTER1 GUA 2003:: address self.assertFalse(self.nodes[MED1].ping(router1_addr)) @@ -188,20 +185,20 @@ class Cert_5_3_10_AddressQuery(unittest.TestCase): command.check_router_id_cached(self.nodes[DUT_ROUTER2], router1_id, False) # Verify DUT_ROUTER2 sent an Address Query Request - dut_router2_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_router2_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) msg = dut_router2_messages.next_coap_message('0.02', '/a/aq') msg.assertSentToDestinationAddress(config.REALM_LOCAL_ALL_ROUTERS_ADDRESS) # 7 MED1: Power off MED1 and wait to allow DUT_ROUTER2 to timeout the child self.nodes[MED1].stop() - time.sleep(config.MLE_END_DEVICE_TIMEOUT) + self.simulator.go(config.MLE_END_DEVICE_TIMEOUT) # BR sends two ICMPv6 Echo Requests to MED1 GUA 2003:: address self.assertFalse(self.nodes[BR].ping(med1_addr)) self.assertFalse(self.nodes[BR].ping(med1_addr)) # Verify DUT_ROUTER2 didn't generate an Address Notification message - dut_router2_messages = self.sniffer.get_messages_sent_by(DUT_ROUTER2) + dut_router2_messages = self.simulator.get_messages_sent_by(DUT_ROUTER2) msg = dut_router2_messages.next_coap_message('0.02', '/a/an/', False) assert msg is None, "Error: The DUT_ROUTER2 sent an unexpected Address Notification message" diff --git a/tests/scripts/thread-cert/Cert_5_5_01_LeaderReset.py b/tests/scripts/thread-cert/Cert_5_5_01_LeaderReset.py index f41947197..ddcb586e8 100755 --- a/tests/scripts/thread-cert/Cert_5_5_01_LeaderReset.py +++ b/tests/scripts/thread-cert/Cert_5_5_01_LeaderReset.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ROUTER = 2 class Cert_5_5_1_LeaderReset(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -59,24 +62,25 @@ class Cert_5_5_1_LeaderReset(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') rloc16 = self.nodes[LEADER].get_addr16() self.nodes[LEADER].reset(); self._setUpLeader() - time.sleep(5) + self.simulator.go(5) self.nodes[LEADER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.assertEqual(self.nodes[LEADER].get_addr16(), rloc16) diff --git a/tests/scripts/thread-cert/Cert_5_5_02_LeaderReboot.py b/tests/scripts/thread-cert/Cert_5_5_02_LeaderReboot.py index 1a88cffe9..403edc322 100755 --- a/tests/scripts/thread-cert/Cert_5_5_02_LeaderReboot.py +++ b/tests/scripts/thread-cert/Cert_5_5_02_LeaderReboot.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -38,9 +39,11 @@ ED = 3 class Cert_5_5_2_LeaderReboot(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -67,27 +70,28 @@ class Cert_5_5_2_LeaderReboot(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[LEADER].reset() self._setUpLeader() - time.sleep(140) + self.simulator.go(140) self.assertEqual(self.nodes[ROUTER].get_state(), 'leader') self.nodes[LEADER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'router') addrs = self.nodes[ED].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_5_5_03_SplitMergeChildren.py b/tests/scripts/thread-cert/Cert_5_5_03_SplitMergeChildren.py index c8cb18c50..bad45596a 100755 --- a/tests/scripts/thread-cert/Cert_5_5_03_SplitMergeChildren.py +++ b/tests/scripts/thread-cert/Cert_5_5_03_SplitMergeChildren.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -43,9 +44,11 @@ MTDS = [ED1, ED2, ED3] class Cert_5_5_3_SplitMergeChildren(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,7): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -91,30 +94,31 @@ class Cert_5_5_3_SplitMergeChildren(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[ED2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED2].get_state(), 'child') self.nodes[ED3].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED3].get_state(), 'child') self.nodes[LEADER].reset() @@ -123,15 +127,15 @@ class Cert_5_5_3_SplitMergeChildren(unittest.TestCase): self.nodes[ED1].add_whitelist(self.nodes[ROUTER1].get_addr64()) self.nodes[ROUTER1].add_whitelist(self.nodes[ED1].get_addr64()) - time.sleep(140) + self.simulator.go(140) self.assertEqual(self.nodes[ROUTER1].get_state(), 'leader') self.assertEqual(self.nodes[ROUTER2].get_state(), 'leader') self.nodes[LEADER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'router') - time.sleep(30) + self.simulator.go(30) addrs = self.nodes[ED1].get_addrs() for addr in addrs: diff --git a/tests/scripts/thread-cert/Cert_5_5_04_SplitMergeRouters.py b/tests/scripts/thread-cert/Cert_5_5_04_SplitMergeRouters.py index 496d5417d..80d43d3f9 100755 --- a/tests/scripts/thread-cert/Cert_5_5_04_SplitMergeRouters.py +++ b/tests/scripts/thread-cert/Cert_5_5_04_SplitMergeRouters.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -40,9 +41,11 @@ ROUTER4 = 5 class Cert_5_5_4_SplitMergeRouters(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -84,34 +87,35 @@ class Cert_5_5_4_SplitMergeRouters(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER3].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER3].get_state(), 'router') self.nodes[ROUTER4].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER4].get_state(), 'router') self.nodes[LEADER].reset() self._setUpLeader() - time.sleep(150) + self.simulator.go(150) self.nodes[LEADER].start() - time.sleep(50) + self.simulator.go(50) self.assertEqual(self.nodes[LEADER].get_state(), 'router') diff --git a/tests/scripts/thread-cert/Cert_5_5_05_SplitMergeREED.py b/tests/scripts/thread-cert/Cert_5_5_05_SplitMergeREED.py index 5884be6b3..b8e5bcd8a 100755 --- a/tests/scripts/thread-cert/Cert_5_5_05_SplitMergeREED.py +++ b/tests/scripts/thread-cert/Cert_5_5_05_SplitMergeREED.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ REED1 = 17 class Cert_5_5_5_SplitMergeREED(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,18): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -76,30 +79,31 @@ class Cert_5_5_5_SplitMergeREED(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') for i in range(ROUTER2, ROUTER15+1): self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[i].get_state(), 'router') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[REED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED1].get_state(), 'child') self.nodes[ROUTER1].add_whitelist(self.nodes[REED1].get_addr64()) self.nodes[REED1].add_whitelist(self.nodes[ROUTER1].get_addr64()) self.nodes[ROUTER3].stop() - time.sleep(140) + self.simulator.go(140) self.assertEqual(self.nodes[ROUTER1].get_state(), 'child') self.assertEqual(self.nodes[REED1].get_state(), 'router') diff --git a/tests/scripts/thread-cert/Cert_5_5_07_SplitMergeThreeWay.py b/tests/scripts/thread-cert/Cert_5_5_07_SplitMergeThreeWay.py index fee1e8ead..ec68df2ef 100755 --- a/tests/scripts/thread-cert/Cert_5_5_07_SplitMergeThreeWay.py +++ b/tests/scripts/thread-cert/Cert_5_5_07_SplitMergeThreeWay.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER1 = 1 @@ -39,9 +40,11 @@ ROUTER3 = 4 class Cert_5_5_7_SplitMergeThreeWay(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER1].set_panid(0xface) self.nodes[LEADER1].set_mode('rsdn') @@ -76,30 +79,31 @@ class Cert_5_5_7_SplitMergeThreeWay(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER1].start() - self.nodes[LEADER1].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER1].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER3].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER3].get_state(), 'router') self.nodes[LEADER1].reset() self._setUpLeader1() - time.sleep(140) + self.simulator.go(140) self.nodes[LEADER1].start() - time.sleep(30) + self.simulator.go(30) addrs = self.nodes[LEADER1].get_addrs() for addr in addrs: diff --git a/tests/scripts/thread-cert/Cert_5_5_08_SplitRoutersLostLeader.py b/tests/scripts/thread-cert/Cert_5_5_08_SplitRoutersLostLeader.py index b51c4f57c..c8dcee177 100755 --- a/tests/scripts/thread-cert/Cert_5_5_08_SplitRoutersLostLeader.py +++ b/tests/scripts/thread-cert/Cert_5_5_08_SplitRoutersLostLeader.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER1 = 1 @@ -40,9 +41,11 @@ ED1 = 5 class Cert_5_5_8_SplitRoutersLostLeader(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i == ED1)) + self.nodes[i] = node.Node(i, (i == ED1), simulator=self.simulator) self.nodes[LEADER1].set_panid(0xface) self.nodes[LEADER1].set_mode('rsdn') @@ -88,23 +91,23 @@ class Cert_5_5_8_SplitRoutersLostLeader(unittest.TestCase): def test(self): self.nodes[LEADER1].start() - self.nodes[LEADER1].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER1].get_state(), 'leader') self.nodes[ROUTER3].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER3].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') addrs = self.nodes[ED1].get_addrs() @@ -114,10 +117,10 @@ class Cert_5_5_8_SplitRoutersLostLeader(unittest.TestCase): self.nodes[ROUTER3].reset() self._setUpRouter3() - time.sleep(140) + self.simulator.go(140) self.nodes[ROUTER3].start() - time.sleep(60) + self.simulator.go(60) addrs = self.nodes[ED1].get_addrs() for addr in addrs: diff --git a/tests/scripts/thread-cert/Cert_5_6_01_NetworkDataRegisterBeforeAttachLeader.py b/tests/scripts/thread-cert/Cert_5_6_01_NetworkDataRegisterBeforeAttachLeader.py index 5a23f3e95..66ac8a508 100755 --- a/tests/scripts/thread-cert/Cert_5_6_01_NetworkDataRegisterBeforeAttachLeader.py +++ b/tests/scripts/thread-cert/Cert_5_6_01_NetworkDataRegisterBeforeAttachLeader.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [ED1, SED1] class Cert_5_6_1_NetworkDataLeaderAsBr(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,10 +76,11 @@ class Cert_5_6_1_NetworkDataLeaderAsBr(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[LEADER].add_prefix('2001:2:0:1::/64', 'paros') @@ -84,15 +88,15 @@ class Cert_5_6_1_NetworkDataLeaderAsBr(unittest.TestCase): self.nodes[LEADER].register_netdata() self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') addrs = self.nodes[ED1].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_5_6_02_NetworkDataRegisterBeforeAttachRouter.py b/tests/scripts/thread-cert/Cert_5_6_02_NetworkDataRegisterBeforeAttachRouter.py index 55cb631f7..374f5664a 100755 --- a/tests/scripts/thread-cert/Cert_5_6_02_NetworkDataRegisterBeforeAttachRouter.py +++ b/tests/scripts/thread-cert/Cert_5_6_02_NetworkDataRegisterBeforeAttachRouter.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [ED1, SED1] class Cert_5_6_2_NetworkDataRouterAsBr(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,14 +76,15 @@ class Cert_5_6_2_NetworkDataRouterAsBr(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ROUTER].add_prefix('2001:2:0:1::/64', 'paros') @@ -88,11 +92,11 @@ class Cert_5_6_2_NetworkDataRouterAsBr(unittest.TestCase): self.nodes[ROUTER].register_netdata() self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') addrs = self.nodes[ED1].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_5_6_03_NetworkDataRegisterAfterAttachLeader.py b/tests/scripts/thread-cert/Cert_5_6_03_NetworkDataRegisterAfterAttachLeader.py index e05c6fb81..9a4a0b61b 100755 --- a/tests/scripts/thread-cert/Cert_5_6_03_NetworkDataRegisterAfterAttachLeader.py +++ b/tests/scripts/thread-cert/Cert_5_6_03_NetworkDataRegisterAfterAttachLeader.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [ED1, SED1] class Cert_5_6_3_NetworkDataRegisterAfterAttachLeader(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,29 +76,30 @@ class Cert_5_6_3_NetworkDataRegisterAfterAttachLeader(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') self.nodes[LEADER].add_prefix('2001:2:0:1::/64', 'paros') self.nodes[LEADER].add_prefix('2001:2:0:2::/64', 'paro') self.nodes[LEADER].register_netdata() - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[ED1].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_5_6_04_NetworkDataRegisterAfterAttachRouter.py b/tests/scripts/thread-cert/Cert_5_6_04_NetworkDataRegisterAfterAttachRouter.py index 622ac2d82..ca7ec4ebd 100755 --- a/tests/scripts/thread-cert/Cert_5_6_04_NetworkDataRegisterAfterAttachRouter.py +++ b/tests/scripts/thread-cert/Cert_5_6_04_NetworkDataRegisterAfterAttachRouter.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [ED1, SED1] class Cert_5_6_4_NetworkDataRegisterAfterAttachRouter(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,29 +76,30 @@ class Cert_5_6_4_NetworkDataRegisterAfterAttachRouter(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') self.nodes[ROUTER].add_prefix('2001:2:0:1::/64', 'paros') self.nodes[ROUTER].add_prefix('2001:2:0:2::/64', 'paro') self.nodes[ROUTER].register_netdata() - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[ED1].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_5_6_05_NetworkDataRegisterAfterAttachRouter.py b/tests/scripts/thread-cert/Cert_5_6_05_NetworkDataRegisterAfterAttachRouter.py index dcdae9dac..e40ed5681 100755 --- a/tests/scripts/thread-cert/Cert_5_6_05_NetworkDataRegisterAfterAttachRouter.py +++ b/tests/scripts/thread-cert/Cert_5_6_05_NetworkDataRegisterAfterAttachRouter.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [ED1, SED1] class Cert_5_6_5_NetworkDataRegisterAfterAttachRouter(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,29 +76,30 @@ class Cert_5_6_5_NetworkDataRegisterAfterAttachRouter(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') self.nodes[ROUTER].add_prefix('2001:2:0:1::/64', 'paros') self.nodes[ROUTER].add_prefix('2001:2:0:2::/64', 'paro') self.nodes[ROUTER].register_netdata() - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[ED1].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) @@ -114,7 +118,7 @@ class Cert_5_6_5_NetworkDataRegisterAfterAttachRouter(unittest.TestCase): self.nodes[ROUTER].add_prefix('2001:2:0:3::/64', 'pacs') self.nodes[ROUTER].register_netdata() - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[ED1].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_5_6_06_NetworkDataExpiration.py b/tests/scripts/thread-cert/Cert_5_6_06_NetworkDataExpiration.py index 7d2557124..2b17c0186 100755 --- a/tests/scripts/thread-cert/Cert_5_6_06_NetworkDataExpiration.py +++ b/tests/scripts/thread-cert/Cert_5_6_06_NetworkDataExpiration.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [ED1, SED1] class Cert_5_6_6_NetworkDataExpiration(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,29 +76,30 @@ class Cert_5_6_6_NetworkDataExpiration(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') self.nodes[ROUTER].add_prefix('2001:2:0:1::/64', 'paros') self.nodes[ROUTER].add_prefix('2001:2:0:2::/64', 'paro') self.nodes[ROUTER].register_netdata() - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[ED1].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) @@ -114,7 +118,7 @@ class Cert_5_6_6_NetworkDataExpiration(unittest.TestCase): self.nodes[ROUTER].add_prefix('2001:2:0:3::/64', 'pacs') self.nodes[ROUTER].register_netdata() - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[ED1].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) @@ -134,7 +138,7 @@ class Cert_5_6_6_NetworkDataExpiration(unittest.TestCase): self.nodes[ROUTER].remove_prefix('2001:2:0:3::/64') self.nodes[ROUTER].register_netdata() - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[ED1].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_5_6_07_NetworkDataRequestREED.py b/tests/scripts/thread-cert/Cert_5_6_07_NetworkDataRequestREED.py index 4abc47484..aa09d9774 100755 --- a/tests/scripts/thread-cert/Cert_5_6_07_NetworkDataRequestREED.py +++ b/tests/scripts/thread-cert/Cert_5_6_07_NetworkDataRequestREED.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -38,9 +39,11 @@ REED = 3 class Cert_5_6_7_NetworkDataRequestREED(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -64,18 +67,19 @@ class Cert_5_6_7_NetworkDataRequestREED(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[REED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED].get_state(), 'child') self.nodes[LEADER].remove_whitelist(self.nodes[REED].get_addr64()) @@ -84,12 +88,12 @@ class Cert_5_6_7_NetworkDataRequestREED(unittest.TestCase): self.nodes[ROUTER].add_prefix('2001:2:0:3::/64', 'paros') self.nodes[ROUTER].register_netdata() - time.sleep(2) + self.simulator.go(2) self.nodes[LEADER].add_whitelist(self.nodes[REED].get_addr64()) self.nodes[REED].add_whitelist(self.nodes[LEADER].get_addr64()) - time.sleep(35) + self.simulator.go(35) addrs = self.nodes[REED].get_addrs() self.assertTrue(any('2001:2:0:3' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_5_6_08_ContextManagement.py b/tests/scripts/thread-cert/Cert_5_6_08_ContextManagement.py index 64ed47566..e606f7b10 100755 --- a/tests/scripts/thread-cert/Cert_5_6_08_ContextManagement.py +++ b/tests/scripts/thread-cert/Cert_5_6_08_ContextManagement.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -38,9 +39,11 @@ ED = 3 class Cert_5_6_8_ContextManagement(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -64,23 +67,24 @@ class Cert_5_6_8_ContextManagement(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[ROUTER].add_prefix('2001:2:0:1::/64', 'paros') self.nodes[ROUTER].register_netdata() - time.sleep(2) + self.simulator.go(2) addrs = self.nodes[LEADER].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) @@ -90,7 +94,7 @@ class Cert_5_6_8_ContextManagement(unittest.TestCase): self.nodes[ROUTER].remove_prefix('2001:2:0:1::/64') self.nodes[ROUTER].register_netdata() - time.sleep(5) + self.simulator.go(5) addrs = self.nodes[LEADER].get_addrs() self.assertFalse(any('2001:2:0:1' in addr[0:10] for addr in addrs)) @@ -100,7 +104,7 @@ class Cert_5_6_8_ContextManagement(unittest.TestCase): self.nodes[ROUTER].add_prefix('2001:2:0:2::/64', 'paros') self.nodes[ROUTER].register_netdata() - time.sleep(5) + self.simulator.go(5) addrs = self.nodes[LEADER].get_addrs() self.assertFalse(any('2001:2:0:1' in addr[0:10] for addr in addrs)) @@ -109,10 +113,10 @@ class Cert_5_6_8_ContextManagement(unittest.TestCase): if addr[0:3] == '200': self.assertTrue(self.nodes[ED].ping(addr)) - time.sleep(5) + self.simulator.go(5) self.nodes[ROUTER].add_prefix('2001:2:0:3::/64', 'paros') self.nodes[ROUTER].register_netdata() - time.sleep(5) + self.simulator.go(5) addrs = self.nodes[LEADER].get_addrs() self.assertFalse(any('2001:2:0:1' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_5_6_09_NetworkDataForwarding.py b/tests/scripts/thread-cert/Cert_5_6_09_NetworkDataForwarding.py index 42d5b7bf1..9e23b7e69 100755 --- a/tests/scripts/thread-cert/Cert_5_6_09_NetworkDataForwarding.py +++ b/tests/scripts/thread-cert/Cert_5_6_09_NetworkDataForwarding.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -42,9 +43,11 @@ MTDS = [ED, SED] class Cert_5_6_9_NetworkDataForwarding(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -81,37 +84,38 @@ class Cert_5_6_9_NetworkDataForwarding(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[SED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED].get_state(), 'child') self.nodes[LEADER].add_prefix('2001:2:0:1::/64', 'paros', 'med') self.nodes[LEADER].add_route('2001:2:0:2::/64', 'med') self.nodes[LEADER].register_netdata() - time.sleep(10) + self.simulator.go(10) self.nodes[ROUTER2].add_prefix('2001:2:0:1::/64', 'paros', 'low') self.nodes[ROUTER2].add_route('2001:2:0:2::/64', 'high') self.nodes[ROUTER2].register_netdata() - time.sleep(10) + self.simulator.go(10) self.assertFalse(self.nodes[SED].ping('2001:2:0:2::1')) @@ -120,14 +124,14 @@ class Cert_5_6_9_NetworkDataForwarding(unittest.TestCase): self.nodes[ROUTER2].remove_prefix('2001:2:0:1::/64') self.nodes[ROUTER2].add_prefix('2001:2:0:1::/64', 'paros', 'high') self.nodes[ROUTER2].register_netdata() - time.sleep(10) + self.simulator.go(10) self.assertFalse(self.nodes[SED].ping('2007::1')) self.nodes[ROUTER2].remove_prefix('2001:2:0:1::/64') self.nodes[ROUTER2].add_prefix('2001:2:0:1::/64', 'paros', 'med') self.nodes[ROUTER2].register_netdata() - time.sleep(10) + self.simulator.go(10) self.assertFalse(self.nodes[SED].ping('2007::1')) diff --git a/tests/scripts/thread-cert/Cert_5_8_01_KeySynchronization.py b/tests/scripts/thread-cert/Cert_5_8_01_KeySynchronization.py index b16271af4..9d44d1c37 100755 --- a/tests/scripts/thread-cert/Cert_5_8_01_KeySynchronization.py +++ b/tests/scripts/thread-cert/Cert_5_8_01_KeySynchronization.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ED = 2 class Cert_5_8_1_KeySynchronization(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -57,14 +60,15 @@ class Cert_5_8_1_KeySynchronization(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') addrs = self.nodes[LEADER].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_5_8_02_KeyIncrement.py b/tests/scripts/thread-cert/Cert_5_8_02_KeyIncrement.py index 1b4285b07..53527a6ef 100755 --- a/tests/scripts/thread-cert/Cert_5_8_02_KeyIncrement.py +++ b/tests/scripts/thread-cert/Cert_5_8_02_KeyIncrement.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ROUTER = 2 class Cert_5_8_2_KeyIncrement(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -58,13 +61,15 @@ class Cert_5_8_2_KeyIncrement(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) + self.assertEqual(self.nodes[LEADER].get_state(), "leader") self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), "router") addrs = self.nodes[ROUTER].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_5_8_03_KeyIncrementRollOver.py b/tests/scripts/thread-cert/Cert_5_8_03_KeyIncrementRollOver.py index 9f9a9dc5b..9a7e1dbdf 100755 --- a/tests/scripts/thread-cert/Cert_5_8_03_KeyIncrementRollOver.py +++ b/tests/scripts/thread-cert/Cert_5_8_03_KeyIncrementRollOver.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ROUTER = 2 class Cert_5_8_3_KeyIncrementRollOver(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -59,14 +62,15 @@ class Cert_5_8_3_KeyIncrementRollOver(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(4) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') addrs = self.nodes[ROUTER].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_6_1_01_RouterAttach.py b/tests/scripts/thread-cert/Cert_6_1_01_RouterAttach.py index 5cb9be34b..12f6d1e73 100755 --- a/tests/scripts/thread-cert/Cert_6_1_01_RouterAttach.py +++ b/tests/scripts/thread-cert/Cert_6_1_01_RouterAttach.py @@ -36,13 +36,14 @@ import node LEADER = 1 ED = 2 -SNIFFER = 3 class Cert_6_1_1_RouterAttach(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -54,28 +55,23 @@ class Cert_6_1_1_RouterAttach(unittest.TestCase): self.nodes[ED].add_whitelist(self.nodes[LEADER].get_addr64()) self.nodes[ED].enable_whitelist() - self.sniffer = config.create_default_thread_sniffer(SNIFFER) - self.sniffer.start() - def tearDown(self): - self.sniffer.stop() - del self.sniffer - for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') - leader_messages = self.sniffer.get_messages_sent_by(LEADER) - ed_messages = self.sniffer.get_messages_sent_by(ED) + leader_messages = self.simulator.get_messages_sent_by(LEADER) + ed_messages = self.simulator.get_messages_sent_by(ED) # 1 - leader msg = leader_messages.next_mle_message(mle.CommandType.ADVERTISEMENT) diff --git a/tests/scripts/thread-cert/Cert_6_1_02_REEDAttach.py b/tests/scripts/thread-cert/Cert_6_1_02_REEDAttach.py index 280d29f8f..d934b086b 100755 --- a/tests/scripts/thread-cert/Cert_6_1_02_REEDAttach.py +++ b/tests/scripts/thread-cert/Cert_6_1_02_REEDAttach.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -38,9 +39,11 @@ ED = 3 class Cert_6_1_2_REEDAttach(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -63,18 +66,19 @@ class Cert_6_1_2_REEDAttach(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[REED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED].get_state(), 'child') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.assertEqual(self.nodes[REED].get_state(), 'router') diff --git a/tests/scripts/thread-cert/Cert_6_1_03_RouterAttachConnectivity.py b/tests/scripts/thread-cert/Cert_6_1_03_RouterAttachConnectivity.py index 0f4e52a40..bfab1fb39 100755 --- a/tests/scripts/thread-cert/Cert_6_1_03_RouterAttachConnectivity.py +++ b/tests/scripts/thread-cert/Cert_6_1_03_RouterAttachConnectivity.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -40,9 +41,11 @@ ED = 5 class Cert_6_1_3_RouterAttachConnectivity(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -83,19 +86,20 @@ class Cert_6_1_3_RouterAttachConnectivity(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') for i in range(2, 5): self.nodes[i].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[i].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') addrs = self.nodes[ED].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_6_1_04_REEDAttachConnectivity.py b/tests/scripts/thread-cert/Cert_6_1_04_REEDAttachConnectivity.py index e4c58e605..0a2c24d89 100755 --- a/tests/scripts/thread-cert/Cert_6_1_04_REEDAttachConnectivity.py +++ b/tests/scripts/thread-cert/Cert_6_1_04_REEDAttachConnectivity.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -40,9 +41,11 @@ ED = 5 class Cert_6_1_4_REEDAttachConnectivity(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -83,28 +86,29 @@ class Cert_6_1_4_REEDAttachConnectivity(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[REED0].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED0].get_state(), 'child') self.nodes[REED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED1].get_state(), 'child') - time.sleep(10) + self.simulator.go(10) self.nodes[ED].start() - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[ED].get_state(), 'child') self.assertEqual(self.nodes[REED1].get_state(), 'router') diff --git a/tests/scripts/thread-cert/Cert_6_1_05_RouterAttachLinkQuality.py b/tests/scripts/thread-cert/Cert_6_1_05_RouterAttachLinkQuality.py index 2da8dd412..772e55b28 100755 --- a/tests/scripts/thread-cert/Cert_6_1_05_RouterAttachLinkQuality.py +++ b/tests/scripts/thread-cert/Cert_6_1_05_RouterAttachLinkQuality.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -39,9 +40,11 @@ ED = 4 class Cert_6_1_5_RouterAttachLinkQuality(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,22 +76,23 @@ class Cert_6_1_5_RouterAttachLinkQuality(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') if __name__ == '__main__': diff --git a/tests/scripts/thread-cert/Cert_6_1_06_REEDAttachLinkQuality.py b/tests/scripts/thread-cert/Cert_6_1_06_REEDAttachLinkQuality.py index f6932a115..13488ea60 100755 --- a/tests/scripts/thread-cert/Cert_6_1_06_REEDAttachLinkQuality.py +++ b/tests/scripts/thread-cert/Cert_6_1_06_REEDAttachLinkQuality.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -39,9 +40,11 @@ ED = 4 class Cert_6_1_6_REEDAttachLinkQuality(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,22 +76,23 @@ class Cert_6_1_6_REEDAttachLinkQuality(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[REED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[REED].get_state(), 'child') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ED].start() - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[ED].get_state(), 'child') self.assertEqual(self.nodes[REED].get_state(), 'router') diff --git a/tests/scripts/thread-cert/Cert_6_1_07_EDSynchronization.py b/tests/scripts/thread-cert/Cert_6_1_07_EDSynchronization.py index 7cbd3d9f2..c7f48b341 100755 --- a/tests/scripts/thread-cert/Cert_6_1_07_EDSynchronization.py +++ b/tests/scripts/thread-cert/Cert_6_1_07_EDSynchronization.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -40,9 +41,11 @@ ROUTER3 = 5 class Cert_6_1_7_EDSynchronization(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -87,26 +90,27 @@ class Cert_6_1_7_EDSynchronization(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER3].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER3].get_state(), 'router') if __name__ == '__main__': diff --git a/tests/scripts/thread-cert/Cert_6_2_01_NewPartition.py b/tests/scripts/thread-cert/Cert_6_2_01_NewPartition.py index 894344aff..7c893568b 100755 --- a/tests/scripts/thread-cert/Cert_6_2_01_NewPartition.py +++ b/tests/scripts/thread-cert/Cert_6_2_01_NewPartition.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -38,9 +39,11 @@ ED = 3 class Cert_6_2_1_NewPartition(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -63,22 +66,23 @@ class Cert_6_2_1_NewPartition(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[LEADER].stop() - time.sleep(140) + self.simulator.go(140) self.assertEqual(self.nodes[ROUTER1].get_state(), 'leader') self.assertEqual(self.nodes[ED].get_state(), 'child') diff --git a/tests/scripts/thread-cert/Cert_6_2_02_NewPartition.py b/tests/scripts/thread-cert/Cert_6_2_02_NewPartition.py index f09e7f4d5..c95f52ca6 100755 --- a/tests/scripts/thread-cert/Cert_6_2_02_NewPartition.py +++ b/tests/scripts/thread-cert/Cert_6_2_02_NewPartition.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -39,9 +40,11 @@ ED = 4 class Cert_6_2_2_NewPartition(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -74,26 +77,27 @@ class Cert_6_2_2_NewPartition(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[LEADER].stop() - time.sleep(140) + self.simulator.go(140) self.assertEqual(self.nodes[ROUTER2].get_state(), 'leader') self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.assertEqual(self.nodes[ED].get_state(), 'child') diff --git a/tests/scripts/thread-cert/Cert_6_3_01_OrphanReattach.py b/tests/scripts/thread-cert/Cert_6_3_01_OrphanReattach.py index e005fe181..ff76e4d8c 100755 --- a/tests/scripts/thread-cert/Cert_6_3_01_OrphanReattach.py +++ b/tests/scripts/thread-cert/Cert_6_3_01_OrphanReattach.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -38,9 +39,11 @@ ED = 3 class Cert_6_3_1_OrphanReattach(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -64,24 +67,25 @@ class Cert_6_3_1_OrphanReattach(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[ROUTER].stop() self.nodes[LEADER].add_whitelist(self.nodes[ED].get_addr64()) self.nodes[ED].add_whitelist(self.nodes[LEADER].get_addr64()) - time.sleep(20) + self.simulator.go(20) self.assertEqual(self.nodes[ED].get_state(), 'child') diff --git a/tests/scripts/thread-cert/Cert_6_3_02_NetworkDataUpdate.py b/tests/scripts/thread-cert/Cert_6_3_02_NetworkDataUpdate.py index f47fa91c2..de9b6906e 100755 --- a/tests/scripts/thread-cert/Cert_6_3_02_NetworkDataUpdate.py +++ b/tests/scripts/thread-cert/Cert_6_3_02_NetworkDataUpdate.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ED = 2 class Cert_5_6_2_NetworkDataUpdate(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -56,19 +59,20 @@ class Cert_5_6_2_NetworkDataUpdate(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[LEADER].add_prefix('2001:2:0:1::/64', 'paros') self.nodes[LEADER].register_netdata() - time.sleep(5) + self.simulator.go(5) addrs = self.nodes[ED].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) @@ -81,11 +85,11 @@ class Cert_5_6_2_NetworkDataUpdate(unittest.TestCase): self.nodes[LEADER].add_prefix('2001:2:0:2::/64', 'paros') self.nodes[LEADER].register_netdata() - time.sleep(5) + self.simulator.go(5) self.nodes[LEADER].add_whitelist(self.nodes[ED].get_addr64()) self.nodes[ED].add_whitelist(self.nodes[LEADER].get_addr64()) - time.sleep(10) + self.simulator.go(10) addrs = self.nodes[ED].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_6_4_01_LinkLocal.py b/tests/scripts/thread-cert/Cert_6_4_01_LinkLocal.py index caca7f2a4..e4339c9e1 100755 --- a/tests/scripts/thread-cert/Cert_6_4_01_LinkLocal.py +++ b/tests/scripts/thread-cert/Cert_6_4_01_LinkLocal.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ED = 2 class Cert_6_4_1_LinkLocal(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -55,14 +58,15 @@ class Cert_6_4_1_LinkLocal(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') addrs = self.nodes[ED].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_6_4_02_RealmLocal.py b/tests/scripts/thread-cert/Cert_6_4_02_RealmLocal.py index 6836253a1..2a0bd969d 100755 --- a/tests/scripts/thread-cert/Cert_6_4_02_RealmLocal.py +++ b/tests/scripts/thread-cert/Cert_6_4_02_RealmLocal.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -38,9 +39,11 @@ ED = 3 class Cert_5_3_2_RealmLocal(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -63,18 +66,19 @@ class Cert_5_3_2_RealmLocal(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') addrs = self.nodes[ED].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_6_5_01_ChildResetSynchronize.py b/tests/scripts/thread-cert/Cert_6_5_01_ChildResetSynchronize.py index 9f124dd2a..265fb9115 100755 --- a/tests/scripts/thread-cert/Cert_6_5_01_ChildResetSynchronize.py +++ b/tests/scripts/thread-cert/Cert_6_5_01_ChildResetSynchronize.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ED = 2 class Cert_6_5_1_ChildResetSynchronize(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -59,31 +62,32 @@ class Cert_6_5_1_ChildResetSynchronize(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[ED].reset() self._setUpEd() - time.sleep(5) + self.simulator.go(5) self.nodes[ED].set_timeout(100) self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[ED].reset() self._setUpEd() - time.sleep(5) + self.simulator.go(5) self.nodes[ED].set_timeout(100) self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') addrs = self.nodes[ED].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_6_5_02_ChildResetReattach.py b/tests/scripts/thread-cert/Cert_6_5_02_ChildResetReattach.py index adcd0fcb2..549102ad5 100755 --- a/tests/scripts/thread-cert/Cert_6_5_02_ChildResetReattach.py +++ b/tests/scripts/thread-cert/Cert_6_5_02_ChildResetReattach.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ED = 2 class Cert_6_5_2_ChildResetReattach(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -58,14 +61,15 @@ class Cert_6_5_2_ChildResetReattach(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[LEADER].remove_whitelist(self.nodes[ED].get_addr64()) @@ -73,12 +77,12 @@ class Cert_6_5_2_ChildResetReattach(unittest.TestCase): self.nodes[ED].reset() self._setUpEd() - time.sleep(5) + self.simulator.go(5) self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.nodes[LEADER].add_whitelist(self.nodes[ED].get_addr64()) - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') addrs = self.nodes[ED].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_6_6_01_KeyIncrement.py b/tests/scripts/thread-cert/Cert_6_6_01_KeyIncrement.py index 05fb21748..cc327a055 100755 --- a/tests/scripts/thread-cert/Cert_6_6_01_KeyIncrement.py +++ b/tests/scripts/thread-cert/Cert_6_6_01_KeyIncrement.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ED = 2 class Cert_6_6_1_KeyIncrement(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -57,13 +60,15 @@ class Cert_6_6_1_KeyIncrement(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) + self.assertEqual(self.nodes[LEADER].get_state(), "leader") self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), "child") addrs = self.nodes[ED].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_6_6_02_KeyIncrementRollOver.py b/tests/scripts/thread-cert/Cert_6_6_02_KeyIncrementRollOver.py index 677db5a76..d37b052db 100755 --- a/tests/scripts/thread-cert/Cert_6_6_02_KeyIncrementRollOver.py +++ b/tests/scripts/thread-cert/Cert_6_6_02_KeyIncrementRollOver.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -37,9 +38,11 @@ ED = 2 class Cert_6_6_2_KeyIncrement1(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i, (i == ED)) + self.nodes[i] = node.Node(i, (i == ED), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -58,14 +61,15 @@ class Cert_6_6_2_KeyIncrement1(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') addrs = self.nodes[ED].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_7_1_01_BorderRouterAsLeader.py b/tests/scripts/thread-cert/Cert_7_1_01_BorderRouterAsLeader.py index c79382231..23eda976e 100755 --- a/tests/scripts/thread-cert/Cert_7_1_01_BorderRouterAsLeader.py +++ b/tests/scripts/thread-cert/Cert_7_1_01_BorderRouterAsLeader.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [SED1, ED1] class Cert_7_1_1_BorderRouterAsLeader(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,10 +76,11 @@ class Cert_7_1_1_BorderRouterAsLeader(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[LEADER].add_prefix('2001:2:0:1::/64', 'paros') @@ -84,15 +88,15 @@ class Cert_7_1_1_BorderRouterAsLeader(unittest.TestCase): self.nodes[LEADER].register_netdata() self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') addrs = self.nodes[SED1].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_7_1_02_BorderRouterAsRouter.py b/tests/scripts/thread-cert/Cert_7_1_02_BorderRouterAsRouter.py index a0b5ce6e7..1f7ff178e 100755 --- a/tests/scripts/thread-cert/Cert_7_1_02_BorderRouterAsRouter.py +++ b/tests/scripts/thread-cert/Cert_7_1_02_BorderRouterAsRouter.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [ED2, SED2] class Cert_7_1_2_BorderRouterAsRouter(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,14 +76,15 @@ class Cert_7_1_2_BorderRouterAsRouter(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ROUTER].add_prefix('2001:2:0:1::/64', 'paros') @@ -88,11 +92,11 @@ class Cert_7_1_2_BorderRouterAsRouter(unittest.TestCase): self.nodes[ROUTER].register_netdata() self.nodes[ED2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED2].get_state(), 'child') self.nodes[SED2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED2].get_state(), 'child') addrs = self.nodes[ED2].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_7_1_03_BorderRouterAsLeader.py b/tests/scripts/thread-cert/Cert_7_1_03_BorderRouterAsLeader.py index c3407a5fb..deaddb6b2 100755 --- a/tests/scripts/thread-cert/Cert_7_1_03_BorderRouterAsLeader.py +++ b/tests/scripts/thread-cert/Cert_7_1_03_BorderRouterAsLeader.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [SED1, ED1] class Cert_7_1_3_BorderRouterAsLeader(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,28 +76,29 @@ class Cert_7_1_3_BorderRouterAsLeader(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[LEADER].add_prefix('2001:2:0:1::/64', 'paros') self.nodes[LEADER].add_prefix('2001:2:0:2::/64', 'paro') self.nodes[LEADER].register_netdata() - time.sleep(5) + self.simulator.go(5) addrs = self.nodes[SED1].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_7_1_04_BorderRouterAsRouter.py b/tests/scripts/thread-cert/Cert_7_1_04_BorderRouterAsRouter.py index a2a3bb13c..64c9462b6 100755 --- a/tests/scripts/thread-cert/Cert_7_1_04_BorderRouterAsRouter.py +++ b/tests/scripts/thread-cert/Cert_7_1_04_BorderRouterAsRouter.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [SED2, ED2] class Cert_7_1_4_BorderRouterAsRouter(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,28 +76,29 @@ class Cert_7_1_4_BorderRouterAsRouter(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED2].get_state(), 'child') self.nodes[SED2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED2].get_state(), 'child') self.nodes[ROUTER].add_prefix('2001:2:0:1::/64', 'paros') self.nodes[ROUTER].add_prefix('2001:2:0:2::/64', 'paro') self.nodes[ROUTER].register_netdata() - time.sleep(5) + self.simulator.go(5) addrs = self.nodes[ED2].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_7_1_05_BorderRouterAsRouter.py b/tests/scripts/thread-cert/Cert_7_1_05_BorderRouterAsRouter.py index abca9fbd3..89ed2901f 100755 --- a/tests/scripts/thread-cert/Cert_7_1_05_BorderRouterAsRouter.py +++ b/tests/scripts/thread-cert/Cert_7_1_05_BorderRouterAsRouter.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER = 1 @@ -41,9 +42,11 @@ MTDS = [ED2, SED2] class Cert_7_1_5_BorderRouterAsRouter(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -73,28 +76,29 @@ class Cert_7_1_5_BorderRouterAsRouter(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED2].get_state(), 'child') self.nodes[SED2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED2].get_state(), 'child') self.nodes[ROUTER].add_prefix('2001:2:0:1::/64', 'paros') self.nodes[ROUTER].add_prefix('2001:2:0:2::/64', 'paro') self.nodes[ROUTER].register_netdata() - time.sleep(5) + self.simulator.go(5) addrs = self.nodes[ED2].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) @@ -112,7 +116,7 @@ class Cert_7_1_5_BorderRouterAsRouter(unittest.TestCase): self.nodes[ROUTER].add_prefix('2001:2:0:3::/64', 'paros') self.nodes[ROUTER].register_netdata() - time.sleep(5) + self.simulator.go(5) addrs = self.nodes[ED2].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) diff --git a/tests/scripts/thread-cert/Cert_8_1_01_Commissioning.py b/tests/scripts/thread-cert/Cert_8_1_01_Commissioning.py index 4ca5d09d9..2608b758c 100755 --- a/tests/scripts/thread-cert/Cert_8_1_01_Commissioning.py +++ b/tests/scripts/thread-cert/Cert_8_1_01_Commissioning.py @@ -30,6 +30,7 @@ import time import unittest +import config import node COMMISSIONER = 1 @@ -37,9 +38,11 @@ JOINER = 2 class Cert_8_1_01_Commissioning(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[COMMISSIONER].set_panid(0xface) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -53,23 +56,24 @@ class Cert_8_1_01_Commissioning(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[COMMISSIONER].interface_up() self.nodes[COMMISSIONER].thread_start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'leader') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[COMMISSIONER].commissioner_add_joiner(self.nodes[JOINER].get_eui64(), 'OPENTHREAD') self.nodes[JOINER].interface_up() self.nodes[JOINER].joiner_start('OPENTHREAD') - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[JOINER].get_masterkey(), self.nodes[COMMISSIONER].get_masterkey()) self.nodes[JOINER].thread_start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[JOINER].get_state(), 'router') if __name__ == '__main__': diff --git a/tests/scripts/thread-cert/Cert_8_1_02_Commissioning.py b/tests/scripts/thread-cert/Cert_8_1_02_Commissioning.py index c859551f7..62b5b75f6 100755 --- a/tests/scripts/thread-cert/Cert_8_1_02_Commissioning.py +++ b/tests/scripts/thread-cert/Cert_8_1_02_Commissioning.py @@ -30,6 +30,7 @@ import time import unittest +import config import node COMMISSIONER = 1 @@ -37,6 +38,8 @@ JOINER = 2 class Cert_8_1_02_Commissioning(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): self.nodes[i] = node.Node(i) @@ -53,19 +56,20 @@ class Cert_8_1_02_Commissioning(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[COMMISSIONER].interface_up() self.nodes[COMMISSIONER].thread_start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'leader') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[COMMISSIONER].commissioner_add_joiner(self.nodes[JOINER].get_eui64(), 'OPENTHREAD') self.nodes[JOINER].interface_up() self.nodes[JOINER].joiner_start('DAERHTNEPO') - time.sleep(10) + self.simulator.go(10) self.assertNotEqual(self.nodes[JOINER].get_masterkey(), self.nodes[COMMISSIONER].get_masterkey()) if __name__ == '__main__': diff --git a/tests/scripts/thread-cert/Cert_8_2_01_JoinerRouter.py b/tests/scripts/thread-cert/Cert_8_2_01_JoinerRouter.py index c7da138a4..4d5f885dc 100755 --- a/tests/scripts/thread-cert/Cert_8_2_01_JoinerRouter.py +++ b/tests/scripts/thread-cert/Cert_8_2_01_JoinerRouter.py @@ -30,6 +30,7 @@ import time import unittest +import config import node COMMISSIONER = 1 @@ -38,6 +39,8 @@ JOINER = 3 class Cert_8_2_01_JoinerRouter(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): self.nodes[i] = node.Node(i) @@ -62,31 +65,32 @@ class Cert_8_2_01_JoinerRouter(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[COMMISSIONER].interface_up() self.nodes[COMMISSIONER].thread_start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'leader') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(5) + self.simulator.go(5) self.nodes[COMMISSIONER].commissioner_add_joiner(self.nodes[JOINER_ROUTER].get_eui64(), 'OPENTHREAD') self.nodes[COMMISSIONER].commissioner_add_joiner(self.nodes[JOINER].get_eui64(), 'OPENTHREAD2') - time.sleep(5) + self.simulator.go(5) self.nodes[COMMISSIONER].add_whitelist(self.nodes[JOINER_ROUTER].get_joiner_id()) self.nodes[JOINER_ROUTER].add_whitelist(self.nodes[COMMISSIONER].get_addr64()) self.nodes[JOINER_ROUTER].interface_up() self.nodes[JOINER_ROUTER].joiner_start('OPENTHREAD') - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[JOINER_ROUTER].get_masterkey(), self.nodes[COMMISSIONER].get_masterkey()) self.nodes[COMMISSIONER].add_whitelist(self.nodes[JOINER_ROUTER].get_addr64()) self.nodes[JOINER_ROUTER].thread_start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[JOINER_ROUTER].get_state(), 'router') self.nodes[JOINER_ROUTER].add_whitelist(self.nodes[JOINER].get_joiner_id()) @@ -94,13 +98,13 @@ class Cert_8_2_01_JoinerRouter(unittest.TestCase): self.nodes[JOINER].interface_up() self.nodes[JOINER].joiner_start('OPENTHREAD2') - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[JOINER].get_masterkey(), self.nodes[COMMISSIONER].get_masterkey()) self.nodes[JOINER_ROUTER].add_whitelist(self.nodes[JOINER].get_addr64()) self.nodes[JOINER].thread_start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[JOINER].get_state(), 'router') if __name__ == '__main__': diff --git a/tests/scripts/thread-cert/Cert_8_2_02_JoinerRouter.py b/tests/scripts/thread-cert/Cert_8_2_02_JoinerRouter.py index 4e43e8e5d..ea25b64b7 100755 --- a/tests/scripts/thread-cert/Cert_8_2_02_JoinerRouter.py +++ b/tests/scripts/thread-cert/Cert_8_2_02_JoinerRouter.py @@ -30,6 +30,7 @@ import time import unittest +import config import node COMMISSIONER = 1 @@ -38,9 +39,11 @@ JOINER = 3 class Cert_8_2_02_JoinerRouter(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[COMMISSIONER].set_panid(0xface) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -62,31 +65,32 @@ class Cert_8_2_02_JoinerRouter(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[COMMISSIONER].interface_up() self.nodes[COMMISSIONER].thread_start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'leader') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(5) + self.simulator.go(5) self.nodes[COMMISSIONER].commissioner_add_joiner(self.nodes[JOINER_ROUTER].get_eui64(), 'OPENTHREAD') self.nodes[COMMISSIONER].commissioner_add_joiner(self.nodes[JOINER].get_eui64(), 'OPENTHREAD2') - time.sleep(5) + self.simulator.go(5) self.nodes[COMMISSIONER].add_whitelist(self.nodes[JOINER_ROUTER].get_joiner_id()) self.nodes[JOINER_ROUTER].add_whitelist(self.nodes[COMMISSIONER].get_addr64()) self.nodes[JOINER_ROUTER].interface_up() self.nodes[JOINER_ROUTER].joiner_start('OPENTHREAD') - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[JOINER_ROUTER].get_masterkey(), self.nodes[COMMISSIONER].get_masterkey()) self.nodes[COMMISSIONER].add_whitelist(self.nodes[JOINER_ROUTER].get_addr64()) self.nodes[JOINER_ROUTER].thread_start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[JOINER_ROUTER].get_state(), 'router') self.nodes[JOINER_ROUTER].add_whitelist(self.nodes[JOINER].get_joiner_id()) @@ -94,7 +98,7 @@ class Cert_8_2_02_JoinerRouter(unittest.TestCase): self.nodes[JOINER].interface_up() self.nodes[JOINER].joiner_start('2DAERHTNEPO') - time.sleep(10) + self.simulator.go(10) self.assertNotEqual(self.nodes[JOINER].get_masterkey(), self.nodes[COMMISSIONER].get_masterkey()) if __name__ == '__main__': diff --git a/tests/scripts/thread-cert/Cert_9_2_04_ActiveDataset.py b/tests/scripts/thread-cert/Cert_9_2_04_ActiveDataset.py index 5ac3bcc6d..ad69a6990 100755 --- a/tests/scripts/thread-cert/Cert_9_2_04_ActiveDataset.py +++ b/tests/scripts/thread-cert/Cert_9_2_04_ActiveDataset.py @@ -30,6 +30,7 @@ import time import unittest +import config import node COMMISSIONER = 1 @@ -37,9 +38,11 @@ LEADER = 2 class Cert_9_2_15_PendingPartition(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,3): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[COMMISSIONER].set_active_dataset(10, panid=0xface, master_key='000102030405060708090a0b0c0d0e0f') self.nodes[COMMISSIONER].set_mode('rsdn') @@ -53,24 +56,25 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[COMMISSIONER].send_mgmt_active_set(active_timestamp=101, channel_mask=0x001fffe0, extended_panid='000db70000000000', network_name='GRL') - time.sleep(3) + self.simulator.go(3) self.assertEqual(self.nodes[LEADER].get_network_name(), 'GRL') # Step 6 @@ -80,7 +84,7 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): channel_mask=0x001fffe0, extended_panid='000db70000000001', network_name='threadcert') - time.sleep(3) + self.simulator.go(3) self.assertEqual(self.nodes[LEADER].get_network_name(), 'GRL') # Step 8 @@ -90,7 +94,7 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): extended_panid='000db70000000000', mesh_local='fd00:0db7::', network_name='UL') - time.sleep(3) + self.simulator.go(3) self.assertEqual(self.nodes[LEADER].get_network_name(), 'GRL') # Step 10 @@ -101,7 +105,7 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): master_key='00112233445566778899aabbccddeeff', mesh_local='fd00:0db7::', network_name='UL') - time.sleep(3) + self.simulator.go(3) self.assertEqual(self.nodes[LEADER].get_network_name(), 'GRL') # Step 12 @@ -113,7 +117,7 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): mesh_local='fd00:0db7::', network_name='UL', panid=0xafce) - time.sleep(3) + self.simulator.go(3) self.assertEqual(self.nodes[LEADER].get_network_name(), 'GRL') # Step 14 @@ -123,7 +127,7 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): extended_panid='000db70000000000', network_name='UL', binary='0b02abcd') - time.sleep(3) + self.simulator.go(3) self.assertEqual(self.nodes[LEADER].get_network_name(), 'GRL') # Step 16 @@ -132,7 +136,7 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): channel_mask=0x001fffe0, extended_panid='000db70000000000', network_name='UL') - time.sleep(3) + self.simulator.go(3) self.assertEqual(self.nodes[LEADER].get_network_name(), 'GRL') # Step 18 @@ -142,7 +146,7 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): extended_panid='000db70000000000', network_name='UL', binary='0806113320440000') - time.sleep(3) + self.simulator.go(3) self.assertEqual(self.nodes[LEADER].get_network_name(), 'UL') # Step 20 @@ -152,7 +156,7 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): extended_panid='000db70000000000', network_name='GRL', binary='8202aa55') - time.sleep(3) + self.simulator.go(3) self.assertEqual(self.nodes[LEADER].get_network_name(), 'GRL') ipaddrs = self.nodes[COMMISSIONER].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_9_2_07_DelayTimer.py b/tests/scripts/thread-cert/Cert_9_2_07_DelayTimer.py index 5347b654a..b15c63c35 100755 --- a/tests/scripts/thread-cert/Cert_9_2_07_DelayTimer.py +++ b/tests/scripts/thread-cert/Cert_9_2_07_DelayTimer.py @@ -30,6 +30,7 @@ import time import unittest +import config import node PANID_INIT = 0xface @@ -48,9 +49,11 @@ COMMISSIONER_PENDING_PANID = 0xafce class Cert_9_2_7_DelayTimer(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[COMMISSIONER].set_active_dataset(LEADER_ACTIVE_TIMESTAMP) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -78,26 +81,27 @@ class Cert_9_2_7_DelayTimer(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER].start() - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[ROUTER].get_state(), 'leader') self.nodes[LEADER].add_whitelist(self.nodes[ROUTER].get_addr64()) self.nodes[ROUTER].add_whitelist(self.nodes[LEADER].get_addr64()) - time.sleep(30) + self.simulator.go(30) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.assertEqual(self.nodes[ROUTER].get_state(), 'router') @@ -113,7 +117,7 @@ class Cert_9_2_7_DelayTimer(unittest.TestCase): delay_timer=10000, channel=COMMISSIONER_PENDING_CHANNEL, panid=COMMISSIONER_PENDING_PANID) - time.sleep(40) + self.simulator.go(40) self.assertEqual(self.nodes[LEADER].get_panid(), COMMISSIONER_PENDING_PANID) self.assertEqual(self.nodes[COMMISSIONER].get_panid(), COMMISSIONER_PENDING_PANID) self.assertEqual(self.nodes[ROUTER].get_panid(), COMMISSIONER_PENDING_PANID) diff --git a/tests/scripts/thread-cert/Cert_9_2_08_PersistentDatasets.py b/tests/scripts/thread-cert/Cert_9_2_08_PersistentDatasets.py index 3f9546295..35e582295 100755 --- a/tests/scripts/thread-cert/Cert_9_2_08_PersistentDatasets.py +++ b/tests/scripts/thread-cert/Cert_9_2_08_PersistentDatasets.py @@ -30,6 +30,7 @@ import time import unittest +import config import node COMMISSIONER = 1 @@ -49,9 +50,11 @@ MTDS = [ED, SED] class Cert_9_2_8_PersistentDatasets(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[COMMISSIONER].set_active_dataset(LEADER_ACTIVE_TIMESTAMP, panid=PANID_INIT, channel=CHANNEL_INIT) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -103,40 +106,40 @@ class Cert_9_2_8_PersistentDatasets(unittest.TestCase): def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[ROUTER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER].get_state(), 'router') self.nodes[ED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED].get_state(), 'child') self.nodes[SED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED].get_state(), 'child') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[COMMISSIONER].send_mgmt_pending_set(pending_timestamp=10, active_timestamp=70, delay_timer=60000, channel=COMMISSIONER_PENDING_CHANNEL, panid=COMMISSIONER_PENDING_PANID) - time.sleep(5) + self.simulator.go(5) self.nodes[ROUTER].reset() self.nodes[ED].reset() self.nodes[SED].reset() - time.sleep(60) + self.simulator.go(60) self.assertEqual(self.nodes[LEADER].get_panid(), COMMISSIONER_PENDING_PANID) self.assertEqual(self.nodes[COMMISSIONER].get_panid(), COMMISSIONER_PENDING_PANID) @@ -163,7 +166,7 @@ class Cert_9_2_8_PersistentDatasets(unittest.TestCase): self.assertEqual(self.nodes[ED].get_channel(), CHANNEL_INIT) self.assertEqual(self.nodes[SED].get_channel(), CHANNEL_INIT) - time.sleep(10) + self.simulator.go(10) self.assertEqual(self.nodes[ROUTER].get_panid(), COMMISSIONER_PENDING_PANID) self.assertEqual(self.nodes[ED].get_panid(), COMMISSIONER_PENDING_PANID) @@ -173,7 +176,7 @@ class Cert_9_2_8_PersistentDatasets(unittest.TestCase): self.assertEqual(self.nodes[ED].get_channel(), COMMISSIONER_PENDING_CHANNEL) self.assertEqual(self.nodes[SED].get_channel(), COMMISSIONER_PENDING_CHANNEL) - time.sleep(5) + self.simulator.go(5) ipaddrs = self.nodes[ROUTER].get_addrs() for ipaddr in ipaddrs: diff --git a/tests/scripts/thread-cert/Cert_9_2_09_PendingPartition.py b/tests/scripts/thread-cert/Cert_9_2_09_PendingPartition.py index 1c1cb559e..7b0f51c21 100755 --- a/tests/scripts/thread-cert/Cert_9_2_09_PendingPartition.py +++ b/tests/scripts/thread-cert/Cert_9_2_09_PendingPartition.py @@ -30,6 +30,7 @@ import time import unittest +import config import node CHANNEL_INIT = 19 @@ -45,9 +46,11 @@ ROUTER2 = 4 class Cert_9_2_09_PendingPartition(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[COMMISSIONER].set_active_dataset(10, channel=CHANNEL_INIT, panid=PANID_INIT) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -81,24 +84,25 @@ class Cert_9_2_09_PendingPartition(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[COMMISSIONER].send_mgmt_pending_set(pending_timestamp=30, @@ -106,11 +110,11 @@ class Cert_9_2_09_PendingPartition(unittest.TestCase): delay_timer=500000, channel=20, panid=0xafce) - time.sleep(5) + self.simulator.go(5) self.nodes[LEADER].remove_whitelist(self.nodes[ROUTER1].get_addr64()) self.nodes[ROUTER1].remove_whitelist(self.nodes[LEADER].get_addr64()) - time.sleep(140) + self.simulator.go(140) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.assertEqual(self.nodes[ROUTER2].get_state(), 'leader') @@ -120,11 +124,11 @@ class Cert_9_2_09_PendingPartition(unittest.TestCase): delay_timer=200000, channel=CHANNEL_FINAL, panid=PANID_FINAL) - time.sleep(5) + self.simulator.go(5) self.nodes[LEADER].add_whitelist(self.nodes[ROUTER1].get_addr64()) self.nodes[ROUTER1].add_whitelist(self.nodes[LEADER].get_addr64()) - time.sleep(200) + self.simulator.go(200) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') diff --git a/tests/scripts/thread-cert/Cert_9_2_10_PendingPartition.py b/tests/scripts/thread-cert/Cert_9_2_10_PendingPartition.py index 0115b4f20..63e3e7101 100755 --- a/tests/scripts/thread-cert/Cert_9_2_10_PendingPartition.py +++ b/tests/scripts/thread-cert/Cert_9_2_10_PendingPartition.py @@ -30,6 +30,7 @@ import time import unittest +import config import node CHANNEL_INIT = 19 @@ -48,9 +49,11 @@ MTDS = [ED1, SED1] class Cert_9_2_10_PendingPartition(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[COMMISSIONER].set_active_dataset(15, channel=CHANNEL_INIT, panid=PANID_INIT) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -91,28 +94,29 @@ class Cert_9_2_10_PendingPartition(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') self.nodes[COMMISSIONER].send_mgmt_pending_set(pending_timestamp=30, @@ -120,7 +124,7 @@ class Cert_9_2_10_PendingPartition(unittest.TestCase): delay_timer=150000, channel=CHANNEL_FINAL, panid=PANID_FINAL) - time.sleep(5) + self.simulator.go(5) print(self.nodes[COMMISSIONER].get_channel()) print(self.nodes[LEADER].get_channel()) @@ -130,7 +134,7 @@ class Cert_9_2_10_PendingPartition(unittest.TestCase): self.nodes[LEADER].remove_whitelist(self.nodes[ROUTER1].get_addr64()) self.nodes[ROUTER1].remove_whitelist(self.nodes[LEADER].get_addr64()) - time.sleep(160) + self.simulator.go(160) print(self.nodes[COMMISSIONER].get_channel()) print(self.nodes[LEADER].get_channel()) @@ -152,7 +156,7 @@ class Cert_9_2_10_PendingPartition(unittest.TestCase): self.nodes[LEADER].add_whitelist(self.nodes[ROUTER1].get_addr64()) self.nodes[ROUTER1].add_whitelist(self.nodes[LEADER].get_addr64()) - time.sleep(60) + self.simulator.go(60) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.assertEqual(self.nodes[LEADER].get_state(), 'leader') diff --git a/tests/scripts/thread-cert/Cert_9_2_11_MasterKey.py b/tests/scripts/thread-cert/Cert_9_2_11_MasterKey.py index 9c6c21518..ecf3b8b01 100755 --- a/tests/scripts/thread-cert/Cert_9_2_11_MasterKey.py +++ b/tests/scripts/thread-cert/Cert_9_2_11_MasterKey.py @@ -30,6 +30,7 @@ import time import unittest +import config import node KEY1 = '000102030405060708090a0b0c0d0e0f' @@ -48,9 +49,11 @@ MTDS = [ED1, SED1] class Cert_9_2_11_MasterKey(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[COMMISSIONER].set_active_dataset(10, channel=CHANNEL_INIT, panid=PANID_INIT, master_key=KEY1) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -92,35 +95,36 @@ class Cert_9_2_11_MasterKey(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') self.nodes[COMMISSIONER].send_mgmt_pending_set(pending_timestamp=10, active_timestamp=70, delay_timer=10000, master_key=KEY2) - time.sleep(310) + self.simulator.go(310) print(self.nodes[COMMISSIONER].get_masterkey()) print(self.nodes[LEADER].get_masterkey()) @@ -143,7 +147,7 @@ class Cert_9_2_11_MasterKey(unittest.TestCase): active_timestamp=30, delay_timer=10000, master_key=KEY1) - time.sleep(310) + self.simulator.go(310) print(self.nodes[COMMISSIONER].get_masterkey()) print(self.nodes[LEADER].get_masterkey()) diff --git a/tests/scripts/thread-cert/Cert_9_2_12_Announce.py b/tests/scripts/thread-cert/Cert_9_2_12_Announce.py index 2ed729d9f..fc313d829 100755 --- a/tests/scripts/thread-cert/Cert_9_2_12_Announce.py +++ b/tests/scripts/thread-cert/Cert_9_2_12_Announce.py @@ -30,6 +30,7 @@ import time import unittest +import config import node LEADER1 = 1 @@ -48,9 +49,11 @@ DATASET2_PANID = 0xafce class Cert_9_2_12_Announce(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,6): - self.nodes[i] = node.Node(i, (i == MED)) + self.nodes[i] = node.Node(i, (i == MED), simulator=self.simulator) self.nodes[LEADER1].set_active_dataset(DATASET1_TIMESTAMP, channel=DATASET1_CHANNEL, panid=DATASET1_PANID) self.nodes[LEADER1].set_mode('rsdn') @@ -88,16 +91,17 @@ class Cert_9_2_12_Announce(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER1].start() - self.nodes[LEADER1].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER1].get_state(), 'leader') self.nodes[LEADER1].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[LEADER2].start() @@ -105,11 +109,11 @@ class Cert_9_2_12_Announce(unittest.TestCase): self.assertEqual(self.nodes[LEADER2].get_state(), 'leader') self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[MED].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[MED].get_state(), 'child') ipaddrs = self.nodes[ROUTER1].get_addrs() @@ -118,7 +122,7 @@ class Cert_9_2_12_Announce(unittest.TestCase): break self.nodes[LEADER1].announce_begin(0x1000, 1, 1000, ipaddr) - time.sleep(30) + self.simulator.go(30) self.assertEqual(self.nodes[LEADER2].get_state(), 'router') self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.assertEqual(self.nodes[MED].get_state(), 'child') diff --git a/tests/scripts/thread-cert/Cert_9_2_13_EnergyScan.py b/tests/scripts/thread-cert/Cert_9_2_13_EnergyScan.py index 9fcd9fdbe..3c070a8f7 100755 --- a/tests/scripts/thread-cert/Cert_9_2_13_EnergyScan.py +++ b/tests/scripts/thread-cert/Cert_9_2_13_EnergyScan.py @@ -30,6 +30,7 @@ import time import unittest +import config import node COMMISSIONER = 1 @@ -39,9 +40,11 @@ ED1 = 4 class Cert_9_2_13_EnergyScan(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i, (i == ED1)) + self.nodes[i] = node.Node(i, (i == ED1), simulator=self.simulator) self.nodes[COMMISSIONER].set_panid(0xface) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -71,24 +74,25 @@ class Cert_9_2_13_EnergyScan(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') ipaddrs = self.nodes[ROUTER1].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_9_2_14_PanIdQuery.py b/tests/scripts/thread-cert/Cert_9_2_14_PanIdQuery.py index fcac3b8b5..1c4025180 100755 --- a/tests/scripts/thread-cert/Cert_9_2_14_PanIdQuery.py +++ b/tests/scripts/thread-cert/Cert_9_2_14_PanIdQuery.py @@ -30,6 +30,7 @@ import time import unittest +import config import node COMMISSIONER = 1 @@ -39,9 +40,11 @@ LEADER2 = 4 class Cert_9_2_14_PanIdQuery(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[COMMISSIONER].set_panid(0xface) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -71,24 +74,25 @@ class Cert_9_2_14_PanIdQuery(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER1].start() - self.nodes[LEADER1].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER1].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[LEADER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[LEADER2].get_state(), 'leader') ipaddrs = self.nodes[ROUTER1].get_addrs() diff --git a/tests/scripts/thread-cert/Cert_9_2_15_PendingPartition.py b/tests/scripts/thread-cert/Cert_9_2_15_PendingPartition.py index 8206d5f81..acd7f469f 100755 --- a/tests/scripts/thread-cert/Cert_9_2_15_PendingPartition.py +++ b/tests/scripts/thread-cert/Cert_9_2_15_PendingPartition.py @@ -30,6 +30,7 @@ import time import unittest +import config import node CHANNEL_INIT = 19 @@ -44,9 +45,11 @@ ROUTER2 = 4 class Cert_9_2_15_PendingPartition(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[COMMISSIONER].set_active_dataset(15, channel=CHANNEL_INIT, panid=PANID_INIT) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -82,30 +85,31 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[COMMISSIONER].send_mgmt_pending_set(pending_timestamp=10, active_timestamp=70, delay_timer=600000, mesh_local='fd00:0db9::') - time.sleep(5) + self.simulator.go(5) self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER2].reset() @@ -116,12 +120,12 @@ class Cert_9_2_15_PendingPartition(unittest.TestCase): delay_timer=200000, mesh_local='fd00:0db7::', panid=PANID_FINAL) - time.sleep(100) + self.simulator.go(100) self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') - time.sleep(100) + self.simulator.go(100) self.assertEqual(self.nodes[COMMISSIONER].get_panid(), PANID_FINAL) self.assertEqual(self.nodes[LEADER].get_panid(), PANID_FINAL) diff --git a/tests/scripts/thread-cert/Cert_9_2_16_ActivePendingPartition.py b/tests/scripts/thread-cert/Cert_9_2_16_ActivePendingPartition.py index 17f9a0eeb..e5219d12f 100755 --- a/tests/scripts/thread-cert/Cert_9_2_16_ActivePendingPartition.py +++ b/tests/scripts/thread-cert/Cert_9_2_16_ActivePendingPartition.py @@ -30,6 +30,7 @@ import time import unittest +import config import node CHANNEL_INIT = 19 @@ -45,9 +46,11 @@ ROUTER2 = 4 class Cert_9_2_16_ActivePendingPartition(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,5): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[COMMISSIONER].set_active_dataset(1, channel=CHANNEL_INIT, panid=PANID_INIT) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -83,30 +86,31 @@ class Cert_9_2_16_ActivePendingPartition(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[COMMISSIONER].send_mgmt_pending_set(pending_timestamp=10, active_timestamp=10, delay_timer=600000, mesh_local='fd00:0db9::') - time.sleep(5) + self.simulator.go(5) self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.nodes[ROUTER2].reset() @@ -117,14 +121,14 @@ class Cert_9_2_16_ActivePendingPartition(unittest.TestCase): delay_timer=200000, mesh_local='fd00:0db7::', panid=PANID_FINAL) - time.sleep(5) + self.simulator.go(5) self.nodes[COMMISSIONER].send_mgmt_active_set(active_timestamp=15, network_name='threadCert') - time.sleep(100) + self.simulator.go(100) self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') self.assertEqual(self.nodes[COMMISSIONER].get_network_name(), NETWORK_NAME_FINAL) @@ -132,7 +136,7 @@ class Cert_9_2_16_ActivePendingPartition(unittest.TestCase): self.assertEqual(self.nodes[ROUTER1].get_network_name(), NETWORK_NAME_FINAL) self.assertEqual(self.nodes[ROUTER2].get_network_name(), NETWORK_NAME_FINAL) - time.sleep(100) + self.simulator.go(100) self.assertEqual(self.nodes[COMMISSIONER].get_panid(), PANID_FINAL) self.assertEqual(self.nodes[LEADER].get_panid(), PANID_FINAL) diff --git a/tests/scripts/thread-cert/Cert_9_2_17_Orphan.py b/tests/scripts/thread-cert/Cert_9_2_17_Orphan.py index b15bfbddd..485c6d3f9 100755 --- a/tests/scripts/thread-cert/Cert_9_2_17_Orphan.py +++ b/tests/scripts/thread-cert/Cert_9_2_17_Orphan.py @@ -30,6 +30,7 @@ import time import unittest +import config import node CHANNEL1 = 11 @@ -43,9 +44,11 @@ ED1 = 3 class Cert_9_2_17_Orphan(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i, (i == ED1)) + self.nodes[i] = node.Node(i, (i == ED1), simulator=self.simulator) self.nodes[LEADER1].set_active_dataset(10, channel=CHANNEL1, panid=PANID_INIT, channel_mask=CHANNEL_MASK) self.nodes[LEADER1].set_mode('rsdn') @@ -69,10 +72,11 @@ class Cert_9_2_17_Orphan(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def test(self): self.nodes[LEADER1].start() - self.nodes[LEADER1].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER1].get_state(), 'leader') self.nodes[LEADER2].start() @@ -80,13 +84,13 @@ class Cert_9_2_17_Orphan(unittest.TestCase): self.assertEqual(self.nodes[LEADER2].get_state(), 'leader') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[LEADER1].stop() self.nodes[LEADER2].add_whitelist(self.nodes[ED1].get_addr64()) self.nodes[ED1].add_whitelist(self.nodes[LEADER2].get_addr64()) - time.sleep(20) + self.simulator.go(20) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.assertEqual(self.nodes[ED1].get_channel(), CHANNEL2) diff --git a/tests/scripts/thread-cert/Cert_9_2_18_RollBackActiveTimestamp.py b/tests/scripts/thread-cert/Cert_9_2_18_RollBackActiveTimestamp.py index d1d5323ee..43a81758e 100755 --- a/tests/scripts/thread-cert/Cert_9_2_18_RollBackActiveTimestamp.py +++ b/tests/scripts/thread-cert/Cert_9_2_18_RollBackActiveTimestamp.py @@ -30,6 +30,7 @@ import time import unittest +import config import node KEY1 = '00112233445566778899aabbccddeeff' @@ -49,9 +50,11 @@ MTDS = [ED1, SED1] class Cert_9_2_18_RollBackActiveTimestamp(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,7): - self.nodes[i] = node.Node(i, (i in MTDS)) + self.nodes[i] = node.Node(i, (i in MTDS), simulator=self.simulator) self.nodes[COMMISSIONER].set_active_dataset(1, channel=CHANNEL_INIT, panid=PANID_INIT, master_key=KEY1) self.nodes[COMMISSIONER].set_mode('rsdn') @@ -104,43 +107,43 @@ class Cert_9_2_18_RollBackActiveTimestamp(unittest.TestCase): def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[COMMISSIONER].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[COMMISSIONER].get_state(), 'router') self.nodes[COMMISSIONER].commissioner_start() - time.sleep(3) + self.simulator.go(3) self.nodes[ROUTER1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.nodes[ED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ED1].get_state(), 'child') self.nodes[SED1].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') self.nodes[COMMISSIONER].send_mgmt_active_set(active_timestamp=20000, network_name='GRL') - time.sleep(5) + self.simulator.go(5) self.nodes[COMMISSIONER].send_mgmt_pending_set(pending_timestamp=20, active_timestamp=20, delay_timer=20000, network_name='Shouldnotbe') - time.sleep(5) + self.simulator.go(5) self.nodes[COMMISSIONER].send_mgmt_pending_set(pending_timestamp=20, active_timestamp=20, delay_timer=20000, network_name='MyHouse', master_key=KEY2) - time.sleep(310) + self.simulator.go(310) self.assertEqual(self.nodes[COMMISSIONER].get_masterkey(), KEY2) self.assertEqual(self.nodes[LEADER].get_masterkey(), KEY2) @@ -150,7 +153,7 @@ class Cert_9_2_18_RollBackActiveTimestamp(unittest.TestCase): self.assertEqual(self.nodes[ROUTER2].get_masterkey(), KEY1) self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER2].get_state(), 'leader') if __name__ == '__main__': diff --git a/tests/scripts/thread-cert/Makefile.am b/tests/scripts/thread-cert/Makefile.am index ea21ce393..02579c584 100644 --- a/tests/scripts/thread-cert/Makefile.am +++ b/tests/scripts/thread-cert/Makefile.am @@ -133,6 +133,7 @@ EXTRA_DIST = \ network_layer.py \ node.py \ node_cli.py \ + simulator.py \ sniffer.py \ sniffer_transport.py \ test_coap.py \ diff --git a/tests/scripts/thread-cert/config.py b/tests/scripts/thread-cert/config.py index a6a1f4b1c..fb3d0d10a 100644 --- a/tests/scripts/thread-cert/config.py +++ b/tests/scripts/thread-cert/config.py @@ -37,6 +37,7 @@ import mle import net_crypto import network_data import network_layer +import simulator import sniffer MESH_LOCAL_PREFIX = 'fdde:ad00:beef::/64' @@ -67,6 +68,8 @@ INFINITE_COST_TIMEOUT = 90 MAX_ADVERTISEMENT_INTERVAL = 32 MLE_END_DEVICE_TIMEOUT = 100 +VIRTUAL_TIME = bool(os.getenv('VIRTUAL_TIME', False)) + def create_default_network_data_prefix_sub_tlvs_factories(): return { network_data.TlvType.HAS_ROUTE: network_data.HasRouteFactory( @@ -331,3 +334,9 @@ def create_default_thread_message_factory(master_key=DEFAULT_MASTER_KEY): def create_default_thread_sniffer(nodeid=SNIFFER_ID): return sniffer.Sniffer(nodeid, create_default_thread_message_factory()) + + +def create_default_simulator(): + if VIRTUAL_TIME: + return simulator.VirtualTime() + return simulator.RealTime() diff --git a/tests/scripts/thread-cert/node.py b/tests/scripts/thread-cert/node.py index a585172ff..8f37cdf86 100755 --- a/tests/scripts/thread-cert/node.py +++ b/tests/scripts/thread-cert/node.py @@ -38,9 +38,11 @@ import unittest import config class Node: - def __init__(self, nodeid, is_mtd=False): + def __init__(self, nodeid, is_mtd=False, simulator=None): + self.simulator = simulator + if sys.platform != 'win32': - self.interface = node_cli.otCli(nodeid, is_mtd) + self.interface = node_cli.otCli(nodeid, is_mtd, simulator=simulator) else: self.interface = node_api.otApi(nodeid) @@ -239,7 +241,7 @@ class Node: def scan(self): return self.interface.scan() - def ping(self, ipaddr, num_responses=1, size=None, timeout=5000): + def ping(self, ipaddr, num_responses=1, size=None, timeout=5): return self.interface.ping(ipaddr, num_responses, size, timeout) def reset(self): diff --git a/tests/scripts/thread-cert/node_cli.py b/tests/scripts/thread-cert/node_cli.py index 43b8513fd..1fd42ed9c 100644 --- a/tests/scripts/thread-cert/node_cli.py +++ b/tests/scripts/thread-cert/node_cli.py @@ -35,12 +35,14 @@ import re import ipaddress import config +import simulator class otCli: - def __init__(self, nodeid, is_mtd): + def __init__(self, nodeid, is_mtd, simulator=None): self.nodeid = nodeid self.verbose = int(float(os.getenv('VERBOSE', 0))) self.node_type = os.getenv('NODE_TYPE', 'sim') + self.simulator = simulator mode = os.environ.get('USE_MTD') is '1' and is_mtd and 'mtd' or 'ftd' @@ -103,7 +105,10 @@ class otCli: def send_command(self, cmd): print("%d: %s" % (self.nodeid, cmd)) - self.pexpect.sendline(cmd) + self.pexpect.send(cmd + '\n') + + if isinstance(self.simulator, simulator.VirtualTime): + self.simulator.receive_events() def get_commands(self): self.send_command('?') @@ -532,12 +537,26 @@ class otCli: def energy_scan(self, mask, count, period, scan_duration, ipaddr): cmd = 'commissioner energy ' + str(mask) + ' ' + str(count) + ' ' + str(period) + ' ' + str(scan_duration) + ' ' + ipaddr self.send_command(cmd) - self.pexpect.expect('Energy:', timeout=8) + + if isinstance(self.simulator, simulator.VirtualTime): + self.simulator.go(8) + timeout = 1 + else: + timeout = 8 + + self.pexpect.expect('Energy:', timeout=timeout) def panid_query(self, panid, mask, ipaddr): cmd = 'commissioner panid ' + str(panid) + ' ' + str(mask) + ' ' + ipaddr self.send_command(cmd) - self.pexpect.expect('Conflict:', timeout=8) + + if isinstance(self.simulator, simulator.VirtualTime): + self.simulator.go(8) + timeout = 1 + else: + timeout = 8 + + self.pexpect.expect('Conflict:', timeout=timeout) def scan(self): self.send_command('scan') @@ -553,13 +572,21 @@ class otCli: return results - def ping(self, ipaddr, num_responses=1, size=None, timeout=5000): + def ping(self, ipaddr, num_responses=1, size=None, timeout=5): cmd = 'ping ' + ipaddr if size != None: cmd += ' ' + str(size) self.send_command(cmd) + try: + self.pexpect.expect('Done', timeout=0.01) + except pexpect.TIMEOUT: + pass + + if isinstance(self.simulator, simulator.VirtualTime): + self.simulator.go(timeout) + result = True try: responders = {} @@ -575,6 +602,10 @@ class otCli: def reset(self): self.send_command('reset') + try: + self.pexpect.expect('Done', timeout=0.01) + except pexpect.TIMEOUT: + pass def set_router_selection_jitter(self, jitter): cmd = 'routerselectionjitter %d' % jitter diff --git a/tests/scripts/thread-cert/simulator.py b/tests/scripts/thread-cert/simulator.py new file mode 100644 index 000000000..63e9ef65b --- /dev/null +++ b/tests/scripts/thread-cert/simulator.py @@ -0,0 +1,240 @@ +#!/usr/bin/env python +# +# Copyright (c) 2018, The OpenThread Authors. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# 3. Neither the name of the copyright holder nor the +# names of its contributors may be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# + +import bisect +import cmd +import os +import socket +import struct +import time +import sys + +import io +import config +import message + +class RealTime: + + def __init__(self): + self._sniffer = config.create_default_thread_sniffer() + self._sniffer.start() + + def set_lowpan_context(self, cid, prefix): + self._sniffer.set_lowpan_context(cid, prefix) + + def get_messages_sent_by(self, nodeid): + return self._sniffer.get_messages_sent_by(nodeid) + + def go(self, duration): + time.sleep(duration) + +class VirtualTime: + + BASE_PORT = 9000 + MAX_NODES = 34 + PORT_OFFSET = int(os.getenv('PORT_OFFSET', "0")) + + def __init__(self): + self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + + ip = '127.0.0.1' + self.port = self.BASE_PORT + (self.PORT_OFFSET * self.MAX_NODES) + self.sock.bind((ip, self.port)) + + self.devices = {} + self.event_queue = [] + self.event_count = 0 + self.current_time = 0 + self.current_event = None; + + self._message_factory = config.create_default_thread_message_factory() + + def __del__(self): + self.sock.close() + + def _add_message(self, nodeid, message): + addr = ('127.0.0.1', self.port + nodeid) + + # Ignore any exceptions + try: + msg = self._message_factory.create(io.BytesIO(message)) + + if msg is not None: + self.devices[addr]['msgs'].append(msg) + + except Exception as e: + # Just print the exception to the console + print("EXCEPTION: %s" % e) + pass + + def set_lowpan_context(self, cid, prefix): + self._message_factory.set_lowpan_context(cid, prefix) + + def get_messages_sent_by(self, nodeid): + """ Get sniffed messages. + + Note! This method flushes the message queue so calling this method again will return only the newly logged messages. + + Args: + nodeid (int): node id + + Returns: + MessagesSet: a set with received messages. + """ + addr = ('127.0.0.1', self.port + nodeid) + + messages = self.devices[addr]['msgs'] + self.devices[addr]['msgs'] = [] + + return message.MessagesSet(messages) + + def receive_events(self): + + if self.current_event is None: + self.sock.setblocking(0) + else: + self.sock.setblocking(1) + + while True: + try: + msg, addr = self.sock.recvfrom(1024) + except socket.error: + break + + if addr not in self.devices: + self.devices[addr] = {} + self.devices[addr]['alarm'] = None + self.devices[addr]['msgs'] = [] + self.devices[addr]['time'] = self.current_time + #print "New device:", addr, self.devices + + delay, type, datalen = struct.unpack('=QBH', msg[:11]) + data = msg[11:] + + event_time = self.current_time + delay + + if type == 0: + # remove any existing alarm event for device + try: + self.event_queue.remove(self.devices[addr]['alarm']) + #print "-- Remove\t", self.devices[addr]['alarm'] + self.devices[addr]['alarm'] = None + except ValueError: + pass + + # add alarm event to event queue + event = (event_time, addr, type, datalen) + #print "-- Enqueue\t", event, delay, self.current_time + bisect.insort(self.event_queue, event) + self.devices[addr]['alarm'] = event + + if self.current_event is not None and self.current_event[1] == addr: + #print "Done\t", self.current_event + self.current_event = None + return + + elif type == 1: + # add radio receive events event queue + for device in self.devices: + if device != addr: + event = (event_time, device, type, datalen, data) + #print "-- Enqueue\t", event + bisect.insort(self.event_queue, event) + + self._add_message(addr[1] - self.port, data) + + # add radio transmit done events to event queue + event = (event_time, addr, type, datalen, data) + bisect.insort(self.event_queue, event) + + def process_next_event(self): + + if self.current_event != None: + return + + #print "Events", len(self.event_queue) + count = 0 + for event in self.event_queue: + #print count, event + count += 1 + + # process next event + try: + event = self.event_queue.pop(0) + except IndexError: + return + + #print "Pop\t", event + + if len(event) == 4: + event_time, addr, type, datalen = event + else: + event_time, addr, type, datalen, data = event + + self.event_count += 1 + self.current_event = event + + assert(event_time >= self.current_time) + self.current_time = event_time + + elapsed = event_time - self.devices[addr]['time'] + self.devices[addr]['time'] = event_time + + message = struct.pack('=QBH', elapsed, type, datalen) + + if type == 0: + self.devices[addr]['alarm'] = None + self.sock.sendto(message, addr) + elif type == 1: + message += data + self.sock.sendto(message, addr) + + def sync_devices(self): + for addr in self.devices: + elapsed = self.current_time - self.devices[addr]['time'] + self.devices[addr]['time'] = self.current_time + message = struct.pack('=QBH', elapsed, 0, 0) + self.sock.sendto(message, addr) + + def go(self, duration): + + duration = int(duration) * 1000000 + + start_time = self.current_time + self.current_event = None + + print "running for %d us" % duration + + self.receive_events() + + while (self.current_time - start_time) < duration: + self.process_next_event() + self.receive_events() + + self.sync_devices() diff --git a/tests/scripts/thread-cert/test_service.py b/tests/scripts/thread-cert/test_service.py index 577f9f1c5..6312f105e 100755 --- a/tests/scripts/thread-cert/test_service.py +++ b/tests/scripts/thread-cert/test_service.py @@ -50,9 +50,11 @@ SRV_1_SERVER_DATA = 'qux' class Test_Service(unittest.TestCase): def setUp(self): + self.simulator = config.create_default_simulator() + self.nodes = {} for i in range(1,4): - self.nodes[i] = node.Node(i) + self.nodes[i] = node.Node(i, simulator=self.simulator) self.nodes[LEADER].set_panid(0xface) self.nodes[LEADER].set_mode('rsdn') @@ -84,6 +86,7 @@ class Test_Service(unittest.TestCase): for node in list(self.nodes.values()): node.stop() del self.nodes + del self.simulator def hasAloc(self, node_id, service_id): for addr in self.nodes[node_id].get_ip6_address(config.ADDRESS_TYPE.ALOC): @@ -100,16 +103,16 @@ class Test_Service(unittest.TestCase): def failToPingFromAll(self, addr): for node in list(self.nodes.values()): - self.assertFalse(node.ping(addr, timeout=3000)) + self.assertFalse(node.ping(addr, timeout=3)) def test(self): self.nodes[LEADER].start() - self.nodes[LEADER].set_state('leader') + self.simulator.go(5) self.assertEqual(self.nodes[LEADER].get_state(), 'leader') self.nodes[ROUTER1].start() self.nodes[ROUTER2].start() - time.sleep(5) + self.simulator.go(5) self.assertEqual(self.nodes[ROUTER1].get_state(), 'router') self.assertEqual(self.nodes[ROUTER2].get_state(), 'router') @@ -122,7 +125,7 @@ class Test_Service(unittest.TestCase): self.nodes[ROUTER1].add_service(SRV_0_ENT_NUMBER, SRV_0_SERVICE_DATA, SRV_0_SERVER_DATA) self.nodes[ROUTER1].register_netdata() - time.sleep(2) + self.simulator.go(2) self.assertEqual(self.hasAloc(LEADER, SRV_0_ID), False) self.assertEqual(self.hasAloc(LEADER, SRV_1_ID), False) @@ -136,7 +139,7 @@ class Test_Service(unittest.TestCase): self.nodes[LEADER].add_service(SRV_0_ENT_NUMBER, SRV_0_SERVICE_DATA, SRV_0_SERVER_DATA) self.nodes[LEADER].register_netdata() - time.sleep(2) + self.simulator.go(2) self.assertEqual(self.hasAloc(LEADER, SRV_0_ID), True) self.assertEqual(self.hasAloc(LEADER, SRV_1_ID), False) @@ -149,7 +152,7 @@ class Test_Service(unittest.TestCase): self.nodes[ROUTER2].add_service(SRV_1_ENT_NUMBER, SRV_1_SERVICE_DATA, SRV_1_SERVER_DATA) self.nodes[ROUTER2].register_netdata() - time.sleep(2) + self.simulator.go(2) self.assertEqual(self.hasAloc(LEADER, SRV_0_ID), True) self.assertEqual(self.hasAloc(LEADER, SRV_1_ID), False) @@ -164,7 +167,7 @@ class Test_Service(unittest.TestCase): self.nodes[ROUTER1].remove_service(SRV_0_ENT_NUMBER, SRV_0_SERVICE_DATA) self.nodes[ROUTER1].register_netdata() - time.sleep(2) + self.simulator.go(2) self.assertEqual(self.hasAloc(LEADER, SRV_0_ID), True) self.assertEqual(self.hasAloc(LEADER, SRV_1_ID), False) @@ -178,7 +181,7 @@ class Test_Service(unittest.TestCase): self.nodes[LEADER].remove_service(SRV_0_ENT_NUMBER, SRV_0_SERVICE_DATA) self.nodes[LEADER].register_netdata() - time.sleep(2) + self.simulator.go(2) self.assertEqual(self.hasAloc(LEADER, SRV_0_ID), False) self.assertEqual(self.hasAloc(LEADER, SRV_1_ID), False) @@ -192,7 +195,7 @@ class Test_Service(unittest.TestCase): self.nodes[ROUTER2].remove_service(SRV_1_ENT_NUMBER, SRV_1_SERVICE_DATA) self.nodes[ROUTER2].register_netdata() - time.sleep(2) + self.simulator.go(2) self.assertEqual(self.hasAloc(LEADER, SRV_0_ID), False) self.assertEqual(self.hasAloc(LEADER, SRV_1_ID), False)