aiden
/
calamares
mirror of https://github.com/cutefishos/calamares
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
main
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'eead42b773'
${ noResults }
calamares/CMakeModules/CalamaresAddModuleSubdirect...

206 lines
9.1 KiB
CMake
Raw Normal View History Unescape Escape

REUSE: Giant boilerplate cleanup - point to main Calamares site in the 'part of' headers instead of to github (this is the "this file is part of Calamares" opening line for most files). - remove boilerplate from all source files, CMake modules and completions, this is the 3-paragraph summary of the GPL-3.0-or-later, which has a meaning entirely covered by the SPDX tag.
4 years ago
# === This file is part of Calamares - <https://calamares.io> ===
CMake: add license headers, copyright Since we install the CMake files now, also put license headers in them. These files are intended to help plugin and branding component authors write them in a simple Calamares-idiomatic way.
7 years ago
#
REUSE: (BSD-2-Clause) CMakeModules/ The intended license for the CMake modules is BSD-2-Clause; there's no desire to restrict what can be done with these, and CMake modules are generally 2-clause licensed.
4 years ago
# SPDX-FileCopyrightText: 2014 Teo Mrnjavac <teo@kde.org>
# SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
# SPDX-License-Identifier: BSD-2-Clause
#
REUSE: Giant boilerplate cleanup - point to main Calamares site in the 'part of' headers instead of to github (this is the "this file is part of Calamares" opening line for most files). - remove boilerplate from all source files, CMake modules and completions, this is the 3-paragraph summary of the GPL-3.0-or-later, which has a meaning entirely covered by the SPDX tag.
4 years ago
# Calamares is Free Software: see the License-Identifier above.
CMake: add license headers, copyright Since we install the CMake files now, also put license headers in them. These files are intended to help plugin and branding component authors write them in a simple Calamares-idiomatic way.
7 years ago
#
#
###
#
# Function and support code for adding a Calamares module (either a Qt / C++ plugin,
# or a Python module, or whatever) to the build.
#
Python-i18n: install gettext .mo files into system locale dir
7 years ago
include( CalamaresAddTranslations )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
Allow and glob multiple .conf files in module subdirectory.
9 years ago
set( MODULE_DATA_DESTINATION share/calamares/modules )
CMake: explain which modules are skipped Modules may be skipped for different reasons: SKIP_MODULES is the traditional approach to suppress some, but other modules may have unmet build requirements (e.g. Plasma Look-and-Feel, or the Partitioning module) and should be able to opt-out of being built. For all those skipped, log it explicitly after all the modules have been examined. Only CMake-based (e.g. C++) modules support opting-out in this way.
7 years ago
# Convenience function to indicate that a module has been skipped
# (optionally also why). Call this in the module's CMakeLists.txt
macro( calamares_skip_module )
set( SKIPPED_MODULES ${SKIPPED_MODULES} ${ARGV} PARENT_SCOPE )
endmacro()
CMake: factor out explanation of skipped modules. Make a function out of explaining-skipped-modules, and call it not only after collecting all the modules, but also after the feature summary, so that it's quite clear which modules are skipped.
7 years ago
function( calamares_explain_skipped_modules )
if ( ARGN )
message( "${ColorReset}-- Skipped modules:" )
foreach( SUBDIRECTORY ${ARGN} )
message( "${ColorReset}-- Skipped ${BoldRed}${SUBDIRECTORY}${ColorReset}." )
endforeach()
message( "" )
endif()
endfunction()
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
function( calamares_add_module_subdirectory )
set( SUBDIRECTORY ${ARGV0} )
CMake: explain which modules are skipped Modules may be skipped for different reasons: SKIP_MODULES is the traditional approach to suppress some, but other modules may have unmet build requirements (e.g. Plasma Look-and-Feel, or the Partitioning module) and should be able to opt-out of being built. For all those skipped, log it explicitly after all the modules have been examined. Only CMake-based (e.g. C++) modules support opting-out in this way.
7 years ago
set( SKIPPED_MODULES )
Testing: refactor so that C++ and Python modules all get yaml-config tests
7 years ago
set( MODULE_CONFIG_FILES "" )
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
set( _mod_dir "${CMAKE_CURRENT_SOURCE_DIR}/${SUBDIRECTORY}" )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
# If this subdirectory has a CMakeLists.txt, we add_subdirectory it...
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
if( EXISTS "${_mod_dir}/CMakeLists.txt" )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
add_subdirectory( ${SUBDIRECTORY} )
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
file( GLOB MODULE_CONFIG_FILES RELATIVE ${_mod_dir} "${SUBDIRECTORY}/*.conf" )
CMake: explain which modules are skipped Modules may be skipped for different reasons: SKIP_MODULES is the traditional approach to suppress some, but other modules may have unmet build requirements (e.g. Plasma Look-and-Feel, or the Partitioning module) and should be able to opt-out of being built. For all those skipped, log it explicitly after all the modules have been examined. Only CMake-based (e.g. C++) modules support opting-out in this way.
7 years ago
# Module has indicated it should be skipped, show that in
# the calling CMakeLists (which is src/modules/CMakeLists.txt normally).
if ( SKIPPED_MODULES )
set( SKIPPED_MODULES ${SKIPPED_MODULES} PARENT_SCOPE )
CMake: ignore config files (and tests) for skipped modules.
7 years ago
set( MODULE_CONFIG_FILES "" )
CMake: explain which modules are skipped Modules may be skipped for different reasons: SKIP_MODULES is the traditional approach to suppress some, but other modules may have unmet build requirements (e.g. Plasma Look-and-Feel, or the Partitioning module) and should be able to opt-out of being built. For all those skipped, log it explicitly after all the modules have been examined. Only CMake-based (e.g. C++) modules support opting-out in this way.
7 years ago
endif()
module.conf ==> module.desc everywhere.
11 years ago
# ...otherwise, we look for a module.desc.
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
elseif( EXISTS "${_mod_dir}/module.desc" )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
set( MODULES_DIR ${CMAKE_INSTALL_LIBDIR}/calamares/modules )
CMake: handle Python modules built from subdirectory a/b
5 years ago
# The module subdirectory may be given as a/b/c, but the module
# needs to be installed as "c", so we split off any intermediate
# directories.
get_filename_component(_dirname "${SUBDIRECTORY}" DIRECTORY)
if( _dirname )
# Remove the dirname and any leftover leading /s
string( REGEX REPLACE "^${_dirname}/*" "" _modulename "${SUBDIRECTORY}" )
set( MODULE_DESTINATION ${MODULES_DIR}/${_modulename} )
else()
set( MODULE_DESTINATION ${MODULES_DIR}/${SUBDIRECTORY} )
endif()
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
# Read module.desc, check that the interface type is supported.
CMake: add test for python modules - Only Python modules have a loadmodule-test added. This will call run(), but with an empty configuration it should be a no-op.
6 years ago
#
# _mod_enabled boolean if the module should be built (only if the interface is supported)
# _mod_reason is a human-readable explanation why it isn't built
# _mod_testing boolean if the module should be added to the loadmodule tests
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
file(STRINGS "${_mod_dir}/module.desc" MODULE_INTERFACE REGEX "^interface")
if ( MODULE_INTERFACE MATCHES "pythonqt" )
CMake: support out-of-tree builds - The variables that are set for out-of-tree builds are prefixed with to avoid name clashes; make the module-infrastructure respect those instead of the in-tree variable names. - .. and then duplicate the in-tree variables to the out-of-tree variables, so we only need one set of module instructions.
5 years ago
set( _mod_enabled ${Calamares_WITH_PYTHONQT} )
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
set( _mod_reason "No PythonQt support" )
CMake: add test for python modules - Only Python modules have a loadmodule-test added. This will call run(), but with an empty configuration it should be a no-op.
6 years ago
set( _mod_testing OFF )
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
elseif ( MODULE_INTERFACE MATCHES "python" )
CMake: support out-of-tree builds - The variables that are set for out-of-tree builds are prefixed with to avoid name clashes; make the module-infrastructure respect those instead of the in-tree variable names. - .. and then duplicate the in-tree variables to the out-of-tree variables, so we only need one set of module instructions.
5 years ago
set( _mod_enabled ${Calamares_WITH_PYTHON} )
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
set( _mod_reason "No Python support" )
CMake: add test for python modules - Only Python modules have a loadmodule-test added. This will call run(), but with an empty configuration it should be a no-op.
6 years ago
set( _mod_testing ON ) # Will check syntax and imports, at least
CMake: Check module interfaces - Only allow meaningful interface strings - Improve documentation of which interfaces work for which module types.
6 years ago
elseif ( MODULE_INTERFACE MATCHES "qtplugin" )
set( _mod_enabled OFF )
set( _mod_reason "C++ modules must have a CMakeLists.txt instead" )
CMake: add test for python modules - Only Python modules have a loadmodule-test added. This will call run(), but with an empty configuration it should be a no-op.
6 years ago
set( _mod_testing OFF )
CMake: Check module interfaces - Only allow meaningful interface strings - Improve documentation of which interfaces work for which module types.
6 years ago
elseif ( MODULE_INTERFACE MATCHES "process" )
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
set( _mod_enabled ON )
set( _mod_reason "" )
CMake: add test for python modules - Only Python modules have a loadmodule-test added. This will call run(), but with an empty configuration it should be a no-op.
6 years ago
set( _mod_testing OFF )
CMake: Check module interfaces - Only allow meaningful interface strings - Improve documentation of which interfaces work for which module types.
6 years ago
else()
set( _mod_enabled OFF )
set( _mod_reason "Unknown module interface '${MODULE_INTERFACE}'" )
CMake: add test for python modules - Only Python modules have a loadmodule-test added. This will call run(), but with an empty configuration it should be a no-op.
6 years ago
set( _mod_testing OFF )
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
endif()
if ( _mod_enabled )
# We glob all the files inside the subdirectory, and we make sure they are
# synced with the bindir structure and installed.
file( GLOB MODULE_FILES RELATIVE ${_mod_dir} "${SUBDIRECTORY}/*" )
foreach( MODULE_FILE ${MODULE_FILES} )
if( NOT IS_DIRECTORY ${_mod_dir}/${MODULE_FILE} )
configure_file( ${SUBDIRECTORY}/${MODULE_FILE} ${SUBDIRECTORY}/${MODULE_FILE} COPYONLY )
Big configuration overhaul. Module descriptors are now module.desc, no configuration allowed inside. Module config files are <modulename>.conf, installed in share/calamares/modules. settings.conf is read from /etc/calamares, then share/calamares, and if running with --debug also in the current dir. Module config files are read from /etc/calamares/modules, then share/calamares/modules, and if running with --debug also in src/modules/<modulename> relative to the current dir.
11 years ago
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
get_filename_component( FLEXT ${MODULE_FILE} EXT )
CMake: always copy the config files to the build directory. Switching to INSTALL_CONFIG=OFF breaks tests by not having them in the build directory. Some logic was coupling not-installing to not-using-in-build-dir too closely.
7 years ago
if( "${FLEXT}" STREQUAL ".conf" )
if( INSTALL_CONFIG )
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/${SUBDIRECTORY}/${MODULE_FILE}
DESTINATION ${MODULE_DATA_DESTINATION} )
endif()
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
list( APPEND MODULE_CONFIG_FILES ${MODULE_FILE} )
else()
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/${SUBDIRECTORY}/${MODULE_FILE}
DESTINATION ${MODULE_DESTINATION} )
endif()
Big configuration overhaul. Module descriptors are now module.desc, no configuration allowed inside. Module config files are <modulename>.conf, installed in share/calamares/modules. settings.conf is read from /etc/calamares, then share/calamares, and if running with --debug also in the current dir. Module config files are read from /etc/calamares/modules, then share/calamares/modules, and if running with --debug also in src/modules/<modulename> relative to the current dir.
11 years ago
endif()
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
endforeach()
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
message( "-- ${BoldYellow}Found ${CALAMARES_APPLICATION_NAME} module: ${BoldRed}${SUBDIRECTORY}${ColorReset}" )
CMake: don't change cmake logging on release builds - There is no real need to reduce the logging on release builds, it's just confusing that all the cmake-time output changes in a non-meaningful way.
6 years ago
message( " ${Green}TYPE:${ColorReset} jobmodule" )
message( " ${Green}MODULE_DESTINATION:${ColorReset} ${MODULE_DESTINATION}" )
if( MODULE_CONFIG_FILES )
if ( INSTALL_CONFIG )
set( _destination "${MODULE_DATA_DESTINATION}" )
else()
set( _destination "[Build directory only]" )
New cmake switch to skip installing configuration. The INSTALL_CONFIG is "on" by default. When set to off, no *.conf file, both global and related to a single module, will be installed. A warning message is printed by cmake too, and the module description is edited to make this visible. This is useful for testing, when we want to install our own libraries and binary but keep the configuration of the live system we are testing on (e.g. path to distro image). Tested on the master branch.
8 years ago
endif()
CMake: don't change cmake logging on release builds - There is no real need to reduce the logging on release builds, it's just confusing that all the cmake-time output changes in a non-meaningful way.
6 years ago
message( " ${Green}CONFIGURATION_FILES:${ColorReset} ${MODULE_CONFIG_FILES} => ${_destination}" )
Allow and glob multiple .conf files in module subdirectory.
9 years ago
endif()
CMake: don't change cmake logging on release builds - There is no real need to reduce the logging on release builds, it's just confusing that all the cmake-time output changes in a non-meaningful way.
6 years ago
message( "" )
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
# We copy over the lang directory, if any
CMake: allow fine-tuning tests - The Python configuration tests sometimes need extra setup, so do that through a CMakeTests.txt file in the test directory. - Patch up existing tests: - grubcfg needs /tmp/calamares/etc/default to exist - rawfs won't work on FreeBSD because of differences in /proc
5 years ago
if( IS_DIRECTORY "${_mod_dir}/lang" )
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
install_calamares_gettext_translations(
${SUBDIRECTORY}
CMake: allow fine-tuning tests - The Python configuration tests sometimes need extra setup, so do that through a CMakeTests.txt file in the test directory. - Patch up existing tests: - grubcfg needs /tmp/calamares/etc/default to exist - rawfs won't work on FreeBSD because of differences in /proc
5 years ago
SOURCE_DIR "${_mod_dir}/lang"
CMake: don't copy over modules with unsupported interfaces. If Python isn't found, or PythonQt isn't found, there is no point in copying over the modules into the build tree; this may even be misleading because the files are there, but won't work and this will be noticed at runtime only. Instead, skip the modules and explain why.
7 years ago
FILENAME ${SUBDIRECTORY}.mo
RENAME calamares-${SUBDIRECTORY}.mo
)
endif()
else()
# Module disabled due to missing dependencies / unsupported interface
set( SKIPPED_MODULES "${SUBDIRECTORY} (${_mod_reason})" PARENT_SCOPE )
Python-i18n: install gettext .mo files into system locale dir
7 years ago
endif()
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
else()
module.conf ==> module.desc everywhere.
11 years ago
message( "-- ${BoldYellow}Warning:${ColorReset} tried to add module subdirectory ${BoldRed}${SUBDIRECTORY}${ColorReset} which has no CMakeLists.txt or module.desc." )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
message( "" )
endif()
Testing: refactor so that C++ and Python modules all get yaml-config tests
7 years ago
# Check any config files for basic correctness
if ( BUILD_TESTING AND MODULE_CONFIG_FILES )
set( _count 0 )
foreach( _config_file ${MODULE_CONFIG_FILES} )
set( _count_str "-${_count}" )
if ( _count EQUAL 0 )
set( _count_str "" )
endif()
add_test(
NAME config-${SUBDIRECTORY}${_count_str}
COMMAND test_conf ${CMAKE_CURRENT_BINARY_DIR}/${SUBDIRECTORY}/${_config_file} )
math( EXPR _count "${_count} + 1" )
endforeach()
endif()
CMake: document intention to run more tests on modules - Loading the module will check Python modules for syntax, and C++ modules for symbols. This would be a good idea, except for where it calls exec() and does things to the running system. Most modules are harmless with an empty config, but you never know (e.g. a process module).
6 years ago
# Check that the module can be loaded. Since this calls exec(), the module
# may try to do things to the running system. Needs work to make that a
# safe thing to do.
#
CMake: allow fine-tuning tests - The Python configuration tests sometimes need extra setup, so do that through a CMakeTests.txt file in the test directory. - Patch up existing tests: - grubcfg needs /tmp/calamares/etc/default to exist - rawfs won't work on FreeBSD because of differences in /proc
5 years ago
# If the module has a tests/ subdirectory with *.global and *.job
# files (YAML files holding global and job-configurations for
# testing purposes) then those files are used to drive additional
# tests. The files must be numbered (starting from 1) for this to work;
# 1.global and 1.job together make the configuration for test 1.
#
# If the module has a tests/CMakeLists.txt while it doesn't have its
# own CMakeLists.txt (e.g. a Python module), then the subdirectory
# for tests/ is added on its own.
#
CMake: add test for python modules - Only Python modules have a loadmodule-test added. This will call run(), but with an empty configuration it should be a no-op.
6 years ago
if ( BUILD_TESTING AND _mod_enabled AND _mod_testing )
add_test(
NAME load-${SUBDIRECTORY}
COMMAND loadmodule ${SUBDIRECTORY}
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
CMake: add tests when there are test-configs - If a module has tests/#.global or tests/#.job, these are used as arguments to a test-run of loadmodule (which reads them and runs the module with that configuration). - This makes the old python-loading test and test-runner entirely obsolete, so remove them too.
5 years ago
# Try it with the tests/ configurations shipped with the module
set( _count 1 )
CMake: allow fine-tuning tests - The Python configuration tests sometimes need extra setup, so do that through a CMakeTests.txt file in the test directory. - Patch up existing tests: - grubcfg needs /tmp/calamares/etc/default to exist - rawfs won't work on FreeBSD because of differences in /proc
5 years ago
set( _testdir ${_mod_dir}/tests )
CMake: add tests when there are test-configs - If a module has tests/#.global or tests/#.job, these are used as arguments to a test-run of loadmodule (which reads them and runs the module with that configuration). - This makes the old python-loading test and test-runner entirely obsolete, so remove them too.
5 years ago
while ( EXISTS "${_testdir}/${_count}.global" OR EXISTS "${_testdir}/${_count}.job" )
set( _dash_g "" )
set( _dash_j "" )
if ( EXISTS "${_testdir}/${_count}.global" )
set( _dash_g -g ${_testdir}/${_count}.global )
endif()
if ( EXISTS "${_testdir}/${_count}.job" )
set( _dash_j -j ${_testdir}/${_count}.job )
endif()
add_test(
NAME load-${SUBDIRECTORY}-${_count}
COMMAND loadmodule ${_dash_g} ${_dash_j} ${SUBDIRECTORY}
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
math( EXPR _count "${_count} + 1" )
endwhile()
CMake: allow fine-tuning tests - The Python configuration tests sometimes need extra setup, so do that through a CMakeTests.txt file in the test directory. - Patch up existing tests: - grubcfg needs /tmp/calamares/etc/default to exist - rawfs won't work on FreeBSD because of differences in /proc
5 years ago
if ( EXISTS ${_testdir}/CMakeTests.txt AND NOT EXISTS ${_mod_dir}/CMakeLists.txt )
include( ${_testdir}/CMakeTests.txt )
endif()
CMake: add test for python modules - Only Python modules have a loadmodule-test added. This will call run(), but with an empty configuration it should be a no-op.
6 years ago
endif()
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
11 years ago
endfunction()