Merge pull request #9 from c1728p9/resilience_and_wear_leveling

Add filesystem recovery tests

Author: geky

TESTS/filesystem_recovery/resilience/main.cpp

@@ -0,0 +1,80 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2017-2017 ARM Limited
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "mbed.h"
+#include "unity.h"
+#include "utest.h"
+#include "test_env.h"
+
+#include "atomic_usage.h"
+#include "ObservingBlockDevice.h"
+#include "LittleFileSystem.h"
+
+
+using namespace utest::v1;
+
+#define TEST_CYCLES     10
+#define TEST_BD_SIZE    (16 * 1024)
+
+/**
+ * Check that the filesystem is valid after every change
+ *
+ * This test is to ensure that littlefs contains a valid filesystem at
+ * all times. This property is required for handling unexpected power
+ * loss.
+ */
+void test_resilience()
+{
+    HeapBlockDevice bd(TEST_BD_SIZE);
+
+    // Setup the test
+    setup_atomic_operations(&bd, true);
+
+    // Run check on every write operation
+    ObservingBlockDevice observer(&bd);
+    observer.attach(check_atomic_operations);
+
+    // Perform operations
+    printf("Performing %i operations on flash\n", TEST_CYCLES);
+    for (int i = 1; i <= TEST_CYCLES; i++) {
+        int64_t ret = perform_atomic_operations(&observer);
+        TEST_ASSERT_EQUAL(i, ret);
+    }
+    printf("No errors detected\n");
+}
+
+Case cases[] = {
+    Case("test resilience", test_resilience),
+};
+
+utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
+{
+    GREENTEA_SETUP(20, "default_auto");
+    return greentea_test_setup_handler(number_of_cases);
+}
+
+Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
+
+int main()
+{
+    Harness::run(specification);
+}

TESTS/filesystem_recovery/resilience_functional/main.cpp

@@ -0,0 +1,114 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2017-2017 ARM Limited
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "mbed.h"
+#include "unity.h"
+#include "utest.h"
+#include "test_env.h"
+
+#include "atomic_usage.h"
+#include "ObservingBlockDevice.h"
+#include "LittleFileSystem.h"
+
+#include <string.h>
+
+
+using namespace utest::v1;
+
+#ifndef MBED_TEST_BLOCKDEVICE
+#define MBED_TEST_BLOCKDEVICE SPIFBlockDevice
+#define MBED_TEST_BLOCKDEVICE_DECL SPIFBlockDevice bd(PTE2, PTE4, PTE1, PTE5)
+#endif
+
+#ifndef MBED_TEST_BLOCKDEVICE_DECL
+#define MBED_TEST_BLOCKDEVICE_DECL MBED_TEST_BLOCKDEVICE bd
+#endif
+
+// declarations
+#define STRINGIZE(x) STRINGIZE2(x)
+#define STRINGIZE2(x) #x
+#define INCLUDE(x) STRINGIZE(x.h)
+
+#include INCLUDE(MBED_TEST_BLOCKDEVICE)
+
+MBED_TEST_BLOCKDEVICE_DECL;
+
+typedef enum {
+    CMD_STATUS_PASS,
+    CMD_STATUS_FAIL,
+    CMD_STATUS_CONTINUE,
+    CMD_STATUS_ERROR
+} cmd_status_t;
+
+void use_filesystem()
+{
+    // Perform operations
+    while (true) {
+        int64_t ret = perform_atomic_operations(&bd);
+        TEST_ASSERT(ret > 0);
+    }
+}
+
+static cmd_status_t handle_command(const char *key, const char *value)
+{
+    if (strcmp(key, "format") == 0) {
+        setup_atomic_operations(&bd, true);
+        greentea_send_kv("format_done", 1);
+        return CMD_STATUS_CONTINUE;
+
+    } else if (strcmp(key, "run") == 0) {
+        use_filesystem();
+        return CMD_STATUS_CONTINUE;
+
+    } else if (strcmp(key, "exit") == 0) {
+        if (strcmp(value, "pass") != 0) {
+            return CMD_STATUS_FAIL;
+        }
+        check_atomic_operations(&bd);
+        return CMD_STATUS_PASS;
+
+    } else {
+        return CMD_STATUS_ERROR;
+
+    }
+}
+
+int main()
+{
+    GREENTEA_SETUP(60, "unexpected_reset");
+
+    static char _key[10 + 1] = {};
+    static char _value[128 + 1] = {};
+
+    greentea_send_kv("start", 1);
+
+    // Handshake with host
+    cmd_status_t cmd_status = CMD_STATUS_CONTINUE;
+    while (CMD_STATUS_CONTINUE == cmd_status) {
+        memset(_key, 0, sizeof(_key));
+        memset(_value, 0, sizeof(_value));
+        greentea_parse_kv(_key, _value, sizeof(_key) - 1, sizeof(_value) - 1);
+        cmd_status = handle_command(_key, _value);
+    }
+
+    GREENTEA_TESTSUITE_RESULT(CMD_STATUS_PASS == cmd_status);
+}

TESTS/filesystem_recovery/wear_leveling/main.cpp

@@ -0,0 +1,93 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2017-2017 ARM Limited
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "mbed.h"
+#include "unity.h"
+#include "utest.h"
+#include "test_env.h"
+
+#include "atomic_usage.h"
+#include "ExhaustibleBlockDevice.h"
+#include "LittleFileSystem.h"
+
+using namespace utest::v1;
+
+#define ERASE_CYCLES    20
+#define TEST_BD_SIZE    (8 * 1024)
+
+static uint32_t test_wear_leveling_size(uint32_t bd_size)
+{
+    HeapBlockDevice hbd(bd_size, 1, 1, 512);
+    ExhaustibleBlockDevice ebd(&hbd, ERASE_CYCLES);
+
+    printf("Testing size %lu\n", bd_size);
+    setup_atomic_operations(&ebd, true);
+
+    int64_t cycles = 0;
+    while (true) {
+        int64_t ret = perform_atomic_operations(&ebd);
+        check_atomic_operations(&ebd);
+        if (-1 == ret) {
+            break;
+        }
+        cycles++;
+        TEST_ASSERT_EQUAL(cycles, ret);
+
+    }
+
+    printf("  Simulated flash lasted %lli cylces\n", cycles);
+    return cycles;
+}
+
+/**
+ * Check that storage life is proportional to storage size
+ *
+ * This test is to ensure that littlefs is properly handling wear
+ * leveling. It does this by creating a simulated flash block device
+ * which can be worn out and then using it until it is exhausted.
+ * It then doubles the size of the block device and runs the same
+ * test. If the block device with twice the size lasts at least
+ * twice as long then the test passes.
+ */
+void test_wear_leveling()
+{
+    uint32_t cycles_1 = test_wear_leveling_size(TEST_BD_SIZE * 1);
+    uint32_t cycles_2 = test_wear_leveling_size(TEST_BD_SIZE * 2);
+    TEST_ASSERT(cycles_2 > cycles_1 * 2);
+}
+
+Case cases[] = {
+    Case("test wear leveling", test_wear_leveling),
+};
+
+utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
+{
+    GREENTEA_SETUP(60, "default_auto");
+    return greentea_test_setup_handler(number_of_cases);
+}
+
+Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
+
+int main()
+{
+    Harness::run(specification);
+}

TESTS/host_tests/unexpected_reset.py

@@ -0,0 +1,103 @@
+"""
+mbed SDK
+Copyright (c) 2017-2017 ARM Limited
+
+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.
+"""
+from __future__ import print_function
+
+from mbed_host_tests import BaseHostTest
+from time import sleep
+
+
+class UnexpectedResetTest(BaseHostTest):
+    """This test checks that a device's RTC keeps count through a reset
+    
+    It does this by setting the RTC's time, triggering a reset,
+    delaying and then reading the RTC's time again to ensure
+    that the RTC is still counting.
+    """
+
+    """Number of times to reset the device in this test"""
+    RESET_COUNT = 20
+    RESET_DELAY_BASE = 1.0
+    RESET_DELAY_INC = 0.02
+    VALUE_PLACEHOLDER = "0"
+
+    def setup(self):
+        """Register callbacks required for the test"""
+        self._error = False
+        generator = self.unexpected_reset_test()
+        generator.next()
+
+        def run_gen(key, value, time):
+            """Run the generator, and fail testing if the iterator stops"""
+            if self._error:
+                return
+            try:
+                generator.send((key, value, time))
+            except StopIteration:
+                self._error = True
+
+        for resp in ("start", "read", "format_done", "soft_reset_dut_complete"):
+            self.register_callback(resp, run_gen)
+
+    def teardown(self):
+        """No work to do here"""
+        pass
+
+    def unexpected_reset_test(self):
+        """Generator for running the reset test
+        
+        This function calls yield to wait for the next event from
+        the device. If the device gives the wrong response, then the
+        generator terminates by returing which raises a StopIteration
+        exception and fails the test.
+        """
+
+        # Wait for start token
+        key, value, time = yield
+        if key != "start":
+            return
+
+        # Format the device before starting the test
+        self.send_kv("format", self.VALUE_PLACEHOLDER)
+        key, value, time = yield
+        if key != "format_done":
+            return
+
+        for i in range(self.RESET_COUNT):
+
+            self.send_kv("run", self.VALUE_PLACEHOLDER)
+            sleep(self.RESET_DELAY_BASE + self.RESET_DELAY_INC * i)
+
+            self.reset()
+
+            # Wait for start token
+            key, value, time = yield
+            self.log("Key from yield: %s" % key)
+            if key != "soft_reset_dut_complete":
+                return
+
+
+            self.send_kv("__sync", "00000000-0000-000000000-000000000000")
+
+            # Wait for start token
+            key, value, time = yield
+            if key != "start":
+                return
+
+        self.send_kv("exit", "pass")
+
+        yield    # No more events expected
+