From 1c037f26aae9558c752801a21ffc566420663307 Mon Sep 17 00:00:00 2001 From: mvandervoord Date: Mon, 28 May 2012 15:18:26 +0000 Subject: [PATCH] - more cleanup git-svn-id: http://cmock.svn.sourceforge.net/svnroot/cmock/trunk@221 bf332499-1b4d-0410-844d-d2d48d5cc64c --- lib/cmock_config.rb | 4 +- lib/cmock_unityhelper_parser.rb | 150 ++-- test/system/test_compilation/callingconv.h | 22 +- .../all_plugins_but_other_limits.yml | 682 ++++++++-------- .../test_interactions/all_plugins_coexist.yml | 764 +++++++++--------- test/unit/cmock_config_test.rb | 122 ++- 6 files changed, 932 insertions(+), 812 deletions(-) diff --git a/lib/cmock_config.rb b/lib/cmock_config.rb index 866b6e0..34b27a6 100644 --- a/lib/cmock_config.rb +++ b/lib/cmock_config.rb @@ -31,7 +31,7 @@ class CMockConfig :includes_h_pre_orig_header => nil, :includes_h_post_orig_header => nil, :includes_c_pre_header => nil, - :includes_c_post_header => nil, + :includes_c_post_header => nil } def initialize(options=nil) @@ -123,7 +123,7 @@ class CMockConfig 'cstring' => 'STRING', 'CSTRING' => 'STRING', 'float' => 'FLOAT', - 'double' => 'FLOAT', + 'double' => 'FLOAT' } end end diff --git a/lib/cmock_unityhelper_parser.rb b/lib/cmock_unityhelper_parser.rb index c22db7a..aa4e243 100644 --- a/lib/cmock_unityhelper_parser.rb +++ b/lib/cmock_unityhelper_parser.rb @@ -1,75 +1,75 @@ -# ========================================== -# CMock Project - Automatic Mock Generation for C -# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams -# [Released under MIT License. Please refer to license.txt for details] -# ========================================== - -class CMockUnityHelperParser - - attr_accessor :c_types - - def initialize(config) - @config = config - @fallback = @config.plugins.include?(:array) ? 'UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY' : 'UNITY_TEST_ASSERT_EQUAL_MEMORY' - @c_types = map_C_types.merge(import_source) - end - - def get_helper(ctype) - lookup = ctype.gsub(/(?:^|(\S?)(\s*)|(\W))const(?:$|(\s*)(\S)|(\W))/,'\1\3\5\6').strip.gsub(/\s+/,'_') - return [@c_types[lookup], ''] if (@c_types[lookup]) - if (lookup =~ /\*$/) - lookup = lookup.gsub(/\*$/,'') - return [@c_types[lookup], '*'] if (@c_types[lookup]) - else - lookup = lookup + '*' - return [@c_types[lookup], '&'] if (@c_types[lookup]) - end - return ['UNITY_TEST_ASSERT_EQUAL_PTR', ''] if (ctype =~ /cmock_\w+_ptr\d+/) - raise("Don't know how to test #{ctype} and memory tests are disabled!") unless @config.memcmp_if_unknown - return (lookup =~ /\*$/) ? [@fallback, '&'] : [@fallback, ''] - end - - private ########################### - - def map_C_types - c_types = {} - @config.treat_as.each_pair do |ctype, expecttype| - c_type = ctype.gsub(/\s+/,'_') - if (expecttype =~ /\*/) - c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype.gsub(/\*/,'')}_ARRAY" - else - c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype}" - c_types[c_type+'*'] ||= "UNITY_TEST_ASSERT_EQUAL_#{expecttype}_ARRAY" - end - end - c_types - end - - def import_source - source = @config.load_unity_helper - return {} if source.nil? - c_types = {} - source = source.gsub(/\/\/.*$/, '') #remove line comments - source = source.gsub(/\/\*.*?\*\//m, '') #remove block comments - - #scan for comparison helpers - match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+))\s*\(' + Array.new(4,'\s*\w+\s*').join(',') + '\)') - pairs = source.scan(match_regex).flatten.compact - (pairs.size/2).times do |i| - expect = pairs[i*2] - ctype = pairs[(i*2)+1] - c_types[ctype] = expect unless expect.include?("_ARRAY") - end - - #scan for array variants of those helpers - match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+_ARRAY))\s*\(' + Array.new(5,'\s*\w+\s*').join(',') + '\)') - pairs = source.scan(match_regex).flatten.compact - (pairs.size/2).times do |i| - expect = pairs[i*2] - ctype = pairs[(i*2)+1] - c_types[ctype.gsub('_ARRAY','*')] = expect - end - - c_types - end -end +# ========================================== +# CMock Project - Automatic Mock Generation for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +class CMockUnityHelperParser + + attr_accessor :c_types + + def initialize(config) + @config = config + @fallback = @config.plugins.include?(:array) ? 'UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY' : 'UNITY_TEST_ASSERT_EQUAL_MEMORY' + @c_types = map_C_types.merge(import_source) + end + + def get_helper(ctype) + lookup = ctype.gsub(/(?:^|(\S?)(\s*)|(\W))const(?:$|(\s*)(\S)|(\W))/,'\1\3\5\6').strip.gsub(/\s+/,'_') + return [@c_types[lookup], ''] if (@c_types[lookup]) + if (lookup =~ /\*$/) + lookup = lookup.gsub(/\*$/,'') + return [@c_types[lookup], '*'] if (@c_types[lookup]) + else + lookup = lookup + '*' + return [@c_types[lookup], '&'] if (@c_types[lookup]) + end + return ['UNITY_TEST_ASSERT_EQUAL_PTR', ''] if (ctype =~ /cmock_\w+_ptr\d+/) + raise("Don't know how to test #{ctype} and memory tests are disabled!") unless @config.memcmp_if_unknown + return (lookup =~ /\*$/) ? [@fallback, '&'] : [@fallback, ''] + end + + private ########################### + + def map_C_types + c_types = {} + @config.treat_as.each_pair do |ctype, expecttype| + c_type = ctype.gsub(/\s+/,'_') + if (expecttype =~ /\*/) + c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype.gsub(/\*/,'')}_ARRAY" + else + c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype}" + c_types[c_type+'*'] ||= "UNITY_TEST_ASSERT_EQUAL_#{expecttype}_ARRAY" + end + end + c_types + end + + def import_source + source = @config.load_unity_helper + return {} if source.nil? + c_types = {} + source = source.gsub(/\/\/.*$/, '') #remove line comments + source = source.gsub(/\/\*.*?\*\//m, '') #remove block comments + + #scan for comparison helpers + match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+))\s*\(' + Array.new(4,'\s*\w+\s*').join(',') + '\)') + pairs = source.scan(match_regex).flatten.compact + (pairs.size/2).times do |i| + expect = pairs[i*2] + ctype = pairs[(i*2)+1] + c_types[ctype] = expect unless expect.include?("_ARRAY") + end + + #scan for array variants of those helpers + match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+_ARRAY))\s*\(' + Array.new(5,'\s*\w+\s*').join(',') + '\)') + pairs = source.scan(match_regex).flatten.compact + (pairs.size/2).times do |i| + expect = pairs[i*2] + ctype = pairs[(i*2)+1] + c_types[ctype.gsub('_ARRAY','*')] = expect + end + + c_types + end +end diff --git a/test/system/test_compilation/callingconv.h b/test/system/test_compilation/callingconv.h index 49c524d..dfda5bc 100644 --- a/test/system/test_compilation/callingconv.h +++ b/test/system/test_compilation/callingconv.h @@ -1,11 +1,11 @@ -/* ========================================== - CMock Project - Automatic Mock Generation for C - Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams - [Released under MIT License. Please refer to license.txt for details] -========================================== */ - -#ifndef WIN32 -#define __stdcall -#endif - -int __stdcall this_uses_calling_conventions(int b); +/* ========================================== + CMock Project - Automatic Mock Generation for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#ifndef __stdcall +#define __stdcall +#endif + +int __stdcall this_uses_calling_conventions(int b); diff --git a/test/system/test_interactions/all_plugins_but_other_limits.yml b/test/system/test_interactions/all_plugins_but_other_limits.yml index bec1a1d..de9b588 100644 --- a/test/system/test_interactions/all_plugins_but_other_limits.yml +++ b/test/system/test_interactions/all_plugins_but_other_limits.yml @@ -1,341 +1,341 @@ ---- -#this test is different than all_plugins_coexist primarily because of these options -:cmock: - :enforce_strict_ordering: 1 - :treat_externs: :include - :ignore: :args_only - :plugins: - - :array - - :cexception - - :ignore - - :callback - -:systest: - :types: | - typedef struct _POINT_T { - int x; - int y; - } POINT_T; - - :mockable: | - #include "CException.h" - void foo(POINT_T* a); - POINT_T* bar(void); - void fooa(POINT_T a[]); - void foos(const char * a); - extern const char * bars(void); - void no_pointers(int a, char* b); - int mixed(int a, int* b, int c); - void no_args(void); - - :source: - :header: | - #include "CException.h" - void function_a(void); - void function_b(void); - void function_c(void); - int function_d(void); - void function_e(void); - - :code: | - void function_a(void) - { - foo(bar()); - } - - void function_b(void) { - fooa(bar()); - } - - void function_c(void) { - CEXCEPTION_T e; - Try { - foos(bars()); - } Catch(e) { foos("err"); } - } - - int function_d(void) { - int test_list[] = { 1, 2, 3, 4, 5 }; - no_pointers(1, "silly"); - return mixed(6, test_list, 7); - } - - void function_e(void) { - foos("Hello"); - foos("Tuna"); - foos("Oranges"); - } - - :tests: - :common: | - #include "CException.h" - void setUp(void) {} - void tearDown(void) {} - - :units: - - :pass: TRUE - :should: 'handle the situation where we pass nulls to pointers' - :code: | - test() - { - bar_ExpectAndReturn(NULL); - foo_Expect(NULL); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we expected nulls to pointers but did not get that' - :code: | - test() - { - POINT_T pt = {1, 2}; - bar_ExpectAndReturn(&pt); - foo_Expect(NULL); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we did not expect nulls to pointers but got null' - :code: | - test() - { - POINT_T ex = {1, 2}; - bar_ExpectAndReturn(NULL); - foo_Expect(&ex); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we pass single object with expect and it is wrong' - :code: | - test() - { - POINT_T pt = {1, 2}; - POINT_T ex = {1, 3}; - bar_ExpectAndReturn(&pt); - foo_Expect(&ex); - - function_a(); - } - - - :pass: TRUE - :should: 'handle the situation where we pass single object with expect and use array handler' - :code: | - test() - { - POINT_T pt = {1, 2}; - POINT_T ex = {1, 2}; - bar_ExpectAndReturn(&pt); - foo_ExpectWithArray(&ex, 1); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we pass single object with expect and use array handler and it is wrong' - :code: | - test() - { - POINT_T pt = {1, 2}; - POINT_T ex = {1, 3}; - bar_ExpectAndReturn(&pt); - foo_ExpectWithArray(&ex, 1); - - function_a(); - } - - - :pass: TRUE - :should: 'handle the situation where we pass multiple objects with expect and use array handler' - :code: | - test() - { - POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}}; - POINT_T ex[] = {{1, 2}, {3, 4}, {5, 6}}; - bar_ExpectAndReturn(pt); - foo_ExpectWithArray(ex, 3); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we pass multiple objects with expect and use array handler and it is wrong at end' - :code: | - test() - { - POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}}; - POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}}; - bar_ExpectAndReturn(pt); - foo_ExpectWithArray(ex, 3); - - function_a(); - } - - - :pass: TRUE - :should: 'handle the situation where we pass single array element with expect' - :code: | - test() - { - POINT_T pt = {1, 2}; - POINT_T ex = {1, 2}; - bar_ExpectAndReturn(&pt); - fooa_Expect(&ex); - - function_b(); - } - - - :pass: TRUE - :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, passing' - :code: | - test() - { - bars_ExpectAndReturn("This is a\0 silly string"); - foos_Expect("This is a\0 wacky string"); - - function_c(); - } - - - :pass: FALSE - :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, finding failures' - :code: | - test() - { - bars_ExpectAndReturn("This is a silly string"); - foos_Expect("This is a wacky string"); - - function_c(); - } - - - :pass: TRUE - :should: 'handle creating array expects when we have mixed arguments for single object' - :code: | - test() - { - int expect_list[] = { 1, 9 }; - no_pointers_Expect(1, "silly"); - mixed_ExpectAndReturn(6, expect_list, 7, 13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: FALSE - :should: 'handle creating array expects when we have mixed arguments and handle failures for single object' - :code: | - test() - { - int expect_list[] = { 9, 1 }; - no_pointers_Expect(1, "silly"); - mixed_ExpectAndReturn(6, expect_list, 7, 13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'handle creating array expects when we have mixed arguments for multiple objects' - :code: | - test() - { - int expect_list[] = { 1, 2, 3, 4, 6 }; - no_pointers_Expect(1, "silly"); - mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: FALSE - :should: 'handle creating array expects when we have mixed arguments and handle failures for multiple objects' - :code: | - test() - { - int expect_list[] = { 1, 2, 3, 4, 6 }; - no_pointers_Expect(1, "silly"); - mixed_ExpectWithArrayAndReturn(6, expect_list, 5, 7, 13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'handle an exception being caught' - :code: | - test() - { - bars_ExpectAndReturn("This is a\0 silly string"); - foos_ExpectAndThrow("This is a\0 wacky string", 55); - foos_Expect("err"); - - function_c(); - } - - - :pass: FALSE - :should: 'handle an exception being caught but still catch following errors' - :code: | - test() - { - bars_ExpectAndReturn("This is a\0 silly string"); - foos_ExpectAndThrow("This is a\0 wacky string", 55); - foos_Expect("wrong error"); - - function_c(); - } - - - :pass: FALSE - :should: 'fail strict ordering problems even though we would otherwise have passed' - :code: | - test() - { - int expect_list[] = { 1, 2, 3, 4, 6 }; - mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); - no_pointers_Expect(1, "silly"); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'properly ignore first function but the other will work properly' - :code: | - test() - { - int expect_list[] = { 1, 2, 3, 4, 6 }; - no_pointers_Ignore(); - mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'properly ignore last function but the other will work properly' - :code: | - test() - { - no_pointers_Expect(1, "silly"); - mixed_IgnoreAndReturn(13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'be ok if we ignore a call each because we are counting calls' - :code: | - test() - { - foos_Ignore(); - foos_Ignore(); - foos_Ignore(); - - function_e(); - } - - - :pass: FALSE - :should: 'fail if we do not ignore a call once because we are counting calls' - :code: | - test() - { - foos_Ignore(); - foos_Ignore(); - - function_e(); - } - -... +--- +#this test is different than all_plugins_coexist primarily because of these options +:cmock: + :enforce_strict_ordering: 1 + :treat_externs: :include + :ignore: :args_only + :plugins: + - :array + - :cexception + - :ignore + - :callback + +:systest: + :types: | + typedef struct _POINT_T { + int x; + int y; + } POINT_T; + + :mockable: | + #include "CException.h" + void foo(POINT_T* a); + POINT_T* bar(void); + void fooa(POINT_T a[]); + void foos(const char * a); + extern const char * bars(void); + void no_pointers(int a, char* b); + int mixed(int a, int* b, int c); + void no_args(void); + + :source: + :header: | + #include "CException.h" + void function_a(void); + void function_b(void); + void function_c(void); + int function_d(void); + void function_e(void); + + :code: | + void function_a(void) + { + foo(bar()); + } + + void function_b(void) { + fooa(bar()); + } + + void function_c(void) { + CEXCEPTION_T e; + Try { + foos(bars()); + } Catch(e) { foos("err"); } + } + + int function_d(void) { + int test_list[] = { 1, 2, 3, 4, 5 }; + no_pointers(1, "silly"); + return mixed(6, test_list, 7); + } + + void function_e(void) { + foos("Hello"); + foos("Tuna"); + foos("Oranges"); + } + + :tests: + :common: | + #include "CException.h" + void setUp(void) {} + void tearDown(void) {} + + :units: + - :pass: TRUE + :should: 'handle the situation where we pass nulls to pointers' + :code: | + test() + { + bar_ExpectAndReturn(NULL); + foo_Expect(NULL); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we expected nulls to pointers but did not get that' + :code: | + test() + { + POINT_T pt = {1, 2}; + bar_ExpectAndReturn(&pt); + foo_Expect(NULL); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we did not expect nulls to pointers but got null' + :code: | + test() + { + POINT_T ex = {1, 2}; + bar_ExpectAndReturn(NULL); + foo_Expect(&ex); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we pass single object with expect and it is wrong' + :code: | + test() + { + POINT_T pt = {1, 2}; + POINT_T ex = {1, 3}; + bar_ExpectAndReturn(&pt); + foo_Expect(&ex); + + function_a(); + } + + - :pass: TRUE + :should: 'handle the situation where we pass single object with expect and use array handler' + :code: | + test() + { + POINT_T pt = {1, 2}; + POINT_T ex = {1, 2}; + bar_ExpectAndReturn(&pt); + foo_ExpectWithArray(&ex, 1); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we pass single object with expect and use array handler and it is wrong' + :code: | + test() + { + POINT_T pt = {1, 2}; + POINT_T ex = {1, 3}; + bar_ExpectAndReturn(&pt); + foo_ExpectWithArray(&ex, 1); + + function_a(); + } + + - :pass: TRUE + :should: 'handle the situation where we pass multiple objects with expect and use array handler' + :code: | + test() + { + POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}}; + POINT_T ex[] = {{1, 2}, {3, 4}, {5, 6}}; + bar_ExpectAndReturn(pt); + foo_ExpectWithArray(ex, 3); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we pass multiple objects with expect and use array handler and it is wrong at end' + :code: | + test() + { + POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}}; + POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}}; + bar_ExpectAndReturn(pt); + foo_ExpectWithArray(ex, 3); + + function_a(); + } + + - :pass: TRUE + :should: 'handle the situation where we pass single array element with expect' + :code: | + test() + { + POINT_T pt = {1, 2}; + POINT_T ex = {1, 2}; + bar_ExpectAndReturn(&pt); + fooa_Expect(&ex); + + function_b(); + } + + - :pass: TRUE + :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, passing' + :code: | + test() + { + bars_ExpectAndReturn("This is a\0 silly string"); + foos_Expect("This is a\0 wacky string"); + + function_c(); + } + + - :pass: FALSE + :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, finding failures' + :code: | + test() + { + bars_ExpectAndReturn("This is a silly string"); + foos_Expect("This is a wacky string"); + + function_c(); + } + + - :pass: TRUE + :should: 'handle creating array expects when we have mixed arguments for single object' + :code: | + test() + { + int expect_list[] = { 1, 9 }; + no_pointers_Expect(1, "silly"); + mixed_ExpectAndReturn(6, expect_list, 7, 13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: FALSE + :should: 'handle creating array expects when we have mixed arguments and handle failures for single object' + :code: | + test() + { + int expect_list[] = { 9, 1 }; + no_pointers_Expect(1, "silly"); + mixed_ExpectAndReturn(6, expect_list, 7, 13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'handle creating array expects when we have mixed arguments for multiple objects' + :code: | + test() + { + int expect_list[] = { 1, 2, 3, 4, 6 }; + no_pointers_Expect(1, "silly"); + mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: FALSE + :should: 'handle creating array expects when we have mixed arguments and handle failures for multiple objects' + :code: | + test() + { + int expect_list[] = { 1, 2, 3, 4, 6 }; + no_pointers_Expect(1, "silly"); + mixed_ExpectWithArrayAndReturn(6, expect_list, 5, 7, 13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'handle an exception being caught' + :code: | + test() + { + bars_ExpectAndReturn("This is a\0 silly string"); + foos_ExpectAndThrow("This is a\0 wacky string", 55); + foos_Expect("err"); + + function_c(); + } + + - :pass: FALSE + :should: 'handle an exception being caught but still catch following errors' + :code: | + test() + { + bars_ExpectAndReturn("This is a\0 silly string"); + foos_ExpectAndThrow("This is a\0 wacky string", 55); + foos_Expect("wrong error"); + + function_c(); + } + + - :pass: FALSE + :should: 'fail strict ordering problems even though we would otherwise have passed' + :code: | + test() + { + int expect_list[] = { 1, 2, 3, 4, 6 }; + mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); + no_pointers_Expect(1, "silly"); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'properly ignore first function but the other will work properly' + :code: | + test() + { + int expect_list[] = { 1, 2, 3, 4, 6 }; + no_pointers_Ignore(); + mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'properly ignore last function but the other will work properly' + :code: | + test() + { + no_pointers_Expect(1, "silly"); + mixed_IgnoreAndReturn(13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'be ok if we ignore a call each because we are counting calls' + :code: | + test() + { + foos_Ignore(); + foos_Ignore(); + foos_Ignore(); + + function_e(); + } + + - :pass: FALSE + :should: 'fail if we do not ignore a call once because we are counting calls' + :code: | + test() + { + foos_Ignore(); + foos_Ignore(); + + function_e(); + } + +... diff --git a/test/system/test_interactions/all_plugins_coexist.yml b/test/system/test_interactions/all_plugins_coexist.yml index 98d3344..5acd214 100644 --- a/test/system/test_interactions/all_plugins_coexist.yml +++ b/test/system/test_interactions/all_plugins_coexist.yml @@ -1,382 +1,382 @@ ---- -:cmock: - :enforce_strict_ordering: 1 - :plugins: - - :array - - :cexception - - :ignore - - :callback - :callback_after_arg_check: true - :callback_include_count: false - :treat_externs: :include - -:systest: - :types: | - typedef struct _POINT_T { - int x; - int y; - } POINT_T; - - :mockable: | - #include "CException.h" - extern void foo(POINT_T* a); - POINT_T* bar(void); - void fooa(POINT_T a[]); - void foos(const char * a); - const char * bars(void); - void no_pointers(int a, char* b); - int mixed(int a, int* b, int c); - void no_args(void); - - :source: - :header: | - #include "CException.h" - void function_a(void); - void function_b(void); - void function_c(void); - int function_d(void); - void function_e(void); - - :code: | - void function_a(void) - { - foo(bar()); - } - - void function_b(void) { - fooa(bar()); - } - - void function_c(void) { - CEXCEPTION_T e; - Try { - foos(bars()); - } Catch(e) { foos("err"); } - } - - int function_d(void) { - int test_list[] = { 1, 2, 3, 4, 5 }; - no_pointers(1, "silly"); - return mixed(6, test_list, 7); - } - - void function_e(void) { - foos("Hello"); - foos("Tuna"); - foos("Oranges"); - } - - :tests: - :common: | - #include "CException.h" - void setUp(void) {} - void tearDown(void) {} - void my_foo_callback(POINT_T* a) { TEST_ASSERT_EQUAL_INT(2, a->x); } - - :units: - - :pass: TRUE - :should: 'handle the situation where we pass nulls to pointers' - :code: | - test() - { - bar_ExpectAndReturn(NULL); - foo_Expect(NULL); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we expected nulls to pointers but did not get that' - :code: | - test() - { - POINT_T pt = {1, 2}; - bar_ExpectAndReturn(&pt); - foo_Expect(NULL); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we did not expect nulls to pointers but got null' - :code: | - test() - { - POINT_T ex = {1, 2}; - bar_ExpectAndReturn(NULL); - foo_Expect(&ex); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we pass single object with expect and it is wrong' - :code: | - test() - { - POINT_T pt = {1, 2}; - POINT_T ex = {1, 3}; - bar_ExpectAndReturn(&pt); - foo_Expect(&ex); - - function_a(); - } - - - :pass: TRUE - :should: 'handle the situation where we pass single object with expect and use array handler' - :code: | - test() - { - POINT_T pt = {1, 2}; - POINT_T ex = {1, 2}; - bar_ExpectAndReturn(&pt); - foo_ExpectWithArray(&ex, 1); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we pass single object with expect and use array handler and it is wrong' - :code: | - test() - { - POINT_T pt = {1, 2}; - POINT_T ex = {1, 3}; - bar_ExpectAndReturn(&pt); - foo_ExpectWithArray(&ex, 1); - - function_a(); - } - - - :pass: TRUE - :should: 'handle the situation where we pass multiple objects with expect and use array handler' - :code: | - test() - { - POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}}; - POINT_T ex[] = {{1, 2}, {3, 4}, {5, 6}}; - bar_ExpectAndReturn(pt); - foo_ExpectWithArray(ex, 3); - - function_a(); - } - - - :pass: FALSE - :should: 'handle the situation where we pass multiple objects with expect and use array handler and it is wrong at end' - :code: | - test() - { - POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}}; - POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}}; - bar_ExpectAndReturn(pt); - foo_ExpectWithArray(ex, 3); - - function_a(); - } - - - :pass: TRUE - :should: 'handle the situation where we pass single array element with expect' - :code: | - test() - { - POINT_T pt = {1, 2}; - POINT_T ex = {1, 2}; - bar_ExpectAndReturn(&pt); - fooa_Expect(&ex); - - function_b(); - } - - - :pass: TRUE - :should: 'handle standard c string as null terminated on not do crappy memory compares of a byte, passing' - :code: | - test() - { - bars_ExpectAndReturn("This is a\0 silly string"); - foos_Expect("This is a\0 wacky string"); - - function_c(); - } - - - :pass: FALSE - :should: 'handle standard c string as null terminated on not do crappy memory compares of a byte, finding failures' - :code: | - test() - { - bars_ExpectAndReturn("This is a silly string"); - foos_Expect("This is a wacky string"); - - function_c(); - } - - - :pass: TRUE - :should: 'handle creating array expects when we have mixed arguments for single object' - :code: | - test() - { - int expect_list[] = { 1, 9 }; - no_pointers_Expect(1, "silly"); - mixed_ExpectAndReturn(6, expect_list, 7, 13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: FALSE - :should: 'handle creating array expects when we have mixed arguments and handle failures for single object' - :code: | - test() - { - int expect_list[] = { 9, 1 }; - no_pointers_Expect(1, "silly"); - mixed_ExpectAndReturn(6, expect_list, 7, 13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'handle creating array expects when we have mixed arguments for multiple objects' - :code: | - test() - { - int expect_list[] = { 1, 2, 3, 4, 6 }; - no_pointers_Expect(1, "silly"); - mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: FALSE - :should: 'handle creating array expects when we have mixed arguments and handle failures for multiple objects' - :code: | - test() - { - int expect_list[] = { 1, 2, 3, 4, 6 }; - no_pointers_Expect(1, "silly"); - mixed_ExpectWithArrayAndReturn(6, expect_list, 5, 7, 13); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'handle an exception being caught' - :code: | - test() - { - bars_ExpectAndReturn("This is a\0 silly string"); - foos_ExpectAndThrow("This is a\0 wacky string", 55); - foos_Expect("err"); - - function_c(); - } - - - :pass: FALSE - :should: 'handle an exception being caught but still catch following errors' - :code: | - test() - { - bars_ExpectAndReturn("This is a\0 silly string"); - foos_ExpectAndThrow("This is a\0 wacky string", 55); - foos_Expect("wrong error"); - - function_c(); - } - - - :pass: FALSE - :should: 'fail strict ordering problems even though we would otherwise have passed' - :code: | - test() - { - int expect_list[] = { 1, 2, 3, 4, 6 }; - mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); - no_pointers_Expect(1, "silly"); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'that we can properly ignore last function but the other will work properly' - :code: | - test() - { - int expect_list[] = { 1, 2, 3, 4, 6 }; - mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); - no_pointers_Ignore(); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'that we can properly ignore first function but the other will work properly' - :code: | - test() - { - mixed_IgnoreAndReturn(13); - no_pointers_Expect(1, "silly"); - - TEST_ASSERT_EQUAL(13, function_d()); - } - - - :pass: TRUE - :should: 'that we just have to ignore a call once because we are not counting calls' - :code: | - test() - { - foos_Ignore(); - - function_e(); - } - - - :pass: TRUE - :should: 'that we can use a callback and an expect' - :code: | - test() - { - POINT_T pt1 = {2, 3}; - POINT_T pt2 = {2, 3}; - bar_ExpectAndReturn(&pt1); - foo_Expect(&pt2); - foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback); - - function_a(); - } - - - :pass: FALSE - :should: 'that we can fail even when using a callback if we want to expect call but did not and we are checking that' - :code: | - test() - { - POINT_T pt = {2, 3}; - bar_ExpectAndReturn(&pt); - foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback); - - function_a(); - } - - - :pass: FALSE - :should: 'that we can fail even when using a callback if args are wrong and we are checking those' - :code: | - test() - { - POINT_T pt1 = {2, 3}; - POINT_T pt2 = {1, 3}; - bar_ExpectAndReturn(&pt1); - foo_Expect(&pt2); - foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback); - - function_a(); - } - - - :pass: FALSE - :should: 'that we can fail from the callback itself' - :code: | - test() - { - POINT_T pt = {3, 3}; - bar_ExpectAndReturn(&pt); - foo_Expect(&pt); - foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback); - - function_a(); - } - -... +--- +:cmock: + :enforce_strict_ordering: 1 + :plugins: + - :array + - :cexception + - :ignore + - :callback + :callback_after_arg_check: true + :callback_include_count: false + :treat_externs: :include + +:systest: + :types: | + typedef struct _POINT_T { + int x; + int y; + } POINT_T; + + :mockable: | + #include "CException.h" + extern void foo(POINT_T* a); + POINT_T* bar(void); + void fooa(POINT_T a[]); + void foos(const char * a); + const char * bars(void); + void no_pointers(int a, char* b); + int mixed(int a, int* b, int c); + void no_args(void); + + :source: + :header: | + #include "CException.h" + void function_a(void); + void function_b(void); + void function_c(void); + int function_d(void); + void function_e(void); + + :code: | + void function_a(void) + { + foo(bar()); + } + + void function_b(void) { + fooa(bar()); + } + + void function_c(void) { + CEXCEPTION_T e; + Try { + foos(bars()); + } Catch(e) { foos("err"); } + } + + int function_d(void) { + int test_list[] = { 1, 2, 3, 4, 5 }; + no_pointers(1, "silly"); + return mixed(6, test_list, 7); + } + + void function_e(void) { + foos("Hello"); + foos("Tuna"); + foos("Oranges"); + } + + :tests: + :common: | + #include "CException.h" + void setUp(void) {} + void tearDown(void) {} + void my_foo_callback(POINT_T* a) { TEST_ASSERT_EQUAL_INT(2, a->x); } + + :units: + - :pass: TRUE + :should: 'handle the situation where we pass nulls to pointers' + :code: | + test() + { + bar_ExpectAndReturn(NULL); + foo_Expect(NULL); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we expected nulls to pointers but did not get that' + :code: | + test() + { + POINT_T pt = {1, 2}; + bar_ExpectAndReturn(&pt); + foo_Expect(NULL); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we did not expect nulls to pointers but got null' + :code: | + test() + { + POINT_T ex = {1, 2}; + bar_ExpectAndReturn(NULL); + foo_Expect(&ex); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we pass single object with expect and it is wrong' + :code: | + test() + { + POINT_T pt = {1, 2}; + POINT_T ex = {1, 3}; + bar_ExpectAndReturn(&pt); + foo_Expect(&ex); + + function_a(); + } + + - :pass: TRUE + :should: 'handle the situation where we pass single object with expect and use array handler' + :code: | + test() + { + POINT_T pt = {1, 2}; + POINT_T ex = {1, 2}; + bar_ExpectAndReturn(&pt); + foo_ExpectWithArray(&ex, 1); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we pass single object with expect and use array handler and it is wrong' + :code: | + test() + { + POINT_T pt = {1, 2}; + POINT_T ex = {1, 3}; + bar_ExpectAndReturn(&pt); + foo_ExpectWithArray(&ex, 1); + + function_a(); + } + + - :pass: TRUE + :should: 'handle the situation where we pass multiple objects with expect and use array handler' + :code: | + test() + { + POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}}; + POINT_T ex[] = {{1, 2}, {3, 4}, {5, 6}}; + bar_ExpectAndReturn(pt); + foo_ExpectWithArray(ex, 3); + + function_a(); + } + + - :pass: FALSE + :should: 'handle the situation where we pass multiple objects with expect and use array handler and it is wrong at end' + :code: | + test() + { + POINT_T pt[] = {{1, 2}, {3, 4}, {5, 6}}; + POINT_T ex[] = {{1, 2}, {3, 4}, {5, 9}}; + bar_ExpectAndReturn(pt); + foo_ExpectWithArray(ex, 3); + + function_a(); + } + + - :pass: TRUE + :should: 'handle the situation where we pass single array element with expect' + :code: | + test() + { + POINT_T pt = {1, 2}; + POINT_T ex = {1, 2}; + bar_ExpectAndReturn(&pt); + fooa_Expect(&ex); + + function_b(); + } + + - :pass: TRUE + :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, passing' + :code: | + test() + { + bars_ExpectAndReturn("This is a\0 silly string"); + foos_Expect("This is a\0 wacky string"); + + function_c(); + } + + - :pass: FALSE + :should: 'handle standard c string as null terminated and not do crappy memory compares of a byte, finding failures' + :code: | + test() + { + bars_ExpectAndReturn("This is a silly string"); + foos_Expect("This is a wacky string"); + + function_c(); + } + + - :pass: TRUE + :should: 'handle creating array expects when we have mixed arguments for single object' + :code: | + test() + { + int expect_list[] = { 1, 9 }; + no_pointers_Expect(1, "silly"); + mixed_ExpectAndReturn(6, expect_list, 7, 13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: FALSE + :should: 'handle creating array expects when we have mixed arguments and handle failures for single object' + :code: | + test() + { + int expect_list[] = { 9, 1 }; + no_pointers_Expect(1, "silly"); + mixed_ExpectAndReturn(6, expect_list, 7, 13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'handle creating array expects when we have mixed arguments for multiple objects' + :code: | + test() + { + int expect_list[] = { 1, 2, 3, 4, 6 }; + no_pointers_Expect(1, "silly"); + mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: FALSE + :should: 'handle creating array expects when we have mixed arguments and handle failures for multiple objects' + :code: | + test() + { + int expect_list[] = { 1, 2, 3, 4, 6 }; + no_pointers_Expect(1, "silly"); + mixed_ExpectWithArrayAndReturn(6, expect_list, 5, 7, 13); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'handle an exception being caught' + :code: | + test() + { + bars_ExpectAndReturn("This is a\0 silly string"); + foos_ExpectAndThrow("This is a\0 wacky string", 55); + foos_Expect("err"); + + function_c(); + } + + - :pass: FALSE + :should: 'handle an exception being caught but still catch following errors' + :code: | + test() + { + bars_ExpectAndReturn("This is a\0 silly string"); + foos_ExpectAndThrow("This is a\0 wacky string", 55); + foos_Expect("wrong error"); + + function_c(); + } + + - :pass: FALSE + :should: 'fail strict ordering problems even though we would otherwise have passed' + :code: | + test() + { + int expect_list[] = { 1, 2, 3, 4, 6 }; + mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); + no_pointers_Expect(1, "silly"); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'that we can properly ignore last function but the other will work properly' + :code: | + test() + { + int expect_list[] = { 1, 2, 3, 4, 6 }; + mixed_ExpectWithArrayAndReturn(6, expect_list, 4, 7, 13); + no_pointers_Ignore(); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'that we can properly ignore first function but the other will work properly' + :code: | + test() + { + mixed_IgnoreAndReturn(13); + no_pointers_Expect(1, "silly"); + + TEST_ASSERT_EQUAL(13, function_d()); + } + + - :pass: TRUE + :should: 'that we just have to ignore a call once because we are not counting calls' + :code: | + test() + { + foos_Ignore(); + + function_e(); + } + + - :pass: TRUE + :should: 'that we can use a callback and an expect' + :code: | + test() + { + POINT_T pt1 = {2, 3}; + POINT_T pt2 = {2, 3}; + bar_ExpectAndReturn(&pt1); + foo_Expect(&pt2); + foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback); + + function_a(); + } + + - :pass: FALSE + :should: 'that we can fail even when using a callback if we want to expect call but did not and we are checking that' + :code: | + test() + { + POINT_T pt = {2, 3}; + bar_ExpectAndReturn(&pt); + foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback); + + function_a(); + } + + - :pass: FALSE + :should: 'that we can fail even when using a callback if args are wrong and we are checking those' + :code: | + test() + { + POINT_T pt1 = {2, 3}; + POINT_T pt2 = {1, 3}; + bar_ExpectAndReturn(&pt1); + foo_Expect(&pt2); + foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback); + + function_a(); + } + + - :pass: FALSE + :should: 'that we can fail from the callback itself' + :code: | + test() + { + POINT_T pt = {3, 3}; + bar_ExpectAndReturn(&pt); + foo_Expect(&pt); + foo_StubWithCallback((CMOCK_foo_CALLBACK)my_foo_callback); + + function_a(); + } + +... diff --git a/test/unit/cmock_config_test.rb b/test/unit/cmock_config_test.rb index 28f8ce8..1990d99 100644 --- a/test/unit/cmock_config_test.rb +++ b/test/unit/cmock_config_test.rb @@ -1 +1,121 @@ -# ========================================== # CMock Project - Automatic Mock Generation for C # Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams # [Released under MIT License. Please refer to license.txt for details] # ========================================== require File.expand_path(File.dirname(__FILE__)) + "/../test_helper" require 'cmock_config' class CMockConfigTest < Test::Unit::TestCase def setup end def teardown end should "use default settings when no parameters are specified" do config = CMockConfig.new assert_equal(CMockConfig::CMockDefaultOptions[:mock_path], config.mock_path) assert_equal(CMockConfig::CMockDefaultOptions[:includes], config.includes) assert_equal(CMockConfig::CMockDefaultOptions[:attributes], config.attributes) assert_equal(CMockConfig::CMockDefaultOptions[:plugins], config.plugins) assert_equal(CMockConfig::CMockDefaultOptions[:treat_externs], config.treat_externs) end should "replace only options specified in a hash" do test_includes = ['hello'] test_attributes = ['blah', 'bleh'] config = CMockConfig.new(:includes => test_includes, :attributes => test_attributes) assert_equal(CMockConfig::CMockDefaultOptions[:mock_path], config.mock_path) assert_equal(test_includes, config.includes) assert_equal(test_attributes, config.attributes) assert_equal(CMockConfig::CMockDefaultOptions[:plugins], config.plugins) assert_equal(CMockConfig::CMockDefaultOptions[:treat_externs], config.treat_externs) end should "replace only options specified in a yaml file" do test_plugins = [:soda, :pizza] config = CMockConfig.new("#{File.expand_path(File.dirname(__FILE__))}/cmock_config_test.yml") assert_equal(CMockConfig::CMockDefaultOptions[:mock_path], config.mock_path) assert_equal(CMockConfig::CMockDefaultOptions[:includes], config.includes) assert_equal(test_plugins, config.plugins) assert_equal(:include, config.treat_externs) end should "populate treat_as map with internal standard_treat_as_map defaults, redefine defaults, and add custom values" do user_treat_as1 = { 'BOOL' => 'UINT8', # redefine standard default 'unsigned long' => 'INT', # redefine standard default 'U8' => 'UINT8', # custom value 'U16' => 'UINT16' # custom value } user_treat_as2 = { 'BOOL' => 'INT16', # redefine standard default 'U16' => 'HEX16' # custom value } config1 = CMockConfig.new({:treat_as => user_treat_as1}) config2 = CMockConfig.new({:treat_as => user_treat_as2}) # ----- USER SET 1 # standard defaults assert_equal('INT', config1.treat_as['BOOL_T']) assert_equal('HEX32', config1.treat_as['unsigned int']) assert_equal('PTR', config1.treat_as['void*']) assert_equal('STRING', config1.treat_as['CSTRING']) assert_equal('STRING', config1.treat_as['char*']) assert_equal('HEX8', config1.treat_as['unsigned char']) assert_equal('INT', config1.treat_as['long']) assert_equal('INT16', config1.treat_as['short']) # overrides assert_equal('UINT8', config1.treat_as['BOOL']) assert_equal('INT', config1.treat_as['unsigned long']) # added custom values assert_equal('UINT8', config1.treat_as['U8']) assert_equal('UINT16', config1.treat_as['U16']) # standard_treat_as_map: unchanged assert_equal('INT', config1.standard_treat_as_map['BOOL']) assert_equal('HEX32', config1.standard_treat_as_map['unsigned long']) assert_equal('STRING', config1.standard_treat_as_map['char*']) # ----- USER SET 2 # standard defaults assert_equal('INT', config2.treat_as['BOOL_T']) assert_equal('HEX32', config2.treat_as['unsigned int']) assert_equal('PTR', config2.treat_as['void*']) assert_equal('STRING', config2.treat_as['CSTRING']) assert_equal('STRING', config2.treat_as['char*']) assert_equal('HEX8', config2.treat_as['unsigned char']) assert_equal('INT', config2.treat_as['long']) assert_equal('INT16', config2.treat_as['short']) assert_equal('HEX32', config2.treat_as['unsigned long']) # overrides assert_equal('INT16', config2.treat_as['BOOL']) # added custom values assert_equal('HEX16', config2.treat_as['U16']) # standard_treat_as_map: unchanged assert_equal('INT', config2.standard_treat_as_map['BOOL']) assert_equal('HEX32', config2.standard_treat_as_map['unsigned long']) assert_equal('STRING', config2.standard_treat_as_map['char*']) end def "standard treat_as map should be incorruptable" do config = CMockConfig.new({}) assert_equal('INT', config.standard_treat_as_map['BOOL_T']) local = config.standard_treat_as_map local['BOOL_T'] = "U8" assert_equal('INT', config.standard_treat_as_map['BOOL_T']) end end \ No newline at end of file +# ========================================== +# CMock Project - Automatic Mock Generation for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +require File.expand_path(File.dirname(__FILE__)) + "/../test_helper" +require 'cmock_config' + +class CMockConfigTest < Test::Unit::TestCase + def setup + end + + def teardown + end + + should "use default settings when no parameters are specified" do + config = CMockConfig.new + assert_equal(CMockConfig::CMockDefaultOptions[:mock_path], config.mock_path) + assert_equal(CMockConfig::CMockDefaultOptions[:includes], config.includes) + assert_equal(CMockConfig::CMockDefaultOptions[:attributes], config.attributes) + assert_equal(CMockConfig::CMockDefaultOptions[:plugins], config.plugins) + assert_equal(CMockConfig::CMockDefaultOptions[:treat_externs], config.treat_externs) + end + + should "replace only options specified in a hash" do + test_includes = ['hello'] + test_attributes = ['blah', 'bleh'] + config = CMockConfig.new(:includes => test_includes, :attributes => test_attributes) + assert_equal(CMockConfig::CMockDefaultOptions[:mock_path], config.mock_path) + assert_equal(test_includes, config.includes) + assert_equal(test_attributes, config.attributes) + assert_equal(CMockConfig::CMockDefaultOptions[:plugins], config.plugins) + assert_equal(CMockConfig::CMockDefaultOptions[:treat_externs], config.treat_externs) + end + + should "replace only options specified in a yaml file" do + test_plugins = [:soda, :pizza] + config = CMockConfig.new("#{File.expand_path(File.dirname(__FILE__))}/cmock_config_test.yml") + assert_equal(CMockConfig::CMockDefaultOptions[:mock_path], config.mock_path) + assert_equal(CMockConfig::CMockDefaultOptions[:includes], config.includes) + assert_equal(test_plugins, config.plugins) + assert_equal(:include, config.treat_externs) + end + + should "populate treat_as map with internal standard_treat_as_map defaults, redefine defaults, and add custom values" do + + user_treat_as1 = { + 'BOOL' => 'UINT8', # redefine standard default + 'unsigned long' => 'INT', # redefine standard default + 'U8' => 'UINT8', # custom value + 'U16' => 'UINT16' # custom value + } + user_treat_as2 = { + 'BOOL' => 'INT16', # redefine standard default + 'U16' => 'HEX16' # custom value + } + + config1 = CMockConfig.new({:treat_as => user_treat_as1}) + config2 = CMockConfig.new({:treat_as => user_treat_as2}) + + # ----- USER SET 1 + # standard defaults + assert_equal('INT', config1.treat_as['BOOL_T']) + assert_equal('HEX32', config1.treat_as['unsigned int']) + assert_equal('PTR', config1.treat_as['void*']) + assert_equal('STRING', config1.treat_as['CSTRING']) + assert_equal('STRING', config1.treat_as['char*']) + assert_equal('HEX8', config1.treat_as['unsigned char']) + assert_equal('INT', config1.treat_as['long']) + assert_equal('INT16', config1.treat_as['short']) + + # overrides + assert_equal('UINT8', config1.treat_as['BOOL']) + assert_equal('INT', config1.treat_as['unsigned long']) + + # added custom values + assert_equal('UINT8', config1.treat_as['U8']) + assert_equal('UINT16', config1.treat_as['U16']) + + # standard_treat_as_map: unchanged + assert_equal('INT', config1.standard_treat_as_map['BOOL']) + assert_equal('HEX32', config1.standard_treat_as_map['unsigned long']) + assert_equal('STRING', config1.standard_treat_as_map['char*']) + + # ----- USER SET 2 + # standard defaults + assert_equal('INT', config2.treat_as['BOOL_T']) + assert_equal('HEX32', config2.treat_as['unsigned int']) + assert_equal('PTR', config2.treat_as['void*']) + assert_equal('STRING', config2.treat_as['CSTRING']) + assert_equal('STRING', config2.treat_as['char*']) + assert_equal('HEX8', config2.treat_as['unsigned char']) + assert_equal('INT', config2.treat_as['long']) + assert_equal('INT16', config2.treat_as['short']) + assert_equal('HEX32', config2.treat_as['unsigned long']) + + # overrides + assert_equal('INT16', config2.treat_as['BOOL']) + + # added custom values + assert_equal('HEX16', config2.treat_as['U16']) + + # standard_treat_as_map: unchanged + assert_equal('INT', config2.standard_treat_as_map['BOOL']) + assert_equal('HEX32', config2.standard_treat_as_map['unsigned long']) + assert_equal('STRING', config2.standard_treat_as_map['char*']) + end + + should "standard treat_as map should be incorruptable" do + config = CMockConfig.new({}) + + assert_equal('INT', config.standard_treat_as_map['BOOL_T']) + + local = config.standard_treat_as_map + local['BOOL_T'] = "U8" + + assert_equal('INT', config.standard_treat_as_map['BOOL_T']) + end + +end