ceedling 0.20.3 → 0.21.0

data/vendor/cmock/vendor/c_exception/vendor/unity/test/testdata/testRunnerGeneratorSmall.c

@@ -0,0 +1,65 @@
+/* This Test File Is Used To Verify Many Combinations Of Using the Generate Test Runner Script */
+
+#include <stdio.h>
+#include "unity.h"
+#include "Defs.h"
+
+/* Notes about prefixes:
+   test     - normal default prefix. these are "always run" tests for this procedure
+   spec     - normal default prefix. required to run default setup/teardown calls.
+*/
+
+/* Support for Meta Test Rig */
+#define TEST_CASE(a)
+void putcharSpy(int c) { (void)putchar(c);} // include passthrough for linking tests
+
+/* Global Variables Used During These Tests */
+int CounterSetup = 0;
+int CounterTeardown = 0;
+int CounterSuiteSetup = 0;
+
+void setUp(void)
+{
+    CounterSetup = 1;
+}
+
+void tearDown(void)
+{
+    CounterTeardown = 1;
+}
+
+void custom_setup(void)
+{
+    CounterSetup = 2;
+}
+
+void custom_teardown(void)
+{
+    CounterTeardown = 2;
+}
+
+void test_ThisTestAlwaysPasses(void)
+{
+    TEST_PASS();
+}
+
+void test_ThisTestAlwaysFails(void)
+{
+    TEST_FAIL_MESSAGE("This Test Should Fail");
+}
+
+void test_ThisTestAlwaysIgnored(void)
+{
+    TEST_IGNORE_MESSAGE("This Test Should Be Ignored");
+}
+
+void spec_ThisTestPassesWhenNormalSetupRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(1, CounterSetup, "Normal Setup Wasn't Run");
+}
+
+void spec_ThisTestPassesWhenNormalTeardownRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(1, CounterTeardown, "Normal Teardown Wasn't Run");
+}
+

data/vendor/cmock/vendor/c_exception/vendor/unity/test/testdata/testRunnerGeneratorWithMocks.c

@@ -0,0 +1,192 @@
+/* This Test File Is Used To Verify Many Combinations Of Using the Generate Test Runner Script */
+
+#include <stdio.h>
+#include "unity.h"
+#include "Defs.h"
+#include "mockMock.h"
+
+#ifdef USE_CEXCEPTION
+#include "CException.h"
+#endif
+
+/* Notes about prefixes:
+   test     - normal default prefix. these are "always run" tests for this procedure
+   spec     - normal default prefix. required to run default setup/teardown calls.
+   should   - normal default prefix.
+   qwiktest - custom prefix for when tests skip all setup/teardown calls.
+   custtest - custom prefix for when tests use custom setup/teardown calls.
+   paratest - custom prefix for when we want to verify parameterized tests.
+   extest   - custom prefix only used during cexception
+   suitetest- custom prefix for when we want to use custom suite setup/teardown
+*/
+
+/* Support for Meta Test Rig */
+#define TEST_CASE(a)
+void putcharSpy(int c) { (void)putchar(c);} // include passthrough for linking tests
+
+/* Global Variables Used During These Tests */
+int CounterSetup = 0;
+int CounterTeardown = 0;
+int CounterSuiteSetup = 0;
+
+void setUp(void)
+{
+    CounterSetup = 1;
+}
+
+void tearDown(void)
+{
+    CounterTeardown = 1;
+}
+
+void custom_setup(void)
+{
+    CounterSetup = 2;
+}
+
+void custom_teardown(void)
+{
+    CounterTeardown = 2;
+}
+
+/*
+void test_OldSchoolCommentsShouldBeIgnored(void)
+{
+    TEST_ASSERT_FAIL("Old-School Comments Should Be Ignored");
+}
+*/
+
+void test_ThisTestAlwaysPasses(void)
+{
+    TEST_PASS();
+}
+
+void test_ThisTestAlwaysFails(void)
+{
+    TEST_FAIL_MESSAGE("This Test Should Fail");
+}
+
+void test_ThisTestAlwaysIgnored(void)
+{
+    TEST_IGNORE_MESSAGE("This Test Should Be Ignored");
+}
+
+void qwiktest_ThisTestPassesWhenNoSetupRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(0, CounterSetup, "Setup Was Unexpectedly Run");
+}
+
+void qwiktest_ThisTestPassesWhenNoTeardownRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(0, CounterTeardown, "Teardown Was Unexpectedly Run");
+}
+
+void spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(0, CounterSuiteSetup, "Suite Setup Was Unexpectedly Run");
+}
+
+void spec_ThisTestPassesWhenNormalSetupRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(1, CounterSetup, "Normal Setup Wasn't Run");
+}
+
+void spec_ThisTestPassesWhenNormalTeardownRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(1, CounterTeardown, "Normal Teardown Wasn't Run");
+}
+
+void custtest_ThisTestPassesWhenCustomSetupRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(2, CounterSetup, "Custom Setup Wasn't Run");
+}
+
+void custtest_ThisTestPassesWhenCustomTeardownRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(2, CounterTeardown, "Custom Teardown Wasn't Run");
+}
+
+//void test_NewStyleCommentsShouldBeIgnored(void)
+//{
+//    TEST_ASSERT_FAIL("New Style Comments Should Be Ignored");
+//}
+
+void test_NotBeConfusedByLongComplicatedStrings(void)
+{
+    const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n";
+
+    TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are The Same");
+}
+
+void test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings(void)
+{
+    TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True");
+}
+
+void test_StillNotBeConfusedByLongComplicatedStrings(void)
+{
+    const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n";
+
+    TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are Still The Same");
+}
+
+void should_RunTestsStartingWithShouldByDefault(void)
+{
+    TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True");
+}
+
+TEST_CASE(25)
+TEST_CASE(125)
+TEST_CASE(5)
+void paratest_ShouldHandleParameterizedTests(int Num)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(0, (Num % 5), "All The Values Are Divisible By 5");
+}
+
+TEST_CASE(7)
+void paratest_ShouldHandleParameterizedTests2(int Num)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(7, Num, "The Only Call To This Passes");
+}
+
+void paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid(void)
+{
+    TEST_PASS();
+}
+
+TEST_CASE(17)
+void paratest_ShouldHandleParameterizedTestsThatFail(int Num)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(3, Num, "This call should fail");
+}
+
+#ifdef USE_CEXCEPTION
+void extest_ShouldHandleCExceptionInTest(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(1, CEXCEPTION_BEING_USED, "Should be pulling in CException");
+}
+#endif
+
+#ifdef USE_ANOTHER_MAIN
+int custom_main(void);
+
+int main(void)
+{
+    return custom_main();
+}
+#endif
+
+void suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan(void)
+{
+    TEST_ASSERT_EQUAL_MESSAGE(1, CounterSuiteSetup, "Suite Setup Should Have Run");
+}
+
+void test_ShouldCallMockInitAndVerifyFunctionsForEachTest(void)
+{
+    int passes = (int)(Unity.NumberOfTests - Unity.TestFailures - Unity.TestIgnores);
+    TEST_ASSERT_EQUAL_MESSAGE(Unity.NumberOfTests,     mockMock_Init_Counter,    "Mock Init Should Be Called Once Per Test Started");
+    TEST_ASSERT_EQUAL_MESSAGE(passes,                  mockMock_Verify_Counter,  "Mock Verify Should Be Called Once Per Test Passed");
+    TEST_ASSERT_EQUAL_MESSAGE(Unity.NumberOfTests - 1, mockMock_Destroy_Counter, "Mock Destroy Should Be Called Once Per Test Completed");
+    TEST_ASSERT_EQUAL_MESSAGE(0,                       CMockMemFreeFinalCounter, "Mock MemFreeFinal Should Not Be Called Until End");
+}
+

data/vendor/cmock/vendor/c_exception/vendor/unity/test/tests/test_generate_test_runner.rb

@@ -6,96 +6,1246 @@
 
 require '../auto/generate_test_runner.rb'
 
-TEST_FILE = 'testdata/testsample.c'
-TEST_MOCK = 'testdata/mocksample.c'
+$generate_test_runner_tests = 0
+$generate_test_runner_failures = 0
+
 OUT_FILE  = 'build/testsample_'
-EXP_FILE  = 'expectdata/testsample_'
 
-$generate_test_runner_failures = 0
+RUNNER_TESTS = [
+  { :name => 'DefaultsThroughOptions',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :options => nil, #defaults
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'DefaultsThroughCommandLine',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :cmdline => "", #defaults
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'DefaultsThroughYAMLFile',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :cmdline => "", #defaults
+    :yaml => {}, #defaults
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ShorterFilterOfJustTest',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "test",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ShorterFilterOfJustShould',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "should",
+    },
+    :expected => {
+      :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ],
+      :to_fail => [  ],
+      :to_ignore => [  ],
+    }
+  },
+
+  { :name => 'ShorterFilterOfJustSpec',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "spec",
+    },
+    :expected => {
+      :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [  ],
+      :to_ignore => [  ],
+    }
+  },
+
+  { :name => 'InjectIncludes',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :includes => ['Defs.h'],
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ParameterizedThroughOptions',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "paratest",
+      :use_param_tests => true,
+    },
+    :expected => {
+      :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)',
+                    'paratest_ShouldHandleParameterizedTests\(125\)',
+                    'paratest_ShouldHandleParameterizedTests\(5\)',
+                    'paratest_ShouldHandleParameterizedTests2\(7\)',
+                    'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)',
+                  ],
+      :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ParameterizedThroughCommandLine',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :cmdline => " --test_prefix=\"paratest\" --use_param_tests=1",
+    :expected => {
+      :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)',
+                    'paratest_ShouldHandleParameterizedTests\(125\)',
+                    'paratest_ShouldHandleParameterizedTests\(5\)',
+                    'paratest_ShouldHandleParameterizedTests2\(7\)',
+                    'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)',
+                  ],
+      :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ParameterizedThroughCommandLineAndYaml',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :cmdline => "--use_param_tests=1",
+    :yaml => {
+      :test_prefix => "paratest"
+    },
+    :expected => {
+      :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)',
+                    'paratest_ShouldHandleParameterizedTests\(125\)',
+                    'paratest_ShouldHandleParameterizedTests\(5\)',
+                    'paratest_ShouldHandleParameterizedTests2\(7\)',
+                    'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)',
+                  ],
+      :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'CException',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'USE_CEXCEPTION'],
+    :options => {
+      :test_prefix => "extest",
+      :plugins => [ :cexception ],
+    },
+    :expected => {
+      :to_pass => [ 'extest_ShouldHandleCExceptionInTest' ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'CustomSetupAndTeardownThroughOptions',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "custtest|test",
+      :setup_name => "custom_setup",
+      :teardown_name => "custom_teardown",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'custtest_ThisTestPassesWhenCustomSetupRan',
+                    'custtest_ThisTestPassesWhenCustomTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'CustomSetupAndTeardownThroughCommandLine',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :cmdline => " --test_prefix=\"custtest|test\" --setup_name=\"custom_setup\" --teardown_name=\"custom_teardown\"",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'custtest_ThisTestPassesWhenCustomSetupRan',
+                    'custtest_ThisTestPassesWhenCustomTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'CustomSetupAndTeardownThroughYaml',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :cmdline => " --test_prefix=\"custtest|test\"",
+    :yaml => {
+      :setup_name => "custom_setup",
+      :teardown_name => "custom_teardown",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'custtest_ThisTestPassesWhenCustomSetupRan',
+                    'custtest_ThisTestPassesWhenCustomTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'CustomMain',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', "USE_ANOTHER_MAIN"],
+    :options => {
+      :main_name => "custom_main",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'CustomSuiteSetupAndTeardown',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :includes => ['Defs.h'],
+    :options => {
+      :test_prefix    => "suitetest|test",
+      :suite_setup    => "  CounterSuiteSetup = 1;",
+      :suite_teardown => "  return num_failures;",
+    },
+    :expected =>  {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'MainExternDeclaration',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST'],
+    :includes => ['Defs.h'],
+    :options => {
+      :main_export_decl => "EXTERN_DECL",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+
+  #### WITH MOCKS ##########################################
+
+  { :name => 'DefaultsThroughOptions',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :options => nil, #defaults
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'DefaultsThroughCommandLine',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :cmdline => "", #defaults
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'DefaultsThroughYAMLFile',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :cmdline => "", #defaults
+    :yaml => {}, #defaults
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ShorterFilterOfJustTest',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "test",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ShorterFilterOfJustShould',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "should",
+    },
+    :expected => {
+      :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ],
+      :to_fail => [  ],
+      :to_ignore => [  ],
+    }
+  },
+
+  { :name => 'ShorterFilterOfJustSpec',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "spec",
+    },
+    :expected => {
+      :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [  ],
+      :to_ignore => [  ],
+    }
+  },
+
+  { :name => 'InjectIncludes',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :includes => ['Defs.h'],
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ParameterizedThroughOptions',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "paratest",
+      :use_param_tests => true,
+    },
+    :expected => {
+      :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)',
+                    'paratest_ShouldHandleParameterizedTests\(125\)',
+                    'paratest_ShouldHandleParameterizedTests\(5\)',
+                    'paratest_ShouldHandleParameterizedTests2\(7\)',
+                    'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)',
+                  ],
+      :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ParameterizedThroughCommandLine',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :cmdline => " --test_prefix=\"paratest\" --use_param_tests=1",
+    :expected => {
+      :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)',
+                    'paratest_ShouldHandleParameterizedTests\(125\)',
+                    'paratest_ShouldHandleParameterizedTests\(5\)',
+                    'paratest_ShouldHandleParameterizedTests2\(7\)',
+                    'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)',
+                  ],
+      :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ParameterizedThroughCommandLineAndYaml',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :cmdline => "--use_param_tests=1",
+    :yaml => {
+      :test_prefix => "paratest"
+    },
+    :expected => {
+      :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)',
+                    'paratest_ShouldHandleParameterizedTests\(125\)',
+                    'paratest_ShouldHandleParameterizedTests\(5\)',
+                    'paratest_ShouldHandleParameterizedTests2\(7\)',
+                    'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)',
+                  ],
+      :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'CException',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST', 'USE_CEXCEPTION'],
+    :options => {
+      :test_prefix => "extest",
+      :plugins => [ :cexception ],
+    },
+    :expected => {
+      :to_pass => [ 'extest_ShouldHandleCExceptionInTest' ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'CustomSetupAndTeardownThroughOptions',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :options => {
+      :test_prefix => "custtest|test",
+      :setup_name => "custom_setup",
+      :teardown_name => "custom_teardown",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'custtest_ThisTestPassesWhenCustomSetupRan',
+                    'custtest_ThisTestPassesWhenCustomTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'CustomSetupAndTeardownThroughCommandLine',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :cmdline => " --test_prefix=\"custtest|test\" --setup_name=\"custom_setup\" --teardown_name=\"custom_teardown\"",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'custtest_ThisTestPassesWhenCustomSetupRan',
+                    'custtest_ThisTestPassesWhenCustomTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'CustomSetupAndTeardownThroughYaml',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :cmdline => " --test_prefix=\"custtest|test\"",
+    :yaml => {
+      :setup_name => "custom_setup",
+      :teardown_name => "custom_teardown",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'custtest_ThisTestPassesWhenCustomSetupRan',
+                    'custtest_ThisTestPassesWhenCustomTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'CustomMain',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST', "USE_ANOTHER_MAIN"],
+    :options => {
+      :main_name => "custom_main",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'CustomSuiteSetupAndTeardown',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :includes => ['Defs.h'],
+    :options => {
+      :test_prefix    => "suitetest|test",
+      :suite_setup    => "  CounterSuiteSetup = 1;",
+      :suite_teardown => "  return num_failures;",
+    },
+    :expected =>  {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'MainExternDeclaration',
+    :testfile => 'testdata/testRunnerGeneratorWithMocks.c',
+    :testdefines => ['TEST'],
+    :includes => ['Defs.h'],
+    :options => {
+      :main_export_decl => "EXTERN_DECL",
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                    'test_ShouldCallMockInitAndVerifyFunctionsForEachTest',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+
+
+  #### WITH ARGS ##########################################
+
+  { :name => 'ArgsThroughOptions',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
 
-def verify_output_equal(subtest)
-  expected = File.read(EXP_FILE + subtest + '.c').gsub(/\r\n/,"\n")
-  actual   = File.read(OUT_FILE + subtest + '.c').gsub(/\r\n/,"\n")
-  if (expected != actual)
-    report("    #{subtest}:FAIL")
-    $generate_test_runner_failures += 1
+  { :name => 'ArgsThroughCommandLine',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :cmdline => "--cmdline_args=1",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsThroughYAMLFile',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :cmdline => "",
+    :yaml => {
+      :cmdline_args => true,
+    },
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsNameFilterJustTest',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n test_",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsNameFilterJustShould',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n should_",
+    :expected => {
+      :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ],
+      :to_fail => [  ],
+      :to_ignore => [  ],
+    }
+  },
+
+  { :name => 'ArgsNameFilterTestAndShould',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n should_,test_",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault' ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsNameFilterWithWildcardOnFile',
+    :testfile => 'testdata/testRunnerGeneratorSmall.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n testRunnerGeneratorSma*",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan' ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsNameFilterWithWildcardAsName',
+    :testfile => 'testdata/testRunnerGeneratorSmall.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n testRunnerGeneratorSmall:*",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan' ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsNameFilterWithWildcardOnName',
+    :testfile => 'testdata/testRunnerGeneratorSmall.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n testRunnerGeneratorSmall:test_*",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses' ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsNameFilterWithWildcardAndShortName',
+    :testfile => 'testdata/testRunnerGeneratorSmall.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n testRunnerGeneratorSmall:te*",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses' ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsNameFilterWithWildcardOnBoth',
+    :testfile => 'testdata/testRunnerGeneratorSmall.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n testRunnerGeneratorSm*:*",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan' ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsExcludeFilterJustTest',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-x test_",
+    :expected => {
+      :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                    'should_RunTestsStartingWithShouldByDefault',
+                  ],
+      :to_fail => [  ],
+      :to_ignore => [  ],
+    }
+  },
+
+  { :name => 'ArgsIncludeAndExcludeFilter',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+      :includes => ['Defs.h'],
+    },
+    :cmdline_args => "-n test_ -x Ignored",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [  ],
+    }
+  },
+
+  { :name => 'ArgsIncludeSingleTest',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n ThisTestAlwaysPasses",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses' ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsIncludeSingleTestInSpecificFile',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n testRunnerGenerator:ThisTestAlwaysPasses",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses' ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsIncludeTestFileWithExtension',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n testRunnerGenerator.c:ThisTestAlwaysPasses",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses' ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsIncludeDoubleQuotes',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n \"testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails\"",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses' ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsIncludeSingleQuotes',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n 'testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails'",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses' ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsIncludeAValidTestForADifferentFile',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n AnotherFile:ThisTestDoesNotExist",
+    :expected => {
+      :to_pass => [ ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsIncludeNoTests',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n ThisTestDoesNotExist",
+    :expected => {
+      :to_pass => [ ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsExcludeAllTests',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-x _",
+    :expected => {
+      :to_pass => [ ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsIncludeFullFile',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n testRunnerGenerator",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses',
+                    'spec_ThisTestPassesWhenNormalSetupRan',
+                    'spec_ThisTestPassesWhenNormalTeardownRan',
+                    'test_NotBeConfusedByLongComplicatedStrings',
+                    'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings',
+                    'test_StillNotBeConfusedByLongComplicatedStrings',
+                    'should_RunTestsStartingWithShouldByDefault',
+                    'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan',
+                  ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ 'test_ThisTestAlwaysIgnored' ],
+    }
+  },
+
+  { :name => 'ArgsIncludeWithAlternateFlag',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-f=\"testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails\"",
+    :expected => {
+      :to_pass => [ 'test_ThisTestAlwaysPasses' ],
+      :to_fail => [ 'test_ThisTestAlwaysFails' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsIncludeWithParameterized',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :cmdline => "--use_param_tests=1",
+    :yaml => {
+      :cmdline_args => true,
+      :test_prefix => "paratest"
+    },
+    :cmdline_args => "-n ShouldHandleParameterizedTests",
+    :expected => {
+      :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)',
+                    'paratest_ShouldHandleParameterizedTests\(125\)',
+                    'paratest_ShouldHandleParameterizedTests\(5\)',
+                    'paratest_ShouldHandleParameterizedTests2\(7\)',
+                  ],
+      :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ],
+      :to_ignore => [ ],
+    }
+  },
+
+  { :name => 'ArgsList',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-l",
+    :expected => {
+      :to_pass => [ ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+      :text => [  "testRunnerGenerator",
+                  "test_ThisTestAlwaysPasses",
+                  "test_ThisTestAlwaysFails",
+                  "test_ThisTestAlwaysIgnored",
+                  "spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan",
+                  "spec_ThisTestPassesWhenNormalSetupRan",
+                  "spec_ThisTestPassesWhenNormalTeardownRan",
+                  "test_NotBeConfusedByLongComplicatedStrings",
+                  "test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings",
+                  "test_StillNotBeConfusedByLongComplicatedStrings",
+                  "should_RunTestsStartingWithShouldByDefault"
+               ]
+    }
+  },
+
+  { :name => 'ArgsListParameterized',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :test_prefix => "paratest",
+      :use_param_tests => true,
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-l",
+    :expected => {
+      :to_pass => [ ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+      :text => [  "testRunnerGenerator",
+                  'paratest_ShouldHandleParameterizedTests\(25\)',
+                  'paratest_ShouldHandleParameterizedTests\(125\)',
+                  'paratest_ShouldHandleParameterizedTests\(5\)',
+                  'paratest_ShouldHandleParameterizedTests2\(7\)',
+                  'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid\(RUN_TEST_NO_ARGS\)',
+                  'paratest_ShouldHandleParameterizedTestsThatFail\(17\)'
+               ],
+    }
+  },
+
+  { :name => 'ArgsIncompleteIncludeFlags',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-n",
+    :expected => {
+      :to_pass => [ ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+      :text => [ "ERROR: No Test String to Include Matches For" ],
+    }
+  },
+
+  { :name => 'ArgsIncompleteExcludeFlags',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-x",
+    :expected => {
+      :to_pass => [ ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+      :text => [ "ERROR: No Test String to Exclude Matches For" ],
+    }
+  },
+
+  { :name => 'ArgsIllegalFlags',
+    :testfile => 'testdata/testRunnerGenerator.c',
+    :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'],
+    :options => {
+      :cmdline_args => true,
+    },
+    :cmdline_args => "-z",
+    :expected => {
+      :to_pass => [ ],
+      :to_fail => [ ],
+      :to_ignore => [ ],
+      :text => [ "ERROR: Unknown Option z" ],
+    }
+  },
+]
+
+def runner_test(test, runner, expected, test_defines, cmdline_args)
+  # Tack on TEST define for compiling unit tests
+  load_configuration($cfg_file)
+
+  #compile objects
+  obj_list = [
+    compile(runner, test_defines),
+    compile(test, test_defines),
+    compile('../src/unity.c', test_defines),
+  ]
+
+  # Link the test executable
+  test_base = File.basename(test, C_EXTENSION)
+  link_it(test_base, obj_list)
+
+  # Execute unit test and generate results file
+  simulator = build_simulator_fields
+  cmdline_args ||= ""
+  executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension'] + " #{cmdline_args}"
+  if simulator.nil?
+    cmd_str = executable
   else
-    report("    #{subtest}:PASS")
+    cmd_str = "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}"
   end
-end
+  output = execute(cmd_str, true)
 
-should "GenerateARunnerByCreatingRunnerWithOptions" do
-  sets = { 'def'  => nil,
-           'new1' => { :plugins => [:cexception], :includes => ['one.h', 'two.h'], :enforce_strict_ordering => true },
-           'new2' => { :plugins => [:ignore], :suite_setup => "a_custom_setup();", :suite_teardown => "a_custom_teardown();" }
-  }
-
-  sets.each_pair do |subtest, options|
-    UnityTestRunnerGenerator.new(options).run(TEST_FILE, OUT_FILE + subtest + '.c')
-    verify_output_equal(subtest)
-    UnityTestRunnerGenerator.new(options).run(TEST_MOCK, OUT_FILE + 'mock_' + subtest + '.c')
-    verify_output_equal('mock_' + subtest)
-  end
-end
+  #compare to the expected pass/fail
+  allgood = expected[:to_pass].inject(true)      {|s,v| s && verify_match(/#{v}:PASS/,   output) }
+  allgood = expected[:to_fail].inject(allgood)   {|s,v| s && verify_match(/#{v}:FAIL/,   output) }
+  allgood = expected[:to_ignore].inject(allgood) {|s,v| s && verify_match(/#{v}:IGNORE/, output) }
 
-should "GenerateARunnerAlongWithAHeaderIfSpecified" do
-  sets = { 'head1' => { :header_file => "#{OUT_FILE}head1.h" } }
-  sets.each_pair do |subtest, options|
-    UnityTestRunnerGenerator.new(options).run(TEST_FILE, OUT_FILE + subtest + '.c')
-    verify_output_equal(subtest)
-  end
+  #verify there weren't more pass/fail/etc than expected
+  allgood &&= verify_number( expected[:to_pass],   /(:PASS)/,   output)
+  allgood &&= verify_number( expected[:to_fail],   /(:FAIL)/,   output)
+  allgood &&= verify_number( expected[:to_ignore], /(:IGNORE)/, output)
 
-  sets = { 'head1' => { :header_file => "#{OUT_FILE}mock_head1.h" } }
-  sets.each_pair do |subtest, options|
-    UnityTestRunnerGenerator.new(options).run(TEST_MOCK, OUT_FILE + 'mock_' + subtest + '.c')
-    verify_output_equal('mock_' + subtest)
+  #if we care about any other text, check that too
+  if (expected[:text])
+    allgood = expected[:text].inject(allgood) {|s,v| s && verify_match(/#{v}/, output) }
+    allgood &&= verify_number( expected[:text], /.+/, output )
   end
-end
 
-should "GenerateARunnerByRunningRunnerWithOptions" do
-  sets = { 'run1' => { :plugins => [:cexception], :includes => ['one.h', 'two.h'], :enforce_strict_ordering => true },
-           'run2' => { :plugins => [:ignore], :suite_setup => "a_custom_setup();", :suite_teardown => "a_custom_teardown();" }
-  }
+  report output if (!allgood && !$verbose) #report failures if not already reporting everything
+  return allgood
+end
 
-  sets.each_pair do |subtest, options|
-    UnityTestRunnerGenerator.new.run(TEST_FILE, OUT_FILE + subtest + '.c', options)
-    verify_output_equal(subtest)
-    UnityTestRunnerGenerator.new.run(TEST_MOCK, OUT_FILE + 'mock_' + subtest + '.c', options)
-    verify_output_equal('mock_' + subtest)
+def verify_match(expression, output)
+  if (expression =~ output)
+    return true
+  else
+    report "  FAIL: No Match For /#{expression.to_s}/"
+    return false
   end
 end
 
-should "GenerateARunnerByPullingYamlOptions" do
-  subtest = 'yaml'
-  cmdstr = "ruby ../auto/generate_test_runner.rb testdata/sample.yml \"#{TEST_FILE}\" \"#{OUT_FILE + subtest + '.c'}\""
-  `#{cmdstr}`
-  verify_output_equal(subtest)
-
-  cmdstr = "ruby ../auto/generate_test_runner.rb testdata/sample.yml \"#{TEST_MOCK}\" \"#{OUT_FILE + 'mock_' + subtest + '.c'}\""
-  `#{cmdstr}`
-  verify_output_equal('mock_' + subtest)
+def verify_number(expected, expression, output)
+  exp = expected.length
+  act = output.scan(expression).length
+  if (exp == act)
+    return true
+  else
+    report "  FAIL: Expected #{exp} Matches For /#{expression.to_s}/. Was #{act}"
+    return false
+  end
 end
 
-should "GenerateARunnerByPullingCommandlineOptions" do
-  subtest = 'cmd'
-  cmdstr = "ruby ../auto/generate_test_runner.rb -cexception \"#{TEST_FILE}\" \"#{OUT_FILE + subtest + '.c'}\""
-  `#{cmdstr}`
-  verify_output_equal(subtest)
+RUNNER_TESTS.each do |testset|
+  basename = File.basename(testset[:testfile], C_EXTENSION)
+  testset_name = "Runner_#{basename}_#{testset[:name]}"
+  should testset_name do
+    runner_name = OUT_FILE + testset[:name] + '_runner.c'
 
-  cmdstr = "ruby ../auto/generate_test_runner.rb -cexception \"#{TEST_MOCK}\" \"#{OUT_FILE + 'mock_' + subtest + '.c'}\""
-  `#{cmdstr}`
-  verify_output_equal('mock_' + subtest)
-end
+    #create a yaml file first if required
+    yaml_option = ""
+    if (testset[:yaml])
+      File.open("build/runner_options.yml",'w') {|f| f << { :unity => testset[:yaml] }.to_yaml }
+      yaml_option = "build/runner_options.yml"
+    end
 
-should "GenerateARunnerThatUsesParameterizedTests" do
-  sets = { 'param'  => { :plugins => [:ignore], :use_param_tests => true }
-  }
+    #run script via command line or through hash function call, as requested
+    if (testset[:cmdline])
+      cmdstr = "ruby ../auto/generate_test_runner.rb #{yaml_option} #{testset[:cmdline]} \"#{testset[:testfile]}\" \"#{runner_name}\""
+      `#{cmdstr}`
+    else
+      UnityTestRunnerGenerator.new(testset[:options]).run(testset[:testfile], runner_name)
+    end
 
-  sets.each_pair do |subtest, options|
-    UnityTestRunnerGenerator.new(options).run(TEST_FILE, OUT_FILE + subtest + '.c')
-    verify_output_equal(subtest)
-    UnityTestRunnerGenerator.new(options).run(TEST_MOCK, OUT_FILE + 'mock_' + subtest + '.c')
-    verify_output_equal('mock_' + subtest)
+    #test the script against the specified test file and check results
+    if (runner_test(testset[:testfile], runner_name, testset[:expected], testset[:testdefines], testset[:cmdline_args]))
+      report "#{testset_name}:PASS"
+    else
+      report "#{testset_name}:FAIL"
+      $generate_test_runner_failures += 1
+    end
+    $generate_test_runner_tests += 1
   end
 end