ceedling 0.13.0.rc1 → 0.13.0

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

@@ -0,0 +1,81 @@
+//- 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, char* argv[], void (*runAllTests)());
+
+
+#define TEST_GROUP(group)\
+    int TEST_GROUP_##group = 0
+
+#define TEST_SETUP(group) void TEST_##group##_SETUP()
+
+#define TEST_TEAR_DOWN(group) void TEST_##group##_TEAR_DOWN()
+
+
+#define TEST(group, name) \
+    void TEST_##group##_##name##_();\
+    void TEST_##group##_##name##_run()\
+    {\
+        UnityTestRunner(TEST_##group##_SETUP,\
+             TEST_##group##_##name##_,\
+            TEST_##group##_TEAR_DOWN,\
+            "TEST(" #group ", " #name ")",\
+            #group, #name,\
+            __FILE__, __LINE__);\
+    }\
+    void  TEST_##group##_##name##_()
+
+#define IGNORE_TEST(group, name) \
+    void TEST_##group##_##name##_();\
+    void TEST_##group##_##name##_run()\
+    {\
+        UnityIgnoreTest();\
+    }\
+    void  TEST_##group##_##name##_()
+
+#define DECLARE_TEST_CASE(group, name) \
+    void TEST_##group##_##name##_run()
+
+#define RUN_TEST_CASE(group, name) \
+        DECLARE_TEST_CASE(group, name);\
+    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_runAll();\
+    void TEST_##group##_GROUP_RUNNER()\
+    {\
+        TEST_##group##_GROUP_RUNNER_runAll();\
+    }\
+    void TEST_##group##_GROUP_RUNNER_runAll()
+
+//Call this from main
+#define RUN_TEST_GROUP(group)\
+    void TEST_##group##_GROUP_RUNNER();\
+    TEST_##group##_GROUP_RUNNER();
+
+//CppUTest Compatibility Macros
+#define UT_PTR_SET(ptr, newPointerValue)               UnityPointer_Set((void**)&ptr, (void*)newPointerValue)
+#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))
+#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_FLOAT_WITHIN(((expected), (actual), (delta))
+
+void UnityMalloc_MakeMallocFailAfterCount(int count);
+
+#endif /* UNITY_FIXTURE_H_ */

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

@@ -0,0 +1,44 @@
+//- 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_
+
+typedef struct _UNITY_FIXTURE_T
+{
+    int Verbose;
+    unsigned int RepeatCount;
+    const char* NameFilter;
+    const char* GroupFilter;
+} UNITY_FIXTURE_T;
+
+typedef void unityfunction();
+void UnityTestRunner(unityfunction * setup,
+        unityfunction * body,
+        unityfunction * teardown,
+        const char * printableName,
+        const char * group,
+        const char * name,
+        const char * file, int line);
+
+void UnityIgnoreTest();
+void UnityMalloc_StartTest();
+void UnityMalloc_EndTest();
+int UnityFailureCount();
+int UnityGetCommandLineOptions(int argc, char* argv[]);
+void UnityConcludeFixtureTest();
+
+void UnityPointer_Set(void ** ptr, void * newValue);
+void UnityPointer_UndoAllSets();
+void UnityPointer_Init();
+
+void UnityAssertEqualPointer(const void * expected,
+                            const void * actual,
+                            const char* msg,
+                            const UNITY_LINE_TYPE lineNumber);
+
+#endif /* UNITY_FIXTURE_INTERNALS_H_ */

data/vendor/c_exception/vendor/unity/extras/fixture/src/unity_fixture_malloc_overrides.h

@@ -0,0 +1,16 @@
+//- 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_
+
+#define malloc  unity_malloc
+#define calloc  unity_calloc
+#define realloc unity_realloc
+#define free    unity_free
+
+#endif /* UNITY_FIXTURE_MALLOC_OVERRIDES_H_ */

data/vendor/c_exception/vendor/unity/extras/fixture/test/main/AllTests.c

@@ -0,0 +1,21 @@
+//- 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()
+{
+    RUN_TEST_GROUP(UnityFixture);
+    RUN_TEST_GROUP(UnityCommandOptions);
+    RUN_TEST_GROUP(LeakDetection)
+}
+
+int main(int argc, char* argv[])
+{
+    return UnityMain(argc, argv, runAllTests);
+}
+

data/vendor/c_exception/vendor/unity/extras/fixture/test/testunity_fixture.c

@@ -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);
+}

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

@@ -0,0 +1,321 @@
+//- 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>
+
+extern UNITY_FIXTURE_T UnityFixture;
+
+TEST_GROUP(UnityFixture);
+
+TEST_SETUP(UnityFixture)
+{
+}
+
+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;
+
+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)
+{
+    UnityMalloc_MakeMallocFailAfterCount(1);
+    void* m = malloc(10);
+    CHECK(m);
+    void* 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);
+    strcpy((char*)m1, "123456789");
+    void* m2 = realloc(m1, 15);
+    CHECK(m1 != m2);
+    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;
+    TEST_ASSERT_BYTES_EQUAL(0, s[0]);
+    TEST_ASSERT_BYTES_EQUAL(0, s[1]);
+    TEST_ASSERT_BYTES_EQUAL(0, s[2]);
+    free(m);
+}
+
+char *p1;
+char *p2;
+
+TEST(UnityFixture, PointerSet)
+{
+    char c1;
+    char c2;
+    char newC1;
+    char newC2;
+    p1 = &c1;
+    p2 = &c2;
+
+    UnityPointer_Init(10);
+    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_GROUP(UnityCommandOptions);
+
+int savedVerbose;
+int savedRepeat;
+const char* savedName;
+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 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 char* verbose[] = {
+        "testrunner.exe",
+        "-v"
+};
+
+TEST(UnityCommandOptions, OptionVerbose)
+{
+    TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(2, verbose));
+    TEST_ASSERT_EQUAL(1, UnityFixture.Verbose);
+}
+
+static char* group[] = {
+        "testrunner.exe",
+        "-g", "groupname"
+};
+
+TEST(UnityCommandOptions, OptionSelectTestByGroup)
+{
+    TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, group));
+    STRCMP_EQUAL("groupname", UnityFixture.GroupFilter);
+}
+
+static char* name[] = {
+        "testrunner.exe",
+        "-n", "testname"
+};
+
+TEST(UnityCommandOptions, OptionSelectTestByName)
+{
+    TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, name));
+    STRCMP_EQUAL("testname", UnityFixture.NameFilter);
+}
+
+static 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 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 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);
+}
+
+
+//------------------------------------------------------------
+
+TEST_GROUP(LeakDetection);
+
+TEST_SETUP(LeakDetection)
+{
+    UnityOutputCharSpy_Create(1000);
+}
+
+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)); \
+  }
+
+TEST(LeakDetection, DetectsLeak)
+{
+    void* m = malloc(10);
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    UnityMalloc_EndTest();
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    CHECK(strstr(UnityOutputCharSpy_Get(), "This test leaks!"));
+    free(m);
+    Unity.CurrentTestFailed = 0;
+}
+
+TEST(LeakDetection, BufferOverrunFoundDuringFree)
+{
+    void* m = malloc(10);
+    char* s = (char*)m;
+    s[10] = (char)0xFF;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    free(m);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()"));
+    Unity.CurrentTestFailed = 0;
+}
+
+TEST(LeakDetection, BufferOverrunFoundDuringRealloc)
+{
+    void* m = malloc(10);
+    char* s = (char*)m;
+    s[10] = (char)0xFF;
+    UnityOutputCharSpy_Enable(1);
+    EXPECT_ABORT_BEGIN
+    m = realloc(m, 100);
+    EXPECT_ABORT_END
+    UnityOutputCharSpy_Enable(0);
+    CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()"));
+    Unity.CurrentTestFailed = 0;
+}