mirror/cJSON
1
0
Fork 0
mirror of https://github.com/DaveGamble/cJSON.git synced 2023-08-10 21:13:26 +03:00
Code Issues Projects Releases Wiki Activity

Merge commit '6b9b57be226a505a9c9cdd9ed029f22495ce04ec' as 'tests/unity'

Browse Source
This commit is contained in:
Max Bruckner
2017-02-07 21:30:57 +01:00
parent e65ea3a45b 6b9b57be22
commit d19f3ae890
125 changed files with 16533 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
tests/unity/extras/fixture/rakefile.rb Normal file
View File

@ -0,0 +1,48 @@
# ==========================================
# 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]
# ==========================================
HERE = File.expand_path(File.dirname(__FILE__)) + '/'
require 'rake'
require 'rake/clean'
require 'rake/testtask'
require HERE + 'rakefile_helper'
TEMP_DIRS = [
File.join(HERE, 'build')
]
TEMP_DIRS.each do |dir|
directory(dir)
CLOBBER.include(dir)
end
task :prepare_for_tests => TEMP_DIRS
include RakefileHelpers
# Load default configuration, for now
DEFAULT_CONFIG_FILE = 'gcc_auto_stdint.yml'
configure_toolchain(DEFAULT_CONFIG_FILE)
task :unit => [:prepare_for_tests] do
run_tests
end
desc "Build and test Unity Framework"
task :all => [:clean, :unit]
task :default => [:clobber, :all]
task :ci => [:no_color, :default]
task :cruise => [:no_color, :default]
desc "Load configuration"
task :config, :config_file do |t, args|
configure_toolchain(args[:config_file])
end
task :no_color do
$colour_output = false
end

179
tests/unity/extras/fixture/rakefile_helper.rb Normal file
View File

@ -0,0 +1,179 @@
# ==========================================
# 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]
# ==========================================
require 'yaml'
require 'fileutils'
require HERE+'../../auto/unity_test_summary'
require HERE+'../../auto/generate_test_runner'
require HERE+'../../auto/colour_reporter'
module RakefileHelpers
C_EXTENSION = '.c'
def load_configuration(config_file)
unless ($configured)
$cfg_file = HERE+"../../test/targets/#{config_file}" unless (config_file =~ /[\\|\/]/)
$cfg = YAML.load(File.read($cfg_file))
$colour_output = false unless $cfg['colour']
$configured = true if (config_file != DEFAULT_CONFIG_FILE)
end
end
def configure_clean
CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil?
end
def configure_toolchain(config_file=DEFAULT_CONFIG_FILE)
config_file += '.yml' unless config_file =~ /\.yml$/
config_file = config_file unless config_file =~ /[\\|\/]/
load_configuration(config_file)
configure_clean
end
def tackit(strings)
if strings.is_a?(Array)
result = "\"#{strings.join}\""
else
result = strings
end
return result
end
def squash(prefix, items)
result = ''
items.each { |item| result += " #{prefix}#{tackit(item)}" }
return result
end
def build_compiler_fields
command = tackit($cfg['compiler']['path'])
if $cfg['compiler']['defines']['items'].nil?
defines = ''
else
defines = squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar'])
end
options = squash('', $cfg['compiler']['options'])
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
return {:command => command, :defines => defines, :options => options, :includes => includes}
end
def compile(file, defines=[])
compiler = build_compiler_fields
unity_include = $cfg['compiler']['includes']['prefix']+'../../src'
cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{unity_include} #{file} " +
"#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}" +
"#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}"
execute(cmd_str)
end
def build_linker_fields
command = tackit($cfg['linker']['path'])
if $cfg['linker']['options'].nil?
options = ''
else
options = squash('', $cfg['linker']['options'])
end
if ($cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil?)
includes = ''
else
includes = squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items'])
end
includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
return {:command => command, :options => options, :includes => includes}
end
def link_it(exe_name, obj_list)
linker = build_linker_fields
cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " +
(obj_list.map{|obj|"#{$cfg['linker']['object_files']['path']}#{obj} "}).join +
$cfg['linker']['bin_files']['prefix'] + ' ' +
$cfg['linker']['bin_files']['destination'] +
exe_name + $cfg['linker']['bin_files']['extension']
execute(cmd_str)
end
def build_simulator_fields
return nil if $cfg['simulator'].nil?
if $cfg['simulator']['path'].nil?
command = ''
else
command = (tackit($cfg['simulator']['path']) + ' ')
end
if $cfg['simulator']['pre_support'].nil?
pre_support = ''
else
pre_support = squash('', $cfg['simulator']['pre_support'])
end
if $cfg['simulator']['post_support'].nil?
post_support = ''
else
post_support = squash('', $cfg['simulator']['post_support'])
end
return {:command => command, :pre_support => pre_support, :post_support => post_support}
end
def execute(command_string, verbose=true)
report command_string
output = `#{command_string}`.chomp
report(output) if (verbose && !output.nil? && (output.length > 0))
if ($?.exitstatus != 0)
raise "Command failed. (Returned #{$?.exitstatus})"
end
return output
end
def report_summary
summary = UnityTestSummary.new
summary.set_root_path(HERE)
results_glob = "#{$cfg['compiler']['build_path']}*.test*"
results_glob.gsub!(/\\/, '/')
results = Dir[results_glob]
summary.set_targets(results)
summary.run
end
def run_tests
report 'Running Unity system tests...'
# Tack on TEST define for compiling unit tests
load_configuration($cfg_file)
test_defines = ['TEST']
$cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil?
# Get a list of all source files needed
src_files = Dir[HERE+'src/*.c']
src_files += Dir[HERE+'test/*.c']
src_files += Dir[HERE+'test/main/*.c']
src_files << '../../src/unity.c'
# Build object files
src_files.each { |f| compile(f, test_defines) }
obj_list = src_files.map {|f| File.basename(f.ext($cfg['compiler']['object_files']['extension'])) }
# Link the test executable
test_base = "framework_test"
link_it(test_base, obj_list)
# Execute unit test and generate results file
simulator = build_simulator_fields
executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension']
if simulator.nil?
cmd_str = executable + " -v -r"
else
cmd_str = "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}"
end
output = execute(cmd_str)
test_results = $cfg['compiler']['build_path'] + test_base
if output.match(/OK$/m).nil?
test_results += '.testfail'
else
test_results += '.testpass'
end
File.open(test_results, 'w') { |f| f.print output }
end
end

9
tests/unity/extras/fixture/readme.txt Normal file
View File

@ -0,0 +1,9 @@
Copyright (c) 2010 James Grenning and Contributed to Unity Project
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]
This Framework is an optional add-on to Unity. By including unity_framework.h in place of unity.h,
you may now work with Unity in a manner similar to CppUTest. This framework adds the concepts of
test groups and gives finer control of your tests over the command line.

432
tests/unity/extras/fixture/src/unity_fixture.c Normal file
View File

@ -0,0 +1,432 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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_fixture.h"
#include "unity_internals.h"
#include <string.h>
struct UNITY_FIXTURE_T UnityFixture;
/* If you decide to use the function pointer approach.
* Build with -D UNITY_OUTPUT_CHAR=outputChar and include <stdio.h>
* int (*outputChar)(int) = putchar; */
#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA)
void setUp(void) { /*does nothing*/ }
void tearDown(void) { /*does nothing*/ }
#endif
static void announceTestRun(unsigned int runNumber)
{
UnityPrint("Unity test run ");
UnityPrintNumberUnsigned(runNumber+1);
UnityPrint(" of ");
UnityPrintNumberUnsigned(UnityFixture.RepeatCount);
UNITY_PRINT_EOL();
}
int UnityMain(int argc, const char* argv[], void (*runAllTests)(void))
{
int result = UnityGetCommandLineOptions(argc, argv);
unsigned int r;
if (result != 0)
return result;
for (r = 0; r < UnityFixture.RepeatCount; r++)
{
UnityBegin(argv[0]);
announceTestRun(r);
runAllTests();
if (!UnityFixture.Verbose) UNITY_PRINT_EOL();
UnityEnd();
}
return (int)Unity.TestFailures;
}
static int selected(const char* filter, const char* name)
{
if (filter == 0)
return 1;
return strstr(name, filter) ? 1 : 0;
}
static int testSelected(const char* test)
{
return selected(UnityFixture.NameFilter, test);
}
static int groupSelected(const char* group)
{
return selected(UnityFixture.GroupFilter, group);
}
void UnityTestRunner(unityfunction* setup,
unityfunction* testBody,
unityfunction* teardown,
const char* printableName,
const char* group,
const char* name,
const char* file,
unsigned int line)
{
if (testSelected(name) && groupSelected(group))
{
Unity.TestFile = file;
Unity.CurrentTestName = printableName;
Unity.CurrentTestLineNumber = line;
if (!UnityFixture.Verbose)
UNITY_OUTPUT_CHAR('.');
else
{
UnityPrint(printableName);
#ifndef UNITY_REPEAT_TEST_NAME
Unity.CurrentTestName = NULL;
#endif
}
Unity.NumberOfTests++;
UnityMalloc_StartTest();
UnityPointer_Init();
if (TEST_PROTECT())
{
setup();
testBody();
}
if (TEST_PROTECT())
{
teardown();
}
if (TEST_PROTECT())
{
UnityPointer_UndoAllSets();
if (!Unity.CurrentTestFailed)
UnityMalloc_EndTest();
}
UnityConcludeFixtureTest();
}
}
void UnityIgnoreTest(const char* printableName, const char* group, const char* name)
{
if (testSelected(name) && groupSelected(group))
{
Unity.NumberOfTests++;
Unity.TestIgnores++;
if (!UnityFixture.Verbose)
UNITY_OUTPUT_CHAR('!');
else
{
UnityPrint(printableName);
UNITY_PRINT_EOL();
}
}
}
/*------------------------------------------------- */
/* Malloc and free stuff */
#define MALLOC_DONT_FAIL -1
static int malloc_count;
static int malloc_fail_countdown = MALLOC_DONT_FAIL;
void UnityMalloc_StartTest(void)
{
malloc_count = 0;
malloc_fail_countdown = MALLOC_DONT_FAIL;
}
void UnityMalloc_EndTest(void)
{
malloc_fail_countdown = MALLOC_DONT_FAIL;
if (malloc_count != 0)
{
UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!");
}
}
void UnityMalloc_MakeMallocFailAfterCount(int countdown)
{
malloc_fail_countdown = countdown;
}
/* These definitions are always included from unity_fixture_malloc_overrides.h */
/* We undef to use them or avoid conflict with <stdlib.h> per the C standard */
#undef malloc
#undef free
#undef calloc
#undef realloc
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
static unsigned char unity_heap[UNITY_INTERNAL_HEAP_SIZE_BYTES];
static size_t heap_index;
#else
#include <stdlib.h>
#endif
typedef struct GuardBytes
{
size_t size;
size_t guard_space;
} Guard;
static const char end[] = "END";
void* unity_malloc(size_t size)
{
char* mem;
Guard* guard;
size_t total_size = size + sizeof(Guard) + sizeof(end);
if (malloc_fail_countdown != MALLOC_DONT_FAIL)
{
if (malloc_fail_countdown == 0)
return NULL;
malloc_fail_countdown--;
}
if (size == 0) return NULL;
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
if (heap_index + total_size > UNITY_INTERNAL_HEAP_SIZE_BYTES)
{
guard = NULL;
}
else
{
guard = (Guard*)&unity_heap[heap_index];
heap_index += total_size;
}
#else
guard = (Guard*)UNITY_FIXTURE_MALLOC(total_size);
#endif
if (guard == NULL) return NULL;
malloc_count++;
guard->size = size;
guard->guard_space = 0;
mem = (char*)&(guard[1]);
memcpy(&mem[size], end, sizeof(end));
return (void*)mem;
}
static int isOverrun(void* mem)
{
Guard* guard = (Guard*)mem;
char* memAsChar = (char*)mem;
guard--;
return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0;
}
static void release_memory(void* mem)
{
Guard* guard = (Guard*)mem;
guard--;
malloc_count--;
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
if (mem == unity_heap + heap_index - guard->size - sizeof(end))
{
heap_index -= (guard->size + sizeof(Guard) + sizeof(end));
}
#else
UNITY_FIXTURE_FREE(guard);
#endif
}
void unity_free(void* mem)
{
int overrun;
if (mem == NULL)
{
return;
}
overrun = isOverrun(mem);
release_memory(mem);
if (overrun)
{
UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()");
}
}
void* unity_calloc(size_t num, size_t size)
{
void* mem = unity_malloc(num * size);
if (mem == NULL) return NULL;
memset(mem, 0, num * size);
return mem;
}
void* unity_realloc(void* oldMem, size_t size)
{
Guard* guard = (Guard*)oldMem;
void* newMem;
if (oldMem == NULL) return unity_malloc(size);
guard--;
if (isOverrun(oldMem))
{
release_memory(oldMem);
UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()");
}
if (size == 0)
{
release_memory(oldMem);
return NULL;
}
if (guard->size >= size) return oldMem;
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */
if (oldMem == unity_heap + heap_index - guard->size - sizeof(end) &&
heap_index + size - guard->size <= UNITY_INTERNAL_HEAP_SIZE_BYTES)
{
release_memory(oldMem); /* Not thread-safe, like unity_heap generally */
return unity_malloc(size); /* No memcpy since data is in place */
}
#endif
newMem = unity_malloc(size);
if (newMem == NULL) return NULL; /* Do not release old memory */
memcpy(newMem, oldMem, guard->size);
release_memory(oldMem);
return newMem;
}
/*-------------------------------------------------------- */
/*Automatic pointer restoration functions */
struct PointerPair
{
void** pointer;
void* old_value;
};
static struct PointerPair pointer_store[UNITY_MAX_POINTERS];
static int pointer_index = 0;
void UnityPointer_Init(void)
{
pointer_index = 0;
}
void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line)
{
if (pointer_index >= UNITY_MAX_POINTERS)
{
UNITY_TEST_FAIL(line, "Too many pointers set");
}
else
{
pointer_store[pointer_index].pointer = pointer;
pointer_store[pointer_index].old_value = *pointer;
*pointer = newValue;
pointer_index++;
}
}
void UnityPointer_UndoAllSets(void)
{
while (pointer_index > 0)
{
pointer_index--;
*(pointer_store[pointer_index].pointer) =
pointer_store[pointer_index].old_value;
}
}
int UnityGetCommandLineOptions(int argc, const char* argv[])
{
int i;
UnityFixture.Verbose = 0;
UnityFixture.GroupFilter = 0;
UnityFixture.NameFilter = 0;
UnityFixture.RepeatCount = 1;
if (argc == 1)
return 0;
for (i = 1; i < argc; )
{
if (strcmp(argv[i], "-v") == 0)
{
UnityFixture.Verbose = 1;
i++;
}
else if (strcmp(argv[i], "-g") == 0)
{
i++;
if (i >= argc)
return 1;
UnityFixture.GroupFilter = argv[i];
i++;
}
else if (strcmp(argv[i], "-n") == 0)
{
i++;
if (i >= argc)
return 1;
UnityFixture.NameFilter = argv[i];
i++;
}
else if (strcmp(argv[i], "-r") == 0)
{
UnityFixture.RepeatCount = 2;
i++;
if (i < argc)
{
if (*(argv[i]) >= '0' && *(argv[i]) <= '9')
{
unsigned int digit = 0;
UnityFixture.RepeatCount = 0;
while (argv[i][digit] >= '0' && argv[i][digit] <= '9')
{
UnityFixture.RepeatCount *= 10;
UnityFixture.RepeatCount += (unsigned int)argv[i][digit++] - '0';
}
i++;
}
}
}
else
{
/* ignore unknown parameter */
i++;
}
}
return 0;
}
void UnityConcludeFixtureTest(void)
{
if (Unity.CurrentTestIgnored)
{
Unity.TestIgnores++;
UNITY_PRINT_EOL();
}
else if (!Unity.CurrentTestFailed)
{
if (UnityFixture.Verbose)
{
UnityPrint(" PASS");
UNITY_PRINT_EOL();
}
}
else /* Unity.CurrentTestFailed */
{
Unity.TestFailures++;
UNITY_PRINT_EOL();
}
Unity.CurrentTestFailed = 0;
Unity.CurrentTestIgnored = 0;
}

83
tests/unity/extras/fixture/src/unity_fixture.h Normal file
View File

@ -0,0 +1,83 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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_FIXTURE_H_
#define UNITY_FIXTURE_H_
#include "unity.h"
#include "unity_internals.h"
#include "unity_fixture_malloc_overrides.h"
#include "unity_fixture_internals.h"
int UnityMain(int argc, const char* argv[], void (*runAllTests)(void));
#define TEST_GROUP(group)\
static const char* TEST_GROUP_##group = #group
#define TEST_SETUP(group) void TEST_##group##_SETUP(void);\
void TEST_##group##_SETUP(void)
#define TEST_TEAR_DOWN(group) void TEST_##group##_TEAR_DOWN(void);\
void TEST_##group##_TEAR_DOWN(void)
#define TEST(group, name) \
void TEST_##group##_##name##_(void);\
void TEST_##group##_##name##_run(void);\
void TEST_##group##_##name##_run(void)\
{\
UnityTestRunner(TEST_##group##_SETUP,\
TEST_##group##_##name##_,\
TEST_##group##_TEAR_DOWN,\
"TEST(" #group ", " #name ")",\
TEST_GROUP_##group, #name,\
__FILE__, __LINE__);\
}\
void TEST_##group##_##name##_(void)
#define IGNORE_TEST(group, name) \
void TEST_##group##_##name##_(void);\
void TEST_##group##_##name##_run(void);\
void TEST_##group##_##name##_run(void)\
{\
UnityIgnoreTest("IGNORE_TEST(" #group ", " #name ")", TEST_GROUP_##group, #name);\
}\
void TEST_##group##_##name##_(void)
/* Call this for each test, insider the group runner */
#define RUN_TEST_CASE(group, name) \
{ void TEST_##group##_##name##_run(void);\
TEST_##group##_##name##_run(); }
/* This goes at the bottom of each test file or in a separate c file */
#define TEST_GROUP_RUNNER(group)\
void TEST_##group##_GROUP_RUNNER(void);\
void TEST_##group##_GROUP_RUNNER(void)
/* Call this from main */
#define RUN_TEST_GROUP(group)\
{ void TEST_##group##_GROUP_RUNNER(void);\
TEST_##group##_GROUP_RUNNER(); }
/* CppUTest Compatibility Macros */
#ifndef UNITY_EXCLUDE_CPPUTEST_ASSERTS
/* Sets a pointer and automatically restores it to its old value after teardown */
#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))
#define CHECK(condition) TEST_ASSERT_TRUE((condition))
#define LONGS_EQUAL(expected, actual) TEST_ASSERT_EQUAL_INT((expected), (actual))
#define STRCMP_EQUAL(expected, actual) TEST_ASSERT_EQUAL_STRING((expected), (actual))
#define DOUBLES_EQUAL(expected, actual, delta) TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual))
#endif
/* You must compile with malloc replacement, as defined in unity_fixture_malloc_overrides.h */
void UnityMalloc_MakeMallocFailAfterCount(int count);
#endif /* UNITY_FIXTURE_H_ */

51
tests/unity/extras/fixture/src/unity_fixture_internals.h Normal file
View File

@ -0,0 +1,51 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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_FIXTURE_INTERNALS_H_
#define UNITY_FIXTURE_INTERNALS_H_
#ifdef __cplusplus
extern "C"
{
#endif
struct UNITY_FIXTURE_T
{
int Verbose;
unsigned int RepeatCount;
const char* NameFilter;
const char* GroupFilter;
};
extern struct UNITY_FIXTURE_T UnityFixture;
typedef void unityfunction(void);
void UnityTestRunner(unityfunction* setup,
unityfunction* body,
unityfunction* teardown,
const char* printableName,
const char* group,
const char* name,
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);
int UnityGetCommandLineOptions(int argc, const char* argv[]);
void UnityConcludeFixtureTest(void);
void UnityPointer_Set(void** ptr, void* newValue, UNITY_LINE_TYPE line);
void UnityPointer_UndoAllSets(void);
void UnityPointer_Init(void);
#ifndef UNITY_MAX_POINTERS
#define UNITY_MAX_POINTERS 5
#endif
#ifdef __cplusplus
}
#endif
#endif /* UNITY_FIXTURE_INTERNALS_H_ */

46
tests/unity/extras/fixture/src/unity_fixture_malloc_overrides.h Normal file
View File

@ -0,0 +1,46 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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_FIXTURE_MALLOC_OVERRIDES_H_
#define UNITY_FIXTURE_MALLOC_OVERRIDES_H_
#include <stddef.h>
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
/* Define this macro to remove the use of stdlib.h, malloc, and free.
* Many embedded systems do not have a heap or malloc/free by default.
* This internal unity_malloc() provides allocated memory deterministically from
* the end of an array only, unity_free() only releases from end-of-array,
* blocks are not coalesced, and memory not freed in LIFO order is stranded. */
#ifndef UNITY_INTERNAL_HEAP_SIZE_BYTES
#define UNITY_INTERNAL_HEAP_SIZE_BYTES 256
#endif
#endif
/* These functions are used by the Unity Fixture to allocate and release memory
* on the heap and can be overridden with platform-specific implementations.
* For example, when using FreeRTOS UNITY_FIXTURE_MALLOC becomes pvPortMalloc()
* and UNITY_FIXTURE_FREE becomes vPortFree(). */
#if !defined(UNITY_FIXTURE_MALLOC) || !defined(UNITY_FIXTURE_FREE)
#define UNITY_FIXTURE_MALLOC(size) malloc(size)
#define UNITY_FIXTURE_FREE(ptr) free(ptr)
#else
extern void* UNITY_FIXTURE_MALLOC(size_t size);
extern void UNITY_FIXTURE_FREE(void* ptr);
#endif
#define malloc unity_malloc
#define calloc unity_calloc
#define realloc unity_realloc
#define free unity_free
void* unity_malloc(size_t size);
void* unity_calloc(size_t num, size_t size);
void* unity_realloc(void * oldMem, size_t size);
void unity_free(void * mem);
#endif /* UNITY_FIXTURE_MALLOC_OVERRIDES_H_ */

74
tests/unity/extras/fixture/test/Makefile Normal file
View File

@ -0,0 +1,74 @@
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
SRC = ../src/unity_fixture.c \
../../../src/unity.c \
unity_fixture_Test.c \
unity_fixture_TestRunner.c \
unity_output_Spy.c \
main/AllTests.c
INC_DIR = -I../src -I../../../src/
BUILD_DIR = ../build
TARGET = ../build/fixture_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_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

22
tests/unity/extras/fixture/test/main/AllTests.c Normal file
View File

@ -0,0 +1,22 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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_fixture.h"
static void runAllTests(void)
{
RUN_TEST_GROUP(UnityFixture);
RUN_TEST_GROUP(UnityCommandOptions);
RUN_TEST_GROUP(LeakDetection);
RUN_TEST_GROUP(InternalMalloc);
}
int main(int argc, const char* argv[])
{
return UnityMain(argc, argv, runAllTests);
}

39
tests/unity/extras/fixture/test/template_fixture_tests.c Normal file
View File

@ -0,0 +1,39 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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_fixture.h"
static int data = -1;
TEST_GROUP(mygroup);
TEST_SETUP(mygroup)
{
data = 0;
}
TEST_TEAR_DOWN(mygroup)
{
data = -1;
}
TEST(mygroup, test1)
{
TEST_ASSERT_EQUAL_INT(0, data);
}
TEST(mygroup, test2)
{
TEST_ASSERT_EQUAL_INT(0, data);
data = 5;
}
TEST(mygroup, test3)
{
data = 7;
TEST_ASSERT_EQUAL_INT(7, data);
}

543
tests/unity/extras/fixture/test/unity_fixture_Test.c Normal file
View File

@ -0,0 +1,543 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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_fixture.h"
#include "unity_output_Spy.h"
#include <stdlib.h>
#include <string.h>
TEST_GROUP(UnityFixture);
TEST_SETUP(UnityFixture)
{
}
TEST_TEAR_DOWN(UnityFixture)
{
}
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)
{
TEST_ASSERT_POINTERS_EQUAL(pointer1, 0);
UT_PTR_SET(pointer1, &int1);
UT_PTR_SET(pointer2, &int2);
UT_PTR_SET(pointer3, &int3);
TEST_ASSERT_POINTERS_EQUAL(pointer1, &int1);
TEST_ASSERT_POINTERS_EQUAL(pointer2, &int2);
TEST_ASSERT_POINTERS_EQUAL(pointer3, &int3);
UT_PTR_SET(pointer1, &int4);
UnityPointer_UndoAllSets();
TEST_ASSERT_POINTERS_EQUAL(pointer1, 0);
TEST_ASSERT_POINTERS_EQUAL(pointer2, (int*)2);
TEST_ASSERT_POINTERS_EQUAL(pointer3, (int*)3);
}
TEST(UnityFixture, ForceMallocFail)
{
void* m;
void* mfails;
UnityMalloc_MakeMallocFailAfterCount(1);
m = malloc(10);
CHECK(m);
mfails = malloc(10);
TEST_ASSERT_POINTERS_EQUAL(0, mfails);
free(m);
}
TEST(UnityFixture, ReallocSmallerIsUnchanged)
{
void* m1 = malloc(10);
void* m2 = realloc(m1, 5);
TEST_ASSERT_POINTERS_EQUAL(m1, m2);
free(m2);
}
TEST(UnityFixture, ReallocSameIsUnchanged)
{
void* m1 = malloc(10);
void* m2 = realloc(m1, 10);
TEST_ASSERT_POINTERS_EQUAL(m1, m2);
free(m2);
}
TEST(UnityFixture, ReallocLargerNeeded)
{
void* m1 = malloc(10);
void* m2;
CHECK(m1);
strcpy((char*)m1, "123456789");
m2 = realloc(m1, 15);
/* CHECK(m1 != m2); //Depends on implementation */
STRCMP_EQUAL("123456789", m2);
free(m2);
}
TEST(UnityFixture, ReallocNullPointerIsLikeMalloc)
{
void* m = realloc(0, 15);
CHECK(m != 0);
free(m);
}
TEST(UnityFixture, ReallocSizeZeroFreesMemAndReturnsNullPointer)
{
void* m1 = malloc(10);
void* m2 = realloc(m1, 0);
TEST_ASSERT_POINTERS_EQUAL(0, m2);
}
TEST(UnityFixture, CallocFillsWithZero)
{
void* m = calloc(3, sizeof(char));
char* s = (char*)m;
CHECK(m);
TEST_ASSERT_BYTES_EQUAL(0, s[0]);
TEST_ASSERT_BYTES_EQUAL(0, s[1]);
TEST_ASSERT_BYTES_EQUAL(0, s[2]);
free(m);
}
static char *p1;
static char *p2;
TEST(UnityFixture, PointerSet)
{
char c1;
char c2;
char newC1;
char newC2;
p1 = &c1;
p2 = &c2;
UnityPointer_Init();
UT_PTR_SET(p1, &newC1);
UT_PTR_SET(p2, &newC2);
TEST_ASSERT_POINTERS_EQUAL(&newC1, p1);
TEST_ASSERT_POINTERS_EQUAL(&newC2, p2);
UnityPointer_UndoAllSets();
TEST_ASSERT_POINTERS_EQUAL(&c1, p1);
TEST_ASSERT_POINTERS_EQUAL(&c2, p2);
}
TEST(UnityFixture, FreeNULLSafety)
{
free(NULL);
}
TEST(UnityFixture, ConcludeTestIncrementsFailCount)
{
UNITY_UINT savedFails = Unity.TestFailures;
UNITY_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);
static int savedVerbose;
static unsigned int savedRepeat;
static const char* savedName;
static const char* savedGroup;
TEST_SETUP(UnityCommandOptions)
{
savedVerbose = UnityFixture.Verbose;
savedRepeat = UnityFixture.RepeatCount;
savedName = UnityFixture.NameFilter;
savedGroup = UnityFixture.GroupFilter;
}
TEST_TEAR_DOWN(UnityCommandOptions)
{
UnityFixture.Verbose = savedVerbose;
UnityFixture.RepeatCount= savedRepeat;
UnityFixture.NameFilter = savedName;
UnityFixture.GroupFilter = savedGroup;
}
static const char* noOptions[] = {
"testrunner.exe"
};
TEST(UnityCommandOptions, DefaultOptions)
{
UnityGetCommandLineOptions(1, noOptions);
TEST_ASSERT_EQUAL(0, UnityFixture.Verbose);
TEST_ASSERT_POINTERS_EQUAL(0, UnityFixture.GroupFilter);
TEST_ASSERT_POINTERS_EQUAL(0, UnityFixture.NameFilter);
TEST_ASSERT_EQUAL(1, UnityFixture.RepeatCount);
}
static const char* verbose[] = {
"testrunner.exe",
"-v"
};
TEST(UnityCommandOptions, OptionVerbose)
{
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(2, verbose));
TEST_ASSERT_EQUAL(1, UnityFixture.Verbose);
}
static const char* group[] = {
"testrunner.exe",
"-g", "groupname"
};
TEST(UnityCommandOptions, OptionSelectTestByGroup)
{
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, group));
STRCMP_EQUAL("groupname", UnityFixture.GroupFilter);
}
static const char* name[] = {
"testrunner.exe",
"-n", "testname"
};
TEST(UnityCommandOptions, OptionSelectTestByName)
{
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, name));
STRCMP_EQUAL("testname", UnityFixture.NameFilter);
}
static const char* repeat[] = {
"testrunner.exe",
"-r", "99"
};
TEST(UnityCommandOptions, OptionSelectRepeatTestsDefaultCount)
{
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(2, repeat));
TEST_ASSERT_EQUAL(2, UnityFixture.RepeatCount);
}
TEST(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount)
{
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, repeat));
TEST_ASSERT_EQUAL(99, UnityFixture.RepeatCount);
}
static const char* multiple[] = {
"testrunner.exe",
"-v",
"-g", "groupname",
"-n", "testname",
"-r", "98"
};
TEST(UnityCommandOptions, MultipleOptions)
{
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(8, multiple));
TEST_ASSERT_EQUAL(1, UnityFixture.Verbose);
STRCMP_EQUAL("groupname", UnityFixture.GroupFilter);
STRCMP_EQUAL("testname", UnityFixture.NameFilter);
TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount);
}
static const char* dashRNotLast[] = {
"testrunner.exe",
"-v",
"-g", "gggg",
"-r",
"-n", "tttt",
};
TEST(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified)
{
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(7, dashRNotLast));
TEST_ASSERT_EQUAL(1, UnityFixture.Verbose);
STRCMP_EQUAL("gggg", UnityFixture.GroupFilter);
STRCMP_EQUAL("tttt", UnityFixture.NameFilter);
TEST_ASSERT_EQUAL(2, UnityFixture.RepeatCount);
}
static const char* unknownCommand[] = {
"testrunner.exe",
"-v",
"-g", "groupname",
"-n", "testname",
"-r", "98",
"-z"
};
TEST(UnityCommandOptions, UnknownCommandIsIgnored)
{
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(9, unknownCommand));
TEST_ASSERT_EQUAL(1, UnityFixture.Verbose);
STRCMP_EQUAL("groupname", UnityFixture.GroupFilter);
STRCMP_EQUAL("testname", UnityFixture.NameFilter);
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)
{
UNITY_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!");
}
/*------------------------------------------------------------ */
TEST_GROUP(LeakDetection);
TEST_SETUP(LeakDetection)
{
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
UnityOutputCharSpy_Create(200);
#else
UnityOutputCharSpy_Create(1000);
#endif
}
TEST_TEAR_DOWN(LeakDetection)
{
UnityOutputCharSpy_Destroy();
}
#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__
#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
TEST_IGNORE_MESSAGE("Build with '-D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar' to enable tests");
#else
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;
CHECK(strstr(UnityOutputCharSpy_Get(), "This test leaks!"));
free(m);
#endif
}
TEST(LeakDetection, BufferOverrunFoundDuringFree)
{
#ifndef USING_OUTPUT_SPY
TEST_IGNORE();
#else
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;
CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
#endif
}
TEST(LeakDetection, BufferOverrunFoundDuringRealloc)
{
#ifndef USING_OUTPUT_SPY
TEST_IGNORE();
#else
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;
CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
#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 < UNITY_MAX_POINTERS; 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);
#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");
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);
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);
#endif
}
TEST(InternalMalloc, CallocPastBufferFails)
{
#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);
#endif
}
TEST(InternalMalloc, MallocThenReallocGrowsMemoryInPlace)
{
#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);
#endif
}
TEST(InternalMalloc, ReallocFailDoesNotFreeMem)
{
#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);
#endif
}

57
tests/unity/extras/fixture/test/unity_fixture_TestRunner.c Normal file
View File

@ -0,0 +1,57 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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_fixture.h"
TEST_GROUP_RUNNER(UnityFixture)
{
RUN_TEST_CASE(UnityFixture, PointerSetting);
RUN_TEST_CASE(UnityFixture, ForceMallocFail);
RUN_TEST_CASE(UnityFixture, ReallocSmallerIsUnchanged);
RUN_TEST_CASE(UnityFixture, ReallocSameIsUnchanged);
RUN_TEST_CASE(UnityFixture, ReallocLargerNeeded);
RUN_TEST_CASE(UnityFixture, ReallocNullPointerIsLikeMalloc);
RUN_TEST_CASE(UnityFixture, ReallocSizeZeroFreesMemAndReturnsNullPointer);
RUN_TEST_CASE(UnityFixture, CallocFillsWithZero);
RUN_TEST_CASE(UnityFixture, PointerSet);
RUN_TEST_CASE(UnityFixture, FreeNULLSafety);
RUN_TEST_CASE(UnityFixture, ConcludeTestIncrementsFailCount);
}
TEST_GROUP_RUNNER(UnityCommandOptions)
{
RUN_TEST_CASE(UnityCommandOptions, DefaultOptions);
RUN_TEST_CASE(UnityCommandOptions, OptionVerbose);
RUN_TEST_CASE(UnityCommandOptions, OptionSelectTestByGroup);
RUN_TEST_CASE(UnityCommandOptions, OptionSelectTestByName);
RUN_TEST_CASE(UnityCommandOptions, OptionSelectRepeatTestsDefaultCount);
RUN_TEST_CASE(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount);
RUN_TEST_CASE(UnityCommandOptions, MultipleOptions);
RUN_TEST_CASE(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified);
RUN_TEST_CASE(UnityCommandOptions, UnknownCommandIsIgnored);
RUN_TEST_CASE(UnityCommandOptions, GroupOrNameFilterWithoutStringFails);
RUN_TEST_CASE(UnityCommandOptions, GroupFilterReallyFilters);
RUN_TEST_CASE(UnityCommandOptions, TestShouldBeIgnored);
}
TEST_GROUP_RUNNER(LeakDetection)
{
RUN_TEST_CASE(LeakDetection, DetectsLeak);
RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringFree);
RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringRealloc);
RUN_TEST_CASE(LeakDetection, BufferGuardWriteFoundDuringFree);
RUN_TEST_CASE(LeakDetection, BufferGuardWriteFoundDuringRealloc);
RUN_TEST_CASE(LeakDetection, PointerSettingMax);
}
TEST_GROUP_RUNNER(InternalMalloc)
{
RUN_TEST_CASE(InternalMalloc, MallocPastBufferFails);
RUN_TEST_CASE(InternalMalloc, CallocPastBufferFails);
RUN_TEST_CASE(InternalMalloc, MallocThenReallocGrowsMemoryInPlace);
RUN_TEST_CASE(InternalMalloc, ReallocFailDoesNotFreeMem);
}

57
tests/unity/extras/fixture/test/unity_output_Spy.c Normal file
View File

@ -0,0 +1,57 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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_output_Spy.h"
#include "unity_fixture.h"
#include <stdio.h>
#include <string.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;
}

17
tests/unity/extras/fixture/test/unity_output_Spy.h Normal file
View File

@ -0,0 +1,17 @@
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
* ==========================================
* 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 D_unity_output_Spy_H
#define D_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