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 7319fc9bd..a0466908f 100755 --- a/tests/scripts/thread-cert/Cert_5_6_01_NetworkDataRegisterBeforeAttachLeader.py +++ b/tests/scripts/thread-cert/Cert_5_6_01_NetworkDataRegisterBeforeAttachLeader.py @@ -31,6 +31,9 @@ import unittest import config import thread_cert +from pktverify.consts import MLE_ADVERTISEMENT, MLE_LINK_REQUEST, MLE_PARENT_REQUEST, MLE_PARENT_RESPONSE, MLE_CHILD_UPDATE_RESPONSE, MLE_CHILD_ID_REQUEST, MLE_CHILD_ID_RESPONSE, RESPONSE_TLV, LINK_LAYER_FRAME_COUNTER_TLV, MODE_TLV, TIMEOUT_TLV, VERSION_TLV, TLV_REQUEST_TLV, ADDRESS16_TLV, NETWORK_DATA_TLV, ROUTE64_TLV, MODE_TLV, TIMEOUT_TLV, CHALLENGE_TLV, SOURCE_ADDRESS_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV +from pktverify.packet_verifier import PacketVerifier +from pktverify.addrs import Ipv6Addr LEADER = 1 ROUTER = 2 @@ -43,23 +46,27 @@ MTDS = [ED1, SED1] class Cert_5_6_1_NetworkDataLeaderAsBr(thread_cert.TestCase): TOPOLOGY = { LEADER: { + 'name': 'LEADER', 'mode': 'rsdn', 'panid': 0xface, 'whitelist': [ROUTER] }, ROUTER: { + 'name': 'ROUTER', 'mode': 'rsdn', 'panid': 0xface, 'router_selection_jitter': 1, 'whitelist': [LEADER, ED1, SED1] }, ED1: { + 'name': 'MED', 'is_mtd': True, 'mode': 'rsn', 'panid': 0xface, 'whitelist': [ROUTER] }, SED1: { + 'name': 'SED', 'is_mtd': True, 'mode': 's', 'panid': 0xface, @@ -95,6 +102,7 @@ class Cert_5_6_1_NetworkDataLeaderAsBr(thread_cert.TestCase): self.simulator.go(5) self.assertEqual(self.nodes[SED1].get_state(), 'child') + self.collect_rloc16s() addrs = self.nodes[ED1].get_addrs() self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) self.assertTrue(any('2001:2:0:2' in addr[0:10] for addr in addrs)) @@ -109,6 +117,62 @@ class Cert_5_6_1_NetworkDataLeaderAsBr(thread_cert.TestCase): if addr[0:10] == '2001:2:0:1' or addr[0:10] == '2001:2:0:2': self.assertTrue(self.nodes[LEADER].ping(addr)) + def verify(self, pv): + pkts = pv.pkts + pv.summary.show() + + ROUTER = pv.vars['ROUTER'] + MED = pv.vars['MED'] + SED = pv.vars['SED'] + _rpkts = pkts.filter_wpan_src64(ROUTER) + _mpkts = pkts.filter_wpan_src64(MED) + _spkts = pkts.filter_wpan_src64(SED) + + # Step 3: The DUT MUST request the Network Data TLV during the + # attaching procedure when sending MLE Child ID Request frame + _rpkts.filter_mle_cmd(MLE_CHILD_ID_REQUEST).must_next().must_verify( + lambda p: { + RESPONSE_TLV, LINK_LAYER_FRAME_COUNTER_TLV, MODE_TLV, TIMEOUT_TLV, VERSION_TLV, TLV_REQUEST_TLV, + ADDRESS16_TLV, NETWORK_DATA_TLV, ROUTE64_TLV + } < set(p.mle.tlv.type)) + _rpkts_med = _rpkts.copy() + _rpkts_sed = _rpkts.copy() + + # Step 6: The DUT MUST send an MLE Child ID Response to SED_1, + # containing only stable Network Data + _rpkts_sed.filter_mle_cmd(MLE_CHILD_ID_RESPONSE).filter_wpan_dst64(SED).must_next().must_verify( + lambda p: {MODE_TLV, TIMEOUT_TLV, CHALLENGE_TLV} == set(p.thread_nwd.tlv.type) and + {Ipv6Addr('2001:2:0:1::')} == set(p.thread_nwd.tlv.prefix) and p.thread_nwd.tlv.border_router.flag.p == + [1] and p.thread_nwd.tlv.border_router.flag.s == [1] and p.thread_nwd.tlv.border_router.flag.r == [1] and p + .thread_nwd.tlv.border_router.flag.o == [1] and p.thread_nwd.tlv.stable == [1, 1, 1]) + + # Step 8: The DUT MUST send a MLE Child ID Response to MED_1, + # containing the full Network Data + _rpkts_med.filter_mle_cmd(MLE_CHILD_ID_RESPONSE).filter_wpan_dst64(MED).must_next().must_verify( + lambda p: {Ipv6Addr('2001:2:0:1::'), Ipv6Addr('2001:2:0:2::')} == set( + p.thread_nwd.tlv.prefix) and p.thread_nwd.tlv.border_router.flag.p == [1, 1] and p.thread_nwd.tlv. + border_router.flag.s == [1, 1] and p.thread_nwd.tlv.border_router.flag.r == [1, 1] and p.thread_nwd.tlv. + border_router.flag.o == [1, 1] and p.thread_nwd.tlv.stable == [0, 1, 1, 1, 0, 0, 0]) + + # Step 10: The DUT MUST send a unicast MLE Child Update + # Response to each of MED_1 and SED_1 + _rpkts_med.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).must_next().must_verify( + lambda p: p.wpan.dst64 == MED and + {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + _rpkts_sed.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).must_next().must_verify( + lambda p: p.wpan.dst64 == SED and + {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + + # Step 11: MED_1 and SED_1 MUST respond to each ICMPv6 Echo Request + # with an ICMPv6 Echo Reply + med_rloc16 = pv.vars['MED_RLOC16'] + sed_rloc16 = pv.vars['SED_RLOC16'] + router_rloc16 = pv.vars['ROUTER_RLOC16'] + _mpkts.range(_rpkts_med.index).filter( + lambda p: p.wpan.src16 == med_rloc16 and p.wpan.dst16 == router_rloc16).filter_ping_reply().must_next() + _spkts.range(_rpkts_sed.index).filter( + lambda p: p.wpan.src16 == sed_rloc16 and p.wpan.dst16 == router_rloc16).filter_ping_reply().must_next() + if __name__ == '__main__': unittest.main() 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 1663533ac..5fd1ae9ff 100755 --- a/tests/scripts/thread-cert/Cert_5_6_02_NetworkDataRegisterBeforeAttachRouter.py +++ b/tests/scripts/thread-cert/Cert_5_6_02_NetworkDataRegisterBeforeAttachRouter.py @@ -31,6 +31,9 @@ import unittest import config import thread_cert +from pktverify.consts import MLE_ADVERTISEMENT, MLE_DATA_RESPONSE, MLE_CHILD_ID_RESPONSE, ADDR_SOL_URI, MLE_CHILD_UPDATE_RESPONSE, MODE_TLV, LEADER_DATA_TLV, ROUTE64_TLV, SOURCE_ADDRESS_TLV, ACTIVE_TIMESTAMP_TLV, ADDRESS16_TLV, NETWORK_DATA_TLV, ADDRESS_REGISTRATION_TLV +from pktverify.packet_verifier import PacketVerifier +from pktverify.addrs import Ipv6Addr LEADER = 1 ROUTER = 2 @@ -43,23 +46,27 @@ MTDS = [ED1, SED1] class Cert_5_6_2_NetworkDataRouterAsBr(thread_cert.TestCase): TOPOLOGY = { LEADER: { + 'name': 'LEADER', 'mode': 'rsdn', 'panid': 0xface, 'whitelist': [ROUTER, ED1, SED1] }, ROUTER: { + 'name': 'ROUTER', 'mode': 'rsdn', 'panid': 0xface, 'router_selection_jitter': 1, 'whitelist': [LEADER] }, ED1: { + 'name': 'MED', 'is_mtd': True, 'mode': 'rsn', 'panid': 0xface, 'whitelist': [LEADER] }, SED1: { + 'name': 'SED', 'is_mtd': True, 'mode': 's', 'panid': 0xface, @@ -107,6 +114,60 @@ class Cert_5_6_2_NetworkDataRouterAsBr(thread_cert.TestCase): if addr[0:10] == '2001:2:0:1' or addr[0:10] == '2001:2:0:2': self.assertTrue(self.nodes[LEADER].ping(addr)) + def verify(self, pv): + pkts = pv.pkts + pv.summary.show() + + LEADER = pv.vars['LEADER'] + ROUTER = pv.vars['ROUTER'] + MED = pv.vars['MED'] + SED = pv.vars['SED'] + _lpkts = pkts.filter_wpan_src64(LEADER) + + # Step 1: The DUT MUST send properly formatted MLE Advertisements + _lpkts.filter_mle_cmd(MLE_ADVERTISEMENT).must_next().must_verify( + lambda p: {LEADER_DATA_TLV, ROUTE64_TLV, SOURCE_ADDRESS_TLV} == set(p.mle.tlv.type)) + + # Step 3: The DUT MUST properly attach Router_1 device to the network, + # and transmit Network Data during the attach phase in the + # Child ID Response frame of the Network Data TLV + _lpkts.filter_mle_cmd(MLE_CHILD_ID_RESPONSE).must_next().must_verify(lambda p: p.wpan.dst64 == ROUTER and { + SOURCE_ADDRESS_TLV, LEADER_DATA_TLV, ACTIVE_TIMESTAMP_TLV, ADDRESS16_TLV, NETWORK_DATA_TLV + } < set(p.mle.tlv.type)) + + # Step 5: The DUT Automatically sends a CoAP Response frame and + # MLE Data Response message + _lpkts.filter_coap_ack(ADDR_SOL_URI).must_next() + _lpkts.filter_mle_cmd(MLE_DATA_RESPONSE).must_next().must_verify( + lambda p: {Ipv6Addr('2001:2:0:1::'), Ipv6Addr('2001:2:0:2::')} == set( + p.thread_nwd.tlv.prefix) and p.thread_nwd.tlv.border_router.flag.p == [1, 1] and p.thread_nwd.tlv. + border_router.flag.s == [1, 1] and p.thread_nwd.tlv.border_router.flag.r == [1, 1] and p.thread_nwd.tlv. + border_router.flag.o == [1, 1] and p.thread_nwd.tlv.stable == [0, 1, 1, 1, 0, 0, 0]) + _lpkts_med = _lpkts.copy() + _lpkts_sed = _lpkts.copy() + + # Step 7: The DUT MUST send a MLE Child ID Response to SED_1, + # containing the stable Network Data + _lpkts_sed.filter_mle_cmd(MLE_CHILD_ID_RESPONSE).filter_wpan_dst64(SED).must_next().must_verify( + lambda p: {Ipv6Addr('2001:2:0:1::')} == set(p.thread_nwd.tlv.prefix) and p.thread_nwd.tlv.border_router. + flag.p == [1] and p.thread_nwd.tlv.border_router.flag.s == [1] and p.thread_nwd.tlv.border_router.flag.r == + [1] and p.thread_nwd.tlv.border_router.flag.o == [1] and p.thread_nwd.tlv.stable == [1, 1, 1]) + + # Step 9: The DUT MUST send a MLE Child ID Response to MED_1, + # containing the full Network Data + _lpkts_med.filter_mle_cmd(MLE_CHILD_ID_RESPONSE).filter_wpan_dst64(MED).must_next().must_verify( + lambda p: {Ipv6Addr('2001:2:0:1::'), Ipv6Addr('2001:2:0:2::')} == set( + p.thread_nwd.tlv.prefix) and p.thread_nwd.tlv.border_router.flag.p == [1, 1] and p.thread_nwd.tlv. + border_router.flag.s == [1, 1] and p.thread_nwd.tlv.border_router.flag.r == [1, 1] and p.thread_nwd.tlv. + border_router.flag.o == [1, 1] and p.thread_nwd.tlv.stable == [0, 1, 1, 1, 0, 0, 0]) + + # Step 10: The DUT MUST send a unicast MLE Child Update + # Response to each of MED_1 and SED_1 + _lpkts_med.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).filter_wpan_dst64(MED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + _lpkts_sed.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).filter_wpan_dst64(SED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + if __name__ == '__main__': unittest.main() 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 5dab72fb4..cae9ba83a 100755 --- a/tests/scripts/thread-cert/Cert_5_6_03_NetworkDataRegisterAfterAttachLeader.py +++ b/tests/scripts/thread-cert/Cert_5_6_03_NetworkDataRegisterAfterAttachLeader.py @@ -31,6 +31,9 @@ import unittest import config import thread_cert +from pktverify.consts import MLE_ADVERTISEMENT, MLE_DATA_RESPONSE, MLE_CHILD_ID_RESPONSE, MLE_CHILD_UPDATE_REQUEST, ADDR_SOL_URI, MLE_CHILD_UPDATE_RESPONSE, MODE_TLV, LEADER_DATA_TLV, ROUTE64_TLV, SOURCE_ADDRESS_TLV, ACTIVE_TIMESTAMP_TLV, ADDRESS16_TLV, NETWORK_DATA_TLV, ADDRESS_REGISTRATION_TLV, LINK_LOCAL_ALL_NODES_MULTICAST_ADDRESS +from pktverify.packet_verifier import PacketVerifier +from pktverify.addrs import Ipv6Addr LEADER = 1 ROUTER = 2 @@ -43,23 +46,27 @@ MTDS = [ED1, SED1] class Cert_5_6_3_NetworkDataRegisterAfterAttachLeader(thread_cert.TestCase): TOPOLOGY = { LEADER: { + 'name': 'LEADER', 'mode': 'rsdn', 'panid': 0xface, 'whitelist': [ROUTER] }, ROUTER: { + 'name': 'ROUTER', 'mode': 'rsdn', 'panid': 0xface, 'router_selection_jitter': 1, 'whitelist': [LEADER, ED1, SED1] }, ED1: { + 'name': 'MED', 'is_mtd': True, 'mode': 'rsn', 'panid': 0xface, 'whitelist': [ROUTER] }, SED1: { + 'name': 'SED', 'is_mtd': True, 'mode': 's', 'panid': 0xface, @@ -109,6 +116,45 @@ class Cert_5_6_3_NetworkDataRegisterAfterAttachLeader(thread_cert.TestCase): if addr[0:10] == '2001:2:0:1' or addr[0:10] == '2001:2:0:2': self.assertTrue(self.nodes[LEADER].ping(addr)) + def verify(self, pv): + pkts = pv.pkts + pv.summary.show() + + ROUTER = pv.vars['ROUTER'] + MED = pv.vars['MED'] + SED = pv.vars['SED'] + _rpkts = pkts.filter_wpan_src64(ROUTER) + + _rpkts_med = _rpkts.copy() + _rpkts_sed = _rpkts.copy() + + # Step 3: The DUT MUST multicast a MLE Data Response for each + # prefix sent by the Leader (Prefix 1 and Prefix 2) + _rpkts.filter_mle_cmd(MLE_DATA_RESPONSE).filter_ipv6_dst(LINK_LOCAL_ALL_NODES_MULTICAST_ADDRESS).must_next( + ).must_verify(lambda p: {Ipv6Addr('2001:2:0:1::'), Ipv6Addr('2001:2:0:2::')} == set(p.thread_nwd.tlv.prefix) + and p.thread_nwd.tlv.border_router.flag.p == [1, 1] and p.thread_nwd.tlv.border_router.flag.s == + [1, 1] and p.thread_nwd.tlv.border_router.flag.r == [1, 1] and p.thread_nwd.tlv.border_router. + flag.o == [1, 1] and p.thread_nwd.tlv.stable == [0, 1, 1, 1, 0, 0, 0]) + + # Step 5: The DUT MUST send a unicast MLE Child Update + # Response to MED_1 + _rpkts_med.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).filter_wpan_dst64(MED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + + # Step 6: The DUT MUST send a unicast MLE Child Update + # Request to SED_1 + _rpkts_sed.filter_mle_cmd(MLE_CHILD_UPDATE_REQUEST).filter_wpan_dst64(SED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, LEADER_DATA_TLV, NETWORK_DATA_TLV, ACTIVE_TIMESTAMP_TLV} == set( + p.mle.tlv.type) and {Ipv6Addr('2001:2:0:1::')} == set(p.thread_nwd.tlv.prefix) and p.thread_nwd.tlv. + border_router.flag.p == [1] and p.thread_nwd.tlv.border_router.flag.s == [1] and p.thread_nwd.tlv. + border_router.flag.r == [1] and p.thread_nwd.tlv.border_router.flag.o == [1] and p.thread_nwd.tlv.stable == + [1, 1, 1] and p.thread_nwd.tlv.border_router_16 == 0xFFFE) + + # Step 8: The DUT MUST send a unicast MLE Child Update + # Response to SED_1 + _rpkts_sed.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).filter_wpan_dst64(SED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + if __name__ == '__main__': unittest.main() 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 bbef541bb..e5f132f25 100755 --- a/tests/scripts/thread-cert/Cert_5_6_04_NetworkDataRegisterAfterAttachRouter.py +++ b/tests/scripts/thread-cert/Cert_5_6_04_NetworkDataRegisterAfterAttachRouter.py @@ -31,6 +31,9 @@ import unittest import config import thread_cert +from pktverify.consts import MLE_ADVERTISEMENT, MLE_DATA_RESPONSE, MLE_CHILD_ID_RESPONSE, MLE_CHILD_UPDATE_REQUEST, SVR_DATA_URI, MLE_CHILD_UPDATE_RESPONSE, MODE_TLV, LEADER_DATA_TLV, ROUTE64_TLV, SOURCE_ADDRESS_TLV, ACTIVE_TIMESTAMP_TLV, ADDRESS16_TLV, NETWORK_DATA_TLV, ADDRESS_REGISTRATION_TLV, LINK_LOCAL_ALL_NODES_MULTICAST_ADDRESS +from pktverify.packet_verifier import PacketVerifier +from pktverify.addrs import Ipv6Addr LEADER = 1 ROUTER = 2 @@ -43,28 +46,32 @@ MTDS = [ED1, SED1] class Cert_5_6_4_NetworkDataRegisterAfterAttachRouter(thread_cert.TestCase): TOPOLOGY = { LEADER: { + 'name': 'LEADER', 'mode': 'rsdn', 'panid': 0xface, - 'whitelist': [ROUTER] + 'whitelist': [ROUTER, ED1, SED1] }, ROUTER: { + 'name': 'ROUTER', 'mode': 'rsdn', 'panid': 0xface, 'router_selection_jitter': 1, - 'whitelist': [LEADER, ED1, SED1] + 'whitelist': [LEADER] }, ED1: { + 'name': 'MED', 'is_mtd': True, 'mode': 'rsn', 'panid': 0xface, - 'whitelist': [ROUTER] + 'whitelist': [LEADER] }, SED1: { + 'name': 'SED', 'is_mtd': True, 'mode': 's', 'panid': 0xface, 'timeout': config.DEFAULT_CHILD_TIMEOUT, - 'whitelist': [ROUTER] + 'whitelist': [LEADER] }, } @@ -109,6 +116,52 @@ class Cert_5_6_4_NetworkDataRegisterAfterAttachRouter(thread_cert.TestCase): if addr[0:10] == '2001:2:0:1' or addr[0:10] == '2001:2:0:2': self.assertTrue(self.nodes[LEADER].ping(addr)) + def verify(self, pv): + pkts = pv.pkts + pv.summary.show() + + LEADER = pv.vars['LEADER'] + MED = pv.vars['MED'] + SED = pv.vars['SED'] + _lpkts = pkts.filter_wpan_src64(LEADER) + + # Step 1: Ensure the topology is formed correctly + _lpkts.filter_mle_cmd(MLE_CHILD_ID_RESPONSE).filter_wpan_dst64(SED).must_next() + + # Step 3: The DUT Automatically sends a CoAP Response frame and + # MLE Data Response message + _lpkts.copy().filter_coap_ack(SVR_DATA_URI).must_next() + + _lpkts_med = _lpkts.copy() + _lpkts_sed = _lpkts.copy() + + # Step 4: The DUT MUST send a multicast MLE Data Response with + # the new network information collected from Router_1 + _lpkts.filter_mle_cmd(MLE_DATA_RESPONSE).filter_ipv6_dst(LINK_LOCAL_ALL_NODES_MULTICAST_ADDRESS).must_next( + ).must_verify(lambda p: {Ipv6Addr('2001:2:0:1::'), Ipv6Addr('2001:2:0:2::')} == set(p.thread_nwd.tlv.prefix) + and p.thread_nwd.tlv.border_router.flag.p == [1, 1] and p.thread_nwd.tlv.border_router.flag.s == + [1, 1] and p.thread_nwd.tlv.border_router.flag.r == [1, 1] and p.thread_nwd.tlv.border_router. + flag.o == [1, 1] and p.thread_nwd.tlv.stable == [0, 1, 1, 1, 0, 0, 0]) + + # Step 7: The DUT MUST send a unicast MLE Child Update + # Response to MED_1 + _lpkts_med.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).filter_wpan_dst64(MED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + + # Step 9: The DUT MUST send a unicast MLE Child Update + # Request to SED_1 + _lpkts_sed.filter_mle_cmd(MLE_CHILD_UPDATE_REQUEST).filter_wpan_dst64(SED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, LEADER_DATA_TLV, NETWORK_DATA_TLV, ACTIVE_TIMESTAMP_TLV} == set( + p.mle.tlv.type) and {Ipv6Addr('2001:2:0:1::')} == set(p.thread_nwd.tlv.prefix) and p.thread_nwd.tlv. + border_router.flag.p == [1] and p.thread_nwd.tlv.border_router.flag.s == [1] and p.thread_nwd.tlv. + border_router.flag.r == [1] and p.thread_nwd.tlv.border_router.flag.o == [1] and p.thread_nwd.tlv.stable == + [1, 1, 1] and p.thread_nwd.tlv.border_router_16 == 0xFFFE) + + # Step 11: The DUT MUST send a unicast MLE Child Update + # Response to SED_1 + _lpkts_sed.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).filter_wpan_dst64(SED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + if __name__ == '__main__': unittest.main() 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 9c84f1b1d..69d4b7687 100755 --- a/tests/scripts/thread-cert/Cert_5_6_05_NetworkDataRegisterAfterAttachRouter.py +++ b/tests/scripts/thread-cert/Cert_5_6_05_NetworkDataRegisterAfterAttachRouter.py @@ -31,6 +31,9 @@ import unittest import config import thread_cert +from pktverify.consts import MLE_ADVERTISEMENT, MLE_DATA_RESPONSE, MLE_CHILD_ID_RESPONSE, MLE_CHILD_UPDATE_REQUEST, SVR_DATA_URI, MLE_CHILD_UPDATE_RESPONSE, MODE_TLV, LEADER_DATA_TLV, ROUTE64_TLV, SOURCE_ADDRESS_TLV, ACTIVE_TIMESTAMP_TLV, ADDRESS16_TLV, NETWORK_DATA_TLV, ADDRESS_REGISTRATION_TLV, LINK_LOCAL_ALL_NODES_MULTICAST_ADDRESS +from pktverify.packet_verifier import PacketVerifier +from pktverify.addrs import Ipv6Addr LEADER = 1 ROUTER = 2 @@ -43,28 +46,32 @@ MTDS = [ED1, SED1] class Cert_5_6_5_NetworkDataRegisterAfterAttachRouter(thread_cert.TestCase): TOPOLOGY = { LEADER: { + 'name': 'LEADER', 'mode': 'rsdn', 'panid': 0xface, - 'whitelist': [ROUTER] + 'whitelist': [ROUTER, ED1, SED1] }, ROUTER: { + 'name': 'ROUTER', 'mode': 'rsdn', 'panid': 0xface, 'router_selection_jitter': 1, - 'whitelist': [LEADER, ED1, SED1] + 'whitelist': [LEADER] }, ED1: { + 'name': 'MED', 'is_mtd': True, 'mode': 'rsn', 'panid': 0xface, - 'whitelist': [ROUTER] + 'whitelist': [LEADER] }, SED1: { + 'name': 'SED', 'is_mtd': True, 'mode': 's', 'panid': 0xface, 'timeout': config.DEFAULT_CHILD_TIMEOUT, - 'whitelist': [ROUTER] + 'whitelist': [LEADER] }, } @@ -87,32 +94,12 @@ class Cert_5_6_5_NetworkDataRegisterAfterAttachRouter(thread_cert.TestCase): 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].add_prefix('2001:2:0:3::/64', 'paos') self.nodes[ROUTER].register_netdata() # Set lowpan context of sniffer self.simulator.set_lowpan_context(1, '2001:2:0:1::/64') self.simulator.set_lowpan_context(2, '2001:2:0:2::/64') - - 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)) - self.assertTrue(any('2001:2:0:2' in addr[0:10] for addr in addrs)) - for addr in addrs: - if addr[0:3] == '200': - self.assertTrue(self.nodes[LEADER].ping(addr)) - - addrs = self.nodes[SED1].get_addrs() - self.assertTrue(any('2001:2:0:1' in addr[0:10] for addr in addrs)) - self.assertFalse(any('2001:2:0:2' in addr[0:10] for addr in addrs)) - for addr in addrs: - if addr[0:3] == '200': - self.assertTrue(self.nodes[LEADER].ping(addr)) - - self.nodes[ROUTER].add_prefix('2001:2:0:3::/64', 'paos') - self.nodes[ROUTER].register_netdata() - - # Set lowpan context of sniffer self.simulator.set_lowpan_context(3, '2001:2:0:3::/64') self.simulator.go(10) @@ -133,6 +120,54 @@ class Cert_5_6_5_NetworkDataRegisterAfterAttachRouter(thread_cert.TestCase): if addr[0:3] == '200': self.assertTrue(self.nodes[LEADER].ping(addr)) + def verify(self, pv): + pkts = pv.pkts + pv.summary.show() + + LEADER = pv.vars['LEADER'] + MED = pv.vars['MED'] + SED = pv.vars['SED'] + _lpkts = pkts.filter_wpan_src64(LEADER) + + # Step 1: Ensure the topology is formed correctly + _lpkts.filter_mle_cmd(MLE_CHILD_ID_RESPONSE).filter_wpan_dst64(SED).must_next() + + # Step 3: The DUT Automatically sends a CoAP Response frame and + # MLE Data Response message + _lpkts.copy().filter_coap_ack(SVR_DATA_URI).must_next() + + _lpkts_med = _lpkts.copy() + _lpkts_sed = _lpkts.copy() + + # Step 4: The DUT MUST send a multicast MLE Data Response with + # the new network information collected from Router_1 + _lpkts.filter_mle_cmd(MLE_DATA_RESPONSE).filter_ipv6_dst(LINK_LOCAL_ALL_NODES_MULTICAST_ADDRESS).must_next( + ).must_verify(lambda p: {Ipv6Addr('2001:2:0:1::'), + Ipv6Addr('2001:2:0:2::'), + Ipv6Addr('2001:2:0:3::')} == set(p.thread_nwd.tlv.prefix) and p.thread_nwd.tlv. + border_router.flag.p == [1, 1, 1] and p.thread_nwd.tlv.border_router.flag.s == [1, 1, 1] and p. + thread_nwd.tlv.border_router.flag.r == [1, 1, 0] and p.thread_nwd.tlv.border_router.flag.o == + [1, 1, 1] and p.thread_nwd.tlv.stable == [0, 1, 1, 1, 0, 0, 0, 1, 1, 1]) + + # Step 7: The DUT MUST send a unicast MLE Child Update + # Response to MED_1 + _lpkts_med.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).filter_wpan_dst64(MED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + + # Step 8: The DUT MUST send a unicast MLE Child Update + # Request to SED_1 + _lpkts_sed.filter_mle_cmd(MLE_CHILD_UPDATE_REQUEST).filter_wpan_dst64(SED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, LEADER_DATA_TLV, NETWORK_DATA_TLV, ACTIVE_TIMESTAMP_TLV} == set( + p.mle.tlv.type) and {Ipv6Addr('2001:2:0:1::'), Ipv6Addr('2001:2:0:3::')} == set( + p.thread_nwd.tlv.prefix) and p.thread_nwd.tlv.border_router.flag.p == [1, 1] and p.thread_nwd.tlv. + border_router.flag.s == [1, 1] and p.thread_nwd.tlv.border_router.flag.r == [1, 0] and p.thread_nwd.tlv. + border_router.flag.o == [1, 1] and p.thread_nwd.tlv.stable == [1, 1, 1, 1, 1, 1]) + + # Step 10: The DUT MUST send a unicast MLE Child Update + # Response to SED_1 + _lpkts_sed.filter_mle_cmd(MLE_CHILD_UPDATE_RESPONSE).filter_wpan_dst64(SED).must_next().must_verify( + lambda p: {SOURCE_ADDRESS_TLV, MODE_TLV, LEADER_DATA_TLV, ADDRESS_REGISTRATION_TLV} < set(p.mle.tlv.type)) + if __name__ == '__main__': unittest.main()