Merge pull request #5323 from maciejbocianski/malloc_tests

malloc test refactoring

TESTS/mbedmicro-rtos-mbed/malloc/main.cpp

@@ -14,14 +14,22 @@
  * limitations under the License.
  */
 #include "mbed.h"
-#include "test_env.h"
+#include "greentea-client/test_env.h"
-#include "rtos.h"
+#include "utest/utest.h"
+#include "unity/unity.h"
+
 
 #if defined(MBED_RTOS_SINGLE_THREAD)
   #error [NOT_SUPPORTED] test not supported
 #endif
 
-#define NUM_THREADS         5
+using utest::v1::Case;
+
+extern uint32_t mbed_heap_size;
+static const int test_timeout = 25;
+volatile bool thread_should_continue = true;
+#define NUM_THREADS         4
+#define THREAD_MALLOC_SIZE  100
 
 #if defined(__CORTEX_A9)
 #define THREAD_STACK_SIZE   DEFAULT_STACK_SIZE
@@ -29,65 +37,138 @@
 #define THREAD_STACK_SIZE   256
 #endif
 
-DigitalOut led1(LED1);
-volatile bool should_exit = false;
-volatile bool allocation_failure = false;
 
 void task_using_malloc(void)
 {
-    void* data;
+    void *data = NULL;
-    while (1) {
-        // Repeatedly allocate and free memory
-        data = malloc(100);
-        if (data != NULL) {
-            memset(data, 0, 100);
-        } else {
-            allocation_failure = true;
-        }
-        free(data);
 
-        if (should_exit) {
+    while (thread_should_continue) {
-            return;
+        // Repeatedly allocate and free memory
-        }
+        data = malloc(THREAD_MALLOC_SIZE);
+        TEST_ASSERT_NOT_NULL(data);
+
+        // test whole allocated memory
+        memset(data, 0, THREAD_MALLOC_SIZE);
+
+        free(data);
     }
 }
 
-int main()
+/** Test for multithreaded heap allocations
+
+    Given multiple threads are started in parallel
+    When each of the threads allocate memory
+    Then the memory allocation succeed and @a malloc return valid memory
+ */
+void test_multithread_allocation(void)
 {
     // static stack for threads to reduce heap usage on devices with small RAM
     // and eliminate run out of heap memory problem
     uint8_t stack[NUM_THREADS][THREAD_STACK_SIZE];
 
+    bool thread_alloc_failure = false;
     Thread *thread_list[NUM_THREADS];
-    int test_time = 15;
+    int test_time = 20;
-    GREENTEA_SETUP(20, "default_auto");
 
     // Allocate threads for the test
     for (int i = 0; i < NUM_THREADS; i++) {
         thread_list[i] = new Thread(osPriorityNormal, THREAD_STACK_SIZE, stack[i]);
         if (NULL == thread_list[i]) {
-            allocation_failure = true;
+            thread_alloc_failure = true;
         } else {
             thread_list[i]->start(task_using_malloc);
         }
     }
 
     // Give the test time to run
-    while (test_time) {
+    while (test_time--) {
-        led1 = !led1;
         Thread::wait(1000);
-        test_time--;
     }
 
     // Join and delete all threads
-    should_exit = 1;
+    thread_should_continue = false;
     for (int i = 0; i < NUM_THREADS; i++) {
-        if (NULL == thread_list[i]) {
+        if (NULL != thread_list[i]) {
-            continue;
-        }
             thread_list[i]->join();
             delete thread_list[i];
+            thread_list[i] = NULL;
         }
-
+    }
-    GREENTEA_TESTSUITE_RESULT(!allocation_failure);
+    TEST_ASSERT_FALSE(thread_alloc_failure);
+}
+
+/** Test for large heap allocation
+
+    Given a heap of size mbed_heap_size
+    When try to allocate memory of size mbed_heap_size/5 (20% of whole heap)
+    Then the memory is allocated and @a malloc return valid memory
+ */
+void test_big_allocation(void)
+{
+    const uint32_t alloc_size = mbed_heap_size / 5;
+    void *data = NULL;
+
+    data = malloc(alloc_size);
+    TEST_ASSERT_NOT_NULL(data);
+
+    // test whole allocated memory
+    memset(data, 0, alloc_size);
+
+    free(data);
+}
+
+/** Test if allocation of zero size does not cause any undefined behaviour
+
+    Given a heap
+    When try to allocate memory of size 0
+    Then the return value of @a malloc depends on the particular library implementation
+     (NULL or smallest possible allocation) and no undefined behaviour happens
+
+    @note If allocation size is zero, the return value depends on the particular library implementation
+    (it may or may not be a null pointer), but the returned pointer shall not be dereferenced
+ */
+void test_zero_allocation(void)
+{
+    void *data = NULL;
+
+    data = malloc(0);
+    if(data != NULL) {
+        free(data);
+    }
+    TEST_ASSERT_MESSAGE(true, "malloc(0) succeed - no undefined behaviour happens");
+}
+
+/** Test if free on NULL pointer does not cause any undefined behaviour
+
+    Given a NULL pointer
+    When try to free it
+    Then the function @a free does nothing and no undefined behaviour happens
+ */
+void test_null_free(void)
+{
+    void *data = NULL;
+    free(data);
+
+    TEST_ASSERT_MESSAGE(true, "free(NULL) succeed - no undefined behaviour happens");
+}
+
+// Test cases
+Case cases[] = {
+    Case("Test 0 size allocation", test_zero_allocation),
+    Case("Test NULL pointer free", test_null_free),
+    Case("Test multithreaded allocations", test_multithread_allocation),
+    Case("Test large allocation", test_big_allocation)
+};
+
+utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
+{
+    GREENTEA_SETUP(test_timeout, "timing_drift_auto");
+    return utest::v1::greentea_test_setup_handler(number_of_cases);
+}
+
+utest::v1::Specification specification(greentea_test_setup, cases);
+
+int main()
+{
+    return !utest::v1::Harness::run(specification);
 }