edhoc 1.0.4 → 1.1.0

package/external/libedhoc/externals/Unity/extras/memory/test/unity_memory_Test.c

@@ -0,0 +1,326 @@
+/* =========================================================================
+    Unity - A Test Framework for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+#include "unity.h"
+#include "unity_memory.h"
+#include "unity_output_Spy.h"
+#include <stdlib.h>
+#include <string.h>
+
+/* This test module includes the following tests: */
+
+void test_ForceMallocFail(void);
+void test_ReallocSmallerIsUnchanged(void);
+void test_ReallocSameIsUnchanged(void);
+void test_ReallocLargerNeeded(void);
+void test_ReallocNullPointerIsLikeMalloc(void);
+void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void);
+void test_CallocFillsWithZero(void);
+void test_FreeNULLSafety(void);
+void test_DetectsLeak(void);
+void test_BufferOverrunFoundDuringFree(void);
+void test_BufferOverrunFoundDuringRealloc(void);
+void test_BufferGuardWriteFoundDuringFree(void);
+void test_BufferGuardWriteFoundDuringRealloc(void);
+void test_MallocPastBufferFails(void);
+void test_CallocPastBufferFails(void);
+void test_MallocThenReallocGrowsMemoryInPlace(void);
+void test_ReallocFailDoesNotFreeMem(void);
+
+/* It makes use of the following features */
+void setUp(void);
+void tearDown(void);
+
+/* Let's Go! */
+void setUp(void) 
+{ 
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    UnityOutputCharSpy_Create(200);
+#else
+    UnityOutputCharSpy_Create(1000);
+#endif
+    UnityMalloc_StartTest();
+}
+
+void tearDown(void) 
+{ 
+    UnityMalloc_EndTest();
+    UnityOutputCharSpy_Destroy();
+}
+
+void test_ForceMallocFail(void)
+{
+    void* m;
+    void* mfails;
+    UnityMalloc_MakeMallocFailAfterCount(1);
+    m = malloc(10);
+    TEST_ASSERT_NOT_NULL(m);
+    mfails = malloc(10);
+    TEST_ASSERT_EQUAL_PTR(0, mfails);
+    free(m);
+}
+
+void test_ReallocSmallerIsUnchanged(void)
+{
+    void* m1 = malloc(10);
+    void* m2 = realloc(m1, 5);
+    TEST_ASSERT_NOT_NULL(m1);
+    TEST_ASSERT_EQUAL_PTR(m1, m2);
+    free(m2);
+}
+
+void test_ReallocSameIsUnchanged(void)
+{
+    void* m1 = malloc(10);
+    void* m2 = realloc(m1, 10);
+    TEST_ASSERT_NOT_NULL(m1);
+    TEST_ASSERT_EQUAL_PTR(m1, m2);
+    free(m2);
+}
+
+void test_ReallocLargerNeeded(void)
+{
+    void* m2;
+    void* m1 = malloc(10);
+    TEST_ASSERT_NOT_NULL(m1);
+    strcpy((char*)m1, "123456789");
+    m2 = realloc(m1, 15);
+    TEST_ASSERT_EQUAL_STRING("123456789", m2);
+    free(m2);
+}
+
+void test_ReallocNullPointerIsLikeMalloc(void)
+{
+    void* m = realloc(0, 15);
+    TEST_ASSERT_NOT_NULL(m);
+    free(m);
+}
+
+void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void)
+{
+    void* m1 = malloc(10);
+    void* m2 = realloc(m1, 0);
+    TEST_ASSERT_EQUAL_PTR(0, m2);
+}
+
+void test_CallocFillsWithZero(void)
+{
+    void* m = calloc(3, sizeof(char));
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    TEST_ASSERT_EQUAL_HEX8(0, s[0]);
+    TEST_ASSERT_EQUAL_HEX8(0, s[1]);
+    TEST_ASSERT_EQUAL_HEX8(0, s[2]);
+    free(m);
+}
+
+void test_FreeNULLSafety(void)
+{
+    free(NULL);
+}
+
+/*------------------------------------------------------------ */
+
+#define EXPECT_ABORT_BEGIN \
+  { \
+    jmp_buf TestAbortFrame;   \
+    memcpy(TestAbortFrame, Unity.AbortFrame, sizeof(jmp_buf)); \
+    if (TEST_PROTECT()) \
+    {
+
+#define EXPECT_ABORT_END \
+    } \
+    memcpy(Unity.AbortFrame, TestAbortFrame, sizeof(jmp_buf)); \
+  }
+
+/* This tricky set of defines lets us see if we are using the Spy, returns 1 if true */
+#ifdef __STDC_VERSION__
+
+#ifdef UNITY_SUPPORT_VARIADIC_MACROS
+#define USING_SPY_AS(a)                    EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0)
+#define ASSIGN_VALUE(a)                    VAL_##a
+#define VAL_UnityOutputCharSpy_OutputChar  0, 1
+#define EXPAND_AND_USE_2ND(a, b)           SECOND_PARAM(a, b, throwaway)
+#define SECOND_PARAM(a, b, ...)            b
+#if USING_SPY_AS(UNITY_OUTPUT_CHAR)
+  #define USING_OUTPUT_SPY /* UNITY_OUTPUT_CHAR = UnityOutputCharSpy_OutputChar */
+#endif
+#endif /* UNITY_SUPPORT_VARIADIC_MACROS */
+
+#else  /* __STDC_VERSION__ else */
+
+#define UnityOutputCharSpy_OutputChar 42
+#if UNITY_OUTPUT_CHAR == UnityOutputCharSpy_OutputChar /* Works if no -Wundef -Werror */
+  #define USING_OUTPUT_SPY
+#endif
+#undef UnityOutputCharSpy_OutputChar
+  
+#endif /* __STDC_VERSION__ */
+
+void test_DetectsLeak(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    TEST_ASSERT_NOT_NULL(m);
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    UnityMalloc_EndTest();
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "This test leaks!"));
+    free(m);
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+void test_BufferOverrunFoundDuringFree(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    s[10] = (char)0xFF;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    free(m);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+void test_BufferOverrunFoundDuringRealloc(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    s[10] = (char)0xFF;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    m = realloc(m, 100);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+void test_BufferGuardWriteFoundDuringFree(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    s[-1] = (char)0x00; /* Will not detect 0 */
+    s[-2] = (char)0x01;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    free(m);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+void test_BufferGuardWriteFoundDuringRealloc(void)
+{
+#ifdef USING_OUTPUT_SPY
+    void* m = malloc(10);
+    char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
+    s[-1] = (char)0x0A;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    m = realloc(m, 100);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    TEST_ASSERT_NOT_NULL(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
+#else
+    TEST_IGNORE_MESSAGE("Enable USING_OUTPUT_SPY To Run This Test");
+#endif
+}
+
+/*------------------------------------------------------------ */
+
+#define TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(first_mem_ptr, ptr) \
+    ptr = malloc(10); free(ptr);                                   \
+    TEST_ASSERT_EQUAL_PTR_MESSAGE(first_mem_ptr, ptr, "Memory was stranded, free in LIFO order");
+
+void test_MallocPastBufferFails(void)
+{
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
+    void* n = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
+    free(m);
+    TEST_ASSERT_NOT_NULL(m);
+    TEST_ASSERT_NULL(n);
+    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n);
+#else
+    TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test");
+#endif
+}
+
+void test_CallocPastBufferFails(void)
+{
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    void* m = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
+    void* n = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
+    free(m);
+    TEST_ASSERT_NOT_NULL(m);
+    TEST_ASSERT_NULL(n);
+    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n);
+#else
+    TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test");
+#endif
+}
+
+void test_MallocThenReallocGrowsMemoryInPlace(void)
+{
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
+    void* n = realloc(m, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 9);
+    free(n);
+    TEST_ASSERT_NOT_NULL(m);
+    TEST_ASSERT_EQUAL(m, n);
+    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n);
+#else
+    TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test");
+#endif
+}
+
+void test_ReallocFailDoesNotFreeMem(void)
+{
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
+    void* n1 = malloc(10);
+    void* out_of_mem = realloc(n1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
+    void* n2 = malloc(10);
+
+    free(n2);
+    if (out_of_mem == NULL) free(n1);
+    free(m);
+
+    TEST_ASSERT_NOT_NULL(m);       /* Got a real memory location */
+    TEST_ASSERT_NULL(out_of_mem);  /* The realloc should have failed */
+    TEST_ASSERT_NOT_EQUAL(n2, n1); /* If n1 != n2 then realloc did not free n1 */
+    TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n2);
+#else
+    TEST_IGNORE_MESSAGE("Enable UNITY_EXCLUDE_STDLIB_MALLOC to Run This Test");
+#endif
+}

package/external/libedhoc/externals/Unity/extras/memory/test/unity_memory_TestRunner.c

@@ -0,0 +1,50 @@
+/* =========================================================================
+    Unity - A Test Framework for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+#include "unity.h"
+#include "unity_memory.h"
+
+extern void test_ForceMallocFail(void);
+extern void test_ReallocSmallerIsUnchanged(void);
+extern void test_ReallocSameIsUnchanged(void);
+extern void test_ReallocLargerNeeded(void);
+extern void test_ReallocNullPointerIsLikeMalloc(void);
+extern void test_ReallocSizeZeroFreesMemAndReturnsNullPointer(void);
+extern void test_CallocFillsWithZero(void);
+extern void test_FreeNULLSafety(void);
+extern void test_DetectsLeak(void);
+extern void test_BufferOverrunFoundDuringFree(void);
+extern void test_BufferOverrunFoundDuringRealloc(void);
+extern void test_BufferGuardWriteFoundDuringFree(void);
+extern void test_BufferGuardWriteFoundDuringRealloc(void);
+extern void test_MallocPastBufferFails(void);
+extern void test_CallocPastBufferFails(void);
+extern void test_MallocThenReallocGrowsMemoryInPlace(void);
+extern void test_ReallocFailDoesNotFreeMem(void);
+
+int main(void)
+{
+    UnityBegin("unity_memory_Test.c");
+    RUN_TEST(test_ForceMallocFail);
+    RUN_TEST(test_ReallocSmallerIsUnchanged);
+    RUN_TEST(test_ReallocSameIsUnchanged);
+    RUN_TEST(test_ReallocLargerNeeded);
+    RUN_TEST(test_ReallocNullPointerIsLikeMalloc);
+    RUN_TEST(test_ReallocSizeZeroFreesMemAndReturnsNullPointer);
+    RUN_TEST(test_CallocFillsWithZero);
+    RUN_TEST(test_FreeNULLSafety);
+    RUN_TEST(test_DetectsLeak);
+    RUN_TEST(test_BufferOverrunFoundDuringFree);
+    RUN_TEST(test_BufferOverrunFoundDuringRealloc);
+    RUN_TEST(test_BufferGuardWriteFoundDuringFree);
+    RUN_TEST(test_BufferGuardWriteFoundDuringRealloc);
+    RUN_TEST(test_MallocPastBufferFails);
+    RUN_TEST(test_CallocPastBufferFails);
+    RUN_TEST(test_MallocThenReallocGrowsMemoryInPlace);
+    RUN_TEST(test_ReallocFailDoesNotFreeMem);
+    return UnityEnd();
+}

package/external/libedhoc/externals/Unity/extras/memory/test/unity_output_Spy.c

@@ -0,0 +1,57 @@
+/* =========================================================================
+    Unity - A Test Framework for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+#include "unity.h"
+#include "unity_output_Spy.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static int size;
+static int count;
+static char* buffer;
+static int spy_enable;
+
+void UnityOutputCharSpy_Create(int s)
+{
+    size = (s > 0) ? s : 0;
+    count = 0;
+    spy_enable = 0;
+    buffer = malloc((size_t)size);
+    TEST_ASSERT_NOT_NULL_MESSAGE(buffer, "Internal malloc failed in Spy Create():" __FILE__);
+    memset(buffer, 0, (size_t)size);
+}
+
+void UnityOutputCharSpy_Destroy(void)
+{
+    size = 0;
+    free(buffer);
+}
+
+void UnityOutputCharSpy_OutputChar(int c)
+{
+    if (spy_enable)
+    {
+        if (count < (size-1))
+            buffer[count++] = (char)c;
+    }
+    else
+    {
+        putchar(c);
+    }
+}
+
+const char * UnityOutputCharSpy_Get(void)
+{
+    return buffer;
+}
+
+void UnityOutputCharSpy_Enable(int enable)
+{
+    spy_enable = enable;
+}

package/external/libedhoc/externals/Unity/extras/memory/test/unity_output_Spy.h

@@ -0,0 +1,17 @@
+/* =========================================================================
+    Unity - A Test Framework for C
+    ThrowTheSwitch.org
+    Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+#ifndef UNITY_OUTPUT_SPY_H
+#define UNITY_OUTPUT_SPY_H
+
+void UnityOutputCharSpy_Create(int s);
+void UnityOutputCharSpy_Destroy(void);
+void UnityOutputCharSpy_OutputChar(int c);
+const char * UnityOutputCharSpy_Get(void);
+void UnityOutputCharSpy_Enable(int enable);
+
+#endif