From 6370b02fccc063f04ab1927ed125d485d4863ecd1f90b0143f8b26e392e2ae09 Mon Sep 17 00:00:00 2001 From: Adam Majer Date: Tue, 17 Jan 2017 12:41:18 +0000 Subject: [PATCH] - test_lowcase.patch: downcase Boost::Test usage of uppercase variables. VERSION was clashing with GNU Autotools define resulting in compilation errors of various packages. OBS-URL: https://build.opensuse.org/package/show/devel:libraries:c_c++/boost?expand=0&rev=185 --- boost.changes | 7 + boost.spec | 2 + test_lowcase.patch | 654 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 663 insertions(+) create mode 100644 test_lowcase.patch diff --git a/boost.changes b/boost.changes index c57269b..7afa627 100644 --- a/boost.changes +++ b/boost.changes @@ -1,3 +1,10 @@ +------------------------------------------------------------------- +Tue Jan 17 12:00:48 UTC 2017 - adam.majer@suse.de + +- test_lowcase.patch: downcase Boost::Test usage of uppercase + variables. VERSION was clashing with GNU Autotools define + resulting in compilation errors of various packages. + ------------------------------------------------------------------- Sun Jan 15 18:57:34 UTC 2017 - adam.majer@suse.de diff --git a/boost.spec b/boost.spec index 67dd802..6171226 100644 --- a/boost.spec +++ b/boost.spec @@ -92,6 +92,7 @@ Patch15: boost-1.57.0-python-abi_letters.patch Patch16: boost-1.55.0-python-test-PyImport_AppendInittab.patch Patch17: python_mpi.patch Patch18: dynamic_linking.patch +Patch19: test_lowcase.patch Patch100: gcc_path.patch BuildRequires: chrpath BuildRequires: dos2unix @@ -994,6 +995,7 @@ find -type f ! \( -name \*.sh -o -name \*.py -o -name \*.pl \) -exec chmod -x {} %patch16 -p1 %patch17 -p1 %patch18 -p1 +%patch19 -p1 %patch100 -p1 #stupid build machinery copies .orig files diff --git a/test_lowcase.patch b/test_lowcase.patch new file mode 100644 index 0000000..35e6b0b --- /dev/null +++ b/test_lowcase.patch @@ -0,0 +1,654 @@ +Author: Adam Majer +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 ); + } + + //____________________________________________________________________________//