| #!/usr/bin/env python | |
| # | |
| # Copyright (c) 2016, 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 os | |
| import sys | |
| import time | |
| if sys.platform != 'win32': | |
| import node_cli | |
| else: | |
| import node_api | |
| import unittest | |
| class Node: | |
| def __init__(self, nodeid): | |
| if sys.platform != 'win32': | |
| self.interface = node_cli.otCli(nodeid) | |
| else: | |
| self.interface = node_api.otApi(nodeid) | |
| self.interface.clear_whitelist() | |
| self.interface.disable_whitelist() | |
| self.interface.set_timeout(100) | |
| def __del__(self): | |
| del self.interface | |
| def set_mode(self, mode): | |
| self.interface.set_mode(mode) | |
| def debug(self, level): | |
| self.interface.debug(level) | |
| def interface_up(self): | |
| self.interface.interface_up() | |
| def interface_down(self): | |
| self.interface.interface_down() | |
| def thread_start(self): | |
| self.interface.thread_start() | |
| def thread_stop(self): | |
| self.interface.thread_stop() | |
| def commissioner_start(self): | |
| self.interface.commissioner_start() | |
| def commissioner_add_joiner(self, addr, psk): | |
| self.interface.commissioner_add_joiner(addr, psk) | |
| def joiner_start(self, pskd='', provisioning_url=''): | |
| self.interface.joiner_start(pskd, provisioning_url) | |
| def start(self): | |
| self.interface.interface_up() | |
| self.interface.thread_start() | |
| def stop(self): | |
| self.interface.thread_stop() | |
| self.interface.interface_down() | |
| def clear_whitelist(self): | |
| self.interface.clear_whitelist() | |
| def enable_whitelist(self): | |
| self.interface.enable_whitelist() | |
| def disable_whitelist(self): | |
| self.interface.disable_whitelist() | |
| def add_whitelist(self, addr, rssi=None): | |
| self.interface.add_whitelist(addr, rssi) | |
| def remove_whitelist(self, addr): | |
| self.interface.remove_whitelist(addr) | |
| def get_addr16(self): | |
| return self.interface.get_addr16() | |
| def get_addr64(self): | |
| return self.interface.get_addr64() | |
| def get_hashmacaddr(self): | |
| return self.interface.get_hashmacaddr() | |
| def get_channel(self): | |
| return self.interface.get_channel() | |
| def set_channel(self, channel): | |
| self.interface.set_channel(channel) | |
| def get_masterkey(self): | |
| return self.interface.get_masterkey() | |
| def set_masterkey(self, masterkey): | |
| self.interface.set_masterkey(masterkey) | |
| def get_key_sequence_counter(self): | |
| return self.interface.get_key_sequence_counter() | |
| def set_key_sequence_counter(self, key_sequence_counter): | |
| self.interface.set_key_sequence_counter(key_sequence_counter) | |
| def set_key_switch_guardtime(self, key_switch_guardtime): | |
| self.interface.set_key_switch_guardtime(key_switch_guardtime) | |
| def set_network_id_timeout(self, network_id_timeout): | |
| self.interface.set_network_id_timeout(network_id_timeout) | |
| def get_network_name(self): | |
| return self.interface.get_network_name() | |
| def set_network_name(self, network_name): | |
| self.interface.set_network_name(network_name) | |
| def get_panid(self): | |
| return self.interface.get_panid() | |
| def set_panid(self, panid): | |
| self.interface.set_panid(panid) | |
| def get_partition_id(self): | |
| return self.interface.get_partition_id() | |
| def set_partition_id(self, partition_id): | |
| self.interface.set_partition_id(partition_id) | |
| def set_router_upgrade_threshold(self, threshold): | |
| self.interface.set_router_upgrade_threshold(threshold) | |
| def set_router_downgrade_threshold(self, threshold): | |
| self.interface.set_router_downgrade_threshold(threshold) | |
| def release_router_id(self, router_id): | |
| self.interface.release_router_id(router_id) | |
| def get_state(self): | |
| return self.interface.get_state() | |
| def set_state(self, state): | |
| self.interface.set_state(state) | |
| def get_timeout(self): | |
| return self.interface.get_timeout() | |
| def set_timeout(self, timeout): | |
| self.interface.set_timeout(timeout) | |
| def set_max_children(self, number): | |
| self.interface.set_max_children(number) | |
| def get_weight(self): | |
| return self.interface.get_weight() | |
| def set_weight(self, weight): | |
| self.interface.set_weight(weight) | |
| def add_ipaddr(self, ipaddr): | |
| self.interface.add_ipaddr(ipaddr) | |
| def get_addrs(self): | |
| return self.interface.get_addrs() | |
| def get_context_reuse_delay(self): | |
| return self.interface.get_context_reuse_delay() | |
| def set_context_reuse_delay(self, delay): | |
| self.interface.set_context_reuse_delay(delay) | |
| def add_prefix(self, prefix, flags, prf = 'med'): | |
| self.interface.add_prefix(prefix, flags, prf) | |
| def remove_prefix(self, prefix): | |
| self.interface.remove_prefix(prefix) | |
| def add_route(self, prefix, prf = 'med'): | |
| self.interface.add_route(prefix, prf) | |
| def remove_route(self, prefix): | |
| self.interface.remove_route(prefix) | |
| def register_netdata(self): | |
| self.interface.register_netdata() | |
| def energy_scan(self, mask, count, period, scan_duration, ipaddr): | |
| self.interface.energy_scan(mask, count, period, scan_duration, ipaddr) | |
| def panid_query(self, panid, mask, ipaddr): | |
| self.interface.panid_query(panid, mask, ipaddr) | |
| def scan(self): | |
| return self.interface.scan() | |
| def ping(self, ipaddr, num_responses=1, size=None, timeout=5000): | |
| return self.interface.ping(ipaddr, num_responses, size, timeout) | |
| def reset(self): | |
| return self.interface.reset() | |
| def set_router_selection_jitter(self, jitter): | |
| self.interface.set_router_selection_jitter(jitter) | |
| def set_active_dataset(self, timestamp, panid=None, channel=None, channel_mask=None, master_key=None): | |
| self.interface.set_active_dataset(timestamp, panid, channel, channel_mask, master_key) | |
| def set_pending_dataset(self, pendingtimestamp, activetimestamp, panid=None, channel=None): | |
| self.interface.set_pending_dataset(pendingtimestamp, activetimestamp, panid, channel) | |
| def announce_begin(self, mask, count, period, ipaddr): | |
| self.interface.announce_begin(mask, count, period, ipaddr) | |
| def send_mgmt_active_set(self, active_timestamp=None, channel=None, channel_mask=None, extended_panid=None, | |
| panid=None, master_key=None, mesh_local=None, network_name=None, binary=None): | |
| self.interface.send_mgmt_active_set(active_timestamp, channel, channel_mask, extended_panid, panid, | |
| master_key, mesh_local, network_name, binary) | |
| def send_mgmt_pending_set(self, pending_timestamp=None, active_timestamp=None, delay_timer=None, channel=None, | |
| panid=None, master_key=None, mesh_local=None, network_name=None): | |
| self.interface.send_mgmt_pending_set(pending_timestamp, active_timestamp, delay_timer, channel, panid, | |
| master_key, mesh_local, network_name) | |
| if __name__ == '__main__': | |
| unittest.main() |