static void
stub_equal_object_custom (void)
{
object1 = G_OBJECT(cut_test_new("test-name", NULL));
object2 = G_OBJECT(cut_test_new("test-name", NULL));
object3 = G_OBJECT(cut_test_new("no-name", NULL));
gcut_assert_equal_object_custom(object1, object2, equal_name);
MARK_FAIL(gcut_assert_equal_object_custom(object1, object3, equal_name));
}
void
test_equal_list_enum (void)
{
const gchar inspected_expected[] =
"(#<CutTestResultStatus: "
"pending(CUT_TEST_RESULT_PENDING:3)>, "
"#<CutTestResultStatus: "
"success(CUT_TEST_RESULT_SUCCESS:0)>)";
const gchar inspected_actual[] =
"(#<CutTestResultStatus: "
"failure(CUT_TEST_RESULT_FAILURE:4)>)";
test = cut_test_new("equal_list_enum test", stub_equal_list_enum);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_list_enum test",
NULL,
"<list1 == list2>",
inspected_expected, inspected_actual,
FAIL_LOCATION,
FUNCTION("stub_equal_list_enum"),
NULL);
}
void
test_equal_list_object (void)
{
const gchar *inspected_expected, *inspected_actual;
test = cut_test_new("equal_list_object test",
stub_equal_list_object);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
inspected_expected = cut_take_printf(
"(#<CutRepository:%p directory=<\"directory1\">>, "
"(null), "
"#<CutTest:%p name=<\"test1\">, element-name=<\"test\">, "
"test-function=<NULL>, base-directory=<NULL>>)",
list1->data, g_list_nth_data(list1, 2));
inspected_actual = cut_take_printf(
"(#<CutRepository:%p directory=<\"directory2\">>, "
"(null), "
"#<CutTest:%p name=<\"test2\">, element-name=<\"test\">, "
"test-function=<NULL>, base-directory=<NULL>>)",
list2->data, g_list_nth_data(list2, 2));
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_list_object test",
NULL,
"<list1 == list2>",
inspected_expected, inspected_actual,
FAIL_LOCATION,
FUNCTION("stub_equal_list_object"),
NULL);
}
void
test_equal_flags (void)
{
static const GFlagsValue values[] = {
{1 << 0, "CUTTEST_ASSERT_STUB_FIRST", "first"},
{1 << 1, "CUTTEST_ASSERT_STUB_SECOND", "second"},
{1 << 2, "CUTTEST_ASSERT_STUB_THIRD", "third"},
{0, NULL, NULL}
};
flags_type = g_flags_register_static("CuttestAssertStubFlags", values);
test = cut_test_new("gcut_assert_equal_flags test", stub_equal_flags);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 1, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"gcut_assert_equal_flags test",
NULL,
"<(1 << 1) | (1 << 2) == (1 << 3)> (flags_type)",
"#<CuttestAssertStubFlags: "
"second|third "
"(CUTTEST_ASSERT_STUB_SECOND:0x2)|"
"(CUTTEST_ASSERT_STUB_THIRD:0x4)>",
"#<CuttestAssertStubFlags: (unknown flags: 0x8)>",
FAIL_LOCATION,
FUNCTION("stub_equal_flags"),
NULL);
}
void
test_equal_object_null (void)
{
const gchar *inspected_expected;
test = cut_test_new("gcut_assert_equal_object_null test",
stub_equal_object_null);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 0, 0, 1, 0, 0, 0, 0);
inspected_expected = cut_take_printf("#<CutLoader:%p "
"so-filename=<\"so-name\">, "
"base-directory=<NULL>>",
object1);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"gcut_assert_equal_object_null test",
NULL,
"<object1 == NULL>",
inspected_expected, "(null)",
FAIL_LOCATION,
FUNCTION("stub_equal_object_null"),
NULL);
}
void
test_equal_object_custom (void)
{
const gchar *inspected_expected, *inspected_actual;
test = cut_test_new("gcut_assert_equal_object_custom test",
stub_equal_object_custom);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 1, 0, 1, 0, 0, 0, 0);
inspected_expected = cut_take_printf("#<CutTest:%p "
"name=<\"test-name\">, "
"element-name=<\"test\">, "
"test-function=<NULL>, "
"base-directory=<NULL>>",
object1);
inspected_actual = cut_take_printf("#<CutTest:%p "
"name=<\"no-name\">, "
"element-name=<\"test\">, "
"test-function=<NULL>, "
"base-directory=<NULL>>",
object3);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"gcut_assert_equal_object_custom test",
NULL,
"<equal_name(object1, object3)>",
inspected_expected, inspected_actual,
FAIL_LOCATION,
FUNCTION("stub_equal_object_custom"),
NULL);
}
static void
stub_equal_list_object (void)
{
need_to_free_list_contents = TRUE;
list_element_free_function = g_object_unref_with_null_check;
list1 = g_list_append(list1, cut_repository_new("directory1"));
list1 = g_list_append(list1, NULL);
list1 = g_list_append(list1, cut_test_new("test1", NULL));
list2 = g_list_append(list2, cut_repository_new("directory2"));
list2 = g_list_append(list2, NULL);
list2 = g_list_append(list2, cut_test_new("test2", NULL));
gcut_assert_equal_list_object(list1, list1);
gcut_assert_equal_list_object(list2, list2);
MARK_FAIL(gcut_assert_equal_list_object(list1, list2));
}
void
test_equal_list_string_both_null (void)
{
test = cut_test_new("equal_list_string test (both NULL)",
stub_equal_list_string_both_null);
cut_assert_not_null(test);
cut_assert_true(run());
cut_assert_test_result_summary(run_context, 1, 3, 1, 0, 0, 0, 0, 0);
}
void
cuttest_add_test (CutTestCase *test_case, const gchar *test_name,
CutTestFunction test_function)
{
CutTest *test;
test = cut_test_new(test_name, test_function);
cut_test_case_add_test(test_case, test);
g_object_unref(test);
}
void
test_not_equal_uint64 (void)
{
test = cut_test_new("cut_assert_not_equal_uint64()", stub_not_equal_uint64);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"cut_assert_not_equal_uint64()", NULL,
"<G_MAXUINT64 != G_MAXUINT64>",
"18446744073709551615", "18446744073709551615",
FAIL_LOCATION,
FUNCTION("stub_not_equal_uint64"),
NULL);
}
void
test_not_equal_int64 (void)
{
test = cut_test_new("cut_assert_not_equal_int64()", stub_not_equal_int64);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"cut_assert_not_equal_int64()", NULL,
"<G_MAXINT64 != G_MAXINT64>",
"9223372036854775807", "9223372036854775807",
FAIL_LOCATION,
FUNCTION("stub_not_equal_int64"),
NULL);
}
void
test_not_equal_pid (void)
{
test = cut_test_new("cut_assert_not_equal_pid()", stub_not_equal_pid);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 1, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"cut_assert_not_equal_pid()", NULL,
"<0 != 0>",
"0", "0",
FAIL_LOCATION,
FUNCTION("stub_not_equal_pid"),
NULL);
}
void
test_report_notification (void)
{
const gchar *expected_template =
" <result>\n"
" <test-case>\n"
" <name>stub test case</name>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </test-case>\n"
" <test>\n"
" <name>stub-notification-test</name>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </test>\n"
" <status>notification</status>\n"
" <detail>This test has been notifable ever!</detail>\n"
" <backtrace>\n"
" <entry>\n"
" <file>" __FILE__ "</file>\n"
" <line>0</line>\n"
" <info>" FUNCTION("stub_notification_test") ": "
"cut_notify("This test has been "
"notifable ever!")"
"</info>\n"
" </entry>\n"
" </backtrace>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </result>\n";
const gchar *expected;
gchar *result;
const gchar *normalized_result;
test = cut_test_new("stub-notification-test", stub_notification_test);
g_signal_connect_after(test, "notification",
G_CALLBACK(cb_test_signal), NULL);
cut_test_case_add_test(test_case, test);
cut_assert_true(run());
g_signal_handlers_disconnect_by_func(test,
G_CALLBACK(cb_test_signal),
NULL);
expected = fill_fail_line(expected_template);
result = cut_report_get_notification_results(report);
normalized_result = normalize_result(result);
g_free(result);
cut_assert_equal_string(expected, normalized_result);
}
void
test_report_success (void)
{
gchar expected[] =
" <result>\n"
" <test-case>\n"
" <name>stub test case</name>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </test-case>\n"
" <test>\n"
" <name>stub-success-test</name>\n"
" <description>A success test</description>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" <option>\n"
" <name>price</name>\n"
" <value>$199</value>\n"
" </option>\n"
" <option>\n"
" <name>bug</name>\n"
" <value>1234</value>\n"
" </option>\n"
" </test>\n"
" <status>success</status>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </result>\n";
gchar *result;
const gchar *normalized_result;
test = cut_test_new("stub-success-test", stub_success_test);
cut_test_set_attribute(test, "description", "A success test");
cut_test_set_attribute(test, "bug", "1234");
cut_test_set_attribute(test, "price", "$199");
g_signal_connect_after(test, "success",
G_CALLBACK(cb_test_signal), NULL);
cut_test_case_add_test(test_case, test);
cut_assert_true(run());
g_signal_handlers_disconnect_by_func(test,
G_CALLBACK(cb_test_signal),
NULL);
result = cut_report_get_success_results(report);
normalized_result = normalize_result(result);
g_free(result);
cut_assert_equal_string(expected, normalized_result);
}
void
cut_setup (void)
{
context = cut_test_context_new_empty();
test_suite = cut_test_suite_new_empty();
test_case = cut_test_case_new("my-test-case",
NULL, NULL,
NULL, NULL);
test_iterator = cut_test_iterator_new("my-test-iterator", NULL, NULL);
test = cut_test_new("my-test", NULL);
test_data = NULL;
destroy_called = FALSE;
destroyed_string = NULL;
pipeline = NULL;
}
void
test_equal_type (void)
{
test = cut_test_new("equal_type test", stub_equal_type);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 1, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_type test",
NULL,
"<G_TYPE_INT == G_TYPE_STRING>",
"gint", "gchararray",
FAIL_LOCATION,
FUNCTION("stub_equal_type"),
NULL);
}
void
test_equal_error (void)
{
test = cut_test_new("gcut_assert_equal_error test", stub_equal_error);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 1, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"gcut_assert_equal_error test",
NULL,
"<error1 == error2>",
"g-file-error-quark:4: not found",
"g-file-error-quark:4: no entry",
FAIL_LOCATION,
FUNCTION("stub_equal_error"),
NULL);
}
void
test_equal_value (void)
{
test = cut_test_new("equal_value test", stub_equal_value);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_value test",
NULL,
"<value1 == value2>",
"10 (gint)",
"\"String\" (gchararray)",
FAIL_LOCATION,
FUNCTION("stub_equal_value"),
NULL);
}
void
test_equal_list_uint (void)
{
test = cut_test_new("equal_list_uint test", stub_equal_list_uint);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_list_uint test",
NULL,
"<list1 == list2>",
"(100, 200)",
"(1000, 2000)",
FAIL_LOCATION,
FUNCTION("stub_equal_list_uint"),
NULL);
}
void
test_error (void)
{
test = cut_test_new("gcut_assert_error test", stub_error);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 1, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"gcut_assert_error test",
NULL,
"expected: <error> is NULL\n"
" actual: <g-file-error-quark:4: not found>",
NULL, NULL,
FAIL_LOCATION,
FUNCTION("stub_error"),
NULL);
}
void
test_equal_list_string (void)
{
test = cut_test_new("equal_list_string test", stub_equal_list_string);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_list_string test",
NULL,
"<list1 == list2>",
"(\"abc\", \"def\")",
"(\"zyx\", \"wvu\")",
FAIL_LOCATION,
FUNCTION("stub_equal_list_string"),
NULL);
}
void
test_equal_list (void)
{
test = cut_test_new("equal_list test", stub_equal_list);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(
run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_list test",
NULL,
"<stub_equal_list_equal_func(list1[i], list2[i]) == TRUE>",
"(CCC: <100>, CCC: <-200>)",
"(CCC: <-1000>, CCC: <2000>)",
FAIL_LOCATION,
FUNCTION("stub_equal_list"),
NULL);
}
void
test_equal_hash_table_string_string (void)
{
test = cut_test_new("equal_hash_table_string_string test",
stub_equal_hash_table_string_string);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_hash_table_string_string test",
NULL,
"<hash1 == hash2>",
"{\"abc\" => \"11\", \"def\" => \"22\"}",
"{\"wvu\" => \"88\", \"zyx\" => \"99\"}",
FAIL_LOCATION,
FUNCTION("stub_equal_hash_table_string_string"),
NULL);
}
void
test_equal_hash_table (void)
{
test = cut_test_new("equal_hash_table test",
stub_equal_hash_table);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_hash_table test",
NULL,
"<g_str_equal(hash1[key], hash2[key]) == TRUE>",
"{1 => \"11\", 10 => \"22\"}",
"{2 => \"99\", 20 => \"88\"}",
FAIL_LOCATION,
FUNCTION("stub_equal_hash_table"),
NULL);
}
void
test_equal_enum (void)
{
test = cut_test_new("gcut_assert_equal_enum test", stub_equal_enum);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 1, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(
run_context, 0, CUT_TEST_RESULT_FAILURE,
"gcut_assert_equal_enum test",
NULL,
"<CUT_TEST_RESULT_FAILURE == CUT_TEST_RESULT_PENDING>"
" (CUT_TYPE_TEST_RESULT_STATUS)",
"#<CutTestResultStatus: failure(CUT_TEST_RESULT_FAILURE:4)>",
"#<CutTestResultStatus: pending(CUT_TEST_RESULT_PENDING:3)>",
FAIL_LOCATION,
FUNCTION("stub_equal_enum"),
NULL);
}
void
test_equal_list_flags (void)
{
const gchar inspected_expected[] =
"(#<CuttestAssertListStubFlags: "
"first|second "
"(CUTTEST_ASSERT_LIST_STUB_FIRST:0x1)|"
"(CUTTEST_ASSERT_LIST_STUB_SECOND:0x2)>, "
"#<CuttestAssertListStubFlags: "
"third (CUTTEST_ASSERT_LIST_STUB_THIRD:0x4)>)";
const gchar inspected_actual[] =
"(#<CuttestAssertListStubFlags>)";
static const GFlagsValue values[] = {
{1 << 0, "CUTTEST_ASSERT_LIST_STUB_FIRST", "first"},
{1 << 1, "CUTTEST_ASSERT_LIST_STUB_SECOND", "second"},
{1 << 2, "CUTTEST_ASSERT_LIST_STUB_THIRD", "third"},
{0, NULL, NULL}
};
flags_type = g_flags_register_static("CuttestAssertListStubFlags", values);
test = cut_test_new("equal_list_flags test", stub_equal_list_flags);
cut_assert_not_null(test);
cut_assert_false(run());
cut_assert_test_result_summary(run_context, 1, 2, 0, 1, 0, 0, 0, 0);
cut_assert_test_result(run_context, 0, CUT_TEST_RESULT_FAILURE,
"equal_list_flags test",
NULL,
"<list1 == list2>",
inspected_expected, inspected_actual,
FAIL_LOCATION,
FUNCTION("stub_equal_list_flags"),
NULL);
}
void
test_plural_reports (void)
{
const gchar *expected_template =
" <result>\n"
" <test-case>\n"
" <name>stub test case</name>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </test-case>\n"
" <test>\n"
" <name>stub-success-test</name>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </test>\n"
" <status>success</status>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </result>\n"
" <result>\n"
" <test-case>\n"
" <name>stub test case</name>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </test-case>\n"
" <test>\n"
" <name>stub-error-test</name>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </test>\n"
" <status>error</status>\n"
" <detail>This test should error</detail>\n"
" <backtrace>\n"
" <entry>\n"
" <file>" __FILE__ "</file>\n"
" <line>0</line>\n"
" <info>" FUNCTION("stub_error_test") ": "
"cut_error("This test should error")"
"</info>\n"
" </entry>\n"
" </backtrace>\n"
" <start-time>1970-01-01T00:00:00Z</start-time>\n"
" <elapsed>0.0</elapsed>\n"
" </result>\n";
const gchar *expected;
gchar *result;
const gchar *normalized_result;
test = cut_test_new("stub-success-test", stub_success_test);
g_signal_connect_after(test, "success",
G_CALLBACK(cb_test_signal), NULL);
cut_test_case_add_test(test_case, test);
test = cut_test_new("stub-error-test", stub_error_test);
g_signal_connect_after(test, "error",
G_CALLBACK(cb_test_signal), NULL);
cut_test_case_add_test(test_case, test);
cut_assert_false(cut_test_runner_run_test_case(CUT_TEST_RUNNER(run_context),
test_case));
g_signal_handlers_disconnect_by_func(test,
G_CALLBACK(cb_test_signal),
NULL);
expected = fill_fail_line(expected_template);
result = cut_report_get_all_results(report);
normalized_result = normalize_result(result);
g_free(result);
cut_assert_equal_string(expected, normalized_result);
}
