mirror of
https://github.com/espressif/openthread.git
synced 2026-08-22 18:39:50 +00:00
Zhanglong XiaandGitHub
aee0ba47e8
This commit refactors the cp-caps test as follows: 1. uses the unittest framework to refactor the cp-caps. 2. all tests are sorted alphabetically 3. all test names are changed to long names.
312 lines
11 KiB
Python
312 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
#
|
|
# Copyright (c) 2025, 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 unittest
|
|
import os
|
|
|
|
from typing import List
|
|
from otci import OTCI
|
|
from device_manager import DeviceManager, Frame
|
|
|
|
|
|
class TestDiagCommands(unittest.TestCase):
|
|
"""Test whether the DUT supports all diag commands."""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.__device_manager = DeviceManager()
|
|
cls.__dut = cls.__device_manager.dut
|
|
cls.__ref = cls.__device_manager.ref
|
|
cls.__dut.factory_reset()
|
|
cls.__ref.factory_reset()
|
|
|
|
def setUp(self):
|
|
self.__dut.diag_start()
|
|
self.__ref.diag_start()
|
|
|
|
def test_diag_channel(self):
|
|
"""Test whether the DUT supports the `diag channel` commands."""
|
|
channel = 20
|
|
commands = ['diag channel', f'diag channel {channel}']
|
|
|
|
if self.__support_commands(commands):
|
|
self.__dut.diag_set_channel(channel)
|
|
value = self.__dut.diag_get_channel()
|
|
ret = value == channel
|
|
else:
|
|
ret = False
|
|
|
|
self.__output_results(commands, ret)
|
|
|
|
def test_diag_cw(self):
|
|
"""Test whether the DUT supports the `diag cw` commands."""
|
|
commands = ['diag cw start', 'diag cw stop']
|
|
|
|
for command in commands:
|
|
ret = self.__dut.is_command_supported(command)
|
|
self.__device_manager.output_test_result_bool(command, ret)
|
|
|
|
def test_diag_echo(self):
|
|
"""Test whether the DUT supports the `diag echo` commands."""
|
|
echo_msg = '0123456789'
|
|
cmd_diag_echo = f'diag echo {echo_msg}'
|
|
cmd_diag_echo_num = f'diag echo -n 10'
|
|
|
|
if self.__dut.is_command_supported(cmd_diag_echo):
|
|
reply = self.__dut.diag_echo(echo_msg)
|
|
ret = reply == echo_msg
|
|
else:
|
|
ret = False
|
|
self.__device_manager.output_test_result_bool(cmd_diag_echo, ret)
|
|
|
|
if self.__dut.is_command_supported(cmd_diag_echo_num):
|
|
reply = self.__dut.diag_echo_number(10)
|
|
ret = reply == echo_msg
|
|
else:
|
|
ret = False
|
|
self.__device_manager.output_test_result_bool(cmd_diag_echo_num, ret)
|
|
|
|
def test_diag_frame(self):
|
|
"""Test whether the DUT supports the `diag frame` commands."""
|
|
frame = Frame(name='diag frame 00010203040506070809', tx_frame='00010203040506070809', dst_address='-')
|
|
ret = self.__device_manager.send_formatted_frames_retries(self.__dut, self.__ref, frame)
|
|
self.__device_manager.output_test_result_bool(frame.name, ret)
|
|
# The method send_formatted_frames_retries() calls the `diag stop`.
|
|
# Here calls the `diag start` to make the 'tearDown()' happy.
|
|
self.__dut.diag_start()
|
|
self.__ref.diag_start()
|
|
|
|
def test_diag_gpio_mode(self):
|
|
"""Test whether the DUT supports the `diag gpio mode` commands."""
|
|
gpio = self.__get_dut_diag_gpio()
|
|
commands = [f'diag gpio mode {gpio}', f'diag gpio mode {gpio} in', f'diag gpio mode {gpio} out']
|
|
|
|
if self.__support_commands(commands):
|
|
self.__dut.diag_set_gpio_mode(gpio, 'in')
|
|
mode_in = self.__dut.diag_get_gpio_mode(gpio)
|
|
self.__dut.diag_set_gpio_mode(gpio, 'out')
|
|
mode_out = self.__dut.diag_get_gpio_mode(gpio)
|
|
|
|
ret = mode_in == 'in' and mode_out == 'out'
|
|
else:
|
|
ret = False
|
|
|
|
self.__output_results(commands, ret)
|
|
|
|
def test_diag_gpio_value(self):
|
|
"""Test whether the DUT supports the `diag gpio get` and 'diag gpio set' commands."""
|
|
gpio = self.__get_dut_diag_gpio()
|
|
commands = [f'diag gpio get {gpio}', f'diag gpio set {gpio} 0', f'diag gpio set {gpio} 1']
|
|
|
|
if self.__support_commands(commands):
|
|
self.__dut.diag_set_gpio_value(gpio, 0)
|
|
value_0 = self.__dut.diag_get_gpio_value(gpio)
|
|
self.__dut.diag_set_gpio_value(gpio, 1)
|
|
value_1 = self.__dut.diag_get_gpio_value(gpio)
|
|
|
|
ret = value_0 == 0 and value_1 == 1
|
|
else:
|
|
ret = False
|
|
|
|
self.__output_results(commands, ret)
|
|
|
|
def test_diag_power(self):
|
|
"""Test whether the DUT supports the `diag power` commands."""
|
|
power = self.__get_dut_diag_power()
|
|
commands = ['diag power', f'diag power {power}']
|
|
|
|
if self.__support_commands(commands):
|
|
self.__dut.diag_set_power(power)
|
|
value = self.__dut.diag_get_power()
|
|
ret = value == power
|
|
else:
|
|
ret = False
|
|
|
|
self.__output_results(commands, ret)
|
|
|
|
def test_diag_powersettings(self):
|
|
"""Test whether the DUT supports the `diag powersettings` commands."""
|
|
commands = ['diag powersettings', 'diag powersettings 20']
|
|
|
|
if self.__support_commands(commands):
|
|
powersettings = self.__dut.diag_get_powersettings()
|
|
ret = len(powersettings) > 0
|
|
else:
|
|
ret = False
|
|
|
|
self.__output_results(commands, ret)
|
|
|
|
def test_diag_radio(self):
|
|
"""Test whether the DUT supports the `diag radio` commands."""
|
|
commands = ['diag radio receive', 'diag radio sleep', 'diag radio state']
|
|
|
|
if self.__support_commands(commands):
|
|
self.__dut.diag_radio_receive()
|
|
receive_state = self.__dut.diag_get_radio_state()
|
|
self.__dut.wait(0.1)
|
|
self.__dut.diag_radio_sleep()
|
|
sleep_state = self.__dut.diag_get_radio_state()
|
|
|
|
ret = sleep_state == 'sleep' and receive_state == 'receive'
|
|
else:
|
|
ret = False
|
|
|
|
self.__output_results(commands, ret)
|
|
|
|
def test_diag_rawpowersetting(self):
|
|
"""Test whether the DUT supports the `diag rawpowersetting` commands."""
|
|
rawpowersetting = self.__get_dut_diag_raw_power_setting()
|
|
commands = [
|
|
'diag rawpowersetting enable', f'diag rawpowersetting {rawpowersetting}', 'diag rawpowersetting',
|
|
'diag rawpowersetting disable'
|
|
]
|
|
|
|
if self.__support_commands(commands):
|
|
self.__dut.diag_enable_rawpowersetting()
|
|
self.__dut.diag_set_rawpowersetting(rawpowersetting)
|
|
reply = self.__dut.diag_get_rawpowersetting()
|
|
self.__dut.diag_disable_rawpowersetting()
|
|
|
|
ret = reply == rawpowersetting
|
|
else:
|
|
ret = False
|
|
|
|
self.__output_results(commands, ret)
|
|
|
|
def test_diag_repeat(self):
|
|
"""Test whether the DUT supports the `diag repeat` commands."""
|
|
delay = 10
|
|
threshold = 80
|
|
length = 64
|
|
channel = 20
|
|
cmd_diag_repeat = f'diag repeat {delay} {length}'
|
|
cmd_diag_repeat_stop = 'diag repeat stop'
|
|
commands = [cmd_diag_repeat, 'diag repeat stop', 'diag stats', 'diag stats clear']
|
|
|
|
if self.__support_commands(commands):
|
|
self.__dut.diag_set_channel(channel)
|
|
self.__ref.diag_set_channel(channel)
|
|
self.__ref.diag_radio_receive()
|
|
|
|
self.__dut.diag_stats_clear()
|
|
self.__ref.diag_stats_clear()
|
|
|
|
self.__dut.diag_repeat(delay, length)
|
|
self.__dut.wait(1)
|
|
self.__dut.diag_repeat_stop()
|
|
dut_stats = self.__dut.diag_get_stats()
|
|
ref_stats = self.__ref.diag_get_stats()
|
|
|
|
ret = dut_stats['sent_success_packets'] > threshold and ref_stats['received_packets'] > threshold
|
|
else:
|
|
ret = False
|
|
|
|
self.__device_manager.output_test_result_bool(cmd_diag_repeat, ret)
|
|
self.__device_manager.output_test_result_bool(cmd_diag_repeat_stop, ret)
|
|
|
|
def test_diag_send(self):
|
|
"""Test whether the DUT supports the `diag send` commands."""
|
|
packets = 100
|
|
threshold = 80
|
|
length = 64
|
|
channel = 20
|
|
commands = [f'diag send {packets} {length}']
|
|
|
|
if self.__support_commands(commands):
|
|
self.__dut.wait(1)
|
|
self.__dut.diag_set_channel(channel)
|
|
self.__ref.diag_set_channel(channel)
|
|
self.__ref.diag_radio_receive()
|
|
|
|
self.__dut.diag_stats_clear()
|
|
self.__ref.diag_stats_clear()
|
|
|
|
self.__dut.diag_send(packets, length)
|
|
self.__dut.wait(1)
|
|
dut_stats = self.__dut.diag_get_stats()
|
|
ref_stats = self.__ref.diag_get_stats()
|
|
|
|
ret = dut_stats['sent_success_packets'] == packets and ref_stats['received_packets'] > threshold
|
|
else:
|
|
ret = False
|
|
|
|
self.__output_results(commands, ret)
|
|
|
|
def test_diag_stats(self):
|
|
"""Test whether the DUT supports the `diag stats` commands."""
|
|
commands = ['diag stats', 'diag stats clear']
|
|
|
|
for command in commands:
|
|
ret = self.__dut.is_command_supported(command)
|
|
self.__device_manager.output_test_result_bool(command, ret)
|
|
|
|
def test_diag_stream(self):
|
|
"""Test whether the DUT supports the 'diag stream' commands."""
|
|
commands = ['diag stream start', 'diag stream stop']
|
|
|
|
for command in commands:
|
|
ret = self.__dut.is_command_supported(command)
|
|
self.__device_manager.output_test_result_bool(command, ret)
|
|
|
|
def __get_dut_diag_power(self) -> int:
|
|
return int(os.getenv('DUT_DIAG_POWER', '10'))
|
|
|
|
def __get_dut_diag_gpio(self) -> int:
|
|
return int(os.getenv('DUT_DIAG_GPIO', '0'))
|
|
|
|
def __get_dut_diag_raw_power_setting(self) -> str:
|
|
return os.getenv('DUT_DIAG_RAW_POWER_SETTING', '112233')
|
|
|
|
def __support_commands(self, commands: List[str]) -> bool:
|
|
ret = True
|
|
|
|
for command in commands:
|
|
if self.__dut.is_command_supported(command) is False:
|
|
ret = False
|
|
break
|
|
|
|
return ret
|
|
|
|
def __output_results(self, commands: List[str], support: bool):
|
|
for command in commands:
|
|
self.__device_manager.output_test_result_bool(command, support)
|
|
|
|
def tearDown(self):
|
|
self.__ref.diag_stop()
|
|
self.__dut.diag_stop()
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.__dut.close()
|
|
cls.__ref.close()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|