Add configuration option UNITY_EXCLUDE_STDLIB_MALLOC to Fixture

This feature removes the dependency on malloc/free for constrained
  embedded systems without a heap. It uses a static heap inside
  Unity Fixture. Setting UNITY_INTERNAL_HEAP_SIZE_BYTES sizes the heap.
 Add tests for new option, add targets to makefile for running tests.
 UNITY_FIXTURE_MALLOC for Fixture use only, remove from unity_output_Spy.c.

extras/fixture/test/Makefile

@@ -14,6 +14,22 @@ SRC = ../src/unity_fixture.c \
 INC_DIR = -I../src -I../../../src/
 TARGET = fixture_tests.exe
 
-all:
+all: default noStdlibMalloc 32bits
+
+default:
 	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET)
+	@ echo "default build"
 	./$(TARGET)
+
+32bits:
+	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32
+	@ echo "32bits build"
+	./$(TARGET)
+
+noStdlibMalloc:
+	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC
+	@ echo "build with noStdlibMalloc"
+	./$(TARGET)
+
+clangEverything:
+	$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m64 -Weverything # || true #prevents make from failing

extras/fixture/test/main/AllTests.c

@@ -11,7 +11,8 @@ static void runAllTests(void)
 {
     RUN_TEST_GROUP(UnityFixture);
     RUN_TEST_GROUP(UnityCommandOptions);
-    RUN_TEST_GROUP(LeakDetection)
+    RUN_TEST_GROUP(LeakDetection);
+    RUN_TEST_GROUP(InternalMalloc);
 }
 
 int main(int argc, const char* argv[])

extras/fixture/test/unity_fixture_Test.c

@@ -82,7 +82,7 @@ TEST(UnityFixture, ReallocLargerNeeded)
     CHECK(m1);
     strcpy((char*)m1, "123456789");
     m2 = realloc(m1, 15);
-    CHECK(m1 != m2);
+    // CHECK(m1 != m2); //Depends on implementation
     STRCMP_EQUAL("123456789", m2);
     free(m2);
 }
@@ -136,7 +136,7 @@ TEST(UnityFixture, PointerSet)
 
 TEST(UnityFixture, FreeNULLSafety)
 {
-  unity_free(NULL);
+    free(NULL);
 }
 
 //------------------------------------------------------------
@@ -290,7 +290,11 @@ TEST_GROUP(LeakDetection);
 
 TEST_SETUP(LeakDetection)
 {
+#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
+    UnityOutputCharSpy_Create(200);
+#else
     UnityOutputCharSpy_Create(1000);
+#endif
 }
 
 TEST_TEAR_DOWN(LeakDetection)
@@ -376,3 +380,57 @@ TEST(LeakDetection, BufferOverrunFoundDuringRealloc)
     CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
 #endif
 }
+
+TEST_GROUP(InternalMalloc);
+
+TEST_SETUP(InternalMalloc) { }
+TEST_TEAR_DOWN(InternalMalloc) { }
+
+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_NULL(n);
+    free(m);
+#endif
+}
+
+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_NULL(n);
+    free(m);
+#endif
+}
+
+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_EQUAL(m, n);
+    free(n);
+#endif
+}
+
+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_EQUAL(n2, n1);
+    free(n2);
+    free(n1);
+    free(m);
+#endif
+}

extras/fixture/test/unity_fixture_TestRunner.c

@@ -41,3 +41,11 @@ TEST_GROUP_RUNNER(LeakDetection)
     RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringFree);
     RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringRealloc);
 }
+
+TEST_GROUP_RUNNER(InternalMalloc)
+{
+    RUN_TEST_CASE(InternalMalloc, MallocPastBufferFails);
+    RUN_TEST_CASE(InternalMalloc, CallocPastBufferFails);
+    RUN_TEST_CASE(InternalMalloc, MallocThenReallocGrowsMemoryInPlace);
+    RUN_TEST_CASE(InternalMalloc, ReallocFailDoesNotFreeMem);
+}

extras/fixture/test/unity_output_Spy.c

@@ -22,7 +22,7 @@ void UnityOutputCharSpy_Create(int s)
     size = s;
     count = 0;
     spy_enable = 0;
-    buffer = UNITY_FIXTURE_MALLOC(size);
+    buffer = malloc(size);
     TEST_ASSERT_NOT_NULL_MESSAGE(buffer, "Internal malloc failed in Spy Create():" __FILE__);
     memset(buffer, 0, size);
 }
@@ -30,7 +30,7 @@ void UnityOutputCharSpy_Create(int s)
 void UnityOutputCharSpy_Destroy(void)
 {
     size = 0;
-    UNITY_FIXTURE_FREE(buffer);
+    free(buffer);
 }
 
 int UnityOutputCharSpy_OutputChar(int c)