ceedling 0.19.0 → 0.20.2

data/vendor/unity/extras/fixture/src/unity_fixture.c

@@ -9,7 +9,7 @@
 #include "unity_fixture.h"
 #include "unity_internals.h"
 
-UNITY_FIXTURE_T UnityFixture;
+struct _UnityFixture UnityFixture;
 
 //If you decide to use the function pointer approach.
 //Build with -D UNITY_OUTPUT_CHAR=outputChar and include <stdio.h>
@@ -23,9 +23,9 @@ void tearDown(void) { /*does nothing*/ }
 static void announceTestRun(unsigned int runNumber)
 {
     UnityPrint("Unity test run ");
-    UnityPrintNumber(runNumber+1);
+    UnityPrintNumberUnsigned(runNumber+1);
     UnityPrint(" of ");
-    UnityPrintNumber(UnityFixture.RepeatCount);
+    UnityPrintNumberUnsigned(UnityFixture.RepeatCount);
     UNITY_PRINT_EOL();
 }
 
@@ -45,7 +45,7 @@ int UnityMain(int argc, const char* argv[], void (*runAllTests)(void))
         UnityEnd();
     }
 
-    return UnityFailureCount();
+    return (int)Unity.TestFailures;
 }
 
 static int selected(const char* filter, const char* name)
@@ -71,11 +71,10 @@ void UnityTestRunner(unityfunction* setup,
                      const char* printableName,
                      const char* group,
                      const char* name,
-                     const char* file, int line)
+                     const char* file, unsigned int line)
 {
     if (testSelected(name) && groupSelected(group))
     {
-        Unity.CurrentTestFailed = 0;
         Unity.TestFile = file;
         Unity.CurrentTestName = printableName;
         Unity.CurrentTestLineNumber = line;
@@ -112,12 +111,14 @@ void UnityIgnoreTest(const char* printableName, const char* group, const char* n
     if (testSelected(name) && groupSelected(group))
     {
         Unity.NumberOfTests++;
-        Unity.CurrentTestIgnored = 1;
+        Unity.TestIgnores++;
         if (!UnityFixture.Verbose)
             UNITY_OUTPUT_CHAR('!');
         else
+        {
             UnityPrint(printableName);
-        UnityConcludeFixtureTest();
+            UNITY_PRINT_EOL();
+        }
     }
 }
 
@@ -140,7 +141,7 @@ void UnityMalloc_EndTest(void)
     malloc_fail_countdown = MALLOC_DONT_FAIL;
     if (malloc_count != 0)
     {
-        TEST_FAIL_MESSAGE("This test leaks!");
+        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!");
     }
 }
 
@@ -158,7 +159,7 @@ void UnityMalloc_MakeMallocFailAfterCount(int countdown)
 
 #ifdef UNITY_EXCLUDE_STDLIB_MALLOC
 static unsigned char unity_heap[UNITY_INTERNAL_HEAP_SIZE_BYTES];
-static unsigned int  heap_index;
+static size_t heap_index;
 #else
 #include <stdlib.h>
 #endif
@@ -166,7 +167,7 @@ static unsigned int  heap_index;
 typedef struct GuardBytes
 {
     size_t size;
-    char guard_space[4];
+    size_t guard_space;
 } Guard;
 
 
@@ -202,6 +203,7 @@ void* unity_malloc(size_t size)
     if (guard == NULL) return NULL;
     malloc_count++;
     guard->size = size;
+    guard->guard_space = 0;
     mem = (char*)&(guard[1]);
     memcpy(&mem[size], end, sizeof(end));
 
@@ -214,7 +216,7 @@ static int isOverrun(void* mem)
     char* memAsChar = (char*)mem;
     guard--;
 
-    return strcmp(&memAsChar[guard->size], end) != 0;
+    return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0;
 }
 
 static void release_memory(void* mem)
@@ -246,7 +248,7 @@ void unity_free(void* mem)
     release_memory(mem);
     if (overrun)
     {
-        TEST_FAIL_MESSAGE("Buffer overrun detected during free()");
+        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()");
     }
 }
 
@@ -269,7 +271,7 @@ void* unity_realloc(void* oldMem, size_t size)
     if (isOverrun(oldMem))
     {
         release_memory(oldMem);
-        TEST_FAIL_MESSAGE("Buffer overrun detected during realloc()");
+        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()");
     }
 
     if (size == 0)
@@ -298,15 +300,14 @@ void* unity_realloc(void* oldMem, size_t size)
 
 //--------------------------------------------------------
 //Automatic pointer restoration functions
-typedef struct _PointerPair
+struct PointerPair
 {
-    struct _PointerPair* next;
     void** pointer;
     void* old_value;
-} PointerPair;
+};
 
-enum {MAX_POINTERS=50};
-static PointerPair pointer_store[MAX_POINTERS+1];
+enum { MAX_POINTERS = 50 };
+static struct PointerPair pointer_store[MAX_POINTERS];
 static int pointer_index = 0;
 
 void UnityPointer_Init(void)
@@ -314,11 +315,11 @@ void UnityPointer_Init(void)
     pointer_index = 0;
 }
 
-void UnityPointer_Set(void** pointer, void* newValue)
+void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line)
 {
     if (pointer_index >= MAX_POINTERS)
     {
-        TEST_FAIL_MESSAGE("Too many pointers set");
+        UNITY_TEST_FAIL(line, "Too many pointers set");
     }
     else
     {
@@ -339,21 +340,6 @@ void UnityPointer_UndoAllSets(void)
     }
 }
 
-UNITY_COUNTER_TYPE UnityFailureCount(void)
-{
-    return Unity.TestFailures;
-}
-
-UNITY_COUNTER_TYPE UnityIgnoreCount(void)
-{
-    return Unity.TestIgnores;
-}
-
-UNITY_COUNTER_TYPE UnityTestsCount(void)
-{
-    return Unity.NumberOfTests;
-}
-
 int UnityGetCommandLineOptions(int argc, const char* argv[])
 {
     int i;
@@ -418,11 +404,8 @@ void UnityConcludeFixtureTest(void)
 {
     if (Unity.CurrentTestIgnored)
     {
-        if (UnityFixture.Verbose)
-        {
-            UNITY_PRINT_EOL();
-        }
         Unity.TestIgnores++;
+        UNITY_PRINT_EOL();
     }
     else if (!Unity.CurrentTestFailed)
     {
@@ -432,7 +415,7 @@ void UnityConcludeFixtureTest(void)
             UNITY_PRINT_EOL();
         }
     }
-    else if (Unity.CurrentTestFailed)
+    else // Unity.CurrentTestFailed
     {
         Unity.TestFailures++;
         UNITY_PRINT_EOL();

data/vendor/unity/extras/fixture/src/unity_fixture.h

@@ -64,7 +64,7 @@ int UnityMain(int argc, const char* argv[], void (*runAllTests)(void));
       TEST_##group##_GROUP_RUNNER(); }
 
 //CppUTest Compatibility Macros
-#define UT_PTR_SET(ptr, newPointerValue)               UnityPointer_Set((void**)&(ptr), (void*)(newPointerValue))
+#define UT_PTR_SET(ptr, newPointerValue)               UnityPointer_Set((void**)&(ptr), (void*)(newPointerValue), __LINE__)
 #define TEST_ASSERT_POINTERS_EQUAL(expected, actual)   TEST_ASSERT_EQUAL_PTR((expected), (actual))
 #define TEST_ASSERT_BYTES_EQUAL(expected, actual)      TEST_ASSERT_EQUAL_HEX8(0xff & (expected), 0xff & (actual))
 #define FAIL(message)                                  TEST_FAIL_MESSAGE((message))

data/vendor/unity/extras/fixture/src/unity_fixture_internals.h

@@ -8,13 +8,14 @@
 #ifndef UNITY_FIXTURE_INTERNALS_H_
 #define UNITY_FIXTURE_INTERNALS_H_
 
-typedef struct _UNITY_FIXTURE_T
+struct _UnityFixture
 {
     int Verbose;
     unsigned int RepeatCount;
     const char* NameFilter;
     const char* GroupFilter;
-} UNITY_FIXTURE_T;
+};
+extern struct _UnityFixture UnityFixture;
 
 typedef void unityfunction(void);
 void UnityTestRunner(unityfunction* setup,
@@ -23,18 +24,15 @@ void UnityTestRunner(unityfunction* setup,
                      const char* printableName,
                      const char* group,
                      const char* name,
-                     const char* file, int line);
+                     const char* file, unsigned int line);
 
 void UnityIgnoreTest(const char* printableName, const char* group, const char* name);
 void UnityMalloc_StartTest(void);
 void UnityMalloc_EndTest(void);
-UNITY_COUNTER_TYPE UnityFailureCount(void);
-UNITY_COUNTER_TYPE UnityIgnoreCount(void);
-UNITY_COUNTER_TYPE UnityTestsCount(void);
 int UnityGetCommandLineOptions(int argc, const char* argv[]);
 void UnityConcludeFixtureTest(void);
 
-void UnityPointer_Set(void** ptr, void* newValue);
+void UnityPointer_Set(void** ptr, void* newValue, UNITY_LINE_TYPE line);
 void UnityPointer_UndoAllSets(void);
 void UnityPointer_Init(void);
 

data/vendor/unity/extras/fixture/test/Makefile

@@ -1,8 +1,14 @@
 CC = gcc
-CFLAGS += -Werror
+ifeq ($(shell uname -s), Darwin)
+CC = clang
+endif
+#DEBUG = -O0 -g
 CFLAGS += -std=c99
 CFLAGS += -pedantic
-CFLAGS += -Wundef
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -Werror
+CFLAGS += $(DEBUG)
 DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar
 SRC = ../src/unity_fixture.c \
       ../../../src/unity.c   \
@@ -12,24 +18,63 @@ SRC = ../src/unity_fixture.c \
       main/AllTests.c
 
 INC_DIR = -I../src -I../../../src/
-TARGET = fixture_tests.exe
+BUILD_DIR = ../build
+TARGET = ../build/fixture_tests.exe
 
 all: default noStdlibMalloc 32bits
 
-default:
-	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET)
+default: $(BUILD_DIR)
+	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_SUPPORT_64
 	@ echo "default build"
 	./$(TARGET)
 
-32bits:
+32bits: $(BUILD_DIR)
 	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32
 	@ echo "32bits build"
 	./$(TARGET)
 
-noStdlibMalloc:
+noStdlibMalloc: $(BUILD_DIR)
 	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC
 	@ echo "build with noStdlibMalloc"
 	./$(TARGET)
 
+clang89: ../build/
+	clang $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32 -std=c89 -Wno-comment
+	clang $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32 \
+		-D UNITY_EXCLUDE_STDLIB_MALLOC -std=c89 -Wno-comment ; ./$(TARGET)
+
 clangEverything:
-	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m64 -Weverything # || true #prevents make from failing
+	clang $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -Weverything
+
+$(BUILD_DIR):
+	mkdir -p $(BUILD_DIR)
+
+clean:
+	rm -f $(TARGET) $(BUILD_DIR)/*.gc*
+
+coverage: $(BUILD_DIR)
+	cd $(BUILD_DIR) && \
+	$(CC) $(DEFINES) $(foreach i, $(SRC), ../test/$(i)) $(INC_DIR) -o $(TARGET) -fprofile-arcs -ftest-coverage
+	rm -f $(BUILD_DIR)/*.gcda
+	./$(TARGET) > /dev/null ; ./$(TARGET) -v > /dev/null
+	cd $(BUILD_DIR) && \
+	gcov unity_fixture.c | head -3
+	grep '###' $(BUILD_DIR)/unity_fixture.c.gcov -C2 || true # Show uncovered lines
+
+# These extended flags DO get included before any target build runs
+CFLAGS += -Wbad-function-cast
+CFLAGS += -Wcast-qual
+CFLAGS += -Wconversion
+CFLAGS += -Wformat=2
+CFLAGS += -Wmissing-prototypes
+CFLAGS += -Wold-style-definition
+CFLAGS += -Wpointer-arith
+CFLAGS += -Wshadow
+CFLAGS += -Wstrict-overflow=5
+CFLAGS += -Wstrict-prototypes
+CFLAGS += -Wswitch-default
+CFLAGS += -Wundef
+CFLAGS += -Wno-error=undef  # Warning only, this should not stop the build
+CFLAGS += -Wunreachable-code
+CFLAGS += -Wunused
+CFLAGS += -fstrict-aliasing

data/vendor/unity/extras/fixture/test/unity_fixture_Test.c

@@ -10,8 +10,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-extern UNITY_FIXTURE_T UnityFixture;
-
 TEST_GROUP(UnityFixture);
 
 TEST_SETUP(UnityFixture)
@@ -22,14 +20,13 @@ TEST_TEAR_DOWN(UnityFixture)
 {
 }
 
-int my_int;
-int* pointer1 = 0;
-int* pointer2 = (int*)2;
-int* pointer3 = (int*)3;
-int int1;
-int int2;
-int int3;
-int int4;
+static int* pointer1 = 0;
+static int* pointer2 = (int*)2;
+static int* pointer3 = (int*)3;
+static int int1;
+static int int2;
+static int int3;
+static int int4;
 
 TEST(UnityFixture, PointerSetting)
 {
@@ -112,8 +109,8 @@ TEST(UnityFixture, CallocFillsWithZero)
     free(m);
 }
 
-char *p1;
-char *p2;
+static char *p1;
+static char *p2;
 
 TEST(UnityFixture, PointerSet)
 {
@@ -139,14 +136,30 @@ TEST(UnityFixture, FreeNULLSafety)
     free(NULL);
 }
 
+TEST(UnityFixture, ConcludeTestIncrementsFailCount)
+{
+    _U_UINT savedFails = Unity.TestFailures;
+    _U_UINT savedIgnores = Unity.TestIgnores;
+    UnityOutputCharSpy_Enable(1);
+    Unity.CurrentTestFailed = 1;
+    UnityConcludeFixtureTest(); // Resets TestFailed for this test to pass
+    Unity.CurrentTestIgnored = 1;
+    UnityConcludeFixtureTest(); // Resets TestIgnored
+    UnityOutputCharSpy_Enable(0);
+    TEST_ASSERT_EQUAL(savedFails + 1, Unity.TestFailures);
+    TEST_ASSERT_EQUAL(savedIgnores + 1, Unity.TestIgnores);
+    Unity.TestFailures = savedFails;
+    Unity.TestIgnores = savedIgnores;
+}
+
 //------------------------------------------------------------
 
 TEST_GROUP(UnityCommandOptions);
 
-int savedVerbose;
-int savedRepeat;
-const char* savedName;
-const char* savedGroup;
+static int savedVerbose;
+static unsigned int savedRepeat;
+static const char* savedName;
+static const char* savedGroup;
 
 TEST_SETUP(UnityCommandOptions)
 {
@@ -279,6 +292,21 @@ TEST(UnityCommandOptions, UnknownCommandIsIgnored)
     TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount);
 }
 
+TEST(UnityCommandOptions, GroupOrNameFilterWithoutStringFails)
+{
+    TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(3, unknownCommand));
+    TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(5, unknownCommand));
+    TEST_ASSERT_EQUAL(1, UnityMain(3, unknownCommand, NULL));
+}
+
+TEST(UnityCommandOptions, GroupFilterReallyFilters)
+{
+    _U_UINT saved = Unity.NumberOfTests;
+    TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(4, unknownCommand));
+    UnityIgnoreTest(NULL, "non-matching", NULL);
+    TEST_ASSERT_EQUAL(saved, Unity.NumberOfTests);
+}
+
 IGNORE_TEST(UnityCommandOptions, TestShouldBeIgnored)
 {
     TEST_FAIL_MESSAGE("This test should not run!");
@@ -314,15 +342,28 @@ TEST_TEAR_DOWN(LeakDetection)
     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, else 0
-#define USING_SPY_AS(a)                          EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0)
-#define ASSIGN_VALUE(a)                          VAL_FUNC_##a
-#define VAL_FUNC_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())
+// This tricky set of defines lets us see if we are using the Spy, returns 1 if true
+#ifdef __STDC_VERSION__
+
+#if __STDC_VERSION__ >= 199901L
+#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 // >= 199901
+
+#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__
+
 TEST(LeakDetection, DetectsLeak)
 {
 #ifndef USING_OUTPUT_SPY
@@ -344,12 +385,11 @@ TEST(LeakDetection, DetectsLeak)
 TEST(LeakDetection, BufferOverrunFoundDuringFree)
 {
 #ifndef USING_OUTPUT_SPY
-    UNITY_PRINT_EOL();
     TEST_IGNORE();
 #else
     void* m = malloc(10);
-    TEST_ASSERT_NOT_NULL(m);
     char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
     s[10] = (char)0xFF;
     UnityOutputCharSpy_Enable(1);
     EXPECT_ABORT_BEGIN
@@ -364,12 +404,11 @@ TEST(LeakDetection, BufferOverrunFoundDuringFree)
 TEST(LeakDetection, BufferOverrunFoundDuringRealloc)
 {
 #ifndef USING_OUTPUT_SPY
-    UNITY_PRINT_EOL();
     TEST_IGNORE();
 #else
     void* m = malloc(10);
-    TEST_ASSERT_NOT_NULL(m);
     char* s = (char*)m;
+    TEST_ASSERT_NOT_NULL(m);
     s[10] = (char)0xFF;
     UnityOutputCharSpy_Enable(1);
     EXPECT_ABORT_BEGIN
@@ -381,6 +420,64 @@ TEST(LeakDetection, BufferOverrunFoundDuringRealloc)
 #endif
 }
 
+TEST(LeakDetection, BufferGuardWriteFoundDuringFree)
+{
+#ifndef USING_OUTPUT_SPY
+    TEST_IGNORE();
+#else
+    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;
+    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
+#endif
+}
+
+TEST(LeakDetection, BufferGuardWriteFoundDuringRealloc)
+{
+#ifndef USING_OUTPUT_SPY
+    TEST_IGNORE();
+#else
+    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;
+    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
+#endif
+}
+
+TEST(LeakDetection, PointerSettingMax)
+{
+#ifndef USING_OUTPUT_SPY
+    TEST_IGNORE();
+#else
+    int i;
+    for (i = 0; i < 50; i++) UT_PTR_SET(pointer1, &int1);
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    UT_PTR_SET(pointer1, &int1);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    Unity.CurrentTestFailed = 0;
+    CHECK(strstr(UnityOutputCharSpy_Get(), "Too many pointers set"));
+#endif
+}
+
+//------------------------------------------------------------
+
 TEST_GROUP(InternalMalloc);
 
 TEST_SETUP(InternalMalloc) { }
@@ -390,8 +487,8 @@ TEST(InternalMalloc, MallocPastBufferFails)
 {
 #ifdef UNITY_EXCLUDE_STDLIB_MALLOC
     void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
-    TEST_ASSERT_NOT_NULL(m);
     void* n = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
+    TEST_ASSERT_NOT_NULL(m);
     TEST_ASSERT_NULL(n);
     free(m);
 #endif
@@ -401,8 +498,8 @@ TEST(InternalMalloc, CallocPastBufferFails)
 {
 #ifdef UNITY_EXCLUDE_STDLIB_MALLOC
     void* m = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
-    TEST_ASSERT_NOT_NULL(m);
     void* n = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
+    TEST_ASSERT_NOT_NULL(m);
     TEST_ASSERT_NULL(n);
     free(m);
 #endif
@@ -412,8 +509,8 @@ TEST(InternalMalloc, MallocThenReallocGrowsMemoryInPlace)
 {
 #ifdef UNITY_EXCLUDE_STDLIB_MALLOC
     void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
-    TEST_ASSERT_NOT_NULL(m);
     void* n = realloc(m, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 9);
+    TEST_ASSERT_NOT_NULL(m);
     TEST_ASSERT_EQUAL(m, n);
     free(n);
 #endif
@@ -423,11 +520,11 @@ TEST(InternalMalloc, ReallocFailDoesNotFreeMem)
 {
 #ifdef UNITY_EXCLUDE_STDLIB_MALLOC
     void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2);
-    TEST_ASSERT_NOT_NULL(m);
     void* n1 = malloc(10);
     void* out_of_mem = realloc(n1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1);
-    TEST_ASSERT_NULL(out_of_mem);
     void* n2 = malloc(10);
+    TEST_ASSERT_NOT_NULL(m);
+    TEST_ASSERT_NULL(out_of_mem);
     TEST_ASSERT_NOT_EQUAL(n2, n1);
     free(n2);
     free(n1);