Menu
▾
▴
[Cgreen-commits] SF.net SVN: cgreen:[537] trunk/cgreen
|
From: <tho...@us...> - 2013-12-07 10:33:23
|
Revision: 537
http://sourceforge.net/p/cgreen/code/537
Author: thomasnilsson
Date: 2013-12-07 10:33:14 +0000 (Sat, 07 Dec 2013)
Log Message:
-----------
Added non-activated unit test for learning mocks to survive unexpected terminations (which I don't know how to approach, suggestions? ideas?)
Minor format cleanups
Modified Paths:
--------------
trunk/cgreen/src/mocks.c
trunk/cgreen/src/runner.c
trunk/cgreen/tests/mocks_tests.c
Modified: trunk/cgreen/src/mocks.c
===================================================================
--- trunk/cgreen/src/mocks.c 2013-12-03 07:32:49 UTC (rev 536)
+++ trunk/cgreen/src/mocks.c 2013-12-07 10:33:14 UTC (rev 537)
@@ -437,7 +437,7 @@
int e, c;
CgreenBreadcrumb *breadcrumb = get_test_reporter()->breadcrumb;
printf("%s: learned mocks:\n",
- get_current_from_breadcrumb(breadcrumb));
+ get_current_from_breadcrumb(breadcrumb));
if (cgreen_vector_size(learned_mock_calls) == 0) {
printf("\t<none>\n");
Modified: trunk/cgreen/src/runner.c
===================================================================
--- trunk/cgreen/src/runner.c 2013-12-03 07:32:49 UTC (rev 536)
+++ trunk/cgreen/src/runner.c 2013-12-07 10:33:14 UTC (rev 537)
@@ -56,7 +56,7 @@
static void run_every_test(TestSuite *suite, TestReporter *reporter) {
int i;
- run_specified_test_if_child(suite,reporter);
+ run_specified_test_if_child(suite, reporter);
(*reporter->start_suite)(reporter, suite->name, count_tests(suite));
for (i = 0; i < suite->size; i++) {
@@ -133,27 +133,27 @@
#ifdef __cplusplus
return;
} catch(const std::exception& exception) {
- message += '[';
- message += exception.what();
- message += ']';
+ message += '[';
+ message += exception.what();
+ message += ']';
} catch(const std::exception* exception) {
- message += '[';
- message += exception->what();
- message += ']';
+ message += '[';
+ message += exception->what();
+ message += ']';
} catch(const std::string& exception_message) {
- message += '[';
- message += exception_message;
- message += ']';
+ message += '[';
+ message += exception_message;
+ message += ']';
} catch(const std::string *exception_message) {
- message += '[';
- message += *exception_message;
- message += ']';
+ message += '[';
+ message += *exception_message;
+ message += ']';
} catch(const char *exception_message) {
- message += '[';
- message += exception_message;
- message += ']';
+ message += '[';
+ message += exception_message;
+ message += ']';
} catch (...) {
- message += "unknown exception type";
+ message += "unknown exception type";
}
va_list no_arguments;
memset(&no_arguments, 0, sizeof(va_list));
@@ -172,27 +172,27 @@
#ifdef __cplusplus
return;
} catch(const std::exception& exception) {
- message += '[';
- message += exception.what();
- message += ']';
+ message += '[';
+ message += exception.what();
+ message += ']';
} catch(const std::exception* exception) {
- message += '[';
- message += exception->what();
- message += ']';
+ message += '[';
+ message += exception->what();
+ message += ']';
} catch(const std::string& exception_message) {
- message += '[';
- message += exception_message;
- message += ']';
+ message += '[';
+ message += exception_message;
+ message += ']';
} catch(const std::string *exception_message) {
- message += '[';
- message += *exception_message;
- message += ']';
+ message += '[';
+ message += *exception_message;
+ message += ']';
} catch(const char *exception_message) {
- message += '[';
- message += exception_message;
- message += ']';
+ message += '[';
+ message += exception_message;
+ message += ']';
} catch (...) {
- message += "unknown exception type";
+ message += "unknown exception type";
}
va_list no_arguments;
memset(&no_arguments, 0, sizeof(va_list));
@@ -218,27 +218,27 @@
#ifdef __cplusplus
return;
} catch(const std::exception& exception) {
- message += '[';
- message += exception.what();
- message += ']';
+ message += '[';
+ message += exception.what();
+ message += ']';
} catch(const std::exception* exception) {
- message += '[';
- message += exception->what();
- message += ']';
+ message += '[';
+ message += exception->what();
+ message += ']';
} catch(const std::string& exception_message) {
- message += '[';
- message += exception_message;
- message += ']';
+ message += '[';
+ message += exception_message;
+ message += ']';
} catch(const std::string *exception_message) {
- message += '[';
- message += *exception_message;
- message += ']';
+ message += '[';
+ message += *exception_message;
+ message += ']';
} catch(const char *exception_message) {
- message += '[';
- message += exception_message;
- message += ']';
+ message += '[';
+ message += exception_message;
+ message += ']';
} catch (...) {
- message += "unknown exception type";
+ message += "unknown exception type";
}
va_list no_arguments;
memset(&no_arguments, 0, sizeof(va_list));
@@ -268,7 +268,6 @@
}
run(spec);
-
// for historical reasons the suite can have a teardown
if (suite->teardown != &do_nothing) {
(*suite->teardown)();
Modified: trunk/cgreen/tests/mocks_tests.c
===================================================================
--- trunk/cgreen/tests/mocks_tests.c 2013-12-03 07:32:49 UTC (rev 536)
+++ trunk/cgreen/tests/mocks_tests.c 2013-12-07 10:33:14 UTC (rev 537)
@@ -8,16 +8,20 @@
using namespace cgreen;
#endif
+Describe(Mocks);
+BeforeEach(Mocks) {}
+AfterEach(Mocks) {}
+
static int integer_out() {
return (int)mock();
}
-Ensure(default_return_value_when_no_presets_for_loose_mock) {
+Ensure(Mocks, default_return_value_when_no_presets_for_loose_mock) {
cgreen_mocks_are(loose_mocks);
assert_that(integer_out(), is_equal_to(0));
}
-Ensure(can_stub_an_integer_return) {
+Ensure(Mocks, can_stub_an_integer_return) {
expect(integer_out,
will_return(3)
);
@@ -25,7 +29,7 @@
assert_that(integer_out(), is_equal_to(3));
}
-Ensure(repeats_return_value_when_set_to_always) {
+Ensure(Mocks, repeats_return_value_when_set_to_always) {
always_expect(integer_out,
will_return(3)
);
@@ -34,7 +38,7 @@
assert_that(integer_out(), is_equal_to(3));
}
-Ensure(can_stub_an_integer_return_sequence) {
+Ensure(Mocks, can_stub_an_integer_return_sequence) {
expect(integer_out,
will_return(1)
);
@@ -52,7 +56,7 @@
assert_that(integer_out(), is_equal_to(3));
}
-Ensure(expectations_are_reset_between_tests_with_loose_mocks) {
+Ensure(Mocks, expectations_are_reset_between_tests_with_loose_mocks) {
cgreen_mocks_are(loose_mocks);
assert_that(integer_out(), is_equal_to(0));
}
@@ -61,12 +65,12 @@
return (char *)mock(p1);
}
-Ensure(can_stub_a_string_return) {
+Ensure(Mocks, can_stub_a_string_return) {
expect(string_out, will_return("hello"));
assert_string_equal(string_out(1), "hello");
}
-Ensure(can_stub_a_string_sequence) {
+Ensure(Mocks, can_stub_a_string_sequence) {
expect(string_out, will_return("hello"));
expect(string_out, will_return("goodbye"));
@@ -78,24 +82,24 @@
mock(i);
}
-Ensure(expecting_once_with_any_parameters) {
+Ensure(Mocks, expecting_once_with_any_parameters) {
expect(integer_in);
integer_in(3);
}
-Ensure(expecting_once_with_parameter_checks_that_parameter) {
+Ensure(Mocks, expecting_once_with_parameter_checks_that_parameter) {
expect(integer_in, when(i, is_equal_to(3)));
integer_in(3);
}
-Ensure(always_expect_keeps_affirming_parameter) {
+Ensure(Mocks, always_expect_keeps_affirming_parameter) {
always_expect(integer_in, when(i, is_equal_to(3)));
integer_in(3);
integer_in(3);
integer_in(3);
}
-Ensure(expect_a_sequence) {
+Ensure(Mocks, expect_a_sequence) {
expect(integer_in, when(i, is_equal_to(1)));
expect(integer_in, when(i, is_equal_to(2)));
expect(integer_in, when(i, is_equal_to(3)));
@@ -108,29 +112,29 @@
mock(s);
}
-Ensure(string_expect_is_confirmed) {
+Ensure(Mocks, string_expect_is_confirmed) {
expect(string_in, when(s, is_equal_to_string("hello")));
string_in("hello");
}
-Ensure(string_contains_expectation_is_confirmed) {
+Ensure(Mocks, string_contains_expectation_is_confirmed) {
expect(string_in, when(s, contains_string("hello")));
string_in("alice, hello");
}
-Ensure(string_expect_is_confirmed_even_when_null) {
+Ensure(Mocks, string_expect_is_confirmed_even_when_null) {
expect(string_in, when(s, is_equal_to_string((char *)NULL)));
string_in(NULL);
}
-Ensure(string_expect_sequence) {
+Ensure(Mocks, string_expect_sequence) {
expect(string_in, when(s, is_equal_to_string("hello")));
expect(string_in, when(s, is_equal_to_string("goodbye")));
string_in("hello");
string_in("goodbye");
}
-Ensure(expecting_once_with_non_null_parameter_checks_that_parameter) {
+Ensure(Mocks, expecting_once_with_non_null_parameter_checks_that_parameter) {
expect(string_in, when(s, is_non_null));
string_in("anything");
}
@@ -139,12 +143,12 @@
mock(box_double(d));
}
-Ensure(double_expect_is_confirmed) {
+Ensure(Mocks, double_expect_is_confirmed) {
expect(double_in, when(d, is_equal_to_double(3.14)));
double_in(3.14);
}
-Ensure(double_expect_sequence) {
+Ensure(Mocks, double_expect_sequence) {
expect(double_in, when(d, is_equal_to_double(1.0)));
expect(double_in, when(d, is_equal_to_double(2.0)));
double_in(1.0);
@@ -155,7 +159,7 @@
mock(i, s);
}
-Ensure(confirming_multiple_parameters_multiple_times) {
+Ensure(Mocks, confirming_multiple_parameters_multiple_times) {
expect(mixed_parameters,
when(i, is_equal_to(1)),
when(s, is_equal_to_string("Hello"))
@@ -173,7 +177,7 @@
return (int)mock(i, s);
}
-Ensure(can_mock_full_function_call) {
+Ensure(Mocks, can_mock_full_function_call) {
expect(sample_mock,
will_return(5),
when(i, is_equal_to(666)),
@@ -183,7 +187,7 @@
assert_that(sample_mock(666, "devil"), is_equal_to(5));
}
-Ensure(when_called_with_always_should_not_tally_counts) {
+Ensure(Mocks, when_called_with_always_should_not_tally_counts) {
always_expect(string_out,
will_return(5),
when(i, is_equal_to(666)),
@@ -191,7 +195,7 @@
);
}
-Ensure(can_mock_full_sequence) {
+Ensure(Mocks, can_mock_full_sequence) {
expect(sample_mock,
will_return(5),
when(i, is_equal_to(666)),
@@ -208,7 +212,7 @@
assert_that(sample_mock(667, "beastie"), is_equal_to(6));
}
-Ensure(can_always_mock_full_function_call) {
+Ensure(Mocks, can_always_mock_full_function_call) {
always_expect(sample_mock,
will_return(5),
when(i, is_equal_to(666)),
@@ -231,7 +235,7 @@
}
-Ensure(can_stub_an_out_parameter) {
+Ensure(Mocks, can_stub_an_out_parameter) {
LargerThanIntptr actual = { 3.14, 6.66, "bob" };
LargerThanIntptr local = { 4.13, 7.89, "alice" };
@@ -246,11 +250,11 @@
assert_that(&local, is_equal_to_contents_of(&actual, sizeof(LargerThanIntptr)));
}
-Ensure(none_emitted_when_learning_no_mocks) {
+Ensure(Mocks, learning_mocks_emit_none_when_learning_no_mocks) {
cgreen_mocks_are(learning_mocks);
}
-Ensure(pastable_code_emitted_by_learning_mocks) {
+Ensure(Mocks, learning_mocks_emit_pastable_code) {
cgreen_mocks_are(learning_mocks);
string_out(1);
string_out(2);
@@ -260,16 +264,29 @@
integer_out();
}
+/* It would be very nice it learning mocks could survive unexpected
+ terminations but since the child process is already gone when the
+ parent process detects this we need to either start catching
+ exceptions in the child or communicate the learned mock calls to
+ the parent some other way.
+
+Ensure(Mocks, learning_mocks_survive_termination) {
+ cgreen_mocks_are(learning_mocks);
+ string_out(1);
+ *(int*)0 = 0;
+}
+*/
+
/* Expected fail tests follow. */
/* TODO: put these in a separate suite and validate all tests in said suite fail during 'make check' */
/*
-Ensure(can_declare_function_never_called) {
+Ensure(Mocks, can_declare_function_never_called) {
never_expect(sample_mock);
sample_mock(0, "");
}
-Ensure(calls_beyond_expected_sequence_fail_when_mocks_are_strict) {
+Ensure(Mocks, calls_beyond_expected_sequence_fail_when_mocks_are_strict) {
expect(integer_out,
will_return(1)
);
@@ -289,17 +306,17 @@
assert_that(integer_out(), is_equal_to(3));
}
-Ensure(failure_when_no_presets_for_default_strict_mock) {
+Ensure(Mocks, failure_when_no_presets_for_default_strict_mock) {
assert_that(integer_out(), is_equal_to(0));
}
-Ensure(failure_reported_when_expect_after_never_expect_for_same_function) {
+Ensure(Mocks, failure_reported_when_expect_after_never_expect_for_same_function) {
never_expect(integer_out);
expect(integer_out);
}
-Ensure(failure_reported_when_expect_after_always_expect_for_same_function) {
+Ensure(Mocks, failure_reported_when_expect_after_always_expect_for_same_function) {
always_expect(integer_out,
will_return(666)
);
@@ -307,7 +324,7 @@
expect(integer_out);
}
-Ensure(single_uncalled_expectation_fails_tally) {
+Ensure(Mocks, single_uncalled_expectation_fails_tally) {
expect(string_out,
will_return(5),
when(i, is_equal_to(666)),
@@ -318,40 +335,41 @@
TestSuite *mock_tests() {
TestSuite *suite = create_test_suite();
- add_test(suite, none_emitted_when_learning_no_mocks);
- add_test(suite, pastable_code_emitted_by_learning_mocks);
- add_test(suite, default_return_value_when_no_presets_for_loose_mock);
- add_test(suite, can_stub_an_integer_return);
- add_test(suite, repeats_return_value_when_set_to_always);
- add_test(suite, can_stub_an_integer_return_sequence);
- add_test(suite, expectations_are_reset_between_tests_with_loose_mocks);
- add_test(suite, can_stub_a_string_return);
- add_test(suite, can_stub_a_string_sequence);
- add_test(suite, expecting_once_with_any_parameters);
- add_test(suite, expecting_once_with_parameter_checks_that_parameter);
- add_test(suite, always_expect_keeps_affirming_parameter);
- add_test(suite, expect_a_sequence);
- add_test(suite, string_expect_is_confirmed);
- add_test(suite, string_expect_is_confirmed_even_when_null);
- add_test(suite, string_expect_sequence);
- add_test(suite, expecting_once_with_non_null_parameter_checks_that_parameter);
- add_test(suite, double_expect_is_confirmed);
- add_test(suite, double_expect_sequence);
- add_test(suite, confirming_multiple_parameters_multiple_times);
- add_test(suite, can_mock_full_function_call);
- add_test(suite, when_called_with_always_should_not_tally_counts);
- add_test(suite, can_mock_full_sequence);
- add_test(suite, can_always_mock_full_function_call);
- add_test(suite, can_stub_an_out_parameter);
- add_test(suite, string_contains_expectation_is_confirmed);
+ add_test_with_context(suite, Mocks, learning_mocks_emit_none_when_learning_no_mocks);
+ add_test_with_context(suite, Mocks, learning_mocks_emit_pastable_code);
+ // add_test_with_context(suite, Mocks, learning_mocks_survive_termination);
+ add_test_with_context(suite, Mocks, default_return_value_when_no_presets_for_loose_mock);
+ add_test_with_context(suite, Mocks, can_stub_an_integer_return);
+ add_test_with_context(suite, Mocks, repeats_return_value_when_set_to_always);
+ add_test_with_context(suite, Mocks, can_stub_an_integer_return_sequence);
+ add_test_with_context(suite, Mocks, expectations_are_reset_between_tests_with_loose_mocks);
+ add_test_with_context(suite, Mocks, can_stub_a_string_return);
+ add_test_with_context(suite, Mocks, can_stub_a_string_sequence);
+ add_test_with_context(suite, Mocks, expecting_once_with_any_parameters);
+ add_test_with_context(suite, Mocks, expecting_once_with_parameter_checks_that_parameter);
+ add_test_with_context(suite, Mocks, always_expect_keeps_affirming_parameter);
+ add_test_with_context(suite, Mocks, expect_a_sequence);
+ add_test_with_context(suite, Mocks, string_expect_is_confirmed);
+ add_test_with_context(suite, Mocks, string_expect_is_confirmed_even_when_null);
+ add_test_with_context(suite, Mocks, string_expect_sequence);
+ add_test_with_context(suite, Mocks, expecting_once_with_non_null_parameter_checks_that_parameter);
+ add_test_with_context(suite, Mocks, double_expect_is_confirmed);
+ add_test_with_context(suite, Mocks, double_expect_sequence);
+ add_test_with_context(suite, Mocks, confirming_multiple_parameters_multiple_times);
+ add_test_with_context(suite, Mocks, can_mock_full_function_call);
+ add_test_with_context(suite, Mocks, when_called_with_always_should_not_tally_counts);
+ add_test_with_context(suite, Mocks, can_mock_full_sequence);
+ add_test_with_context(suite, Mocks, can_always_mock_full_function_call);
+ add_test_with_context(suite, Mocks, can_stub_an_out_parameter);
+ add_test_with_context(suite, Mocks, string_contains_expectation_is_confirmed);
/* expected failures. TODO: put these in a separate suite, as per comments above. */
-/* add_test(suite, failure_reported_when_expect_after_always_expect_for_same_function);
- add_test(suite, single_uncalled_expectation_fails_tally);
- add_test(suite, can_declare_function_never_called);
- add_test(suite, failure_reported_when_expect_after_never_expect_for_same_function);
- add_test(suite, failure_when_no_presets_for_default_strict_mock);
- add_test(suite, calls_beyond_expected_sequence_fail_when_mocks_are_strict);
+/* add_test_with_context(suite, Mocks, failure_reported_when_expect_after_always_expect_for_same_function);
+ add_test_with_context(suite, Mocks, single_uncalled_expectation_fails_tally);
+ add_test_with_context(suite, Mocks, can_declare_function_never_called);
+ add_test_with_context(suite, Mocks, failure_reported_when_expect_after_never_expect_for_same_function);
+ add_test_with_context(suite, Mocks, failure_when_no_presets_for_default_strict_mock);
+ add_test_with_context(suite, Mocks, calls_beyond_expected_sequence_fail_when_mocks_are_strict);
*/
return suite;
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
