Author: Adam Majer PR: https://github.com/boostorg/test/pull/108 Summary: Change capital variable names to lowercase Capitals clash by convention with #define, and in this case VERSION clashes with GNU Autotools. Index: boost_1_63_0/boost/test/impl/unit_test_parameters.ipp =================================================================== --- boost_1_63_0.orig/boost/test/impl/unit_test_parameters.ipp +++ boost_1_63_0/boost/test/impl/unit_test_parameters.ipp @@ -71,35 +71,35 @@ namespace rt = boost::runtime; namespace runtime_config { // UTF parameters -std::string AUTO_START_DBG = "auto_start_dbg"; -std::string BREAK_EXEC_PATH = "break_exec_path"; -std::string BUILD_INFO = "build_info"; -std::string CATCH_SYS_ERRORS = "catch_system_errors"; -std::string COLOR_OUTPUT = "color_output"; -std::string DETECT_FP_EXCEPT = "detect_fp_exceptions"; -std::string DETECT_MEM_LEAKS = "detect_memory_leaks"; -std::string LIST_CONTENT = "list_content"; -std::string LIST_LABELS = "list_labels"; -std::string LOG_FORMAT = "log_format"; -std::string LOG_LEVEL = "log_level"; -std::string LOG_SINK = "log_sink"; -std::string COMBINED_LOGGER = "logger"; -std::string OUTPUT_FORMAT = "output_format"; -std::string RANDOM_SEED = "random"; -std::string REPORT_FORMAT = "report_format"; -std::string REPORT_LEVEL = "report_level"; -std::string REPORT_MEM_LEAKS = "report_memory_leaks_to"; -std::string REPORT_SINK = "report_sink"; -std::string RESULT_CODE = "result_code"; -std::string RUN_FILTERS = "run_test"; -std::string SAVE_TEST_PATTERN = "save_pattern"; -std::string SHOW_PROGRESS = "show_progress"; -std::string USE_ALT_STACK = "use_alt_stack"; -std::string WAIT_FOR_DEBUGGER = "wait_for_debugger"; - -std::string HELP = "help"; -std::string USAGE = "usage"; -std::string VERSION = "version"; +std::string auto_start_dbg_str = "auto_start_dbg"; +std::string break_exec_path_str = "break_exec_path"; +std::string build_info_str = "build_info"; +std::string catch_sys_errors_str = "catch_system_errors"; +std::string color_output_str = "color_output"; +std::string detect_fp_except_str = "detect_fp_exceptions"; +std::string detect_mem_leaks_str = "detect_memory_leaks"; +std::string list_content_str = "list_content"; +std::string list_labels_str = "list_labels"; +std::string log_format_str = "log_format"; +std::string log_level_str = "log_level"; +std::string log_sink_str = "log_sink"; +std::string combined_logger_str = "logger"; +std::string output_format_str = "output_format"; +std::string random_seed_str = "random"; +std::string report_format_str = "report_format"; +std::string report_level_str = "report_level"; +std::string report_mem_leaks_str = "report_memory_leaks_to"; +std::string report_sink_str = "report_sink"; +std::string result_code_str = "result_code"; +std::string run_filters_str = "run_test"; +std::string save_test_pattern_str = "save_pattern"; +std::string show_progress_str = "show_progress"; +std::string use_alt_stack_str = "use_alt_stack"; +std::string wait_for_debugger_str = "wait_for_debugger"; + +std::string help_str = "help"; +std::string usage_str = "usage"; +std::string version_str = "version"; //____________________________________________________________________________// @@ -108,11 +108,11 @@ namespace { void register_parameters( rt::parameters_store& store ) { - rt::option auto_start_dbg( AUTO_START_DBG, ( + rt::option auto_start_dbg( auto_start_dbg_str, ( rt::description = "Automatically attaches debugger in case of system level failure (signal).", rt::env_var = "BOOST_TEST_AUTO_START_DBG", - rt::help = "Option " + AUTO_START_DBG + " specifies whether Boost.Test should attempt " + rt::help = "Option " + auto_start_dbg_str + " specifies whether Boost.Test should attempt " "to attach a debugger when fatal system error occurs. At the moment this feature " "is only available on a few selected platforms: Win32 and *nix. There is a " "default debugger configured for these platforms. You can manually configure " @@ -120,13 +120,13 @@ register_parameters( rt::parameters_stor "Boost.Test debug API, specifically the function boost::debug::set_debugger." )); - auto_start_dbg.add_cla_id( "--", AUTO_START_DBG, "=" ); + auto_start_dbg.add_cla_id( "--", auto_start_dbg_str, "=" ); auto_start_dbg.add_cla_id( "-", "d", " " ); store.add( auto_start_dbg ); /////////////////////////////////////////////// - rt::parameter break_exec_path( BREAK_EXEC_PATH, ( + rt::parameter break_exec_path( break_exec_path_str, ( rt::description = "For the exception safety testing allows to break at specific execution path.", rt::env_var = "BOOST_TEST_BREAK_EXEC_PATH" #ifndef BOOST_NO_CXX11_LAMBDAS @@ -137,25 +137,25 @@ register_parameters( rt::parameters_stor #endif )); - break_exec_path.add_cla_id( "--", BREAK_EXEC_PATH, "=" ); + break_exec_path.add_cla_id( "--", break_exec_path_str, "=" ); store.add( break_exec_path ); /////////////////////////////////////////////// - rt::option build_info( BUILD_INFO, ( + rt::option build_info( build_info_str, ( rt::description = "Displays library build information.", rt::env_var = "BOOST_TEST_BUILD_INFO", - rt::help = "Option " + BUILD_INFO + " displays library build information, including: platform, " + rt::help = "Option " + build_info_str + " displays library build information, including: platform, " "compiler, STL version and Boost version." )); - build_info.add_cla_id( "--", BUILD_INFO, "=" ); + build_info.add_cla_id( "--", build_info_str, "=" ); build_info.add_cla_id( "-", "i", " " ); store.add( build_info ); /////////////////////////////////////////////// - rt::option catch_sys_errors( CATCH_SYS_ERRORS, ( + rt::option catch_sys_errors( catch_sys_errors_str, ( rt::description = "Allows to switch between catching and ignoring system errors (signals).", rt::env_var = "BOOST_TEST_CATCH_SYSTEM_ERRORS", rt::default_value = @@ -164,7 +164,7 @@ register_parameters( rt::parameters_stor #else true, #endif - rt::help = "If option " + CATCH_SYS_ERRORS + " has value no the frameworks does not attempt to catch " + rt::help = "If option " + catch_sys_errors_str + " has value no the frameworks does not attempt to catch " "asynchronous system failure events (signals on *NIX platforms or structured exceptions on Windows). " " Default value is " #ifdef BOOST_TEST_DEFAULTS_TO_CORE_DUMP @@ -174,13 +174,13 @@ register_parameters( rt::parameters_stor #endif )); - catch_sys_errors.add_cla_id( "--", CATCH_SYS_ERRORS, "=", true ); + catch_sys_errors.add_cla_id( "--", catch_sys_errors_str, "=", true ); catch_sys_errors.add_cla_id( "-", "s", " " ); store.add( catch_sys_errors ); /////////////////////////////////////////////// - rt::option color_output( COLOR_OUTPUT, ( + rt::option color_output( color_output_str, ( rt::description = "Enables color output of the framework log and report messages.", rt::env_var = "BOOST_TEST_COLOR_OUTPUT", rt::help = "The framework is able to produce color output on systems which supports it. " @@ -188,31 +188,31 @@ register_parameters( rt::parameters_stor "does not produces color output." )); - color_output.add_cla_id( "--", COLOR_OUTPUT, "=", true ); + color_output.add_cla_id( "--", color_output_str, "=", true ); color_output.add_cla_id( "-", "x", " " ); store.add( color_output ); /////////////////////////////////////////////// - rt::option detect_fp_except( DETECT_FP_EXCEPT, ( + rt::option detect_fp_except( detect_fp_except_str, ( rt::description = "Enables/disables floating point exceptions traps.", rt::env_var = "BOOST_TEST_DETECT_FP_EXCEPTIONS", - rt::help = "Option " + DETECT_FP_EXCEPT + " enables/disables hardware traps for the floating " + rt::help = "Option " + detect_fp_except_str + " enables/disables hardware traps for the floating " "point exceptions (if supported on your platfrom)." )); - detect_fp_except.add_cla_id( "--", DETECT_FP_EXCEPT, "=", true ); + detect_fp_except.add_cla_id( "--", detect_fp_except_str, "=", true ); store.add( detect_fp_except ); /////////////////////////////////////////////// - rt::parameter detect_mem_leaks( DETECT_MEM_LEAKS, ( + rt::parameter detect_mem_leaks( detect_mem_leaks_str, ( rt::description = "Turns on/off memory leaks detection (optionally breaking on specified alloc order number).", rt::env_var = "BOOST_TEST_DETECT_MEMORY_LEAK", rt::default_value = 1L, rt::optional_value = 1L, rt::value_hint = "", - rt::help = "Parameter " + DETECT_MEM_LEAKS + " enables/disables memory leaks detection. " + rt::help = "Parameter " + detect_mem_leaks_str + " enables/disables memory leaks detection. " "This parameter has optional long integer value. The default value is 1, which " "enables the memory leak detection. The value 0 disables memory leak detection. " "Any value N greater than 1 is treated as leak allocation number and tells the " @@ -220,12 +220,12 @@ register_parameters( rt::parameters_stor "omitted the default value is assumed." )); - detect_mem_leaks.add_cla_id( "--", DETECT_MEM_LEAKS, "=" ); + detect_mem_leaks.add_cla_id( "--", detect_mem_leaks_str, "=" ); store.add( detect_mem_leaks ); /////////////////////////////////////////////// - rt::enum_parameter list_content( LIST_CONTENT, ( + rt::enum_parameter list_content( list_content_str, ( rt::description = "Lists the content of test tree - names of all test suites and test cases.", rt::env_var = "BOOST_TEST_LIST_CONTENT", rt::default_value = OF_INVALID, @@ -242,30 +242,30 @@ register_parameters( rt::parameters_stor ( "DOT", OF_DOT ) , #endif - rt::help = "Parameter " + LIST_CONTENT + " instructs the framework to list the content " + rt::help = "Parameter " + list_content_str + " instructs the framework to list the content " "of the test module instead of executing the test cases. Parameter accepts " "optional string value indicating the format of the output. Currently the " "framework supports two formats: human readable format (HRF) and dot graph " "format (DOT). If value is omitted HRF value is assumed." )); - list_content.add_cla_id( "--", LIST_CONTENT, "=" ); + list_content.add_cla_id( "--", list_content_str, "=" ); store.add( list_content ); /////////////////////////////////////////////// - rt::option list_labels( LIST_LABELS, ( + rt::option list_labels( list_labels_str, ( rt::description = "Lists all available labels.", rt::env_var = "BOOST_TEST_LIST_LABELS", - rt::help = "Option " + LIST_LABELS + " instructs the framework to list all the the labels " + rt::help = "Option " + list_labels_str + " instructs the framework to list all the the labels " "defined in the test module instead of executing the test cases." )); - list_labels.add_cla_id( "--", LIST_LABELS, "=" ); + list_labels.add_cla_id( "--", list_labels_str, "=" ); store.add( list_labels ); /////////////////////////////////////////////// - rt::enum_parameter log_format( LOG_FORMAT, ( + rt::enum_parameter log_format( log_format_str, ( rt::description = "Specifies log format.", rt::env_var = "BOOST_TEST_LOG_FORMAT", rt::default_value = OF_CLF, @@ -285,7 +285,7 @@ register_parameters( rt::parameters_stor ( "JUNIT", OF_JUNIT ) , #endif - rt::help = "Parameter " + LOG_FORMAT + " allows to set the frameowrk's log format to one " + rt::help = "Parameter " + log_format_str + " allows to set the frameowrk's log format to one " "of the formats supplied by the framework. The only acceptable values for this " "parameter are the names of the output formats supplied by the framework. By " "default the framework uses human readable format (HRF) for testing log. This " @@ -293,13 +293,13 @@ register_parameters( rt::parameters_stor "or JUNIT as log format, which are easier to process by testing automation tools." )); - log_format.add_cla_id( "--", LOG_FORMAT, "=" ); + log_format.add_cla_id( "--", log_format_str, "=" ); log_format.add_cla_id( "-", "f", " " ); store.add( log_format ); /////////////////////////////////////////////// - rt::enum_parameter log_level( LOG_LEVEL, ( + rt::enum_parameter log_level( log_level_str, ( rt::description = "Specifies log level.", rt::env_var = "BOOST_TEST_LOG_LEVEL", rt::default_value = log_all_errors, @@ -333,7 +333,7 @@ register_parameters( rt::parameters_stor ( "nothing" , log_nothing ) , #endif - rt::help = "Parameter " + LOG_LEVEL + " allows to set the framework's log level. " + rt::help = "Parameter " + log_level_str + " allows to set the framework's log level. " "Log level defines the verbosity of testing log produced by a testing " "module. The verbosity ranges from a complete log, when all assertions " "(both successful and failing) are reported, all notifications about " @@ -341,29 +341,29 @@ register_parameters( rt::parameters_stor "is reported to a testing log stream." )); - log_level.add_cla_id( "--", LOG_LEVEL, "=" ); + log_level.add_cla_id( "--", log_level_str, "=" ); log_level.add_cla_id( "-", "l", " " ); store.add( log_level ); /////////////////////////////////////////////// - rt::parameter log_sink( LOG_SINK, ( + rt::parameter log_sink( log_sink_str, ( rt::description = "Specifies log sink: stdout(default), stderr or file name.", rt::env_var = "BOOST_TEST_LOG_SINK", rt::value_hint = "", - rt::help = "Parameter " + LOG_SINK + " allows to set the log sink - location " + rt::help = "Parameter " + log_sink_str + " allows to set the log sink - location " "where we report the log to, thus it allows to easily redirect the " "test logs to file or standard streams. By default testing log is " "directed to standard output." )); - log_sink.add_cla_id( "--", LOG_SINK, "=" ); + log_sink.add_cla_id( "--", log_sink_str, "=" ); log_sink.add_cla_id( "-", "k", " " ); store.add( log_sink ); /////////////////////////////////////////////// - rt::enum_parameter output_format( OUTPUT_FORMAT, ( + rt::enum_parameter output_format( output_format_str, ( rt::description = "Specifies output format (both log and report).", rt::env_var = "BOOST_TEST_OUTPUT_FORMAT", rt::enum_values::value = @@ -380,8 +380,8 @@ register_parameters( rt::parameters_stor ( "XML", OF_XML ) , #endif - rt::help = "Parameter " + OUTPUT_FORMAT + " combines an effect of " + REPORT_FORMAT + - " and " + LOG_FORMAT + " parameters. This parameter has higher priority " + rt::help = "Parameter " + output_format_str + " combines an effect of " + report_format_str + + " and " + log_format_str + " parameters. This parameter has higher priority " "than either one of them. In other words if this parameter is specified " "it overrides the value of other two parameters. This parameter does not " "have a default value. The only acceptable values are string names of " @@ -389,33 +389,33 @@ register_parameters( rt::parameters_stor "automation tools processing." )); - output_format.add_cla_id( "--", OUTPUT_FORMAT, "=" ); + output_format.add_cla_id( "--", output_format_str, "=" ); output_format.add_cla_id( "-", "o", " " ); store.add( output_format ); /////////////////////////////////////////////// combined logger option - rt::parameter combined_logger( COMBINED_LOGGER, ( + rt::parameter combined_logger( combined_logger_str, ( rt::description = "Specifies log level and sink for one or several log format", rt::env_var = "BOOST_TEST_LOGGER", rt::value_hint = "log_format:log_level:log_sink", - rt::help = "Parameter " + COMBINED_LOGGER + " allows to specify the logger type, level and sink\n" + rt::help = "Parameter " + combined_logger_str + " allows to specify the logger type, level and sink\n" "in one command." )); - combined_logger.add_cla_id( "--", COMBINED_LOGGER, "=" ); + combined_logger.add_cla_id( "--", combined_logger_str, "=" ); store.add( combined_logger ); /////////////////////////////////////////////// - rt::parameter random_seed( RANDOM_SEED, ( + rt::parameter random_seed( random_seed_str, ( rt::description = "Allows to switch between sequential and random order of test units execution." " Optionally allows to specify concrete seed for random number generator.", rt::env_var = "BOOST_TEST_RANDOM", rt::default_value = 0U, rt::optional_value = 1U, rt::value_hint = "", - rt::help = "Parameter " + RANDOM_SEED + " instructs the framework to execute the " + rt::help = "Parameter " + random_seed_str + " instructs the framework to execute the " "test cases in random order. This parameter accepts optional unsigned " "integer argument. By default test cases are executed in some specific " "order defined by order of test units in test files and dependency between " @@ -425,12 +425,12 @@ register_parameters( rt::parameters_stor "the run." )); - random_seed.add_cla_id( "--", RANDOM_SEED, "=" ); + random_seed.add_cla_id( "--", random_seed_str, "=" ); store.add( random_seed ); /////////////////////////////////////////////// - rt::enum_parameter report_format( REPORT_FORMAT, ( + rt::enum_parameter report_format( report_format_str, ( rt::description = "Specifies report format.", rt::env_var = "BOOST_TEST_REPORT_FORMAT", rt::default_value = OF_CLF, @@ -448,7 +448,7 @@ register_parameters( rt::parameters_stor ( "XML", OF_XML ) , #endif - rt::help = "Parameter " + REPORT_FORMAT + " allows to set the framework's report format " + rt::help = "Parameter " + report_format_str + " allows to set the framework's report format " "to one of the formats supplied by the framework. The only acceptable values " "for this parameter are the names of the output formats. By default the framework " "uses human readable format (HRF) for results reporting. Alternatively you can " @@ -456,13 +456,13 @@ register_parameters( rt::parameters_stor "automation tools." )); - report_format.add_cla_id( "--", REPORT_FORMAT, "=" ); + report_format.add_cla_id( "--", report_format_str, "=" ); report_format.add_cla_id( "-", "m", " " ); store.add( report_format ); /////////////////////////////////////////////// - rt::enum_parameter report_level( REPORT_LEVEL, ( + rt::enum_parameter report_level( report_level_str, ( rt::description = "Specifies report level.", rt::env_var = "BOOST_TEST_REPORT_LEVEL", rt::default_value = CONFIRMATION_REPORT, @@ -482,155 +482,155 @@ register_parameters( rt::parameters_stor ( "no", NO_REPORT ) , #endif - rt::help = "Parameter " + REPORT_LEVEL + " allows to set the verbosity level of the " + rt::help = "Parameter " + report_level_str + " allows to set the verbosity level of the " "testing result report generated by the framework. Use value 'no' to " "eliminate the results report completely." )); - report_level.add_cla_id( "--", REPORT_LEVEL, "=" ); + report_level.add_cla_id( "--", report_level_str, "=" ); report_level.add_cla_id( "-", "r", " " ); store.add( report_level ); /////////////////////////////////////////////// - rt::parameter report_mem_leaks( REPORT_MEM_LEAKS, ( + rt::parameter report_mem_leaks( report_mem_leaks_str, ( rt::description = "File where to report memory leaks to.", rt::env_var = "BOOST_TEST_REPORT_MEMORY_LEAKS_TO", rt::default_value = std::string(), rt::value_hint = "", - rt::help = "Parameter " + REPORT_MEM_LEAKS + " allows to specify a file where to report " + rt::help = "Parameter " + report_mem_leaks_str + " allows to specify a file where to report " "memory leaks to. The parameter does not have default value. If it is not specified, " "memory leaks (if any) are reported to the standard error stream." )); - report_mem_leaks.add_cla_id( "--", REPORT_MEM_LEAKS, "=" ); + report_mem_leaks.add_cla_id( "--", report_mem_leaks_str, "=" ); store.add( report_mem_leaks ); /////////////////////////////////////////////// - rt::parameter report_sink( REPORT_SINK, ( + rt::parameter report_sink( report_sink_str, ( rt::description = "Specifies report sink: stderr(default), stdout or file name.", rt::env_var = "BOOST_TEST_REPORT_SINK", rt::value_hint = "", - rt::help = "Parameter " + REPORT_SINK + " allows to set the result report sink - " + rt::help = "Parameter " + report_sink_str + " allows to set the result report sink - " "the location where the framework writes the result report to, thus it " "allows to easily redirect the result report to a file or a standard " "stream. By default the testing result report is directed to the " "standard error stream." )); - report_sink.add_cla_id( "--", REPORT_SINK, "=" ); + report_sink.add_cla_id( "--", report_sink_str, "=" ); report_sink.add_cla_id( "-", "e", " " ); store.add( report_sink ); /////////////////////////////////////////////// - rt::option result_code( RESULT_CODE, ( + rt::option result_code( result_code_str, ( rt::description = "Disables test modules's result code generation.", rt::env_var = "BOOST_TEST_RESULT_CODE", rt::default_value = true, - rt::help = "The 'no' argument value for the parameter " + RESULT_CODE + " instructs the " + rt::help = "The 'no' argument value for the parameter " + result_code_str + " instructs the " "framework to always return zero result code. This can be used for test programs " "executed within IDE. By default this parameter has value 'yes'." )); - result_code.add_cla_id( "--", RESULT_CODE, "=", true ); + result_code.add_cla_id( "--", result_code_str, "=", true ); result_code.add_cla_id( "-", "c", " " ); store.add( result_code ); /////////////////////////////////////////////// - rt::parameter tests_to_run( RUN_FILTERS, ( + rt::parameter tests_to_run( run_filters_str, ( rt::description = "Filters, which test units to include or exclude from test module execution.", rt::env_var = "BOOST_TEST_RUN_FILTERS", rt::value_hint = "", - rt::help = "Parameter " + RUN_FILTERS + " allows to filter which test units to execute during " + rt::help = "Parameter " + run_filters_str + " allows to filter which test units to execute during " "testing. The framework supports both 'selection filters', which allow to select " "which test units to enable from the set of available test units, and 'disabler " "filters', which allow to disable some test units. The __UTF__ also supports " "enabling/disabling test units at compile time. These settings identify the default " - "set of test units to run. Parameter " + RUN_FILTERS + " is used to change this default. " + "set of test units to run. Parameter " + run_filters_str + " is used to change this default. " "This parameter is repeatable, so you can specify more than one filter if necessary." )); - tests_to_run.add_cla_id( "--", RUN_FILTERS, "=" ); + tests_to_run.add_cla_id( "--", run_filters_str, "=" ); tests_to_run.add_cla_id( "-", "t", " " ); store.add( tests_to_run ); /////////////////////////////////////////////// - rt::option save_test_pattern( SAVE_TEST_PATTERN, ( + rt::option save_test_pattern( save_test_pattern_str, ( rt::description = "Allows to switch between saving or matching test pattern file.", rt::env_var = "BOOST_TEST_SAVE_PATTERN", - rt::help = "Parameter " + SAVE_TEST_PATTERN + " facilitates switching mode of operation for " + rt::help = "Parameter " + save_test_pattern_str + " facilitates switching mode of operation for " "testing output streams.\n\nThis parameter serves no particular purpose within the " "framework itself. It can be used by test modules relying on output_test_stream to " "implement testing logic. Default mode is 'match' (false)." )); - save_test_pattern.add_cla_id( "--", SAVE_TEST_PATTERN, "=" ); + save_test_pattern.add_cla_id( "--", save_test_pattern_str, "=" ); store.add( save_test_pattern ); /////////////////////////////////////////////// - rt::option show_progress( SHOW_PROGRESS, ( + rt::option show_progress( show_progress_str, ( rt::description = "Turns on progress display.", rt::env_var = "BOOST_TEST_SHOW_PROGRESS", - rt::help = "Parameter " + SHOW_PROGRESS + " instructs the framework to display test progress " + rt::help = "Parameter " + show_progress_str + " instructs the framework to display test progress " "information. By default the test progress is not shown." )); - show_progress.add_cla_id( "--", SHOW_PROGRESS, "=" ); + show_progress.add_cla_id( "--", show_progress_str, "=" ); show_progress.add_cla_id( "-", "p", " " ); store.add( show_progress ); /////////////////////////////////////////////// - rt::option use_alt_stack( USE_ALT_STACK, ( + rt::option use_alt_stack( use_alt_stack_str, ( rt::description = "Turns on/off usage of an alternative stack for signal handling.", rt::env_var = "BOOST_TEST_USE_ALT_STACK", rt::default_value = true, - rt::help = "Parameter " + USE_ALT_STACK + " instructs the framework to use alternative " + rt::help = "Parameter " + use_alt_stack_str + " instructs the framework to use alternative " "stack for signals processing, on platforms where they are supported. The feature " "is enabled by default, but can be disabled using this parameter." )); - use_alt_stack.add_cla_id( "--", USE_ALT_STACK, "=", true ); + use_alt_stack.add_cla_id( "--", use_alt_stack_str, "=", true ); store.add( use_alt_stack ); /////////////////////////////////////////////// - rt::option wait_for_debugger( WAIT_FOR_DEBUGGER, ( + rt::option wait_for_debugger( wait_for_debugger_str, ( rt::description = "Forces test module to wait for button to be pressed before starting test run.", rt::env_var = "BOOST_TEST_WAIT_FOR_DEBUGGER", - rt::help = "Parameter " + WAIT_FOR_DEBUGGER + " instructs the framework to pause before starting " + rt::help = "Parameter " + wait_for_debugger_str + " instructs the framework to pause before starting " "test units execution, so that you can attach a debugger to running test module. By " "default this parameters turned off." )); - wait_for_debugger.add_cla_id( "--", WAIT_FOR_DEBUGGER, "=" ); + wait_for_debugger.add_cla_id( "--", wait_for_debugger_str, "=" ); wait_for_debugger.add_cla_id( "-", "w", " " ); store.add( wait_for_debugger ); /////////////////////////////////////////////// - rt::parameter help( HELP, ( + rt::parameter help( help_str, ( rt::description = "Help for framework parameters.", rt::optional_value = std::string(), rt::value_hint = "", - rt::help = "Parameter " + HELP + " displays help on the framework's parameters. " + rt::help = "Parameter " + help_str + " displays help on the framework's parameters. " "The parameter accepts an optional argument value. If present, an argument value is " "interpreted as a parameter name (name guessing works as well, so for example " "--help=rand displays help on the parameter random). If the parameter name is unknown " "or ambiguous error is reported. If argument value is absent, a summary of all " "framework's parameter is displayed." )); - help.add_cla_id( "--", HELP, "=" ); + help.add_cla_id( "--", help_str, "=" ); store.add( help ); /////////////////////////////////////////////// - rt::option usage( USAGE, ( + rt::option usage( usage_str, ( rt::description = "Short message explaining usage of Boost.Test parameters." )); usage.add_cla_id( "-", "?", " " ); @@ -638,10 +638,10 @@ register_parameters( rt::parameters_stor /////////////////////////////////////////////// - rt::option version( VERSION, ( + rt::option version( version_str, ( rt::description = "Prints Boost.Test version and exits." )); - version.add_cla_id( "--", VERSION, " " ); + version.add_cla_id( "--", version_str, " " ); store.add( version ); } @@ -676,24 +676,24 @@ init( int& argc, char** argv ) rt::finalize_arguments( s_parameters_store, s_arguments_store ); // Report help if requested - if( runtime_config::get( VERSION ) ) { + if( runtime_config::get( version_str ) ) { parser->version( std::cerr ); BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_success ) ); } - else if( runtime_config::get( USAGE ) ) { + else if( runtime_config::get( usage_str ) ) { parser->usage( std::cerr ); BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_success ) ); } - else if( s_arguments_store.has( HELP ) ) { - parser->help( std::cerr, s_parameters_store, runtime_config::get( HELP ) ); + else if( s_arguments_store.has( help_str ) ) { + parser->help( std::cerr, s_parameters_store, runtime_config::get( help_str ) ); BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_success ) ); } // A bit of business logic: output_format takes precedence over log/report formats - if( s_arguments_store.has( OUTPUT_FORMAT ) ) { - unit_test::output_format of = s_arguments_store.get( OUTPUT_FORMAT ); - s_arguments_store.set( REPORT_FORMAT, of ); - s_arguments_store.set( LOG_FORMAT, of ); + if( s_arguments_store.has( output_format_str ) ) { + unit_test::output_format of = s_arguments_store.get( output_format_str ); + s_arguments_store.set( report_format_str, of ); + s_arguments_store.set( log_format_str, of ); } } @@ -747,7 +747,7 @@ argument_store() bool save_pattern() { - return runtime_config::get( SAVE_TEST_PATTERN ); + return runtime_config::get( save_test_pattern_str ); } //____________________________________________________________________________// Index: boost_1_63_0/boost/test/impl/framework.ipp =================================================================== --- boost_1_63_0.orig/boost/test/impl/framework.ipp +++ boost_1_63_0/boost/test/impl/framework.ipp @@ -396,7 +396,7 @@ parse_filters( test_unit_id master_tu_id // 10. collect tu to enable and disable based on filters bool had_selector_filter = false; - std::vector const& filters = runtime_config::get >( runtime_config::RUN_FILTERS ); + std::vector const& filters = runtime_config::get >( runtime_config::run_filters_str ); BOOST_TEST_FOREACH( const_string, filter, filters ) { BOOST_TEST_SETUP_ASSERT( !filter.is_empty(), "Invalid filter specification" ); @@ -552,7 +552,7 @@ public: test_unit_id_list tu_to_disable; // 10. If there are any filters supplied, figure out lists of test units to enable/disable - bool had_selector_filter = !runtime_config::get >( runtime_config::RUN_FILTERS ).empty() && + bool had_selector_filter = !runtime_config::get >( runtime_config::run_filters_str ).empty() && parse_filters( master_tu_id, tu_to_enable, tu_to_disable ); // 20. Set the stage: either use default run status or disable all test units @@ -657,7 +657,7 @@ public: if( tu.p_type == TUT_SUITE ) { test_suite const& ts = static_cast( tu ); - if( runtime_config::get( runtime_config::RANDOM_SEED ) == 0 ) { + if( runtime_config::get( runtime_config::random_seed_str ) == 0 ) { typedef std::pair value_type; BOOST_TEST_FOREACH( value_type, chld, ts.m_ranked_children ) { @@ -845,26 +845,26 @@ setup_loggers() BOOST_TEST_I_TRY { #ifdef BOOST_TEST_SUPPORT_TOKEN_ITERATOR - bool has_combined_logger = runtime_config::has( runtime_config::COMBINED_LOGGER ) - && !runtime_config::get< std::vector >( runtime_config::COMBINED_LOGGER ).empty(); + bool has_combined_logger = runtime_config::has( runtime_config::combined_logger_str ) + && !runtime_config::get< std::vector >( runtime_config::combined_logger_str ).empty(); #else bool has_combined_logger = false; #endif if( !has_combined_logger ) { - unit_test_log.set_threshold_level( runtime_config::get( runtime_config::LOG_LEVEL ) ); - const output_format format = runtime_config::get( runtime_config::LOG_FORMAT ); + unit_test_log.set_threshold_level( runtime_config::get( runtime_config::log_level_str ) ); + const output_format format = runtime_config::get( runtime_config::log_format_str ); unit_test_log.set_format( format ); runtime_config::stream_holder& stream_logger = s_frk_state().m_log_sinks[format]; - if( runtime_config::has( runtime_config::LOG_SINK ) ) - stream_logger.setup( runtime_config::get( runtime_config::LOG_SINK ) ); + if( runtime_config::has( runtime_config::log_sink_str ) ) + stream_logger.setup( runtime_config::get( runtime_config::log_sink_str ) ); unit_test_log.set_stream( stream_logger.ref() ); } else { - const std::vector& v_output_format = runtime_config::get< std::vector >( runtime_config::COMBINED_LOGGER ) ; + const std::vector& v_output_format = runtime_config::get< std::vector >( runtime_config::combined_logger_str ) ; static const std::pair all_log_levels[] = { std::make_pair( "all" , log_successful_tests ), @@ -1033,26 +1033,26 @@ init( init_unit_test_func init_func, int impl::setup_loggers(); // 30. Set the desired report level, format and sink - results_reporter::set_level( runtime_config::get( runtime_config::REPORT_LEVEL ) ); - results_reporter::set_format( runtime_config::get( runtime_config::REPORT_FORMAT ) ); + results_reporter::set_level( runtime_config::get( runtime_config::report_level_str ) ); + results_reporter::set_format( runtime_config::get( runtime_config::report_format_str ) ); - if( runtime_config::has( runtime_config::REPORT_SINK ) ) - s_frk_state().m_report_sink.setup( runtime_config::get( runtime_config::REPORT_SINK ) ); + if( runtime_config::has( runtime_config::report_sink_str ) ) + s_frk_state().m_report_sink.setup( runtime_config::get( runtime_config::report_sink_str ) ); results_reporter::set_stream( s_frk_state().m_report_sink.ref() ); // 40. Register default test observers register_observer( results_collector ); register_observer( unit_test_log ); - if( runtime_config::get( runtime_config::SHOW_PROGRESS ) ) { + if( runtime_config::get( runtime_config::show_progress_str ) ) { progress_monitor.set_stream( std::cout ); // defaults to stdout register_observer( progress_monitor ); } // 50. Set up memory leak detection - unsigned long detect_mem_leak = runtime_config::get( runtime_config::DETECT_MEM_LEAKS ); + unsigned long detect_mem_leak = runtime_config::get( runtime_config::detect_mem_leaks_str ); if( detect_mem_leak > 0 ) { - debug::detect_memory_leaks( true, runtime_config::get( runtime_config::REPORT_MEM_LEAKS ) ); + debug::detect_memory_leaks( true, runtime_config::get( runtime_config::report_mem_leaks_str ) ); debug::break_memory_alloc( (long)detect_mem_leak ); } @@ -1408,7 +1408,7 @@ run( test_unit_id id, bool continue_test test_case_counter tcc; traverse_test_tree( id, tcc ); - BOOST_TEST_SETUP_ASSERT( tcc.p_count != 0 , runtime_config::get >( runtime_config::RUN_FILTERS ).empty() + BOOST_TEST_SETUP_ASSERT( tcc.p_count != 0 , runtime_config::get >( runtime_config::run_filters_str ).empty() ? BOOST_TEST_L( "test tree is empty" ) : BOOST_TEST_L( "no test cases matching filter or all test cases were disabled" ) ); @@ -1428,7 +1428,7 @@ run( test_unit_id id, bool continue_test } } - unsigned seed = runtime_config::get( runtime_config::RANDOM_SEED ); + unsigned seed = runtime_config::get( runtime_config::random_seed_str ); switch( seed ) { case 0: break; Index: boost_1_63_0/boost/test/impl/compiler_log_formatter.ipp =================================================================== --- boost_1_63_0.orig/boost/test/impl/compiler_log_formatter.ipp +++ boost_1_63_0/boost/test/impl/compiler_log_formatter.ipp @@ -62,7 +62,7 @@ test_phase_identifier() void compiler_log_formatter::log_start( std::ostream& output, counter_t test_cases_amount ) { - m_color_output = runtime_config::get( runtime_config::COLOR_OUTPUT ); + m_color_output = runtime_config::get( runtime_config::color_output_str ); if( test_cases_amount > 0 ) output << "Running " << test_cases_amount << " test " Index: boost_1_63_0/boost/test/impl/plain_report_formatter.ipp =================================================================== --- boost_1_63_0.orig/boost/test/impl/plain_report_formatter.ipp +++ boost_1_63_0/boost/test/impl/plain_report_formatter.ipp @@ -83,7 +83,7 @@ void plain_report_formatter::results_report_start( std::ostream& ostr ) { m_indent = 0; - m_color_output = runtime_config::get( runtime_config::COLOR_OUTPUT ); + m_color_output = runtime_config::get( runtime_config::color_output_str ); ostr << '\n'; } Index: boost_1_63_0/boost/test/impl/progress_monitor.ipp =================================================================== --- boost_1_63_0.orig/boost/test/impl/progress_monitor.ipp +++ boost_1_63_0/boost/test/impl/progress_monitor.ipp @@ -124,7 +124,7 @@ progress_monitor_impl& s_pm_impl() { sta void progress_monitor_t::test_start( counter_t test_cases_amount ) { - s_pm_impl().m_color_output = runtime_config::get( runtime_config::COLOR_OUTPUT ); + s_pm_impl().m_color_output = runtime_config::get( runtime_config::color_output_str ); PM_SCOPED_COLOR(); Index: boost_1_63_0/boost/test/impl/unit_test_log.ipp =================================================================== --- boost_1_63_0.orig/boost/test/impl/unit_test_log.ipp +++ boost_1_63_0/boost/test/impl/unit_test_log.ipp @@ -168,7 +168,7 @@ unit_test_log_t::test_start( counter_t t current_logger_data.m_log_formatter->log_start( current_logger_data.stream(), test_cases_amount ); - if( runtime_config::get( runtime_config::BUILD_INFO ) ) + if( runtime_config::get( runtime_config::build_info_str ) ) current_logger_data.m_log_formatter->log_build_info( current_logger_data.stream() ); current_logger_data.m_entry_in_progress = false; Index: boost_1_63_0/boost/test/impl/unit_test_main.ipp =================================================================== --- boost_1_63_0.orig/boost/test/impl/unit_test_main.ipp +++ boost_1_63_0/boost/test/impl/unit_test_main.ipp @@ -188,7 +188,7 @@ unit_test_main( init_unit_test_func init BOOST_TEST_I_TRY { framework::init( init_func, argc, argv ); - if( runtime_config::get( runtime_config::WAIT_FOR_DEBUGGER ) ) { + if( runtime_config::get( runtime_config::wait_for_debugger_str ) ) { results_reporter::get_stream() << "Press any key to continue..." << std::endl; // getchar is defined as a macro in uClibc. Use parenthesis to fix @@ -199,7 +199,7 @@ unit_test_main( init_unit_test_func init framework::finalize_setup_phase(); - output_format list_cont = runtime_config::get( runtime_config::LIST_CONTENT ); + output_format list_cont = runtime_config::get( runtime_config::list_content_str ); if( list_cont != unit_test::OF_INVALID ) { if( list_cont == unit_test::OF_DOT ) { ut_detail::dot_content_reporter reporter( results_reporter::get_stream() ); @@ -215,7 +215,7 @@ unit_test_main( init_unit_test_func init return boost::exit_success; } - if( runtime_config::get( runtime_config::LIST_LABELS ) ) { + if( runtime_config::get( runtime_config::list_labels_str ) ) { ut_detail::labels_collector collector; traverse_test_tree( framework::master_test_suite().p_id, collector, true ); @@ -232,7 +232,7 @@ unit_test_main( init_unit_test_func init results_reporter::make_report(); - result_code = !runtime_config::get( runtime_config::RESULT_CODE ) + result_code = !runtime_config::get( runtime_config::result_code_str ) ? boost::exit_success : results_collector.results( framework::master_test_suite().p_id ).result_code(); } Index: boost_1_63_0/boost/test/impl/unit_test_monitor.ipp =================================================================== --- boost_1_63_0.orig/boost/test/impl/unit_test_monitor.ipp +++ boost_1_63_0/boost/test/impl/unit_test_monitor.ipp @@ -37,11 +37,11 @@ unit_test_monitor_t::error_level unit_test_monitor_t::execute_and_translate( boost::function const& func, unsigned timeout ) { BOOST_TEST_I_TRY { - p_catch_system_errors.value = runtime_config::get( runtime_config::CATCH_SYS_ERRORS ); + p_catch_system_errors.value = runtime_config::get( runtime_config::catch_sys_errors_str ); p_timeout.value = timeout; - p_auto_start_dbg.value = runtime_config::get( runtime_config::AUTO_START_DBG ); - p_use_alt_stack.value = runtime_config::get( runtime_config::USE_ALT_STACK ); - p_detect_fp_exceptions.value = runtime_config::get( runtime_config::DETECT_FP_EXCEPT ); + p_auto_start_dbg.value = runtime_config::get( runtime_config::auto_start_dbg_str ); + p_use_alt_stack.value = runtime_config::get( runtime_config::use_alt_stack_str ); + p_detect_fp_exceptions.value = runtime_config::get( runtime_config::detect_fp_except_str ); vexecute( func ); } Index: boost_1_63_0/libs/test/test/execution_monitor-ts/errors-handling-test.cpp =================================================================== --- boost_1_63_0.orig/libs/test/test/execution_monitor-ts/errors-handling-test.cpp +++ boost_1_63_0/libs/test/test/execution_monitor-ts/errors-handling-test.cpp @@ -185,9 +185,9 @@ BOOST_AUTO_TEST_CASE( test_errors_handli framework::run( test ); unit_test_log.set_stream( std::cout ); - unit_test_log.set_format( runtime_config::get( runtime_config::LOG_FORMAT ) ); + unit_test_log.set_format( runtime_config::get( runtime_config::log_format_str ) ); - log_level ll = runtime_config::get( runtime_config::LOG_LEVEL ); + log_level ll = runtime_config::get( runtime_config::log_level_str ); unit_test_log.set_threshold_level( ll != invalid_log_level? ll : log_all_errors ); BOOST_CHECK( test_output.match_pattern() ); Index: boost_1_63_0/libs/test/test/framework-ts/log-formatter-test.cpp =================================================================== --- boost_1_63_0.orig/libs/test/test/framework-ts/log-formatter-test.cpp +++ boost_1_63_0/libs/test/test/framework-ts/log-formatter-test.cpp @@ -117,7 +117,7 @@ void check( output_test_stream& output, struct guard { ~guard() { - boost::unit_test::unit_test_log.set_format( runtime_config::get( runtime_config::LOG_FORMAT ) ); + boost::unit_test::unit_test_log.set_format( runtime_config::get( runtime_config::log_format_str ) ); boost::unit_test::unit_test_log.set_stream( std::cout ); } }; Index: boost_1_63_0/libs/test/test/framework-ts/result-report-test.cpp =================================================================== --- boost_1_63_0.orig/libs/test/test/framework-ts/result-report-test.cpp +++ boost_1_63_0/libs/test/test/framework-ts/result-report-test.cpp @@ -101,7 +101,7 @@ struct guard { { results_reporter::set_stream( std::cerr ); results_reporter::set_format( runtime_config::get( - runtime_config::REPORT_FORMAT ) ); + runtime_config::report_format_str ) ); } }; Index: boost_1_63_0/libs/test/test/test-organization-ts/test_unit-order-shuffled-test.cpp =================================================================== --- boost_1_63_0.orig/libs/test/test/test-organization-ts/test_unit-order-shuffled-test.cpp +++ boost_1_63_0/libs/test/test/test-organization-ts/test_unit-order-shuffled-test.cpp @@ -109,7 +109,7 @@ struct test_tree { BOOST_FIXTURE_TEST_CASE( test_no_seed, test_tree ) { // no seed set - ut::runtime_config::s_arguments_store.set(ut::runtime_config::RANDOM_SEED, 0); + ut::runtime_config::s_arguments_store.set(ut::runtime_config::random_seed_str, 0); tu_order_collector res1 = run_tree( master ); tu_order_collector res2 = run_tree( master ); @@ -120,7 +120,7 @@ BOOST_FIXTURE_TEST_CASE( test_no_seed, t BOOST_FIXTURE_TEST_CASE( test_seed_to_time, test_tree ) { // seed = 1 means current time is used. - ut::runtime_config::s_arguments_store.set(ut::runtime_config::RANDOM_SEED, 1); + ut::runtime_config::s_arguments_store.set(ut::runtime_config::random_seed_str, 1); tu_order_collector res1 = run_tree( master ); tu_order_collector res2 = run_tree( master ); @@ -132,16 +132,16 @@ BOOST_FIXTURE_TEST_CASE( test_seed_ident { // seed = 1 means current time is used. unsigned int seed = static_cast( std::time( 0 ) ); - ut::runtime_config::s_arguments_store.set(ut::runtime_config::RANDOM_SEED, seed); + ut::runtime_config::s_arguments_store.set(ut::runtime_config::random_seed_str, seed); tu_order_collector res1 = run_tree( master ); - ut::runtime_config::s_arguments_store.set(ut::runtime_config::RANDOM_SEED, seed); + ut::runtime_config::s_arguments_store.set(ut::runtime_config::random_seed_str, seed); tu_order_collector res2 = run_tree( master ); BOOST_TEST( res1.m_order == res2.m_order, tt::per_element() ); // using time seed now - ut::runtime_config::s_arguments_store.set(ut::runtime_config::RANDOM_SEED, 1); + ut::runtime_config::s_arguments_store.set(ut::runtime_config::random_seed_str, 1); tu_order_collector res3 = run_tree( master ); BOOST_TEST( res1.m_order != res3.m_order ); // some elements might be the same, but not the full sequences Index: boost_1_63_0/libs/test/test/writing-test-ts/test_tools-test.cpp =================================================================== --- boost_1_63_0.orig/libs/test/test/writing-test-ts/test_tools-test.cpp +++ boost_1_63_0/libs/test/test/writing-test-ts/test_tools-test.cpp @@ -129,9 +129,9 @@ BOOST_AUTO_TEST_CASE( name ) ut::framework::run( impl ); \ \ ut::log_level ll = ut::runtime_config::get( \ - ut::runtime_config::LOG_LEVEL ); \ + ut::runtime_config::log_level_str ); \ ut::output_format lf = ut::runtime_config::get( \ - ut::runtime_config::LOG_FORMAT ); \ + ut::runtime_config::log_format_str ); \ \ ut::unit_test_log.set_threshold_level( \ ll != ut::invalid_log_level ? ll : ut::log_all_errors ); \ Index: boost_1_63_0/libs/test/doc/examples/example51.run.cpp =================================================================== --- boost_1_63_0.orig/libs/test/doc/examples/example51.run.cpp +++ boost_1_63_0/libs/test/doc/examples/example51.run.cpp @@ -13,7 +13,7 @@ using namespace boost::unit_test; BOOST_AUTO_TEST_CASE( test_case0 ) { - if( runtime_config::get( runtime_config::LOG_LEVEL ) < log_warnings ) + if( runtime_config::get( runtime_config::log_level_str ) < log_warnings ) unit_test_log.set_threshold_level( log_warnings ); BOOST_WARN( sizeof(int) > 4 ); Index: boost_1_63_0/boost/test/unit_test_parameters.hpp =================================================================== --- boost_1_63_0.orig/boost/test/unit_test_parameters.hpp +++ boost_1_63_0/boost/test/unit_test_parameters.hpp @@ -36,31 +36,31 @@ namespace runtime_config { // ************************************************************************** // // UTF parameters -BOOST_TEST_DECL extern std::string AUTO_START_DBG; -BOOST_TEST_DECL extern std::string BREAK_EXEC_PATH; -BOOST_TEST_DECL extern std::string BUILD_INFO; -BOOST_TEST_DECL extern std::string CATCH_SYS_ERRORS; -BOOST_TEST_DECL extern std::string COLOR_OUTPUT; -BOOST_TEST_DECL extern std::string DETECT_FP_EXCEPT; -BOOST_TEST_DECL extern std::string DETECT_MEM_LEAKS; -BOOST_TEST_DECL extern std::string LIST_CONTENT; -BOOST_TEST_DECL extern std::string LIST_LABELS; -BOOST_TEST_DECL extern std::string COMBINED_LOGGER; -BOOST_TEST_DECL extern std::string LOG_FORMAT; -BOOST_TEST_DECL extern std::string LOG_LEVEL; -BOOST_TEST_DECL extern std::string LOG_SINK; -BOOST_TEST_DECL extern std::string OUTPUT_FORMAT; -BOOST_TEST_DECL extern std::string RANDOM_SEED; -BOOST_TEST_DECL extern std::string REPORT_FORMAT; -BOOST_TEST_DECL extern std::string REPORT_LEVEL; -BOOST_TEST_DECL extern std::string REPORT_MEM_LEAKS; -BOOST_TEST_DECL extern std::string REPORT_SINK; -BOOST_TEST_DECL extern std::string RESULT_CODE; -BOOST_TEST_DECL extern std::string RUN_FILTERS; -BOOST_TEST_DECL extern std::string SAVE_TEST_PATTERN; -BOOST_TEST_DECL extern std::string SHOW_PROGRESS; -BOOST_TEST_DECL extern std::string USE_ALT_STACK; -BOOST_TEST_DECL extern std::string WAIT_FOR_DEBUGGER; +BOOST_TEST_DECL extern std::string auto_start_dbg_str; +BOOST_TEST_DECL extern std::string break_exec_path_str; +BOOST_TEST_DECL extern std::string build_info_str; +BOOST_TEST_DECL extern std::string catch_sys_errors_str; +BOOST_TEST_DECL extern std::string color_output_str; +BOOST_TEST_DECL extern std::string detect_fp_except_str; +BOOST_TEST_DECL extern std::string detect_mem_leaks_str; +BOOST_TEST_DECL extern std::string list_content_str; +BOOST_TEST_DECL extern std::string list_labels_str; +BOOST_TEST_DECL extern std::string combined_logger_str; +BOOST_TEST_DECL extern std::string log_format_str; +BOOST_TEST_DECL extern std::string log_level_str; +BOOST_TEST_DECL extern std::string log_sink_str; +BOOST_TEST_DECL extern std::string output_format_str; +BOOST_TEST_DECL extern std::string random_seed_str; +BOOST_TEST_DECL extern std::string report_format_str; +BOOST_TEST_DECL extern std::string report_level_str; +BOOST_TEST_DECL extern std::string report_mem_leaks_str; +BOOST_TEST_DECL extern std::string report_sink_str; +BOOST_TEST_DECL extern std::string result_code_str; +BOOST_TEST_DECL extern std::string run_filters_str; +BOOST_TEST_DECL extern std::string save_test_pattern_str; +BOOST_TEST_DECL extern std::string show_progress_str; +BOOST_TEST_DECL extern std::string use_alt_stack_str; +BOOST_TEST_DECL extern std::string wait_for_debugger_str; BOOST_TEST_DECL void init( int& argc, char** argv );