Add unittest for HeapBlockDevice and change some MBED_ASSERTS to errors.

Author: Seppo Takalo

UNITTESTS/features/storage/blockdevice/HeapBlockDevice/test.cpp

@@ -0,0 +1,104 @@
+#include "gtest/gtest.h"
+#include "features/storage/blockdevice/HeapBlockDevice.h"
+#include "string.h"
+#include "mbed_assert.h"
+
+#define BLOCK_SIZE (512)
+#define DEVICE_SIZE (BLOCK_SIZE*10)
+
+class HeapBlockDeviceTest : public testing::Test {
+protected:
+    virtual void SetUp()
+    {
+        bd.init();
+    }
+
+    virtual void TearDown()
+    {
+        bd.deinit();
+    }
+
+    mbed::HeapBlockDevice bd{DEVICE_SIZE};
+};
+
+TEST_F(HeapBlockDeviceTest, constructor)
+{
+    // HeapBlockDevice(bd_size_t size, bd_size_t read, bd_size_t program, bd_size_t erase);
+    mbed::HeapBlockDevice one{3000, 100, 200, 300};
+    EXPECT_EQ(one.init(), BD_ERROR_OK);
+    EXPECT_EQ(one.size(), 3000);
+    EXPECT_EQ(one.get_read_size(), 100);
+    EXPECT_EQ(one.get_program_size(), 200);
+    EXPECT_EQ(one.get_erase_size(), 300);
+    EXPECT_EQ(one.get_erase_size(0), 300);
+    EXPECT_EQ(one.deinit(), BD_ERROR_OK);
+}
+
+TEST_F(HeapBlockDeviceTest, double_init)
+{
+    mbed::HeapBlockDevice one{DEVICE_SIZE};
+    EXPECT_EQ(one.init(), BD_ERROR_OK);
+    EXPECT_EQ(one.init(), BD_ERROR_OK);
+    EXPECT_EQ(one.deinit(), BD_ERROR_OK); // First de-init does only decrement the counter
+    EXPECT_EQ(one.deinit(), BD_ERROR_OK);
+    EXPECT_EQ(one.deinit(), BD_ERROR_OK); //Third one does not de-init, but return immediately
+}
+
+TEST_F(HeapBlockDeviceTest, get_type)
+{
+    EXPECT_EQ(0, strcmp(bd.get_type(), "HEAP"));
+}
+
+TEST_F(HeapBlockDeviceTest, erase_program_read)
+{
+    uint8_t *block = new uint8_t[BLOCK_SIZE]{0xaa,0xbb,0xcc};
+    uint8_t *buf = new uint8_t[BLOCK_SIZE];
+    EXPECT_EQ(bd.erase(0, BLOCK_SIZE),          BD_ERROR_OK);
+    EXPECT_EQ(bd.program(block, 0, BLOCK_SIZE), BD_ERROR_OK);
+    EXPECT_EQ(bd.read(buf, 0, BLOCK_SIZE),      BD_ERROR_OK);
+    EXPECT_EQ(0, memcmp(block, buf, BLOCK_SIZE));
+    delete[] block;
+    delete[] buf;
+}
+
+TEST_F(HeapBlockDeviceTest, use_uninitalized)
+{
+    mbed::HeapBlockDevice one{DEVICE_SIZE};
+    uint8_t *buf = new uint8_t[BLOCK_SIZE];
+    EXPECT_EQ(one.read(buf, 0, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR);
+    EXPECT_EQ(one.program(buf, 0, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR);
+    delete[] buf;
+}
+
+TEST_F(HeapBlockDeviceTest, over_read)
+{
+    uint8_t *buf = new uint8_t[BLOCK_SIZE];
+    EXPECT_EQ(bd.read(buf, DEVICE_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR);
+    delete[] buf;
+}
+
+TEST_F(HeapBlockDeviceTest, over_write)
+{
+    uint8_t *buf = new uint8_t[BLOCK_SIZE]{0xaa,0xbb,0xcc};
+    EXPECT_EQ(bd.program(buf, DEVICE_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR);
+    delete[] buf;
+}
+
+TEST_F(HeapBlockDeviceTest, over_erase)
+{
+    EXPECT_EQ(bd.erase(DEVICE_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR);
+}
+
+TEST_F(HeapBlockDeviceTest, erase_uninitialized)
+{
+    mbed::HeapBlockDevice one{DEVICE_SIZE};
+    EXPECT_EQ(one.erase(DEVICE_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR);
+}
+
+TEST_F(HeapBlockDeviceTest, read_unprogrammed)
+{
+    uint8_t *buf = new uint8_t[BLOCK_SIZE];
+    EXPECT_EQ(bd.read(buf, DEVICE_SIZE - BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_OK);
+    // Ignore the content, it is now zero, but does not need to be.
+    delete[] buf;
+}

UNITTESTS/features/storage/blockdevice/HeapBlockDevice/unittest.cmake

@@ -0,0 +1,19 @@
+
+####################
+# UNIT TESTS
+####################
+
+set(unittest-includes ${unittest-includes}
+  .
+  ..
+)
+
+set(unittest-sources
+  ../features/storage/blockdevice/HeapBlockDevice.cpp
+  stubs/mbed_atomic_stub.c
+  stubs/mbed_assert_stub.c
+)
+
+set(unittest-test-sources
+  features/storage/blockdevice/HeapBlockDevice/test.cpp
+)

features/storage/blockdevice/HeapBlockDevice.cpp

@@ -117,11 +117,12 @@ bd_size_t HeapBlockDevice::size() const
 
 int HeapBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
 {
-    MBED_ASSERT(_blocks != NULL);
-    MBED_ASSERT(is_valid_read(addr, size));
     if (!_is_initialized) {
         return BD_ERROR_DEVICE_ERROR;
     }
+    if (!is_valid_read(addr, size)) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
 
     uint8_t *buffer = static_cast<uint8_t *>(b);
 
@@ -145,11 +146,12 @@ int HeapBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
 
 int HeapBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size)
 {
-    MBED_ASSERT(_blocks != NULL);
-    MBED_ASSERT(is_valid_program(addr, size));
     if (!_is_initialized) {
         return BD_ERROR_DEVICE_ERROR;
     }
+    if (!is_valid_program(addr, size)) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
 
     const uint8_t *buffer = static_cast<const uint8_t *>(b);
 
@@ -176,10 +178,12 @@ int HeapBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size)
 
 int HeapBlockDevice::erase(bd_addr_t addr, bd_size_t size)
 {
-    MBED_ASSERT(_blocks != NULL);
-    MBED_ASSERT(is_valid_erase(addr, size));
-    // TODO assert on programming unerased blocks
-
+    if (!_is_initialized) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
+    if (!is_valid_erase(addr, size)) {
+        return BD_ERROR_DEVICE_ERROR;
+    }
     return 0;
 }