class OTNSTestCase(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
tracemalloc.start()
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)-15s - %(levelname)s - %(message)s')
def setUp(self) -> None:
self.ns = OTNS(otns_args=['-log', 'debug'])
self.ns.speed = OTNS.MAX_SIMULATE_SPEED
def tearDown(self) -> None:
self.ns.close()
def assertFormPartitions(self, count: int):
pars = self.ns.partitions()
self.assertTrue(len(pars) == count and 0 not in pars, pars)
def go(self, duration: float) -> None:
"""
Run the simulation for a given duration.
:param duration: the duration to simulate
"""
self.ns.go(duration)
def assertNodeState(self, nodeid: int, state: str):
cur_state = self.ns.get_state(nodeid)
self.assertEqual(
state, cur_state,
f"Node {nodeid} state mismatch: expected {state}, but is {cur_state}"
)
class BaseStressTest(object, metaclass=StressTestMetaclass):
def __init__(self, name, headers, raw=False):
self.name = name
self._otns_args = []
if raw:
self._otns_args.append('-raw')
self.ns = OTNS(otns_args=self._otns_args)
self.ns.speed = float('inf')
self.ns.web()
self.result = StressTestResult(name=name, headers=headers)
self.result.start()
def run(self):
raise NotImplementedError()
def reset(self):
nodes = self.ns.nodes()
if nodes:
self.ns.delete(*nodes.keys())
def stop(self):
self.result.stop()
self.ns.close()
def expect_node_state(self,
nid: int,
state: str,
timeout: float,
go_step: int = 1) -> None:
while timeout > 0:
self.ns.go(go_step)
timeout -= go_step
if self.ns.get_state(nid) == state:
return
raise UnexpectedNodeState(nid, state, self.ns.get_state(nid))
def report(self):
try:
STRESS_RESULT_FILE = os.environ['STRESS_RESULT_FILE']
stress_result_fd = open(STRESS_RESULT_FILE, 'wt')
except KeyError:
stress_result_fd = sys.stdout
try:
stress_result_fd.write(
f"""**[OTNS](https://github.com/openthread/ot-ns) Stress Tests Report Generated at {time.strftime(
"%m/%d %H:%M:%S")}**\n""")
stress_result_fd.write(self.result.format())
finally:
if stress_result_fd is not sys.stdout:
stress_result_fd.close()
def avg_except_max(self, vals: Collection[float]) -> float:
assert len(vals) >= 2
max_val = max(vals)
max_idxes = [i for i in range(len(vals)) if vals[i] >= max_val]
assert max_idxes
rmidx = max_idxes[0]
vals[rmidx:rmidx + 1] = []
return self.avg(vals)
def avg(self, vals: Collection[float]) -> float:
assert len(vals) > 0
return sum(vals) / len(vals)
def expect_all_nodes_become_routers(self, timeout: int = 1000) -> None:
all_routers = False
while timeout > 0 and not all_routers:
self.ns.go(10)
timeout -= 10
nodes = (self.ns.nodes())
all_routers = True
print(nodes)
for nid, info in nodes.items():
if info['state'] not in ['leader', 'router']:
all_routers = False
break
if all_routers:
break
if not all_routers:
raise UnexpectedError("not all nodes are Routers: %s" %
self.ns.nodes())
def expect_node_addr(self, nodeid: int, addr: str, timeout=100):
addr = ipaddress.IPv6Address(addr)
found_addr = False
while timeout > 0:
if addr in map(ipaddress.IPv6Address, self.ns.get_ipaddrs(nodeid)):
found_addr = True
break
self.ns.go(1)
if not found_addr:
raise UnexpectedNodeAddr(
f'Address {addr} not found on node {nodeid}')
def expect_node_mleid(self, nodeid: int, timeout: int):
while True:
mleid = self.ns.get_mleid(nodeid)
if mleid:
return mleid
self.ns.go(1)
timeout -= 1
if timeout <= 0:
raise UnexpectedNodeAddr(f'MLEID not found on node {nodeid}')