ceedling 0.13.0 → 0.15.0

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

@@ -0,0 +1,2 @@
+16
+

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

@@ -0,0 +1,2 @@
+1.2
+

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

@@ -0,0 +1,27 @@
+#ifndef _EXCEPTION_H
+#define _EXCEPTION_H
+
+//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)
+
+// 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,291 @@
+#include "unity.h"
+#include "CException.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void test_BasicTryDoesNothingIfNoThrow(void)
+{
+  int i;
+  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);
+}
+
+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);
+}
+
+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");
+  }
+}
+
+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);
+  }
+}

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

@@ -0,0 +1,62 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include "unity.h"
+#include "CException.h"
+
+extern void setUp(void);
+extern void tearDown(void);
+
+extern void test_BasicTryDoesNothingIfNoThrow(void);
+extern void test_BasicThrowAndCatch(void);
+extern void test_BasicThrowAndCatch_WithMiniSyntax(void);
+extern void test_VerifyVolatilesSurviveThrowAndCatch(void);
+extern void test_ThrowFromASubFunctionAndCatchInRootFunc(void);
+extern void test_ThrowAndCatchFromASubFunctionAndRethrowToCatchInRootFunc(void);
+extern void test_ThrowAndCatchFromASubFunctionAndNoRethrowToCatchInRootFunc(void);
+extern void test_CanHaveMultipleTryBlocksInASingleFunction(void);
+extern void test_CanHaveNestedTryBlocksInASingleFunction_ThrowInside(void);
+extern void test_CanHaveNestedTryBlocksInASingleFunction_ThrowOutside(void);
+extern void test_ThrowAnErrorThenEnterATryBlockFromWithinCatch_VerifyThisDoesntCorruptExceptionId(void);
+extern void test_ThrowAnErrorThenEnterATryBlockFromWithinCatch_VerifyThatEachExceptionIdIndependent(void);
+
+static void runTest(UnityTestFunction test)
+{
+  CEXCEPTION_T e;
+  if (TEST_PROTECT())
+  {
+    setUp();
+    Try
+    {
+      test();
+    }
+    Catch(e)
+    {
+      TEST_FAIL_MESSAGE("Unexpected exception!")
+    }
+  }
+  tearDown();
+}
+
+
+int main(void)
+{
+  Unity.TestFile = __FILE__;
+  UnityBegin();
+
+  // RUN_TEST calls runTest
+  RUN_TEST(test_BasicTryDoesNothingIfNoThrow, 12);
+  RUN_TEST(test_BasicThrowAndCatch, 30);
+  RUN_TEST(test_BasicThrowAndCatch_WithMiniSyntax, 49);
+  RUN_TEST(test_VerifyVolatilesSurviveThrowAndCatch, 69);
+  RUN_TEST(test_ThrowFromASubFunctionAndCatchInRootFunc, 98);
+  RUN_TEST(test_ThrowAndCatchFromASubFunctionAndRethrowToCatchInRootFunc, 139);
+  RUN_TEST(test_ThrowAndCatchFromASubFunctionAndNoRethrowToCatchInRootFunc, 158);
+  RUN_TEST(test_ThrowAnErrorThenEnterATryBlockFromWithinCatch_VerifyThisDoesntCorruptExceptionId, 175);
+  RUN_TEST(test_ThrowAnErrorThenEnterATryBlockFromWithinCatch_VerifyThatEachExceptionIdIndependent, 193);
+  RUN_TEST(test_CanHaveMultipleTryBlocksInASingleFunction, 220);
+  RUN_TEST(test_CanHaveNestedTryBlocksInASingleFunction_ThrowInside, 245);
+  RUN_TEST(test_CanHaveNestedTryBlocksInASingleFunction_ThrowOutside, 269);
+
+  UnityEnd();
+  
+  return 0;
+}

data/vendor/cmock/vendor/unity/auto/colour_prompt.rb

@@ -0,0 +1,94 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+if RUBY_PLATFORM =~/(win|w)32$/
+	begin
+		require 'Win32API'
+	rescue LoadError
+		puts "ERROR! \"Win32API\" library not found"
+		puts "\"Win32API\" is required for colour on a windows machine"
+		puts "  try => \"gem install Win32API\" on the command line"
+		puts
+	end
+	# puts
+  # puts 'Windows Environment Detected...'
+	# puts 'Win32API Library Found.'
+	# puts
+end
+
+class ColourCommandLine
+  def initialize
+    if RUBY_PLATFORM =~/(win|w)32$/  
+      get_std_handle = Win32API.new("kernel32", "GetStdHandle", ['L'], 'L')
+      @set_console_txt_attrb =
+      Win32API.new("kernel32","SetConsoleTextAttribute",['L','N'], 'I')
+      @hout = get_std_handle.call(-11)
+    end
+  end
+  
+  def change_to(new_colour)
+    if RUBY_PLATFORM =~/(win|w)32$/
+      @set_console_txt_attrb.call(@hout,self.win32_colour(new_colour))
+    else
+	  	"\033[30;#{posix_colour(new_colour)};22m"
+	 	end
+  end
+  
+  def win32_colour(colour)
+    case colour
+      when :black then 0  
+      when :dark_blue then 1
+      when :dark_green then 2
+      when :dark_cyan then 3
+      when :dark_red then 4
+      when :dark_purple then 5
+      when :dark_yellow, :narrative then 6
+      when :default_white, :default, :dark_white then 7
+      when :silver then 8
+      when :blue then 9
+      when :green, :success then 10
+      when :cyan, :output then 11
+      when :red, :failure then 12
+      when :purple then 13
+      when :yellow then 14
+      when :white then 15
+      else
+        0
+    end
+  end
+	
+	def posix_colour(colour)
+	  case colour
+      when :black then 30  
+      when :red, :failure then 31
+      when :green, :success then 32
+			when :yellow then 33
+      when :blue, :narrative then 34
+      when :purple, :magenta then 35
+      when :cyan, :output then 36
+      when :white, :default_white, :default then 37
+      else
+        30
+    end
+  end
+	
+  def out_c(mode, colour, str)
+    case RUBY_PLATFORM
+			when /(win|w)32$/
+			  change_to(colour)
+				 $stdout.puts str if mode == :puts
+				 $stdout.print str if mode == :print
+			  change_to(:default_white)
+			else
+				$stdout.puts("#{change_to(colour)}#{str}\033[0m") if mode == :puts
+				$stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print
+		end			
+  end
+end # ColourCommandLine
+
+def colour_puts(role,str)  ColourCommandLine.new.out_c(:puts, role, str)  end
+def colour_print(role,str) ColourCommandLine.new.out_c(:print, role, str) end
+