Merge pull request #11023 from ARMmbed/release-candidate

Release candidate for mbed-os-5.13.1

TESTS/host_tests/pyusb_msd.py

@@ -127,7 +127,17 @@ def _callback_unmount(self, key, value, timestamp):
         else:
             self.report_error("unmount")
 
+    def _callback_os_type(self, key, value, timestamp):
+        system_name = platform.system()
+        if system_name == "Windows":
+            self.send_kv("os_type", 1)
+        elif system_name == "Linux":
+            self.send_kv("os_type", 2)
+        elif system_name == "Darwin":
+            self.send_kv("os_type", 3)
+
     def setup(self):
+        self.register_callback("get_os_type", self._callback_os_type)
         self.register_callback("get_serial_number", self._callback_device_ready)
         self.register_callback('check_if_mounted', self._callback_check_if_mounted)
         self.register_callback('check_if_not_mounted', self._callback_check_if_not_mounted)
@@ -204,25 +214,16 @@ def _disk_path_mac(serial):
     @staticmethod
     def _unmount_windows(serial):
         disk_path = MSDUtils._disk_path_windows(serial)
-        tmp_file = tempfile.NamedTemporaryFile(suffix='.ps1', delete=False)
-        try:
-            # create unmount script
-            tmp_file.write('$disk_leter=$args[0]\n')
-            tmp_file.write('$driveEject = New-Object -comObject Shell.Application\n')
-            tmp_file.write('$driveEject.Namespace(17).ParseName($disk_leter).InvokeVerb("Eject")\n')
-            # close to allow open by other process
-            tmp_file.close()
-
-            try_count = 10
-            while try_count:
-                p = subprocess.Popen(["powershell.exe", tmp_file.name + " " + disk_path], stdout=sys.stdout)
-                p.communicate()
-                try_count -= 1
-                if MSDUtils._disk_path_windows(serial) is None:
-                    return True
-                time.sleep(1)
-        finally:
-            os.remove(tmp_file.name)
+        cmd_string = r'(New-Object -comObject Shell.Application).Namespace(17).ParseName("{}").InvokeVerb("Eject")'.format(disk_path)
+
+        try_count = 10
+        while try_count:
+            p = subprocess.Popen(["powershell.exe", cmd_string], stdout=sys.stdout)
+            p.communicate()
+            try_count -= 1
+            if MSDUtils._disk_path_windows(serial) is None:
+                return True
+            time.sleep(1)
 
         return False
 

TESTS/host_tests/reset_reason.py

@@ -0,0 +1,163 @@
+"""
+Copyright (c) 2018-2019 Arm Limited and affiliates.
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+import time
+from mbed_host_tests import BaseHostTest
+from mbed_host_tests.host_tests_runner.host_test_default import DefaultTestSelector
+
+DEFAULT_SYNC_DELAY = 4.0
+
+MSG_VALUE_WATCHDOG_PRESENT = 'wdg_present'
+MSG_VALUE_DUMMY = '0'
+MSG_VALUE_RESET_REASON_GET = 'get'
+MSG_VALUE_RESET_REASON_CLEAR = 'clear'
+MSG_VALUE_DEVICE_RESET_NVIC = 'nvic'
+MSG_VALUE_DEVICE_RESET_WATCHDOG = 'watchdog'
+
+MSG_KEY_DEVICE_READY = 'ready'
+MSG_KEY_RESET_REASON_RAW = 'reason_raw'
+MSG_KEY_RESET_REASON = 'reason'
+MSG_KEY_DEVICE_RESET = 'reset'
+MSG_KEY_SYNC = '__sync'
+
+RESET_REASONS = {
+    'POWER_ON': '0',
+    'PIN_RESET': '1',
+    'BROWN_OUT': '2',
+    'SOFTWARE': '3',
+    'WATCHDOG': '4',
+    'LOCKUP': '5',
+    'WAKE_LOW_POWER': '6',
+    'ACCESS_ERROR': '7',
+    'BOOT_ERROR': '8',
+    'MULTIPLE': '9',
+    'PLATFORM': '10',
+    'UNKNOWN': '11'
+}
+
+
+def raise_if_different(expected, actual, text=''):
+    """Raise a RuntimeError if actual is different than expected."""
+    if expected != actual:
+        raise RuntimeError('{}Got {!r}, expected {!r}'
+                           .format(text, actual, expected))
+
+
+class ResetReasonTest(BaseHostTest):
+    """Test for the Reset Reason HAL API.
+
+    Given a device supporting a Reset Reason API.
+    When the device is restarted using various methods.
+    Then the device returns a correct reset reason for every restart.
+    """
+
+    def __init__(self):
+        super(ResetReasonTest, self).__init__()
+        self.device_has_watchdog = None
+        self.raw_reset_reasons = set()
+        self.sync_delay = DEFAULT_SYNC_DELAY
+        self.test_steps_sequence = self.test_steps()
+        # Advance the coroutine to it's first yield statement.
+        self.test_steps_sequence.send(None)
+
+    def setup(self):
+        sync_delay = self.get_config_item('forced_reset_timeout')
+        self.sync_delay = sync_delay if sync_delay is not None else DEFAULT_SYNC_DELAY
+        self.register_callback(MSG_KEY_DEVICE_READY, self.cb_device_ready)
+        self.register_callback(MSG_KEY_RESET_REASON_RAW, self.cb_reset_reason_raw)
+        self.register_callback(MSG_KEY_RESET_REASON, self.cb_reset_reason)
+        self.register_callback(MSG_KEY_DEVICE_RESET, self.cb_reset_reason)
+
+    def cb_device_ready(self, key, value, timestamp):
+        """Request a raw value of the reset_reason register.
+
+        Additionally, save the device's watchdog status on the first call.
+        """
+        if self.device_has_watchdog is None:
+            self.device_has_watchdog = (value == MSG_VALUE_WATCHDOG_PRESENT)
+        self.send_kv(MSG_KEY_RESET_REASON_RAW, MSG_VALUE_RESET_REASON_GET)
+
+    def cb_reset_reason_raw(self, key, value, timestamp):
+        """Verify that the raw reset_reason register value is unique.
+
+        Fail the test suite if the raw reset_reason value is not unique.
+        Request a platform independent reset_reason otherwise.
+        """
+        if value in self.raw_reset_reasons:
+            self.log('TEST FAILED: The raw reset reason is not unique. '
+                     '{!r} is already present in {!r}.'
+                     .format(value, self.raw_reset_reasons))
+            self.notify_complete(False)
+        else:
+            self.raw_reset_reasons.add(value)
+        self.send_kv(MSG_KEY_RESET_REASON, MSG_VALUE_RESET_REASON_GET)
+
+    def cb_reset_reason(self, key, value, timestamp):
+        """Feed the test_steps coroutine with reset_reason value.
+
+        Pass the test suite if the coroutine yields True.
+        Fail the test suite if the iterator stops or raises a RuntimeError.
+        """
+        try:
+            if self.test_steps_sequence.send(value):
+                self.notify_complete(True)
+        except (StopIteration, RuntimeError) as exc:
+            self.log('TEST FAILED: {}'.format(exc))
+            self.notify_complete(False)
+
+    def test_steps(self):
+        """Generate a sequence of test steps.
+
+        This coroutine calls yield to wait for the input from the device
+        (the reset_reason). If the device gives the wrong response, the
+        generator raises a RuntimeError exception and fails the test.
+        """
+        # Ignore the first reason.
+        __ignored_reset_reason = yield
+        self.raw_reset_reasons.clear()
+        self.send_kv(MSG_KEY_RESET_REASON, MSG_VALUE_RESET_REASON_CLEAR)
+        __ignored_clear_ack = yield
+
+        # Request a NVIC_SystemReset() call.
+        self.send_kv(MSG_KEY_DEVICE_RESET, MSG_VALUE_DEVICE_RESET_NVIC)
+        __ignored_reset_ack = yield
+        time.sleep(self.sync_delay)
+        self.send_kv(MSG_KEY_SYNC, MSG_VALUE_DUMMY)
+        reset_reason = yield
+        raise_if_different(RESET_REASONS['SOFTWARE'], reset_reason, 'Wrong reset reason. ')
+        self.send_kv(MSG_KEY_RESET_REASON, MSG_VALUE_RESET_REASON_CLEAR)
+        __ignored_clear_ack = yield
+
+        # Reset the device using DAP.
+        self.reset_dut(DefaultTestSelector.RESET_TYPE_SW_RST)
+        reset_reason = yield
+        raise_if_different(RESET_REASONS['PIN_RESET'], reset_reason, 'Wrong reset reason. ')
+        self.send_kv(MSG_KEY_RESET_REASON, MSG_VALUE_RESET_REASON_CLEAR)
+        __ignored_clear_ack = yield
+
+        # Start a watchdog timer and wait for it to reset the device.
+        if not self.device_has_watchdog:
+            self.log('DUT does not have a watchdog. Skipping this reset reason.')
+        else:
+            self.send_kv(MSG_KEY_DEVICE_RESET, MSG_VALUE_DEVICE_RESET_WATCHDOG)
+            __ignored_reset_ack = yield
+            time.sleep(self.sync_delay)
+            self.send_kv(MSG_KEY_SYNC, MSG_VALUE_DUMMY)
+            reset_reason = yield
+            raise_if_different(RESET_REASONS['WATCHDOG'], reset_reason, 'Wrong reset reason. ')
+
+        # The sequence is correct -- test passed.
+        yield True

TESTS/host_tests/sync_on_reset.py

@@ -0,0 +1,74 @@
+"""
+Copyright (c) 2018-2019 Arm Limited and affiliates.
+
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+import time
+from mbed_host_tests import BaseHostTest
+
+DEFAULT_SYNC_DELAY = 4.0
+
+MSG_VALUE_DUMMY = '0'
+MSG_KEY_DEVICE_READY = 'ready'
+MSG_KEY_START_CASE = 'start_case'
+MSG_KEY_DEVICE_RESET = 'reset_on_case_teardown'
+MSG_KEY_SYNC = '__sync'
+
+
+class SyncOnReset(BaseHostTest):
+    """Host side test that handles device reset during case teardown.
+
+    Given a device that performs a reset during a test case teardown.
+    When the device notifies the host about the reset.
+    Then the host:
+    * keeps track of the test case index of the current test suite,
+    * performs a dev-host handshake,
+    * advances the test suite to next test case.
+
+    Note:
+    Developed for a watchdog test, so that it can be run on devices that
+    do not support watchdog timeout updates after the initial setup.
+    As a solution, after testing watchdog with one set of settings, the
+    device performs a reset and notifies the host with the test case number,
+    so that the test suite may be advanced once the device boots again.
+    """
+
+    def __init__(self):
+        super(SyncOnReset, self).__init__()
+        self.test_case_num = 0
+        self.sync_delay = DEFAULT_SYNC_DELAY
+
+    def setup(self):
+        sync_delay = self.get_config_item('forced_reset_timeout')
+        self.sync_delay = sync_delay if sync_delay is not None else DEFAULT_SYNC_DELAY
+        self.register_callback(MSG_KEY_DEVICE_READY, self.cb_device_ready)
+        self.register_callback(MSG_KEY_DEVICE_RESET, self.cb_device_reset)
+
+    def cb_device_ready(self, key, value, timestamp):
+        """Advance the device test suite to the next test case."""
+        self.send_kv(MSG_KEY_START_CASE, self.test_case_num)
+
+    def cb_device_reset(self, key, value, timestamp):
+        """Wait for the device to boot and perform a handshake.
+
+        Additionally, keep track of the last test case number.
+        """
+        try:
+            self.test_case_num = int(value)
+        except ValueError:
+            pass
+        self.test_case_num += 1
+        time.sleep(self.sync_delay)
+        self.send_kv(MSG_KEY_SYNC, MSG_VALUE_DUMMY)