diff --git a/cmake/ccpp_capgen.cmake b/cmake/ccpp_capgen.cmake index 0d7afb91..4b21a5a9 100644 --- a/cmake/ccpp_capgen.cmake +++ b/cmake/ccpp_capgen.cmake @@ -1,7 +1,6 @@ # CMake wrapper for ccpp_capgen.py # Currently meant to be a CMake API needed for generating caps for regression tests. # -# CAPGEN_DEBUG - ON/OFF (Default: OFF) - Enables debug capability through ccpp_capgen.py # CAPGEN_EXPECT_THROW_ERROR - ON/OFF (Default: OFF) - Scans ccpp_capgen.py log for error string and errors if not found. # HOST_NAME - String name of host # OUTPUT_ROOT - String path to put generated caps @@ -10,7 +9,7 @@ # SCHEMEFILES - CMake list of scheme metadata files # SUITES - CMake list of suite xml files function(ccpp_capgen) - set(optionalArgs CAPGEN_DEBUG CAPGEN_EXPECT_THROW_ERROR) + set(oneValueArgs HOST_NAME OUTPUT_ROOT VERBOSITY KIND_SPECS) set(multi_value_keywords HOSTFILES SCHEMEFILES SUITES) @@ -23,9 +22,6 @@ function(ccpp_capgen) endif() # Interpret parsed arguments - if(DEFINED arg_CAPGEN_DEBUG) - list(APPEND CCPP_CAPGEN_CMD_LIST "--debug") - endif() if(DEFINED arg_HOSTFILES) list(JOIN arg_HOSTFILES "," HOSTFILES_SEPARATED) list(APPEND CCPP_CAPGEN_CMD_LIST "--host-files" "${HOSTFILES_SEPARATED}") diff --git a/scripts/framework_env.py b/scripts/framework_env.py index 582358f8..2237db3e 100644 --- a/scripts/framework_env.py +++ b/scripts/framework_env.py @@ -29,8 +29,7 @@ def __init__(self, logger, ndict=None, verbose=0, clean=False, host_files=None, scheme_files=None, suites=None, preproc_directives=[], generate_docfiles=False, host_name='', kind_types=[], use_error_obj=False, force_overwrite=False, - output_root=os.getcwd(), ccpp_datafile="datatable.xml", - debug=False): + output_root=os.getcwd(), ccpp_datafile="datatable.xml"): """Initialize a new CCPPFrameworkEnv object from the input arguments. is a dict with the parsed command-line arguments (or a dictionary created with the necessary arguments). @@ -230,13 +229,6 @@ def __init__(self, logger, ndict=None, verbose=0, clean=False, self.__datatable_file = os.path.join(self.output_dir, self.datatable_file) # end if - # Enable or disable variable allocation checks - if ndict and ('debug' in ndict): - self.__debug = ndict['debug'] - del ndict['debug'] - else: - self.__debug = debug - # end if self.__logger = logger ## Check to see if anything is left in dictionary if ndict: @@ -369,7 +361,7 @@ def kind_types(self): @property def verbose(self): - """Return true if debug enabled for the CCPPFrameworkEnv's + """Return true if verbose enabled for the CCPPFrameworkEnv's logger object.""" return (self.logger and verbose(self.logger)) @@ -402,12 +394,6 @@ def datatable_file(self): CCPPFrameworkEnv object.""" return self.__datatable_file - @property - def debug(self): - """Return the property for this - CCPPFrameworkEnv object.""" - return self.__debug - @property def logger(self): """Return the property for this CCPPFrameworkEnv object.""" @@ -483,9 +469,6 @@ def parse_command_line(args, description, logger=None): help="""Overwrite all CCPP-generated files, even if unmodified""") - parser.add_argument("--debug", action='store_true', default=False, - help="Add variable allocation checks to assist debugging") - parser.add_argument("--verbose", action='count', default=0, help="Log more activity, repeat for increased output") diff --git a/scripts/suite_objects.py b/scripts/suite_objects.py index e6fa1fca..c16b4a73 100755 --- a/scripts/suite_objects.py +++ b/scripts/suite_objects.py @@ -1028,7 +1028,6 @@ def __init__(self, scheme_xml, context, parent, run_env): self.__lib = scheme_xml.get('lib', None) self.__has_vertical_dimension = False self.__group = None - self.__var_debug_checks = list() self.__forward_transforms = list() self.__reverse_transforms = list() self._has_run_phase = True @@ -1115,19 +1114,6 @@ def analyze(self, phase, group, scheme_library, suite_vars, level, host_dict): dict_var = clone # end if if found: - if self.__group.run_env.debug: - # Add variable allocation checks for group, suite and host variables - if dict_var: - if local_var: - self.add_var_debug_check(local_var) - else: - self.add_var_debug_check(dict_var) - # end if - # end if - # end if -# if not self.has_vertical_dim: -# self.__has_vertical_dimension = vert_dim is not None - # end if # We have a match, make sure var is in call list if new_dims == vdims: self.add_call_list_variable(var, exists_ok=True, gen_unique=True) @@ -1232,364 +1218,6 @@ def add_optional_var(self, dict_var, var, has_transform): return # end def - def add_var_debug_check(self, var): - """Add a debug check for a given variable var (host model variable, - suite variable or group module variable) for this scheme. - Return the variable and an associated dummy variable that is - managed by the group subroutine that calls the scheme, and - which is used to assign the scalar or the lower and upper bounds - of the array to if the intent is 'inout' or 'out'. - """ - # Get the basic attributes that decide whether we need - # to check the variable when we write the group - standard_name = var.get_prop_value('standard_name') - dimensions = var.get_dimensions() - active = var.get_prop_value('active') - var_dicts = [ self.__group.call_list ] + self.__group.suite_dicts() - - # If the variable isn't active, skip it - if active.lower() =='.false.': - return - # Also, if the variable is one of the CCPP error handling messages, skip it - # since it is defined as intent(out) and we can't do meaningful checks on it - elif standard_name == 'ccpp_error_code' or standard_name == 'ccpp_error_message': - return - # To perform allocation checks, we need to know all variables - # that are part of the 'active' attribute conditional and add - # it to the group's call list. - else: - (_, vars_needed) = var.conditional(var_dicts) - for var_needed in vars_needed: - self.update_group_call_list_variable(var_needed) - - # For scalars and arrays, need an internal_var variable (same kind and type) - # that we can assign the scalar or the lbound/ubound of the array to. - # We need to treat DDTs and variables with kind attributes slightly - # differently, and make sure there are no duplicate variables. We - # also need to assign a bogus standard name to these local variables. - vtype = var.get_prop_value('type') - if var.is_ddt(): - vkind = '' - units = '' - else: - vkind = var.get_prop_value('kind') - units = var.get_prop_value('units') - if vkind: - internal_var_lname = f'internal_var_{vtype.replace("=","_")}_{vkind.replace("=","_")}' - else: - internal_var_lname = f'internal_var_{vtype.replace("=","_")}' - if var.is_ddt(): - internal_var = Var({'local_name':internal_var_lname, 'standard_name':f'{internal_var_lname}_local', - 'ddt_type':vtype, 'kind':vkind, 'units':units, 'dimensions':'()'}, - _API_LOCAL, self.run_env) - else: - internal_var = Var({'local_name':internal_var_lname, 'standard_name':f'{internal_var_lname}_local', - 'type':vtype, 'kind':vkind, 'units':units, 'dimensions':'()'}, - _API_LOCAL, self.run_env) - found = self.__group.find_variable(source_var=internal_var, any_scope=False) - if not found: - self.__group.manage_variable(internal_var) - - # For arrays, we need to get information on the dimensions and add it to - # the group's call list so that we can test for the correct size later on - if dimensions: - for dim in dimensions: - if not ':' in dim: - dim_var = self.find_variable(standard_name=dim) - if not dim_var: - # To allow for numerical dimensions in metadata. - if not dim.isnumeric(): - raise Exception(f"No dimension with standard name '{dim}'") - # end if - else: - self.update_group_call_list_variable(dim_var) - # end if - else: - (ldim, udim) = dim.split(":") - ldim_var = self.find_variable(standard_name=ldim) - if not ldim_var: - # To allow for numerical dimensions in metadata. - if not ldim.isnumeric(): - raise Exception(f"No dimension with standard name '{ldim}'") - # end if - # end if - self.update_group_call_list_variable(ldim_var) - udim_var = self.find_variable(standard_name=udim) - if not udim_var: - # To allow for numerical dimensions in metadata. - if not udim.isnumeric(): - raise Exception(f"No dimension with standard name '{udim}'") - # end if - else: - self.update_group_call_list_variable(udim_var) - # end if - - # Add the variable to the list of variables to check. Record which internal_var to use. - self.__var_debug_checks.append([var, internal_var]) - - def replace_horiz_dim_debug_check(self, dim, cldicts, var_in_call_list): - """Determine the correct horizontal dimension to use for a given variable, - depending on the CCPP phase and origin of the variable (from the host/suite - or defined as a module variable for the parent group, or local to the group. - Return the dimension length and other properties needed for debug checks.""" - if not is_horizontal_dimension(dim): - raise Exception(f"Dimension {dim} is not a horizontal dimension") - if self.run_phase(): - if var_in_call_list and \ - self.find_variable(standard_name="horizontal_loop_extent"): - ldim = "ccpp_constant_one" - udim = "horizontal_loop_extent" - else: - ldim = "horizontal_loop_begin" - udim = "horizontal_loop_end" - else: - ldim = "ccpp_constant_one" - udim = "horizontal_dimension" - # Get dimension for lower bound - for var_dict in cldicts: - dvar = var_dict.find_variable(standard_name=ldim, any_scope=False) - if dvar is not None: - break - if not dvar: - raise Exception(f"No variable with standard name '{ldim}' in cldicts") - ldim_lname = dvar.get_prop_value('local_name') - # Get dimension for upper bound - for var_dict in cldicts: - dvar = var_dict.find_variable(standard_name=udim, any_scope=False) - if dvar is not None: - break - if not dvar: - raise Exception(f"No variable with standard name '{udim}' in cldicts") - udim_lname = dvar.get_prop_value('local_name') - # Assemble dimensions and bounds for size checking - dim_length = f'{udim_lname}-{ldim_lname}+1' - # If the variable that uses these dimensions is not in the group's call - # list, then it is defined as a module variable for this group and the - # dimensions run from ldim to udim, otherwise from 1:dim_length. - if not var_in_call_list: - dim_string = f"{ldim_lname}:{udim_lname}" - lbound_string = ldim_lname - ubound_string = udim_lname - else: - dim_string = ":" - lbound_string = '1' - ubound_string = f'{udim_lname}-{ldim_lname}+1' - return (dim_length, dim_string, lbound_string, ubound_string) - - def write_var_debug_check(self, var, internal_var, cldicts, outfile, errcode, errmsg, indent): - """Write the variable debug check for the given variable, as determined - in a previous step (add_var_debug_check). Assign the scalar or lower and - upper bounds of the array to the internal_var variable, and for arrays also check - that the size of the array matches the dimensions from the metadata. - """ - # Get the basic attributes for writing the check - standard_name = var.get_prop_value('standard_name') - dimensions = var.get_dimensions() - active = var.get_prop_value('active') - allocatable = var.get_prop_value('allocatable') - vtype = var.get_prop_value('type') - - # Need the local_name from the Scheme call list (i.e. dvar.call_string(var_dict)) - dvar = self.__group.call_list.find_variable(standard_name=standard_name, any_scope=True) - search_dict = self.__group.call_list - if dvar: - var_in_call_list = True - # If we find a call_list variable that is a DDT, check to see if it has components. - # Variables that are components of a DDT are NOT part of the call_list. - if dvar.is_ddt(): - if dvar.components: - var_in_call_list = False - # end if - # end if - else: - var_in_call_list = False - # If it is not in the call list, try to find it - # in the local variables of this group subroutine. - dvar = self.__group.find_variable(standard_name=standard_name, any_scope=True) - if not dvar: - # This variable is handled by the group - # and is declared as a module variable - for var_dict in self.__group.suite_dicts(): - dvar = var_dict.find_variable(standard_name=standard_name, any_scope=False) - if dvar: - search_dict = var_dict - break - if not dvar: - raise Exception(f"No variable with standard name '{standard_name}' in cldicts") - # end if - local_name = dvar.call_string(search_dict) - - # If the variable is allocatable and the intent for the scheme is 'out', - # then we can't test anything because the scheme is going to allocate - # the variable. We don't have this information earlier in - # add_var_debug_check, therefore need to back out here, - # using the information from the scheme variable (call list). - svar = self.call_list.find_variable(standard_name=standard_name, any_scope=False) - intent = svar.get_prop_value('intent') - if intent == 'out' and allocatable: - return - # end if - - # Get the condition on which the variable is active - (conditional, _) = var.conditional(cldicts) - - # For scalars, assign to internal_var variable if the variable intent is in/inout - if not dimensions: - if not intent == 'out': - internal_var_lname = internal_var.get_prop_value('local_name') - tmp_indent = indent - if conditional != '.true.': - tmp_indent = indent + 1 - outfile.write(f"if {conditional} then", indent) - # end if - outfile.write(f"! Assign value of {local_name} to {internal_var_lname}", tmp_indent) - outfile.write(f"{internal_var_lname} = {local_name}", tmp_indent) - outfile.write('',tmp_indent) - if conditional != '.true.': - outfile.write(f"end if", indent) - # end if - # For arrays, check size of array against dimensions in metadata, then assign - # the lower and upper bounds to the internal_var variable if the intent is in/inout - else: - array_size = 1 - dim_strings = [] - lbound_strings = [] - ubound_strings = [] - dim_lengths = [] - local_names = [] - for dim in dimensions: - if not ':' in dim: - # In capgen, any true dimension (that is not a single index) does - # have a colon (:) in the dimension, therefore this is an index - for var_dict in cldicts: - dvar = var_dict.find_variable(standard_name=dim, any_scope=False) - if dvar is not None: - break - # end if - # end for - if not dvar: - raise Exception(f"No variable with standard name '{dim}' in cldicts") - # end if - dim_lname = dvar.get_prop_value('local_name') - dim_length = 1 - dim_strings.append(dim_lname) - lbound_strings.append(dim_lname) - ubound_strings.append(dim_lname) - else: - # Horizontal dimension needs to be dealt with separately, because it - # depends on the CCPP phase, whether the variable is a host/suite - # variable or locally defined on the group level. - if is_horizontal_dimension(dim): - (dim_length, dim_string, lbound_string, ubound_string) = \ - self.replace_horiz_dim_debug_check(dim, cldicts, var_in_call_list) - else: - (ldim, udim) = dim.split(":") - # Get dimension for lower bound - for var_dict in cldicts: - dvar = var_dict.find_variable(standard_name=ldim, any_scope=False) - if dvar is not None: - ldim_lname = dvar.get_prop_value('local_name') - break - if not dvar: - # To allow for numerical dimensions in metadata. - if ldim.isnumeric(): - ldim_lname = ldim - else: - raise Exception(f"No variable with standard name '{ldim}' in cldicts") - # endif - # endif - # Get dimension for upper bound - for var_dict in cldicts: - dvar = var_dict.find_variable(standard_name=udim, any_scope=False) - if dvar is not None: - udim_lname = dvar.get_prop_value('local_name') - break - if not dvar: - # To allow for numerical dimensions in metadata. - if udim.isnumeric(): - udim_lname = udim - else: - raise Exception(f"No variable with standard name '{udim}' in cldicts") - # end if - # end if - # Assemble dimensions and bounds for size checking - dim_length = f'{udim_lname}-{ldim_lname}+1' - dim_string = ":" - lbound_string = ldim_lname - ubound_string = udim_lname - # end if - dim_strings.append(dim_string) - lbound_strings.append(lbound_string) - ubound_strings.append(ubound_string) - array_size = f'{array_size}*({dim_length})' - dim_lengths.append(dim_length) - local_names.append(local_name) - # end for - # Various strings needed to get the right size - # and lower/upper bound of the array - dim_string = '(' + ','.join(dim_strings) + ')' - lbound_string = '(' + ','.join(lbound_strings) + ')' - ubound_string = '(' + ','.join(ubound_strings) + ')' - - # Write size check - # - Only for types int and real. - if (vtype == "integer") or (vtype == "real"): - tmp_indent = indent - if conditional != '.true.': - tmp_indent = indent + 1 - outfile.write(f"if {conditional} then", indent) - # end if - outfile.write(f"! Check size of array {local_name+dim_string}", tmp_indent) - outfile.write(f"if (size({local_name+dim_string}) /= {array_size}) then", tmp_indent) - outfile.write(f"write({errmsg}, '(2(a,i8))') 'In group {self.__group.name} before "\ - f"{self.__subroutine_name}: for array {local_name+dim_string}, expected size ', "\ - f"{array_size}, ' but got ', size({local_name+dim_string})", tmp_indent+1) - outfile.write(f"{errcode} = 1", tmp_indent+1) - outfile.write(f"return", tmp_indent+1) - outfile.write(f"end if", tmp_indent) - if conditional != '.true.': - outfile.write(f"end if", indent) - # end if - outfile.write('',indent) - # end if - - # Write size check for each dimension in array. - # - If intent is not out. - # - Only for types int and real. - if (vtype == "integer") or (vtype == "real"): - if not intent == 'out': - tmp_indent = indent - if conditional != '.true.': - tmp_indent = indent + 1 - outfile.write(f"if {conditional} then", indent) - # end if - ndims = len(dim_lengths) - - # Loop through dimensions in var and check if length of each dimension - # is the correct size. Skip for 1D variables. - if (ndims > 1): - for index, dim_length in enumerate(dim_lengths): - array_ref = ','+str(index+1) - # - outfile.write(f"! Check length of {local_names[index]+dim_string}{array_ref}", tmp_indent) - outfile.write(f"if (size({local_names[index]+dim_string}{array_ref}) /= {dim_length}) then ", \ - tmp_indent) - outfile.write(f"write({errmsg}, '(2(a,i8))') 'In group {self.__group.name} before " \ - f"{self.__subroutine_name}: for array {local_names[index]+dim_string}{array_ref}, "\ - f"expected size ', {dim_length}, ' but got ', " \ - f"size({local_names[index]+dim_string}{array_ref})", tmp_indent+1) - outfile.write(f"{errcode} = 1", tmp_indent+1) - outfile.write(f"return", tmp_indent+1) - outfile.write(f"end if", tmp_indent) - # end for - #end if - if conditional != '.true.': - outfile.write(f"end if", indent) - # end if - outfile.write('',indent) - # endif - # end if - def associate_optional_var(self, dict_var, var, has_transform, cldicts, indent, outfile): """Write local pointer association for optional variable.""" # Use the local name from the Scheme call list, append "_ptr" suffix. @@ -1885,6 +1513,7 @@ def add_var_transform(self, var, compat_obj): # If needed, modify vertical dimension for vertical orientation flipping _, vdim = find_vertical_dimension(var.get_dimensions()) + # if vdim >= 0: vdims = vdim.split(':') vdim_name = vdims[-1] @@ -1988,25 +1617,6 @@ def write(self, outfile, errcode, errmsg, indent): outfile.write('', indent) outfile.write('if ({} == 0) then'.format(errcode), indent) # - # Write debug checks (operating on variables - # coming from the group's call list) - # - if self.__var_debug_checks: - outfile.write('! ##################################################################', indent+1) - outfile.comment('Begin debug tests', indent+1) - outfile.write('! ##################################################################', indent+1) - outfile.write('', indent+1) - # end if - for (var, internal_var) in self.__var_debug_checks: - stmt = self.write_var_debug_check(var, internal_var, cldicts, outfile, errcode, errmsg, indent+1) - # end for - if self.__var_debug_checks: - outfile.write('! ##################################################################', indent+1) - outfile.comment('End debug tests', indent+1) - outfile.write('! ##################################################################', indent+1) - outfile.write('', indent+1) - # end if - # # Write any reverse (pre-Scheme) transforms. if len(self.__reverse_transforms) > 0: outfile.comment('Compute reverse (pre-scheme) transforms', indent+1) diff --git a/test/README.md b/test/README.md index ba5978aa..03363532 100644 --- a/test/README.md +++ b/test/README.md @@ -50,7 +50,7 @@ There are several `...` to enable tests: 4) `-DCCPP_RUN_DDT_HOST_TEST=ON` Turns on only the ddt host test 5) `-DCCPP_RUN_VAR_COMPATIBILITY_TEST=ON` Turns on only the variable compatibility test -By default, the tests will build in release mode. To enable debug mode, you will need to set the build type: `-DCMAKE_BUILD_TYPE=Release` (or if you want release with debug symbols: `-DCMAKE_BUILD_TYPE=RelWithDebInfo`). +By default, the tests will build in debug mode. To enable release mode, you will need to set the build type: `-DCMAKE_BUILD_TYPE=Release` (or if you want release with debug symbols: `-DCMAKE_BUILD_TYPE=RelWithDebInfo`). To enable more verbose output for `ccpp_capgen.py`, add `-DCCPP_VERBOSITY=` to the `cmake` command line arguments where `n={1,2,3}` (`n=0` or no verbosity by default). diff --git a/test/advection_test/CMakeLists.txt b/test/advection_test/CMakeLists.txt index 0f1be200..4c20835b 100644 --- a/test/advection_test/CMakeLists.txt +++ b/test/advection_test/CMakeLists.txt @@ -22,7 +22,6 @@ list(APPEND ADVECTION_HOST_METADATA_FILES "${HOST}.meta") # Run ccpp_capgen that we expect to fail ccpp_capgen(CAPGEN_EXPECT_THROW_ERROR ON - CAPGEN_DEBUG ON VERBOSITY ${CCPP_VERBOSITY} HOSTFILES ${ADVECTION_HOST_METADATA_FILES} SCHEMEFILES ${SCHEME_ERROR_META_FILES} @@ -31,8 +30,7 @@ ccpp_capgen(CAPGEN_EXPECT_THROW_ERROR ON OUTPUT_ROOT "${CCPP_CAP_FILES}") # Run ccpp_capgen -ccpp_capgen(CAPGEN_DEBUG ON - VERBOSITY ${CCPP_VERBOSITY} +ccpp_capgen(VERBOSITY ${CCPP_VERBOSITY} HOSTFILES ${ADVECTION_HOST_METADATA_FILES} SCHEMEFILES ${SCHEME_META_FILES} SUITES ${SUITE_FILES} diff --git a/test/capgen_test/CMakeLists.txt b/test/capgen_test/CMakeLists.txt index 3a0e1405..49c75842 100644 --- a/test/capgen_test/CMakeLists.txt +++ b/test/capgen_test/CMakeLists.txt @@ -51,8 +51,7 @@ list(TRANSFORM HOST_FILES APPEND ".meta" OUTPUT_VARIABLE CAPGEN_HOST_MET list(APPEND CAPGEN_HOST_METADATA_FILES "${HOST}.meta") -ccpp_capgen(CAPGEN_DEBUG ON - VERBOSITY ${CCPP_VERBOSITY} +ccpp_capgen(VERBOSITY ${CCPP_VERBOSITY} HOSTFILES ${CAPGEN_HOST_METADATA_FILES} SCHEMEFILES ${SCHEME_META_FILES} ${SUITE_SCHEME_META_FILES} SUITES ${SUITE_FILES} diff --git a/test/ddthost_test/CMakeLists.txt b/test/ddthost_test/CMakeLists.txt index cc257619..5516277b 100644 --- a/test/ddthost_test/CMakeLists.txt +++ b/test/ddthost_test/CMakeLists.txt @@ -27,8 +27,7 @@ list(TRANSFORM HOST_FILES APPEND ".meta" OUTPUT_VARIABLE DDT_HOST_METADA list(APPEND DDT_HOST_METADATA_FILES "${HOST}.meta") # Run ccpp_capgen -ccpp_capgen(CAPGEN_DEBUG ON - VERBOSITY ${CCPP_VERBOSITY} +ccpp_capgen(VERBOSITY ${CCPP_VERBOSITY} HOSTFILES ${DDT_HOST_METADATA_FILES} SCHEMEFILES ${SCHEME_META_FILES} ${SUITE_SCHEME_META_FILES} SUITES ${SUITE_FILES} diff --git a/test/nested_suite_test/CMakeLists.txt b/test/nested_suite_test/CMakeLists.txt index 491a8fb4..c55d9bed 100644 --- a/test/nested_suite_test/CMakeLists.txt +++ b/test/nested_suite_test/CMakeLists.txt @@ -24,8 +24,7 @@ list(TRANSFORM HOST_FILES APPEND ".meta" OUTPUT_VARIABLE NESTED_SUITE_HOST_MET list(APPEND NESTED_SUITE_HOST_METADATA_FILES "${HOST}.meta") # Run ccpp_capgen -ccpp_capgen(CAPGEN_DEBUG ON - VERBOSITY ${CCPP_VERBOSITY} +ccpp_capgen(VERBOSITY ${CCPP_VERBOSITY} HOSTFILES ${NESTED_SUITE_HOST_METADATA_FILES} SCHEMEFILES ${SCHEME_META_FILES} SUITES ${SUITE_FILES} diff --git a/test/var_compatibility_test/CMakeLists.txt b/test/var_compatibility_test/CMakeLists.txt index 79ca1b3e..2938c2d0 100644 --- a/test/var_compatibility_test/CMakeLists.txt +++ b/test/var_compatibility_test/CMakeLists.txt @@ -24,8 +24,7 @@ list(TRANSFORM HOST_FILES APPEND ".meta" OUTPUT_VARIABLE VAR_COMPATIBILITY_HOS list(APPEND VAR_COMPATIBILITY_HOST_METADATA_FILES "${HOST}.meta") # Run ccpp_capgen -ccpp_capgen(CAPGEN_DEBUG ON - VERBOSITY ${CCPP_VERBOSITY} +ccpp_capgen(VERBOSITY ${CCPP_VERBOSITY} HOSTFILES ${VAR_COMPATIBILITY_HOST_METADATA_FILES} SCHEMEFILES ${SCHEME_META_FILES} SUITES ${SUITE_FILES}