/*
* Check: a unit test framework for C
* Copyright (C) 2001, 2002 Arien Malec
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
* MA 02110-1301, USA.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <check.h>
#include "config.h"
START_TEST(test_pass)
{
ck_assert_msg(1 == 1, "Shouldn't see this");
}
END_TEST
START_TEST(test_fail)
{
ck_abort_msg("Failure");
}
END_TEST
/*
* This test will fail without fork, as it will result in the
* unit test runniner exiting early.
*/
#if defined(HAVE_FORK) && HAVE_FORK==1
START_TEST(test_exit)
{
exit(1);
}
END_TEST
#endif /* HAVE_FORK */
/*
* This test will intentionally mess up the unit testing program
* when fork is unavailable. The purpose of including it is to
* ensure that the tap output is correct when a test crashes.
*/
START_TEST(test_abort)
{
exit(1);
}
END_TEST
START_TEST(test_pass2)
{
ck_assert_msg(1 == 1, "Shouldn't see this");
}
END_TEST
START_TEST(test_loop)
{
ck_assert_msg(_i == 1, "Iteration %d failed", _i);
}
END_TEST
START_TEST(test_xml_esc_fail_msg)
{
ck_abort_msg("fail \" ' < > & \x9 \xA" "X""\x08"" message"); /* backspace char \x08 deletes the X */
}
END_TEST
static Suite *make_log1_suite(void)
{
Suite *s;
TCase *tc;
s = suite_create("S1");
tc = tcase_create("Core");
suite_add_tcase(s, tc);
tcase_add_test(tc, test_pass);
tcase_add_test(tc, test_fail);
#if defined(HAVE_FORK) && HAVE_FORK==1
tcase_add_test(tc, test_exit);
#endif /* HAVE_FORK */
return s;
}
static Suite *make_log2_suite(int include_exit_test)
{
Suite *s;
TCase *tc;
s = suite_create("S2");
tc = tcase_create("Core");
suite_add_tcase(s, tc);
if(include_exit_test == 1)
{
tcase_add_test(tc, test_abort);
}
tcase_add_test(tc, test_pass2);
tcase_add_loop_test(tc, test_loop, 0, 3);
return s;
}
/* check that XML special characters are properly escaped in XML log file */
static Suite *make_xml_esc_suite(void)
{
Suite *s;
TCase *tc;
s = suite_create("XML escape \" ' < > & \x9 \xA" "X""\x08"" tests"); /* backspace char \x08 deletes the X */
tc = tcase_create("description \" ' < > & \x9 \xA" "X""\x08"" end"); /* backspace char \x08 deletes the X */
suite_add_tcase(s, tc);
tcase_add_test(tc, test_xml_esc_fail_msg);
return s;
}
static void print_usage(void)
{
printf("Usage: ex_output (CK_SILENT | CK_MINIMAL | CK_NORMAL | CK_VERBOSE | CK_ENV");
#if ENABLE_SUBUNIT
printf(" | CK_SUBUNIT");
#endif
printf(")\n");
printf(" (STDOUT | STDOUT_DUMP | LOG | LOG_STDOUT | TAP | TAP_STDOUT | XML | XML_STDOUT)\n");
printf(" (NORMAL | EXIT_TEST)\n");
printf(" If CK_ENV is used, the environment variable CK_VERBOSITY can be set to\n");
printf(" one of these: silent, minimal, or verbose. If it is not set to these, or\n");
printf(" if CK_VERBOSITY is not set, then CK_NORMAL will be used\n");
printf(" If testing the CK_[LOG|TAP_LOG|XML_LOG]_FILE_NAME env var and setting it to '-',\n");
printf(" then use the following mode: CK_SILENT STDOUT [NORMAL|EXIT_TEST].\n");
}
static void run_tests(enum print_output printmode, char *log_type, int include_exit_test)
{
SRunner *sr;
int dump_everything_to_stdout = 0;
sr = srunner_create(make_log1_suite());
srunner_add_suite(sr, make_log2_suite(include_exit_test));
srunner_add_suite(sr, make_xml_esc_suite());
if(strcmp(log_type, "STDOUT") == 0)
{
/* Nothing else to do here */
}
else if(strcmp(log_type, "STDOUT_DUMP") == 0)
{
/*
* Dump each type to stdout, in addition to printing out
* the configured print level.
*/
dump_everything_to_stdout = 1;
}
else if(strcmp(log_type, "LOG") == 0)
{
srunner_set_log(sr, "test.log");
}
else if(strcmp(log_type, "LOG_STDOUT") == 0)
{
srunner_set_log(sr, "-");
}
else if(strcmp(log_type, "TAP") == 0)
{
srunner_set_tap(sr, "test.tap");
}
else if(strcmp(log_type, "TAP_STDOUT") == 0)
{
srunner_set_tap(sr, "-");
}
else if(strcmp(log_type, "XML") == 0)
{
srunner_set_xml(sr, "test.xml");
}
else if(strcmp(log_type, "XML_STDOUT") == 0)
{
srunner_set_xml(sr, "-");
}
else
{
print_usage();
exit(EXIT_FAILURE);
}
srunner_run_all(sr, printmode);
if(dump_everything_to_stdout)
{
srunner_print(sr, CK_SILENT);
srunner_print(sr, CK_MINIMAL);
srunner_print(sr, CK_NORMAL);
srunner_print(sr, CK_VERBOSE);
srunner_print(sr, CK_ENV);
#if ENABLE_SUBUNIT
/*
* Note that this call does not contribute anything, as
* subunit is not fully considered an 'output mode'.
*/
srunner_print(sr, CK_SUBUNIT);
#endif
}
srunner_free(sr);
}
#define OUTPUT_TYPE_ARG 1
#define LOG_TYPE_ARG 2
#define INCLUDE_EXIT_TEST_ARG 3
int main(int argc, char **argv)
{
enum print_output printmode;
int include_exit_test;
if(argc != 4)
{
print_usage();
return EXIT_FAILURE;
}
if(strcmp(argv[OUTPUT_TYPE_ARG], "CK_SILENT") == 0)
{
printmode = CK_SILENT;
}
else if(strcmp(argv[OUTPUT_TYPE_ARG], "CK_MINIMAL") == 0)
{
printmode = CK_MINIMAL;
}
else if(strcmp(argv[OUTPUT_TYPE_ARG], "CK_NORMAL") == 0)
{
printmode = CK_NORMAL;
}
else if(strcmp(argv[OUTPUT_TYPE_ARG], "CK_VERBOSE") == 0)
{
printmode = CK_VERBOSE;
}
else if(strcmp(argv[OUTPUT_TYPE_ARG], "CK_ENV") == 0)
{
printmode = CK_ENV;
}
#if ENABLE_SUBUNIT
else if(strcmp(argv[OUTPUT_TYPE_ARG], "CK_SUBUNIT") == 0)
{
printmode = CK_SUBUNIT;
}
#endif
else
{
print_usage();
return EXIT_FAILURE;
}
if(strcmp(argv[INCLUDE_EXIT_TEST_ARG], "NORMAL") == 0)
{
include_exit_test = 0;
}
else if(strcmp(argv[INCLUDE_EXIT_TEST_ARG], "EXIT_TEST") == 0)
{
include_exit_test = 1;
}
else
{
print_usage();
return EXIT_FAILURE;
}
run_tests(printmode, argv[LOG_TYPE_ARG], include_exit_test);
return EXIT_SUCCESS;
}