ceedling 0.29.1 → 0.30.0

data/vendor/c_exception/lib/CException.h

@@ -1,115 +1,115 @@
-#ifndef _CEXCEPTION_H
-#define _CEXCEPTION_H
-
-#include <setjmp.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-#define CEXCEPTION_VERSION_MAJOR    1
-#define CEXCEPTION_VERSION_MINOR    3
-#define CEXCEPTION_VERSION_BUILD    2
-#define CEXCEPTION_VERSION          ((CEXCEPTION_VERSION_MAJOR << 16) | (CEXCEPTION_VERSION_MINOR << 8) | CEXCEPTION_VERSION_BUILD)
-
-//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[MY_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
+#ifndef _CEXCEPTION_H
+#define _CEXCEPTION_H
+
+#include <setjmp.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+#define CEXCEPTION_VERSION_MAJOR    1
+#define CEXCEPTION_VERSION_MINOR    3
+#define CEXCEPTION_VERSION_BUILD    2
+#define CEXCEPTION_VERSION          ((CEXCEPTION_VERSION_MAJOR << 16) | (CEXCEPTION_VERSION_MINOR << 8) | CEXCEPTION_VERSION_BUILD)
+
+//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[MY_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/lib/meson.build

@@ -0,0 +1,11 @@
+#
+# build script written by : Michael Brockus.
+# github repo author: Mark VanderVoord.
+#
+# license: MIT
+#
+cexception_dir = include_directories('.')
+
+cexception_lib = static_library(meson.project_name(), 
+    sources: ['CException.c'],
+    include_directories: cexception_dir)

data/vendor/c_exception/meson.build

@@ -0,0 +1,48 @@
+#
+# build script written by : Michael Brockus.
+# github repo author: Mark VanderVoord.
+#
+# license: MIT
+#
+project('CException', 'c',
+    license: 'MIT',
+    meson_version: '>=0.53.0',
+    default_options: ['layout=flat', 'warning_level=3', 'werror=true', 'c_std=c11']
+)
+lang = 'c'
+cc = meson.get_compiler(lang)
+
+#
+# Meson: Add compiler flags
+if cc.get_id() == 'clang'
+    add_project_arguments(cc.get_supported_arguments(
+            [
+                '-Wexit-time-destructors',
+                '-Wglobal-constructors',
+                '-Wmissing-prototypes',
+                '-Wmissing-noreturn',
+                '-Wno-missing-braces',
+                '-Wold-style-cast', '-Wpointer-arith', '-Wweak-vtables',
+                '-Wcast-align', '-Wconversion', '-Wcast-qual', '-Wshadow'
+            ]
+        ), language: lang)
+endif
+
+if cc.get_argument_syntax() == 'gcc'
+    add_project_arguments(cc.get_supported_arguments(
+            [
+                '-Wformat', '-Waddress', '-Winit-self', '-Wno-multichar',
+                '-Wpointer-arith'       , '-Wwrite-strings'              ,
+                '-Wno-parentheses'      , '-Wno-type-limits'             ,
+                '-Wformat-security'     , '-Wunreachable-code'           ,
+                '-Waggregate-return'    , '-Wformat-nonliteral'          ,
+                '-Wmissing-declarations', '-Wmissing-include-dirs'       ,
+                '-Wno-unused-parameter'
+            ]
+        ), language: lang)
+endif
+
+#
+# Sub directory to project source code
+subdir('lib')
+cexception_dep = declare_dependency(link_with: cexception_lib, include_directories: cexception_dir)

data/vendor/c_exception/project.yml

@@ -0,0 +1,37 @@
+---
+
+# This project file is for using Ceedling to run CException's self-tests. The
+# only requirement for USING CException is in the lib folder.
+
+:project:
+  :use_exceptions: FALSE
+  :use_test_preprocessor: FALSE
+  :use_auxiliary_dependencies: FALSE
+  :build_root: build
+  :test_file_prefix: Test
+  :which_ceedling: gem
+  :ceedling_version: 0.29.1
+  :default_tasks:
+    - clobber test:all
+
+:extension:
+  :executable: .out
+
+:paths:
+  :test:
+    - +:test/**
+    - -:test/support
+  :source:
+    - lib/**
+  :support:
+    - test/support
+
+:defines:
+  :test:
+    - TEST
+    - CEXCEPTION_USE_CONFIG_FILE
+  :test_preprocess:
+    - TEST
+    - CEXCEPTION_USE_CONFIG_FILE
+
+...

data/vendor/c_exception/test/TestException.c

@@ -1,391 +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 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);
-}
+#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);
+}