ceedling 0.19.0 → 0.20.2

data/vendor/c_exception/lib/CException.c

@@ -1,46 +1,46 @@
-#include "CException.h"
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-volatile CEXCEPTION_FRAME_T CExceptionFrames[CEXCEPTION_NUM_ID] = {{ 0 }};
-#pragma GCC diagnostic pop
-
-//------------------------------------------------------------------------------------------
-//  Throw
-//------------------------------------------------------------------------------------------
-void Throw(CEXCEPTION_T ExceptionID)
-{
-    unsigned int MY_ID = CEXCEPTION_GET_ID;
-    CExceptionFrames[MY_ID].Exception = ExceptionID;
-    if (CExceptionFrames[MY_ID].pFrame)
-    {
-        longjmp(*CExceptionFrames[MY_ID].pFrame, 1);
-    }
-    CEXCEPTION_NO_CATCH_HANDLER(ExceptionID);
-}
-
-//------------------------------------------------------------------------------------------
-//  Explanation of what it's all for:
-//------------------------------------------------------------------------------------------
-/*
-#define Try
-    {                                                                   <- give us some local scope.  most compilers are happy with this
-        jmp_buf *PrevFrame, NewFrame;                                   <- prev frame points to the last try block's frame.  new frame gets created on stack for this Try block
-        unsigned int MY_ID = CEXCEPTION_GET_ID;                         <- look up this task's id for use in frame array.  always 0 if single-tasking
-        PrevFrame = CExceptionFrames[CEXCEPTION_GET_ID].pFrame;         <- set pointer to point at old frame (which array is currently pointing at)
-        CExceptionFrames[MY_ID].pFrame = &NewFrame;                     <- set array to point at my new frame instead, now
-        CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;            <- initialize my exception id to be NONE
-        if (setjmp(NewFrame) == 0) {                                    <- do setjmp.  it returns 1 if longjump called, otherwise 0
-            if (&PrevFrame)                                             <- this is here to force proper scoping.  it requires braces or a single line to be but after Try, otherwise won't compile.  This is always true at this point.
-
-#define Catch(e)
-            else { }                                                    <- this also forces proper scoping.  Without this they could stick their own 'else' in and it would get ugly
-            CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;        <- no errors happened, so just set the exception id to NONE (in case it was corrupted)
-        }
-        else                                                            <- an exception occurred
-        { e = CExceptionFrames[MY_ID].Exception; e=e;}                  <- assign the caught exception id to the variable passed in.
-        CExceptionFrames[MY_ID].pFrame = PrevFrame;                     <- make the pointer in the array point at the previous frame again, as if NewFrame never existed.
-    }                                                                   <- finish off that local scope we created to have our own variables
-    if (CExceptionFrames[CEXCEPTION_GET_ID].Exception != CEXCEPTION_NONE)  <- start the actual 'catch' processing if we have an exception id saved away
- */
-
+#include "CException.h"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+volatile CEXCEPTION_FRAME_T CExceptionFrames[CEXCEPTION_NUM_ID] = {{ 0 }};
+#pragma GCC diagnostic pop
+
+//------------------------------------------------------------------------------------------
+//  Throw
+//------------------------------------------------------------------------------------------
+void Throw(CEXCEPTION_T ExceptionID)
+{
+    unsigned int MY_ID = CEXCEPTION_GET_ID;
+    CExceptionFrames[MY_ID].Exception = ExceptionID;
+    if (CExceptionFrames[MY_ID].pFrame)
+    {
+        longjmp(*CExceptionFrames[MY_ID].pFrame, 1);
+    }
+    CEXCEPTION_NO_CATCH_HANDLER(ExceptionID);
+}
+
+//------------------------------------------------------------------------------------------
+//  Explanation of what it's all for:
+//------------------------------------------------------------------------------------------
+/*
+#define Try
+    {                                                                   <- give us some local scope.  most compilers are happy with this
+        jmp_buf *PrevFrame, NewFrame;                                   <- prev frame points to the last try block's frame.  new frame gets created on stack for this Try block
+        unsigned int MY_ID = CEXCEPTION_GET_ID;                         <- look up this task's id for use in frame array.  always 0 if single-tasking
+        PrevFrame = CExceptionFrames[CEXCEPTION_GET_ID].pFrame;         <- set pointer to point at old frame (which array is currently pointing at)
+        CExceptionFrames[MY_ID].pFrame = &NewFrame;                     <- set array to point at my new frame instead, now
+        CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;            <- initialize my exception id to be NONE
+        if (setjmp(NewFrame) == 0) {                                    <- do setjmp.  it returns 1 if longjump called, otherwise 0
+            if (&PrevFrame)                                             <- this is here to force proper scoping.  it requires braces or a single line to be but after Try, otherwise won't compile.  This is always true at this point.
+
+#define Catch(e)
+            else { }                                                    <- this also forces proper scoping.  Without this they could stick their own 'else' in and it would get ugly
+            CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;        <- no errors happened, so just set the exception id to NONE (in case it was corrupted)
+        }
+        else                                                            <- an exception occurred
+        { e = CExceptionFrames[MY_ID].Exception; e=e;}                  <- assign the caught exception id to the variable passed in.
+        CExceptionFrames[MY_ID].pFrame = PrevFrame;                     <- make the pointer in the array point at the previous frame again, as if NewFrame never existed.
+    }                                                                   <- finish off that local scope we created to have our own variables
+    if (CExceptionFrames[CEXCEPTION_GET_ID].Exception != CEXCEPTION_NONE)  <- start the actual 'catch' processing if we have an exception id saved away
+ */
+

data/vendor/c_exception/lib/CException.h

@@ -1,86 +1,110 @@
-#ifndef _CEXCEPTION_H
-#define _CEXCEPTION_H
-
-#include <setjmp.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-//To Use CException, you have a number of options:
-//1. Just include it and run with the defaults
-//2. Define any of the following symbols at the command line to override them
-//3. Include a header file before CException.h everywhere which defines any of these
-//4. Create an Exception.h in your path, and just define EXCEPTION_USE_CONFIG_FILE first
-
-#ifdef CEXCEPTION_USE_CONFIG_FILE
-#include "CExceptionConfig.h"
-#endif
-
-//This is the value to assign when there isn't an exception
-#ifndef CEXCEPTION_NONE
-#define CEXCEPTION_NONE      (0x5A5A5A5A)
-#endif
-
-//This is number of exception stacks to keep track of (one per task)
-#ifndef CEXCEPTION_NUM_ID
-#define CEXCEPTION_NUM_ID    (1) //there is only the one stack by default
-#endif
-
-//This is the method of getting the current exception stack index (0 if only one stack)
-#ifndef CEXCEPTION_GET_ID
-#define CEXCEPTION_GET_ID    (0) //use the first index always because there is only one anyway
-#endif
-
-//The type to use to store the exception values.
-#ifndef CEXCEPTION_T
-#define CEXCEPTION_T         unsigned int
-#endif
-
-//This is an optional special handler for when there is no global Catch
-#ifndef CEXCEPTION_NO_CATCH_HANDLER
-#define CEXCEPTION_NO_CATCH_HANDLER(id)
-#endif
-
-//exception frame structures
-typedef struct {
-  jmp_buf* pFrame;
-  CEXCEPTION_T volatile Exception;
-} CEXCEPTION_FRAME_T;
-
-//actual root frame storage (only one if single-tasking)
-extern volatile CEXCEPTION_FRAME_T CExceptionFrames[];
-
-//Try (see C file for explanation)
-#define Try                                                         \
-    {                                                               \
-        jmp_buf *PrevFrame, NewFrame;                               \
-        unsigned int MY_ID = CEXCEPTION_GET_ID;                     \
-        PrevFrame = CExceptionFrames[CEXCEPTION_GET_ID].pFrame;     \
-        CExceptionFrames[MY_ID].pFrame = (jmp_buf*)(&NewFrame);     \
-        CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;        \
-        if (setjmp(NewFrame) == 0) {                                \
-            if (1)
-
-//Catch (see C file for explanation)
-#define Catch(e)                                                    \
-            else { }                                                \
-            CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;    \
-        }                                                           \
-        else                                                        \
-        { e = CExceptionFrames[MY_ID].Exception; e=e; }             \
-        CExceptionFrames[MY_ID].pFrame = PrevFrame;                 \
-    }                                                               \
-    if (CExceptionFrames[CEXCEPTION_GET_ID].Exception != CEXCEPTION_NONE)
-
-//Throw an Error
-void Throw(CEXCEPTION_T ExceptionID);
-
-#ifdef __cplusplus
-}   // extern "C"
-#endif
-
-
-#endif // _CEXCEPTION_H
+#ifndef _CEXCEPTION_H
+#define _CEXCEPTION_H
+
+#include <setjmp.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+//To Use CException, you have a number of options:
+//1. Just include it and run with the defaults
+//2. Define any of the following symbols at the command line to override them
+//3. Include a header file before CException.h everywhere which defines any of these
+//4. Create an Exception.h in your path, and just define EXCEPTION_USE_CONFIG_FILE first
+
+#ifdef CEXCEPTION_USE_CONFIG_FILE
+#include "CExceptionConfig.h"
+#endif
+
+//This is the value to assign when there isn't an exception
+#ifndef CEXCEPTION_NONE
+#define CEXCEPTION_NONE      (0x5A5A5A5A)
+#endif
+
+//This is number of exception stacks to keep track of (one per task)
+#ifndef CEXCEPTION_NUM_ID
+#define CEXCEPTION_NUM_ID    (1) //there is only the one stack by default
+#endif
+
+//This is the method of getting the current exception stack index (0 if only one stack)
+#ifndef CEXCEPTION_GET_ID
+#define CEXCEPTION_GET_ID    (0) //use the first index always because there is only one anyway
+#endif
+
+//The type to use to store the exception values.
+#ifndef CEXCEPTION_T
+#define CEXCEPTION_T         unsigned int
+#endif
+
+//This is an optional special handler for when there is no global Catch
+#ifndef CEXCEPTION_NO_CATCH_HANDLER
+#define CEXCEPTION_NO_CATCH_HANDLER(id)
+#endif
+
+//These hooks allow you to inject custom code into places, particularly useful for saving and restoring additional state
+#ifndef CEXCEPTION_HOOK_START_TRY
+#define CEXCEPTION_HOOK_START_TRY
+#endif
+#ifndef CEXCEPTION_HOOK_HAPPY_TRY
+#define CEXCEPTION_HOOK_HAPPY_TRY
+#endif
+#ifndef CEXCEPTION_HOOK_AFTER_TRY
+#define CEXCEPTION_HOOK_AFTER_TRY
+#endif
+#ifndef CEXCEPTION_HOOK_START_CATCH
+#define CEXCEPTION_HOOK_START_CATCH
+#endif
+
+//exception frame structures
+typedef struct {
+  jmp_buf* pFrame;
+  CEXCEPTION_T volatile Exception;
+} CEXCEPTION_FRAME_T;
+
+//actual root frame storage (only one if single-tasking)
+extern volatile CEXCEPTION_FRAME_T CExceptionFrames[];
+
+//Try (see C file for explanation)
+#define Try                                                         \
+    {                                                               \
+        jmp_buf *PrevFrame, NewFrame;                               \
+        unsigned int MY_ID = CEXCEPTION_GET_ID;                     \
+        PrevFrame = CExceptionFrames[CEXCEPTION_GET_ID].pFrame;     \
+        CExceptionFrames[MY_ID].pFrame = (jmp_buf*)(&NewFrame);     \
+        CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;        \
+        CEXCEPTION_HOOK_START_TRY;                                  \
+        if (setjmp(NewFrame) == 0) {                                \
+            if (1)
+
+//Catch (see C file for explanation)
+#define Catch(e)                                                    \
+            else { }                                                \
+            CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;    \
+            CEXCEPTION_HOOK_HAPPY_TRY;                              \
+        }                                                           \
+        else                                                        \
+        {                                                           \
+            e = CExceptionFrames[MY_ID].Exception;                  \
+            (void)e;                                                \
+            CEXCEPTION_HOOK_START_CATCH;                            \
+        }                                                           \
+        CExceptionFrames[MY_ID].pFrame = PrevFrame;                 \
+        CEXCEPTION_HOOK_AFTER_TRY;                                  \
+    }                                                               \
+    if (CExceptionFrames[CEXCEPTION_GET_ID].Exception != CEXCEPTION_NONE)
+
+//Throw an Error
+void Throw(CEXCEPTION_T ExceptionID);
+
+//Just exit the Try block and skip the Catch.
+#define ExitTry() Throw(CEXCEPTION_NONE)
+
+#ifdef __cplusplus
+}   // extern "C"
+#endif
+
+
+#endif // _CEXCEPTION_H

data/vendor/c_exception/makefile

@@ -1,24 +1,24 @@
-#Tool and Lib Locations
-C_COMPILER=gcc
-C_LIBS=C:/MinGW/lib
-UNITY_DIR=vendor/unity/src
-
-#Test File To Be Created
-OUT_FILE=test_cexceptions
-ifeq ($(OS),Windows_NT)
-OUT_EXTENSION=.exe
-else
-OUT_EXTENSION=.out
-endif
-
-#Options
-SRC_FILES=lib/CException.c test/TestException.c test/TestException_Runner.c $(UNITY_DIR)/unity.c
-INC_DIRS=-Ilib -Itest -I$(UNITY_DIR)
-LIB_DIRS=-L$(C_LIBS) 
-SYMBOLS=-DTEST -DCEXCEPTION_USE_CONFIG_FILE
-
-#Default Task: Compile And Run Tests
-default:
-	$(C_COMPILER) $(INC_DIRS) $(LIB_DIRS) $(SYMBOLS) $(SRC_FILES) -o $(OUT_FILE)$(OUT_EXTENSION)
-	$(OUT_FILE)$(OUT_EXTENSION)
+#Tool and Lib Locations
+C_COMPILER=gcc
+C_LIBS=C:/MinGW/lib
+UNITY_DIR=vendor/unity/src
+
+#Test File To Be Created
+OUT_FILE=test_cexceptions
+ifeq ($(OS),Windows_NT)
+OUT_EXTENSION=.exe
+else
+OUT_EXTENSION=.out
+endif
+
+#Options
+SRC_FILES=lib/CException.c test/TestException.c test/TestException_Runner.c $(UNITY_DIR)/unity.c
+INC_DIRS=-Ilib -Itest -I$(UNITY_DIR)
+LIB_DIRS=-L$(C_LIBS) 
+SYMBOLS=-DTEST -DCEXCEPTION_USE_CONFIG_FILE
+
+#Default Task: Compile And Run Tests
+default:
+	$(C_COMPILER) $(INC_DIRS) $(LIB_DIRS) $(SYMBOLS) $(SRC_FILES) -o $(OUT_FILE)$(OUT_EXTENSION)
+	$(OUT_FILE)$(OUT_EXTENSION)
 	

data/vendor/c_exception/test/CExceptionConfig.h

@@ -1,46 +1,46 @@
-#ifndef _EXCEPTION_H
-#define _EXCEPTION_H
-
-#include "unity.h"
-
-extern volatile int TestingTheFallback;
-extern volatile int TestingTheFallbackId;
-
-//Optionally define the exception type (something like an int which can be directly assigned)
-#define CEXCEPTION_T    int
-
-// Optionally define the reserved value representing NO EXCEPTION
-#define CEXCEPTION_NONE (1234)
-
-// Optionally define a special handler for unhandled exceptions
-#define CEXCEPTION_NO_CATCH_HANDLER(id)             \
-{                                                   \
-    if (!TestingTheFallback)                        \
-    {                                               \
-        TEST_FAIL_MESSAGE("Unexpected Exception!"); \
-    }                                               \
-    else                                            \
-    {                                               \
-        TestingTheFallbackId = id;                  \
-        TestingTheFallback--;                       \
-    }                                               \
-}
-
-// Multi-Tasking environments will need a couple of macros defined to make this library
-// properly handle  multiple exception stacks.  You will need to include and required
-// definitions, then define the following macros:
-//    EXCEPTION_GET_ID - returns the id of the current task indexed 0 to (numtasks - 1)
-//    EXCEPTION_NUM_ID - returns the number of tasks that might be returned
-//
-// For example, Quadros might include the following implementation:
-#ifndef TEST
-#include "OSAPI.h"
-#define CEXCEPTION_GET_ID    (KS_GetTaskID())
-#define CEXCEPTION_NUM_ID    (NTASKS + 1)
-#endif
-
-//This could be a good place to define/include some error ID's:
-#define ERROR_ID_EVERYTHING_IS_BROKEN  (0x88)
-#define ERROR_ID_ONLY_THIS_IS_BROKEN   (0x77)
-
-#endif // _EXCEPTION_H
+#ifndef _EXCEPTION_H
+#define _EXCEPTION_H
+
+#include "unity.h"
+
+extern volatile int TestingTheFallback;
+extern volatile int TestingTheFallbackId;
+
+//Optionally define the exception type (something like an int which can be directly assigned)
+#define CEXCEPTION_T    int
+
+// Optionally define the reserved value representing NO EXCEPTION
+#define CEXCEPTION_NONE (1234)
+
+// Optionally define a special handler for unhandled exceptions
+#define CEXCEPTION_NO_CATCH_HANDLER(id)             \
+{                                                   \
+    if (!TestingTheFallback)                        \
+    {                                               \
+        TEST_FAIL_MESSAGE("Unexpected Exception!"); \
+    }                                               \
+    else                                            \
+    {                                               \
+        TestingTheFallbackId = id;                  \
+        TestingTheFallback--;                       \
+    }                                               \
+}
+
+// Multi-Tasking environments will need a couple of macros defined to make this library
+// properly handle  multiple exception stacks.  You will need to include and required
+// definitions, then define the following macros:
+//    EXCEPTION_GET_ID - returns the id of the current task indexed 0 to (numtasks - 1)
+//    EXCEPTION_NUM_ID - returns the number of tasks that might be returned
+//
+// For example, Quadros might include the following implementation:
+#ifndef TEST
+#include "OSAPI.h"
+#define CEXCEPTION_GET_ID    (KS_GetTaskID())
+#define CEXCEPTION_NUM_ID    (NTASKS + 1)
+#endif
+
+//This could be a good place to define/include some error ID's:
+#define ERROR_ID_EVERYTHING_IS_BROKEN  (0x88)
+#define ERROR_ID_ONLY_THIS_IS_BROKEN   (0x77)
+
+#endif // _EXCEPTION_H

data/vendor/c_exception/test/TestException.c

@@ -1,342 +1,391 @@
-#include "unity.h"
-#include "CException.h"
-
-volatile int TestingTheFallback;
-volatile int TestingTheFallbackId;
-
-void setUp(void)
-{
-    CExceptionFrames[0].pFrame = NULL;
-    TestingTheFallback = 0;
-}
-
-void tearDown(void)
-{
-}
-
-void test_BasicTryDoesNothingIfNoThrow(void)
-{
-  int i = 0;
-  CEXCEPTION_T e = 0x5a;
-
-  Try
-  {
-    i += 1;
-  }
-  Catch(e)
-  {
-    TEST_FAIL_MESSAGE("Should Not Enter Catch If Not Thrown");
-  }
-
-  //verify that e was untouched
-  TEST_ASSERT_EQUAL(0x5a, e);
-
-  // verify that i was incremented once
-  TEST_ASSERT_EQUAL(1, i);
-}
-
-void test_BasicThrowAndCatch(void)
-{
-  CEXCEPTION_T e;
-
-  Try
-  {
-    Throw(0xBE);
-    TEST_FAIL_MESSAGE("Should Have Thrown An Error")
-  }
-  Catch(e)
-  {
-    //verify that e has the right data
-    TEST_ASSERT_EQUAL(0xBE, e);
-  }
-
-  //verify that e STILL has the right data
-  TEST_ASSERT_EQUAL(0xBE, e);
-}
-
-void test_BasicThrowAndCatch_WithMiniSyntax(void)
-{
-  CEXCEPTION_T e;
-
-  //Mini Throw and Catch
-  Try
-    Throw(0xEF);
-  Catch(e)
-    TEST_ASSERT_EQUAL(0xEF, e);
-  TEST_ASSERT_EQUAL(0xEF, e);
-
-  //Mini Passthrough
-  Try
-    e = 0;
-  Catch(e)
-    TEST_FAIL_MESSAGE("I shouldn't be caught because there was no throw");
-
-  TEST_ASSERT_EQUAL(0, e);
-}
-
-void test_VerifyVolatilesSurviveThrowAndCatch(void)
-{
-  volatile unsigned int VolVal = 0;
-  CEXCEPTION_T e;
-
-  Try
-  {
-    VolVal = 2;
-    Throw(0xBF);
-    TEST_FAIL_MESSAGE("Should Have Thrown An Error")
-  }
-  Catch(e)
-  {
-    VolVal += 2;
-    TEST_ASSERT_EQUAL(0xBF, e);
-  }
-
-  TEST_ASSERT_EQUAL(4, VolVal);
-  TEST_ASSERT_EQUAL(0xBF, e);
-}
-
-void HappyExceptionThrower(unsigned int ID)
-{
-  if (ID != 0)
-  {
-    Throw(ID);
-  }
-}
-
-void test_ThrowFromASubFunctionAndCatchInRootFunc(void)
-{
-  volatile  unsigned int ID = 0;
-  CEXCEPTION_T e;
-
-  Try
-  {
-
-    HappyExceptionThrower(0xBA);
-    TEST_FAIL_MESSAGE("Should Have Thrown An Exception");
-  }
-  Catch(e)
-  {
-    ID = e;
-  }
-
-  //verify that I can pass that value to something else
-  TEST_ASSERT_EQUAL(0xBA, e);
-  //verify that ID and e have the same value
-  TEST_ASSERT_EQUAL(ID, e);
-}
-
-void HappyExceptionRethrower(unsigned int ID)
-{
-  CEXCEPTION_T e;
-
-  Try
-  {
-    Throw(ID);
-  }
-  Catch(e)
-  {
-    switch (e)
-    {
-    case 0xBD:
-      Throw(0xBF);
-      break;
-    default:
-      break;
-    }
-  }
-}
-
-void test_ThrowAndCatchFromASubFunctionAndRethrowToCatchInRootFunc(void)
-{
-  volatile  unsigned int ID = 0;
-  CEXCEPTION_T e;
-
-  Try
-  {
-    HappyExceptionRethrower(0xBD);
-    TEST_FAIL_MESSAGE("Should Have Rethrown Exception");
-  }
-  Catch(e)
-  {
-    ID = 1;
-  }
-
-  TEST_ASSERT_EQUAL(0xBF, e);
-  TEST_ASSERT_EQUAL(1, ID);
-}
-
-void test_ThrowAndCatchFromASubFunctionAndNoRethrowToCatchInRootFunc(void)
-{
-  CEXCEPTION_T e = 3;
-
-  Try
-  {
-    HappyExceptionRethrower(0xBF);
-  }
-  Catch(e)
-  {
-    TEST_FAIL_MESSAGE("Should Not Have Re-thrown Error (it should have already been caught)");
-  }
-
-  //verify that THIS e is still untouched, even though subfunction was touched
-  TEST_ASSERT_EQUAL(3, e);
-}
-
-void test_ThrowAnErrorThenEnterATryBlockFromWithinCatch_VerifyThisDoesntCorruptExceptionId(void)
-{
-  CEXCEPTION_T e;
-
-  Try
-  {
-    HappyExceptionThrower(0xBF);
-    TEST_FAIL_MESSAGE("Should Have Thrown Exception");
-  }
-  Catch(e)
-  {
-    TEST_ASSERT_EQUAL(0xBF, e);
-    HappyExceptionRethrower(0x12);
-    TEST_ASSERT_EQUAL(0xBF, e);
-  }
-  TEST_ASSERT_EQUAL(0xBF, e);
-}
-
-void test_ThrowAnErrorThenEnterATryBlockFromWithinCatch_VerifyThatEachExceptionIdIndependent(void)
-{
-  CEXCEPTION_T e1, e2;
-
-  Try
-  {
-    HappyExceptionThrower(0xBF);
-    TEST_FAIL_MESSAGE("Should Have Thrown Exception");
-  }
-  Catch(e1)
-  {
-    TEST_ASSERT_EQUAL(0xBF, e1);
-    Try
-    {
-      HappyExceptionThrower(0x12);
-    }
-    Catch(e2)
-    {
-      TEST_ASSERT_EQUAL(0x12, e2);
-    }
-    TEST_ASSERT_EQUAL(0x12, e2);
-    TEST_ASSERT_EQUAL(0xBF, e1);
-  }
-  TEST_ASSERT_EQUAL(0x12, e2);
-  TEST_ASSERT_EQUAL(0xBF, e1);
-}
-
-void test_CanHaveMultipleTryBlocksInASingleFunction(void)
-{
-  CEXCEPTION_T e;
-
-  Try
-  {
-    HappyExceptionThrower(0x01);
-    TEST_FAIL_MESSAGE("Should Have Thrown Exception");
-  }
-  Catch(e)
-  {
-    TEST_ASSERT_EQUAL(0x01, e);
-  }
-
-  Try
-  {
-    HappyExceptionThrower(0xF0);
-    TEST_FAIL_MESSAGE("Should Have Thrown Exception");
-  }
-  Catch(e)
-  {
-    TEST_ASSERT_EQUAL(0xF0, e);
-  }
-}
-
-void test_CanHaveNestedTryBlocksInASingleFunction_ThrowInside(void)
-{
-  int i = 0;
-  CEXCEPTION_T e;
-
-  Try
-  {
-    Try
-    {
-      HappyExceptionThrower(0x01);
-      i = 1;
-      TEST_FAIL_MESSAGE("Should Have Rethrown Exception");
-    }
-    Catch(e)
-    {
-      TEST_ASSERT_EQUAL(0x01, e);
-    }
-  }
-  Catch(e)
-  {
-    TEST_FAIL_MESSAGE("Should Have Been Caught By Inside Catch");
-  }
-
-  // verify that i is still zero
-  TEST_ASSERT_EQUAL(0, i);
-}
-
-void test_CanHaveNestedTryBlocksInASingleFunction_ThrowOutside(void)
-{
-  int i = 0;
-  CEXCEPTION_T e;
-
-  Try
-  {
-    Try
-    {
-      i = 2;
-    }
-    Catch(e)
-    {
-      TEST_FAIL_MESSAGE("Should NotBe Caught Here");
-    }
-    HappyExceptionThrower(0x01);
-    TEST_FAIL_MESSAGE("Should Have Rethrown Exception");
-  }
-  Catch(e)
-  {
-    TEST_ASSERT_EQUAL(0x01, e);
-  }
-
-  // verify that i is 2
-  TEST_ASSERT_EQUAL(2, i);
-}
-
-void test_AThrowWithoutATryCatchWillUseDefaultHandlerIfSpecified(void)
-{
-    //Let the fallback handler know we're expecting it to get called this time, so don't fail
-    TestingTheFallback = 1;
-
-    Throw(0xBE);
-
-    //We know the fallback was run because it decrements the counter above
-    TEST_ASSERT_FALSE(TestingTheFallback);
-    TEST_ASSERT_EQUAL(0xBE, TestingTheFallbackId);
-}
-
-void test_AThrowWithoutOutsideATryCatchWillUseDefaultHandlerEvenAfterTryCatch(void)
-{
-    CEXCEPTION_T e;
-
-    Try
-    {
-        //It's not really important that we do anything here.
-    }
-    Catch(e)
-    {
-        //The entire purpose here is just to make sure things get set back to using the default handler when done
-    }
-
-    //Let the fallback handler know we're expecting it to get called this time, so don't fail
-    TestingTheFallback = 1;
-
-    Throw(0xBE);
-
-    //We know the fallback was run because it decrements the counter above
-    TEST_ASSERT_FALSE(TestingTheFallback);
-    TEST_ASSERT_EQUAL(0xBE, TestingTheFallbackId);
-}
+#include "unity.h"
+#include "CException.h"
+
+volatile int TestingTheFallback;
+volatile int TestingTheFallbackId;
+
+void setUp(void)
+{
+    CExceptionFrames[0].pFrame = NULL;
+    TestingTheFallback = 0;
+}
+
+void tearDown(void)
+{
+}
+
+void test_BasicTryDoesNothingIfNoThrow(void)
+{
+  int i = 0;
+  CEXCEPTION_T e = 0x5a;
+
+  Try
+  {
+    i += 1;
+  }
+  Catch(e)
+  {
+    TEST_FAIL_MESSAGE("Should Not Enter Catch If Not Thrown");
+  }
+
+  //verify that e was untouched
+  TEST_ASSERT_EQUAL(0x5a, e);
+
+  // verify that i was incremented once
+  TEST_ASSERT_EQUAL(1, i);
+}
+
+void test_BasicThrowAndCatch(void)
+{
+  CEXCEPTION_T e;
+
+  Try
+  {
+    Throw(0xBE);
+    TEST_FAIL_MESSAGE("Should Have Thrown An Error");
+  }
+  Catch(e)
+  {
+    //verify that e has the right data
+    TEST_ASSERT_EQUAL(0xBE, e);
+  }
+
+  //verify that e STILL has the right data
+  TEST_ASSERT_EQUAL(0xBE, e);
+}
+
+void test_BasicThrowAndCatch_WithMiniSyntax(void)
+{
+  CEXCEPTION_T e;
+
+  //Mini Throw and Catch
+  Try
+    Throw(0xEF);
+  Catch(e)
+    TEST_ASSERT_EQUAL(0xEF, e);
+  TEST_ASSERT_EQUAL(0xEF, e);
+
+  //Mini Passthrough
+  Try
+    e = 0;
+  Catch(e)
+    TEST_FAIL_MESSAGE("I shouldn't be caught because there was no throw");
+
+  TEST_ASSERT_EQUAL(0, e);
+}
+
+void test_VerifyVolatilesSurviveThrowAndCatch(void)
+{
+  volatile unsigned int VolVal = 0;
+  CEXCEPTION_T e;
+
+  Try
+  {
+    VolVal = 2;
+    Throw(0xBF);
+    TEST_FAIL_MESSAGE("Should Have Thrown An Error");
+  }
+  Catch(e)
+  {
+    VolVal += 2;
+    TEST_ASSERT_EQUAL(0xBF, e);
+  }
+
+  TEST_ASSERT_EQUAL(4, VolVal);
+  TEST_ASSERT_EQUAL(0xBF, e);
+}
+
+void HappyExceptionThrower(unsigned int ID)
+{
+  if (ID != 0)
+  {
+    Throw(ID);
+  }
+}
+
+void test_ThrowFromASubFunctionAndCatchInRootFunc(void)
+{
+  volatile  unsigned int ID = 0;
+  CEXCEPTION_T e;
+
+  Try
+  {
+
+    HappyExceptionThrower(0xBA);
+    TEST_FAIL_MESSAGE("Should Have Thrown An Exception");
+  }
+  Catch(e)
+  {
+    ID = e;
+  }
+
+  //verify that I can pass that value to something else
+  TEST_ASSERT_EQUAL(0xBA, e);
+  //verify that ID and e have the same value
+  TEST_ASSERT_EQUAL(ID, e);
+}
+
+void HappyExceptionRethrower(unsigned int ID)
+{
+  CEXCEPTION_T e;
+
+  Try
+  {
+    Throw(ID);
+  }
+  Catch(e)
+  {
+    switch (e)
+    {
+    case 0xBD:
+      Throw(0xBF);
+      break;
+    default:
+      break;
+    }
+  }
+}
+
+void test_ThrowAndCatchFromASubFunctionAndRethrowToCatchInRootFunc(void)
+{
+  volatile  unsigned int ID = 0;
+  CEXCEPTION_T e;
+
+  Try
+  {
+    HappyExceptionRethrower(0xBD);
+    TEST_FAIL_MESSAGE("Should Have Rethrown Exception");
+  }
+  Catch(e)
+  {
+    ID = 1;
+  }
+
+  TEST_ASSERT_EQUAL(0xBF, e);
+  TEST_ASSERT_EQUAL(1, ID);
+}
+
+void test_ThrowAndCatchFromASubFunctionAndNoRethrowToCatchInRootFunc(void)
+{
+  CEXCEPTION_T e = 3;
+
+  Try
+  {
+    HappyExceptionRethrower(0xBF);
+  }
+  Catch(e)
+  {
+    TEST_FAIL_MESSAGE("Should Not Have Re-thrown Error (it should have already been caught)");
+  }
+
+  //verify that THIS e is still untouched, even though subfunction was touched
+  TEST_ASSERT_EQUAL(3, e);
+}
+
+void test_ThrowAnErrorThenEnterATryBlockFromWithinCatch_VerifyThisDoesntCorruptExceptionId(void)
+{
+  CEXCEPTION_T e;
+
+  Try
+  {
+    HappyExceptionThrower(0xBF);
+    TEST_FAIL_MESSAGE("Should Have Thrown Exception");
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0xBF, e);
+    HappyExceptionRethrower(0x12);
+    TEST_ASSERT_EQUAL(0xBF, e);
+  }
+  TEST_ASSERT_EQUAL(0xBF, e);
+}
+
+void test_ThrowAnErrorThenEnterATryBlockFromWithinCatch_VerifyThatEachExceptionIdIndependent(void)
+{
+  CEXCEPTION_T e1, e2;
+
+  Try
+  {
+    HappyExceptionThrower(0xBF);
+    TEST_FAIL_MESSAGE("Should Have Thrown Exception");
+  }
+  Catch(e1)
+  {
+    TEST_ASSERT_EQUAL(0xBF, e1);
+    Try
+    {
+      HappyExceptionThrower(0x12);
+    }
+    Catch(e2)
+    {
+      TEST_ASSERT_EQUAL(0x12, e2);
+    }
+    TEST_ASSERT_EQUAL(0x12, e2);
+    TEST_ASSERT_EQUAL(0xBF, e1);
+  }
+  TEST_ASSERT_EQUAL(0x12, e2);
+  TEST_ASSERT_EQUAL(0xBF, e1);
+}
+
+void test_CanHaveMultipleTryBlocksInASingleFunction(void)
+{
+  CEXCEPTION_T e;
+
+  Try
+  {
+    HappyExceptionThrower(0x01);
+    TEST_FAIL_MESSAGE("Should Have Thrown Exception");
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0x01, e);
+  }
+
+  Try
+  {
+    HappyExceptionThrower(0xF0);
+    TEST_FAIL_MESSAGE("Should Have Thrown Exception");
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0xF0, e);
+  }
+}
+
+void test_CanHaveNestedTryBlocksInASingleFunction_ThrowInside(void)
+{
+  int i = 0;
+  CEXCEPTION_T e;
+
+  Try
+  {
+    Try
+    {
+      HappyExceptionThrower(0x01);
+      i = 1;
+      TEST_FAIL_MESSAGE("Should Have Rethrown Exception");
+    }
+    Catch(e)
+    {
+      TEST_ASSERT_EQUAL(0x01, e);
+    }
+  }
+  Catch(e)
+  {
+    TEST_FAIL_MESSAGE("Should Have Been Caught By Inside Catch");
+  }
+
+  // verify that i is still zero
+  TEST_ASSERT_EQUAL(0, i);
+}
+
+void test_CanHaveNestedTryBlocksInASingleFunction_ThrowOutside(void)
+{
+  int i = 0;
+  CEXCEPTION_T e;
+
+  Try
+  {
+    Try
+    {
+      i = 2;
+    }
+    Catch(e)
+    {
+      TEST_FAIL_MESSAGE("Should Not Be Caught Here");
+    }
+    HappyExceptionThrower(0x01);
+    TEST_FAIL_MESSAGE("Should Have Rethrown Exception");
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0x01, e);
+  }
+
+  // verify that i is 2
+  TEST_ASSERT_EQUAL(2, i);
+}
+
+void test_AThrowWithoutATryCatchWillUseDefaultHandlerIfSpecified(void)
+{
+    //Let the fallback handler know we're expecting it to get called this time, so don't fail
+    TestingTheFallback = 1;
+
+    Throw(0xBE);
+
+    //We know the fallback was run because it decrements the counter above
+    TEST_ASSERT_FALSE(TestingTheFallback);
+    TEST_ASSERT_EQUAL(0xBE, TestingTheFallbackId);
+}
+
+void test_AThrowWithoutOutsideATryCatchWillUseDefaultHandlerEvenAfterTryCatch(void)
+{
+    CEXCEPTION_T e;
+
+    Try
+    {
+        //It's not really important that we do anything here.
+    }
+    Catch(e)
+    {
+        //The entire purpose here is just to make sure things get set back to using the default handler when done
+    }
+
+    //Let the fallback handler know we're expecting it to get called this time, so don't fail
+    TestingTheFallback = 1;
+
+    Throw(0xBE);
+
+    //We know the fallback was run because it decrements the counter above
+    TEST_ASSERT_FALSE(TestingTheFallback);
+    TEST_ASSERT_EQUAL(0xBE, TestingTheFallbackId);
+}
+
+void test_AbilityToExitTryWithoutThrowingAnError(void)
+{
+    int i=0;
+    CEXCEPTION_T e;
+
+    Try
+    {
+        ExitTry();
+        i = 1;
+        TEST_FAIL_MESSAGE("Should Have Exited Try Before This");
+    }
+    Catch(e)
+    {
+        i = 2;
+        TEST_FAIL_MESSAGE("Should Not Have Been Caught");
+    }
+
+    // verify that i is still zero
+    TEST_ASSERT_EQUAL(0, i);
+}
+
+void test_AbilityToExitTryWillOnlyExitOneLevel(void)
+{
+    int i=0;
+    CEXCEPTION_T e;
+    CEXCEPTION_T e2;
+
+    Try
+    {
+        Try
+        {
+            ExitTry();
+            TEST_FAIL_MESSAGE("Should Have Exited Try Before This");
+        }
+        Catch(e)
+        {
+            TEST_FAIL_MESSAGE("Should Not Have Been Caught By Inside");
+        }
+        i = 1;
+    }
+    Catch(e2)
+    {
+        TEST_FAIL_MESSAGE("Should Not Have Been Caught By Outside");
+    }
+
+    // verify that we picked up and ran after first Try
+    TEST_ASSERT_EQUAL(1, i);
+}