From 894293587045aab4f8c6780b43fe38cfae274dfc Mon Sep 17 00:00:00 2001 From: zachcran Date: Mon, 22 May 2023 15:20:37 -0500 Subject: [PATCH] Remove prefixes from parameter documentation --- cmake_test/add_dir.cmake | 4 +- cmake_test/asserts/defined.cmake | 8 ++-- cmake_test/asserts/equal.cmake | 16 +++---- cmake_test/asserts/file_contains.cmake | 30 ++++++------- cmake_test/asserts/file_exists.cmake | 8 ++-- cmake_test/asserts/library_exists.cmake | 18 ++++---- cmake_test/asserts/list.cmake | 8 ++-- cmake_test/asserts/prints.cmake | 4 +- cmake_test/asserts/string.cmake | 8 ++-- cmake_test/asserts/target_exists.cmake | 8 ++-- cmake_test/asserts/target_has_property.cmake | 16 +++---- cmake_test/asserts/true_false.cmake | 8 ++-- .../detail_/utilities/input_check.cmake | 8 ++-- cmake_test/detail_/utilities/lc_find.cmake | 14 +++--- .../detail_/utilities/print_result.cmake | 44 +++++++++---------- .../detail_/utilities/repeat_string.cmake | 12 ++--- cmake_test/detail_/utilities/return.cmake | 12 ++--- .../detail_/utilities/sanitize_name.cmake | 10 ++--- cmake_test/expectfail_subprocess.cmake | 4 +- cmake_test/set_print_length.cmake | 4 +- 20 files changed, 122 insertions(+), 122 deletions(-) diff --git a/cmake_test/add_dir.cmake b/cmake_test/add_dir.cmake index 80d731c..a6188dc 100644 --- a/cmake_test/add_dir.cmake +++ b/cmake_test/add_dir.cmake @@ -20,8 +20,8 @@ include_guard() # with CTest. The configured templates will be executed seperately via CTest during the Test phase, and each *.cmake # file found in the specified directory is assumed to contain CMakeTest tests. # -# :param _ad_dir: The directory to search for *.cmake files. Subdirectories will be recursively searched. -# :type _ad_dir: path +# :param dir: The directory to search for *.cmake files. Subdirectories will be recursively searched. +# :type dir: path # # **Keyword Arguments** # diff --git a/cmake_test/asserts/defined.cmake b/cmake_test/asserts/defined.cmake index 23c774a..13b3a00 100644 --- a/cmake_test/asserts/defined.cmake +++ b/cmake_test/asserts/defined.cmake @@ -20,8 +20,8 @@ include_guard() # assert that the variable is set to any particular value. If the variable is # not defined it will raise an error. # -# :param _ad_var: The identifier to check for defined-ness. -# :type _ad_var: Identifier +# :param var: The identifier to check for defined-ness. +# :type var: Identifier #]] function(ct_assert_defined _ad_var) if(NOT DEFINED ${_ad_var}) @@ -34,8 +34,8 @@ endfunction() # This function can be used to assert that a variable is not defined. If the # variable is actually defined this function will raise an error. # -# :param _and_var: The identifier to check for defined-ness. -# :type _and_var: Identifier +# :param var: The identifier to check for defined-ness. +# :type var: Identifier #]] function(ct_assert_not_defined _and_var) if(DEFINED ${_and_var}) diff --git a/cmake_test/asserts/equal.cmake b/cmake_test/asserts/equal.cmake index f6dd24f..544a703 100644 --- a/cmake_test/asserts/equal.cmake +++ b/cmake_test/asserts/equal.cmake @@ -20,10 +20,10 @@ include_guard() # specific contents. If the identifier is not set to the specified contents a # fatal error will be raised. # -# :param _ae_var: The identifier whose contents are in question. -# :type _ae_var: Identifier -# :param _ae_contents: What the identifier should be set to. -# :type _ae_contents: String +# :param var: The identifier whose contents are in question. +# :type var: Identifier +# :param contents: What the identifier should be set to. +# :type contents: String #]] function(ct_assert_equal _ae_var _ae_contents) if(NOT "${${_ae_var}}" STREQUAL "${_ae_contents}") @@ -41,10 +41,10 @@ endfunction() # other than the specified contents. If the identifier is set to the specified # contents a fatal error will be raised. # -# :param _ane_var: The identifier whose contents are in question. -# :type _ane_var: Identifier -# :param _ane_contents: What the identifier should not be set to. -# :type _ane_contents: String +# :param var: The identifier whose contents are in question. +# :type var: Identifier +# :param contents: What the identifier should not be set to. +# :type contents: String #]] function(ct_assert_not_equal _ane_var _ane_contents) if("${${_ane_var}}" STREQUAL "${_ane_contents}") diff --git a/cmake_test/asserts/file_contains.cmake b/cmake_test/asserts/file_contains.cmake index cf9ce6b..fa8ca87 100644 --- a/cmake_test/asserts/file_contains.cmake +++ b/cmake_test/asserts/file_contains.cmake @@ -20,10 +20,10 @@ include(cmake_test/asserts/file_exists) # Asserts that the file at the specified path contains the specified text. # Will return if the file does not exist, the assertion failure will be logged as a fatal error. # -# :param _afc_file: The file to check -# :type _afc_file: path -# :param _afc_text: The text to check for -# :type _afc_text: string +# :param file: The file to check +# :type file: path +# :param text: The text to check for +# :type text: string #]] function(ct_assert_file_contains _afc_file _afc_text) # Ensure the file exists @@ -48,10 +48,10 @@ endfunction() # # Will return if the file does not exist, the assertion failure will be logged as a fatal error. # -# :param _afdnc_file: The file to check -# :type _afdnc_file: path -# :param _afdnc_text: The text to check for -# :type _afdnc_text: string +# :param file: The file to check +# :type file: path +# :param text: The text to check for +# :type text: string #]] function(ct_assert_file_does_not_contain _afdnc_file _afdnc_text) # Ensure the file exists @@ -77,13 +77,13 @@ endfunction() # # Will return if the file does not exist, the assertion failure will be logged as a fatal error. # -# :param _fc_result: Name to use for the variable which will hold the result. -# :type _fc_result: bool -# :param _fc_file: The file to check. -# :type _fc_file: string -# :param _fc_text: The text to check for. -# :type _fc_text: string -# :returns: ``_fc_result`` will be set to ``TRUE`` if file contains the text +# :param result: Name to use for the variable which will hold the result. +# :type result: bool +# :param file: The file to check. +# :type file: string +# :param text: The text to check for. +# :type text: string +# :returns: ``result`` will be set to ``TRUE`` if file contains the text # and ``FALSE`` if it does not. # :rtype: bool #]] diff --git a/cmake_test/asserts/file_exists.cmake b/cmake_test/asserts/file_exists.cmake index 147809d..0fbe2b6 100644 --- a/cmake_test/asserts/file_exists.cmake +++ b/cmake_test/asserts/file_exists.cmake @@ -16,8 +16,8 @@ include_guard() #[[[ Assert that the file at the provided path exists. # -# :param _afe_path: The path to check -# :type _afe_path: Path +# :param path: The path to check +# :type path: Path #]] function(ct_assert_file_exists _afe_path) if(NOT EXISTS "${_afe_path}") @@ -29,8 +29,8 @@ endfunction() #[[[ Assert that a file does not exist at the provided path. # -# :param _afdne_path: The path to check -# :type _afdne_path: Path +# :param path: The path to check +# :type path: Path #]] function(ct_assert_file_does_not_exist _afdne_path) if(EXISTS "${_afdne_path}" AND NOT IS_DIRECTORY "${_afdne_path}") diff --git a/cmake_test/asserts/library_exists.cmake b/cmake_test/asserts/library_exists.cmake index 71e9f39..307f189 100644 --- a/cmake_test/asserts/library_exists.cmake +++ b/cmake_test/asserts/library_exists.cmake @@ -18,8 +18,8 @@ include_guard() # # Asserts that the target exists and is a library. # -# :param _ale_name: The name of the library -# :type _afe_path: string +# :param name: The name of the library +# :type path: string #]] function(ct_assert_library_target_exists _ale_name) # Check that the target exists and it is a library @@ -35,8 +35,8 @@ endfunction() # # Asserts that the target does not exist or is not a library. # -# :param _aldne_name: The name of the library -# :type _aldne_name: string +# :param name: The name of the library +# :type name: string #]] function(ct_assert_library_does_not_exist _aldne_name) # Check that the target does not exist or is not a library @@ -52,11 +52,11 @@ endfunction() # target is of type ``STATIC_LIBRARY``, ``MODULE_LIBRARY``, or # ``SHARED_LIBRARY`` and then returns an integer indicating what it found. # -# :param _lte_result: Name to use for the variable which will hold the result. -# :type _lte_result: int -# :param _lte_name: The target name to check. -# :type _lte_name: string -# :returns: ``_lte_result`` will be set to ``0`` if the target is a library, +# :param result: Name to use for the variable which will hold the result. +# :type result: int +# :param name: The target name to check. +# :type name: string +# :returns: ``result`` will be set to ``0`` if the target is a library, ``1`` if the target is not a library, and ``2`` if target does not exist. # :rtype: int diff --git a/cmake_test/asserts/list.cmake b/cmake_test/asserts/list.cmake index 0d0ad1e..fb1f2b3 100644 --- a/cmake_test/asserts/list.cmake +++ b/cmake_test/asserts/list.cmake @@ -22,8 +22,8 @@ include_guard() # function will not consider such strings lists. If the identifier is not a list # an error will be raised. # -# :param _anl_var: The identifier we want to know the list-ness of. -# :type _anl_var: Identifier +# :param var: The identifier we want to know the list-ness of. +# :type var: Identifier #]] function(ct_assert_list _al_var) list(LENGTH ${_al_var} _al_length) @@ -40,8 +40,8 @@ endfunction() # function will not consider such strings lists. If the provided string is a # list this function will raise an error. # -# :param _anl_var: The identifier we want to know the list-ness of. -# :type _anl_var: Identifier +# :param var: The identifier we want to know the list-ness of. +# :type var: Identifier #]] function(ct_assert_not_list _anl_var) list(LENGTH ${_anl_var} _anl_length) diff --git a/cmake_test/asserts/prints.cmake b/cmake_test/asserts/prints.cmake index e67b1b5..fcae7d6 100644 --- a/cmake_test/asserts/prints.cmake +++ b/cmake_test/asserts/prints.cmake @@ -24,8 +24,8 @@ include_guard() # If the previously printed message does not exactly match the expected message, # this function will treat the expected message as a regex to check if it matches. # -# :param _ap_msg: The message expected to have been printed, either exact match or regex. -# :type _ap_msg: String +# :param msg: The message expected to have been printed, either exact match or regex. +# :type msg: String #]] function(ct_assert_prints _ap_msg) cpp_get_global(_ap_last_msg CT_LAST_MESSAGE) diff --git a/cmake_test/asserts/string.cmake b/cmake_test/asserts/string.cmake index 5ec4de6..b06189f 100644 --- a/cmake_test/asserts/string.cmake +++ b/cmake_test/asserts/string.cmake @@ -21,8 +21,8 @@ include_guard() # raise an error if the provided identifier is not a string. Consequentially, # this function is more-or-less equivalent to ct_assert_not_list. # -# :param _as_var: The identifier we want the stringy-ness of. -# :type _as_var: Identifier +# :param var: The identifier we want the stringy-ness of. +# :type var: Identifier #]] function(ct_assert_string _as_var) list(LENGTH ${_as_var} _as_length) @@ -38,8 +38,8 @@ endfunction() # raise an error if the provided identifier is a string. Consequentially, this # function is more-or-less equivalent to ct_assert_list. # -# :param _ans_var: The identifier we want the stringy-ness of. -# :type _ans_var: Identifier +# :param var: The identifier we want the stringy-ness of. +# :type var: Identifier #]] function(ct_assert_not_string _ans_var) list(LENGTH ${_ans_var} _ans_length) diff --git a/cmake_test/asserts/target_exists.cmake b/cmake_test/asserts/target_exists.cmake index 4884627..24ee1fa 100644 --- a/cmake_test/asserts/target_exists.cmake +++ b/cmake_test/asserts/target_exists.cmake @@ -16,8 +16,8 @@ include_guard() #[[[ Assert that a target exists. # -# :param _ate_name: The name of the target -# :type _ate_name: String +# :param name: The name of the target +# :type name: String #]] function(ct_assert_target_exists _ate_name) # Check if the target exists, if not throw an error @@ -28,8 +28,8 @@ endfunction() #[[[ Assert that a target does not exist. # -# :param _ate_name: The name of the target -# :type _ate_name: String +# :param name: The name of the target +# :type name: String #]] function(ct_assert_target_does_not_exist _atdne_name) # Check if the target exists, if it does, throw an error diff --git a/cmake_test/asserts/target_has_property.cmake b/cmake_test/asserts/target_has_property.cmake index 891dbb1..1e174da 100644 --- a/cmake_test/asserts/target_has_property.cmake +++ b/cmake_test/asserts/target_has_property.cmake @@ -18,10 +18,10 @@ include(cmake_test/asserts/target_exists) #[[[ Assert that a target has a property. # -# :param _athp_target: The name of the target -# :type _athp_target: String -# :param _athp_property: The name of the property -# :type _athp_property: String +# :param target: The name of the target +# :type target: String +# :param property: The name of the property +# :type property: String #]] function(ct_assert_target_has_property _athp_target _athp_property) # Ensure the target exists @@ -39,10 +39,10 @@ endfunction() #[[[ Assert that a target does not have a property. # -# :param _atdnhp_target: The name of the target -# :type _atdnhp_target: String -# :param _atdnhp_property: The name of the property -# :type _atdnhp_property: String +# :param target: The name of the target +# :type target: String +# :param property: The name of the property +# :type property: String #]] function(ct_assert_target_does_not_have_property _atdnhp_target _atdnhp_property) # Ensure the target exists diff --git a/cmake_test/asserts/true_false.cmake b/cmake_test/asserts/true_false.cmake index f677245..3c7a87f 100644 --- a/cmake_test/asserts/true_false.cmake +++ b/cmake_test/asserts/true_false.cmake @@ -16,8 +16,8 @@ include_guard() #[[[ Asserts that the provided variable is true. # -# :param _at_var: The identifier to check for trueness. -# :type _at_var: Identifier +# :param var: The identifier to check for trueness. +# :type var: Identifier #]] function(ct_assert_true _at_var) if(NOT ${_at_var}) @@ -27,8 +27,8 @@ endfunction() #[[[ Asserts that the provided variable is false. # -# :param _af_var: The identifier to check for falseness. -# :type _af_var: Identifier +# :param var: The identifier to check for falseness. +# :type var: Identifier #]] function(ct_assert_false _af_var) if(${_af_var}) diff --git a/cmake_test/detail_/utilities/input_check.cmake b/cmake_test/detail_/utilities/input_check.cmake index 7e9b38d..80e7ef2 100644 --- a/cmake_test/detail_/utilities/input_check.cmake +++ b/cmake_test/detail_/utilities/input_check.cmake @@ -22,8 +22,8 @@ include(cmake_test/asserts/list) # the event that the input to this function is not an identifier, or if that # identifier is not set to a value, this function will raise a fatal error. # -# :param _n_var: The identifier to check for defined-ness. -# :type _n_var: Identifier +# :param var: The identifier to check for defined-ness. +# :type var: Identifier #]] function(_ct_nonempty _n_var) cmake_policy(SET CMP0054 NEW) @@ -39,8 +39,8 @@ endfunction() # or if the identifier is set to an empty string this function will raise a # fatal error. # -# :param _ns_var: The identifier whose contents is being examined. -# :type _ns_var: Identifier +# :param var: The identifier whose contents is being examined. +# :type var: Identifier #]] function(_ct_nonempty_string _ns_var) _ct_nonempty("${_ns_var}") diff --git a/cmake_test/detail_/utilities/lc_find.cmake b/cmake_test/detail_/utilities/lc_find.cmake index 182ff84..14feddd 100644 --- a/cmake_test/detail_/utilities/lc_find.cmake +++ b/cmake_test/detail_/utilities/lc_find.cmake @@ -21,14 +21,14 @@ include_guard() # provided as ``${_lf_found}`` will be set to ``TRUE`` otherwise it will be set # to ``FALSE``. # -# :param _lf_found: Identifier to hold the result. -# :type _lf_found: Identifier -# :param _lf_substring: The substring we are looking for. -# :type _lf_substring: str -# :param _lf_string: The string we are searching for ``${_lf_substring}`` in. -# :type _lf_string: str +# :param found: Identifier to hold the result. +# :type found: Identifier +# :param substring: The substring we are looking for. +# :type substring: str +# :param string: The string we are searching for ``${_lf_substring}`` in. +# :type string: str # :returns: ``TRUE`` if the substring is found and ``FALSE`` otherwise. Result -# is accessible to the caller via ``_lf_found``. +# is accessible to the caller via ``found``. #]] function(_ct_lc_find _lf_found _lf_substring _lf_string) string(TOLOWER "${_lf_string}" _lf_lc_string) diff --git a/cmake_test/detail_/utilities/print_result.cmake b/cmake_test/detail_/utilities/print_result.cmake index 9c22e7a..441a7e3 100644 --- a/cmake_test/detail_/utilities/print_result.cmake +++ b/cmake_test/detail_/utilities/print_result.cmake @@ -17,18 +17,18 @@ include(cmake_test/detail_/utilities/repeat_string) #[[[ Wraps the process of printing a test's result # -# This function largely serves as code factorization for ``_ct_print_pass`` and -# ``_ct_print_fail``. This function will print an indent appropriate for the +# This function largely serves as code factorization for ``print_pass`` and +# ``print_fail``. This function will print an indent appropriate for the # current nesting, and then enough dots to right align the result. # -# :param _pr_name: The name of the test we are printing the result of. -# :type _pr_name: str -# :param _pr_result: What to print as the result (usually "PASSED" or "FAILED") -# :type _pr_result: str -# :param _pr_depth: How many sections is this test nested? -# :type _pr_depth: str -# :param _pr_print_length: The total length of the line to be printed, including dots and whitespace -# :type _pr_print_length: int +# :param name: The name of the test we are printing the result of. +# :type name: str +# :param result: What to print as the result (usually "PASSED" or "FAILED") +# :type result: str +# :param depth: How many sections is this test nested? +# :type depth: str +# :param print_length: The total length of the line to be printed, including dots and whitespace +# :type print_length: int #]] function(_ct_print_result _pr_name _pr_result _pr_depth _pr_print_length) #message("Print length is: ${_pr_print_length}") @@ -73,12 +73,12 @@ endfunction() # called this function will print to the standard output that the test ran # successfully. # -# :param _pp_name: The test we are printing the result of. -# :type _pp_name: str -# :param _pp_depth: How many sections is this test nested? -# :type _pp_depth: str -# :param _pp_print_length: The total length of the line to be printed, including dots and whitespace -# :type _pp_print_length: int +# :param name: The test we are printing the result of. +# :type name: str +# :param depth: How many sections is this test nested? +# :type depth: str +# :param print_length: The total length of the line to be printed, including dots and whitespace +# :type print_length: int #]] function(_ct_print_pass _pp_name _pp_depth _pp_print_length) _ct_print_result(${_pp_name} "${CT_BoldGreen}PASSED${CT_ColorReset}" ${_pp_depth} "${_pp_print_length}") @@ -92,12 +92,12 @@ endfunction() # the reason why the test failed. Finally, this function will issue a fatal # error stopping the test. # -# :param _pf_name: The name of the test that just failed. -# :type _pf_name: str -# :param _pf_depth: How many sections is this test nested? -# :type _pf_depth: str -# :param _pf_print_length: The total length of the line to be printed, including dots and whitespace -# :type _pf_print_length: int +# :param name: The name of the test that just failed. +# :type name: str +# :param depth: How many sections is this test nested? +# :type depth: str +# :param print_length: The total length of the line to be printed, including dots and whitespace +# :type print_length: int #]] function(_ct_print_fail _pf_name _pf_depth _pf_print_length) _ct_print_result(${_pf_name} "${CT_BoldRed}FAILED${CT_ColorReset}" ${_pf_depth} "${_pf_print_length}") diff --git a/cmake_test/detail_/utilities/repeat_string.cmake b/cmake_test/detail_/utilities/repeat_string.cmake index 6dbe32d..b3b5796 100644 --- a/cmake_test/detail_/utilities/repeat_string.cmake +++ b/cmake_test/detail_/utilities/repeat_string.cmake @@ -21,14 +21,14 @@ include(cmake_test/detail_/utilities/return) # specified number of times. This is useful for creating the proper indents # for printing and for creating repeated characters like in banners. # -# :param _rs_result: An identifier to save the result to. -# :type _rs_result: Identifier -# :param _rs_str: The substring to repeat. -# :type _rs_str: str +# :param result: An identifier to save the result to. +# :type result: Identifier +# :param str: The substring to repeat. +# :type str: str # :param _rs_n: The number of times to repeat ``${_rs_str}``. -# :type _rs_n: str +# :type n: str # :returns: A string containing the created string. The result is accessible to -# the caller via ``_rs_result``. +# the caller via ``result``. #]] function(_ct_repeat_string _rs_result _rs_str _rs_n) set(_rs_counter 0) diff --git a/cmake_test/detail_/utilities/return.cmake b/cmake_test/detail_/utilities/return.cmake index 7ba50a2..3cafea7 100644 --- a/cmake_test/detail_/utilities/return.cmake +++ b/cmake_test/detail_/utilities/return.cmake @@ -20,7 +20,7 @@ include_guard() # The best way to do this is to have the callee provide the function with an # identifier to save the result to. This function wraps the common case where # internally the function saves the result to a local variable with the same -# name as the callee provided for the result. Without the ``_ct_return`` +# name as the callee provided for the result. Without the ``return`` # function this pattern looks something like: # # .. code-block:: cmake @@ -30,7 +30,7 @@ include_guard() # set(${return_identifier} ${${return_identifier}} PARENT_SCOPE # endfunction() # -# With the ``_ct_return`` function the above becomes: +# With the ``return`` function the above becomes: # # .. code-block:: cmake # @@ -42,15 +42,15 @@ include_guard() # While the new code still has the same number of lines, it is our opinion that # the new code is easier to read and the intent is more clear. # -# :param _r_var: The identifier which needs to be set in the parent namespace. -# :type _r_var: Identifier +# :param var: The identifier which needs to be set in the parent namespace. +# :type var: Identifier # # ..note:: # # This function is a macro to avoid creating another scope. If ``function`` # is used the identifier will be set in the scope of the function that -# called ``_ct_return`` and NOT in the scope of the function that called the -# callee of ``_ct_return``. +# called ``return`` and NOT in the scope of the function that called the +# callee of ``return``. #]] macro(_ct_return _r_var) set(${_r_var} "${${_r_var}}" PARENT_SCOPE) diff --git a/cmake_test/detail_/utilities/sanitize_name.cmake b/cmake_test/detail_/utilities/sanitize_name.cmake index 6ba430c..b2ed40f 100644 --- a/cmake_test/detail_/utilities/sanitize_name.cmake +++ b/cmake_test/detail_/utilities/sanitize_name.cmake @@ -24,12 +24,12 @@ include(cmake_test/detail_/utilities/return) # - Replace spaces with underscores # - Replace colons with hyphens # -# :param _sn_new_name: An identifier to which the new name will be assigned -# :type _sn_new_name: Identifier -# :param _sn_old_name: The string that we are sanitizing. -# :type _sn_old_name: str +# :param new_name: An identifier to which the new name will be assigned +# :type new_name: Identifier +# :param old_name: The string that we are sanitizing. +# :type old_name: str # :returns: A string containing the sanitized name. The result is accessible to -# the caller via ``_sn_new_name``. +# the caller via ``new_name``. #]] function(_ct_sanitize_name _sn_new_name _sn_old_name) string(TOLOWER "${_sn_old_name}" _sn_old_name) diff --git a/cmake_test/expectfail_subprocess.cmake b/cmake_test/expectfail_subprocess.cmake index 5749d94..aa0309d 100644 --- a/cmake_test/expectfail_subprocess.cmake +++ b/cmake_test/expectfail_subprocess.cmake @@ -29,8 +29,8 @@ include_guard() # is executed in a subprocess, resulting in the section and its parents being executed. The subprocess result # code is stored, and if the code is reported as succeeding testing is halted since we expect it to fail. # -# :param _es_curr_section_instance: The section execution unit object that will be executed as a subprocess. -# :type _es_curr_section_instance: CTExecutionUnit +# :param curr_section_instance: The section execution unit object that will be executed as a subprocess. +# :type curr_section_instance: CTExecutionUnit #]] function(ct_expectfail_subprocess _es_curr_section_instance) diff --git a/cmake_test/set_print_length.cmake b/cmake_test/set_print_length.cmake index 92a7c67..a5aafcf 100644 --- a/cmake_test/set_print_length.cmake +++ b/cmake_test/set_print_length.cmake @@ -23,8 +23,8 @@ # 3. Length set by ct_set_print_length() # 4. Built-in default of 80. # -# :param _spl_length: Length for pass/fail print lines. -# :type _spl_length: int +# :param length: Length for pass/fail print lines. +# :type length: int #]] macro(ct_set_print_length _spl_length) set(CT_PRINT_LENGTH "${_spl_length}")