mirror of
https://github.com/ThrowTheSwitch/Unity.git
synced 2026-01-29 11:14:27 +01:00
Split memory from fixtures and make it's own addon
This commit is contained in:
mvandervoord
78
extras/memory/test/Makefile
Normal file
78
extras/memory/test/Makefile
Normal file
@@ -0,0 +1,78 @@
|
||||
CC = gcc
|
||||
ifeq ($(shell uname -s), Darwin)
|
||||
CC = clang
|
||||
endif
|
||||
#DEBUG = -O0 -g
|
||||
CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror
|
||||
CFLAGS += $(DEBUG)
|
||||
DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar
|
||||
ifeq ($(OS),Windows_NT)
|
||||
DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar(int)
|
||||
else
|
||||
DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)
|
||||
endif
|
||||
SRC = ../src/unity_memory.c \
|
||||
../../../src/unity.c \
|
||||
unity_memory_Test.c \
|
||||
unity_memory_TestRunner.c \
|
||||
unity_output_Spy.c \
|
||||
|
||||
INC_DIR = -I../src -I../../../src/
|
||||
BUILD_DIR = ../build
|
||||
TARGET = ../build/memory_tests.exe
|
||||
|
||||
all: default noStdlibMalloc 32bits
|
||||
|
||||
default: $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_SUPPORT_64
|
||||
@ echo "default build"
|
||||
./$(TARGET)
|
||||
|
||||
32bits: $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32
|
||||
@ echo "32bits build"
|
||||
./$(TARGET)
|
||||
|
||||
noStdlibMalloc: $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC
|
||||
@ echo "build with noStdlibMalloc"
|
||||
./$(TARGET)
|
||||
|
||||
C89: CFLAGS += -D UNITY_EXCLUDE_STDINT_H # C89 did not have type 'long long', <stdint.h>
|
||||
C89: $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -std=c89 && ./$(TARGET)
|
||||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC -std=c89
|
||||
./$(TARGET)
|
||||
|
||||
$(BUILD_DIR):
|
||||
mkdir -p $(BUILD_DIR)
|
||||
|
||||
clean:
|
||||
rm -f $(TARGET) $(BUILD_DIR)/*.gc*
|
||||
|
||||
cov: $(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_memory.c | head -3
|
||||
grep '###' $(BUILD_DIR)/unity_memory.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
|
||||
300
extras/memory/test/unity_memory_Test.c
Normal file
300
extras/memory/test/unity_memory_Test.c
Normal file
@@ -0,0 +1,300 @@
|
||||
/* ==========================================
|
||||
* Unity Project - A Test Framework for C
|
||||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
|
||||
* [Released under MIT License. Please refer to license.txt for details]
|
||||
* ========================================== */
|
||||
|
||||
#include "unity.h"
|
||||
#include "unity_memory.h"
|
||||
#include "unity_output_Spy.h"
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
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
|
||||
}
|
||||
49
extras/memory/test/unity_memory_TestRunner.c
Normal file
49
extras/memory/test/unity_memory_TestRunner.c
Normal file
@@ -0,0 +1,49 @@
|
||||
/* ==========================================
|
||||
* Unity Project - A Test Framework for C
|
||||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
|
||||
* [Released under MIT License. Please refer to license.txt for details]
|
||||
* ========================================== */
|
||||
|
||||
#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();
|
||||
}
|
||||
56
extras/memory/test/unity_output_Spy.c
Normal file
56
extras/memory/test/unity_output_Spy.c
Normal file
@@ -0,0 +1,56 @@
|
||||
/* ==========================================
|
||||
* Unity Project - A Test Framework for C
|
||||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
|
||||
* [Released under MIT License. Please refer to license.txt for details]
|
||||
* ========================================== */
|
||||
|
||||
#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;
|
||||
}
|
||||
16
extras/memory/test/unity_output_Spy.h
Normal file
16
extras/memory/test/unity_output_Spy.h
Normal file
@@ -0,0 +1,16 @@
|
||||
/* ==========================================
|
||||
* Unity Project - A Test Framework for C
|
||||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
|
||||
* [Released under MIT License. Please refer to license.txt for details]
|
||||
* ========================================== */
|
||||
|
||||
#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
|
||||
Reference in New Issue
Block a user