ceedling 0.28.2 → 0.28.3

data/vendor/cmock/vendor/c_exception/docs/ThrowTheSwitchCodingStandard.md

@@ -0,0 +1,207 @@
+# ThrowTheSwitch.org Coding Standard
+
+Hi. Welcome to the coding standard for ThrowTheSwitch.org. For the most part,
+we try to follow these standards to unify our contributors' code into a cohesive
+unit (puns intended). You might find places where these standards aren't
+followed. We're not perfect. Please be polite where you notice these discrepancies
+and we'll try to be polite when we notice yours.
+
+;)
+
+
+## Why Have A Coding Standard?
+
+Being consistent makes code easier to understand. We've made an attempt to keep
+our standard simple because we also believe that we can only expect someone to
+follow something that is understandable. Please do your best.
+
+
+## Our Philosophy
+
+Before we get into details on syntax, let's take a moment to talk about our
+vision for these tools. We're C developers and embedded software developers.
+These tools are great to test any C code, but catering to embedded software has
+made us more tolerant of compiler quirks. There are a LOT of quirky compilers
+out there. By quirky I mean "doesn't follow standards because they feel like
+they have a license to do as they wish."
+
+Our philosophy is "support every compiler we can". Most often, this means that
+we aim for writing C code that is standards compliant (often C89... that seems
+to be a sweet spot that is almost always compatible). But it also means these
+tools are tolerant of things that aren't common. Some that aren't even
+compliant. There are configuration options to override the size of standard
+types. There are configuration options to force Unity to not use certain
+standard library functions. A lot of Unity is configurable and we have worked
+hard to make it not TOO ugly in the process.
+
+Similarly, our tools that parse C do their best. They aren't full C parsers
+(yet) and, even if they were, they would still have to accept non-standard
+additions like gcc extensions or specifying `@0x1000` to force a variable to
+compile to a particular location. It's just what we do, because we like
+everything to Just Work™.
+
+Speaking of having things Just Work™, that's our second philosophy. By that, we
+mean that we do our best to have EVERY configuration option have a logical
+default. We believe that if you're working with a simple compiler and target,
+you shouldn't need to configure very much... we try to make the tools guess as
+much as they can, but give the user the power to override it when it's wrong.
+
+
+## Naming Things
+
+Let's talk about naming things. Programming is all about naming things. We name
+files, functions, variables, and so much more. While we're not always going to
+find the best name for something, we actually put quite a bit of effort into
+finding *What Something WANTS to be Called*™.
+
+When naming things, we more or less follow this hierarchy, the first being the
+most important to us (but we do all four whenever possible):
+1. Readable
+2. Descriptive
+3. Consistent
+4. Memorable
+
+
+#### Readable
+
+We want to read our code. This means we like names and flow that are more
+naturally read. We try to avoid double negatives. We try to avoid cryptic
+abbreviations (sticking to ones we feel are common).
+
+
+#### Descriptive
+
+We like descriptive names for things, especially functions and variables.
+Finding the right name for something is an important endeavor. You might notice
+from poking around our code that this often results in names that are a little
+longer than the average. Guilty. We're okay with a tiny bit more typing if it
+means our code is easier to understand.
+
+There are two exceptions to this rule that we also stick to as religiously as
+possible:
+
+First, while we realize hungarian notation (and similar systems for encoding
+type information into variable names) is providing a more descriptive name, we
+feel that (for the average developer) it takes away from readability and
+therefore is to be avoided.
+
+Second, loop counters and other local throw-away variables often have a purpose
+which is obvious. There's no need, therefore, to get carried away with complex
+naming. We find i, j, and k are better loop counters than loopCounterVar or
+whatnot. We only break this rule when we see that more description could improve
+understanding of an algorithm.
+
+
+#### Consistent
+
+We like consistency, but we're not really obsessed with it. We try to name our
+configuration macros in a consistent fashion... you'll notice a repeated use of
+UNITY_EXCLUDE_BLAH or UNITY_USES_BLAH macros. This helps users avoid having to
+remember each macro's details.
+
+
+#### Memorable
+
+Where ever it doesn't violate the above principles, we try to apply memorable
+names. Sometimes this means using something that is simply descriptive, but
+often we strive for descriptive AND unique... we like quirky names that stand
+out in our memory and are easier to search for. Take a look through the file
+names in Ceedling and you'll get a good idea of what we are talking about here.
+Why use preprocess when you can use preprocessinator? Or what better describes a
+module in charge of invoking tasks during releases than release_invoker? Don't
+get carried away. The names are still descriptive and fulfill the above
+requirements, but they don't feel stale.
+
+
+## C and C++ Details
+
+We don't really want to add to the style battles out there. Tabs or spaces?
+How many spaces? Where do the braces go? These are age-old questions that will
+never be answered... or at least not answered in a way that will make everyone
+happy.
+
+We've decided on our own style preferences. If you'd like to contribute to these
+projects (and we hope that you do), then we ask if you do your best to follow
+the same. It will only hurt a little. We promise.
+
+
+#### Whitespace
+
+Our C-style is to use spaces and to use 4 of them per indent level. It's a nice
+power-of-2 number that looks decent on a wide screen. We have no more reason
+than that. We break that rule when we have lines that wrap (macros or function
+arguments or whatnot). When that happens, we like to indent further to line
+things up in nice tidy columns.
+
+```C
+    if (stuff_happened)
+    {
+        do_something();
+    }
+```
+
+
+#### Case
+
+- Files - all lower case with underscores.
+- Variables - all lower case with underscores
+- Macros - all caps with underscores.
+- Typedefs - all caps with underscores. (also ends with _T).
+- Functions - camel cased. Usually named ModuleName_FuncName
+- Constants and Globals - camel cased.
+
+
+#### Braces
+
+The left brace is on the next line after the declaration. The right brace is
+directly below that. Everything in between in indented one level. If you're
+catching an error and you have a one-line, go ahead and to it on the same line.
+
+```C
+    while (blah)
+    {
+        //Like so. Even if only one line, we use braces.
+    }
+```
+
+
+#### Comments
+
+Do you know what we hate? Old-school C block comments. BUT, we're using them
+anyway. As we mentioned, our goal is to support every compiler we can,
+especially embedded compilers. There are STILL C compilers out there that only
+support old-school block comments. So that is what we're using. We apologize. We
+think they are ugly too.
+
+
+## Ruby Details
+
+Is there really such thing as a Ruby coding standard? Ruby is such a free form
+language, it seems almost sacrilegious to suggest that people should comply to
+one method! We'll keep it really brief!
+
+
+#### Whitespace
+
+Our Ruby style is to use spaces and to use 2 of them per indent level. It's a
+nice power-of-2 number that really grooves with Ruby's compact style. We have no
+more reason than that. We break that rule when we have lines that wrap. When
+that happens, we like to indent further to line things up in nice tidy columns.
+
+
+#### Case
+
+- Files - all lower case with underscores.
+- Variables - all lower case with underscores
+- Classes, Modules, etc - Camel cased.
+- Functions - all lower case with underscores
+- Constants - all upper case with underscores
+
+
+## Documentation
+
+Egad. Really? We use markdown and we like pdf files because they can be made to
+look nice while still being portable. Good enough?
+
+
+*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)*

data/vendor/cmock/vendor/c_exception/lib/CException.c

@@ -0,0 +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
+ */
+

data/vendor/cmock/vendor/c_exception/lib/CException.h

@@ -0,0 +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
+
+//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/cmock/vendor/c_exception/makefile

@@ -0,0 +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)
+	

data/vendor/cmock/vendor/c_exception/release/build.info

@@ -0,0 +1,2 @@
+18
+

data/vendor/cmock/vendor/c_exception/release/version.info

@@ -0,0 +1,2 @@
+1.3.1
+

data/vendor/cmock/vendor/c_exception/test/CExceptionConfig.h

@@ -0,0 +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

data/vendor/cmock/vendor/c_exception/test/TestException.c

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