napcok/calamares
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
b9ad701a5c
calamares/CMakeModules/CalamaresAddModuleSubdirectory.cmake

206 lines
9.1 KiB
CMake
Raw Normal View History

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.
2020-08-25 16:05:56 +02:00
# === 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.
2018-03-09 17:13:42 +01:00
#
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.
2020-08-26 00:24:40 +02:00
# 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.
2020-08-25 16:05:56 +02:00
# 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.
2018-03-09 17:13:42 +01:00
#
#
###
#
# 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
2017-08-15 10:34:28 +02:00
include( CalamaresAddTranslations )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
2014-07-14 16:26:10 +02:00
Allow and glob multiple .conf files in module subdirectory.
2015-09-09 18:55:08 +02:00
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.
2017-12-24 22:08:48 +01:00
# 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.
2018-01-10 15:20:49 +01:00
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.
2014-07-14 16:26:10 +02:00
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.
2017-12-24 22:08:48 +01:00
set( SKIPPED_MODULES )
Testing: refactor so that C++ and Python modules all get yaml-config tests
2017-10-12 18:37:54 +02:00
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.
2018-01-15 22:41:06 +01:00
set( _mod_dir "${CMAKE_CURRENT_SOURCE_DIR}/${SUBDIRECTORY}" )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
2014-07-14 16:26:10 +02:00
# 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.
2018-01-15 22:41:06 +01:00
if( EXISTS "${_mod_dir}/CMakeLists.txt" )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
2014-07-14 16:26:10 +02:00
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.
2018-01-15 22:41:06 +01:00
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.
2017-12-24 22:08:48 +01:00
# 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.
2018-02-07 13:31:50 +01:00
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.
2017-12-24 22:08:48 +01:00
endif()
module.conf ==> module.desc everywhere.
2014-08-06 16:01:39 +02:00
# ...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.
2018-01-15 22:41:06 +01:00
elseif( EXISTS "${_mod_dir}/module.desc" )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
2014-07-14 16:26:10 +02:00
set( MODULES_DIR ${CMAKE_INSTALL_LIBDIR}/calamares/modules )
CMake: handle Python modules built from subdirectory a/b
2020-06-12 12:05:35 +02:00
# 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.
2014-07-14 16:26:10 +02:00
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.
2018-01-15 22:41:06 +01:00
# 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.
2019-04-28 15:06:10 +02:00
#
# _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.
2018-01-15 22:41:06 +01:00
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.
2020-06-12 11:35:23 +02:00
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.
2018-01-15 22:41:06 +01:00
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.
2019-04-28 15:06:10 +02:00
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.
2018-01-15 22:41:06 +01:00
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.
2020-06-12 11:35:23 +02:00
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.
2018-01-15 22:41:06 +01:00
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.
2019-04-28 15:06:10 +02:00
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.
2019-04-27 17:30:16 +02:00
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.
2019-04-28 15:06:10 +02:00
set( _mod_testing OFF )
CMake: Check module interfaces - Only allow meaningful interface strings - Improve documentation of which interfaces work for which module types.
2019-04-27 17:30:16 +02:00
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.
2018-01-15 22:41:06 +01:00
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.
2019-04-28 15:06:10 +02:00
set( _mod_testing OFF )
CMake: Check module interfaces - Only allow meaningful interface strings - Improve documentation of which interfaces work for which module types.
2019-04-27 17:30:16 +02:00
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.
2019-04-28 15:06:10 +02:00
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.
2018-01-15 22:41:06 +01:00
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.
2014-08-05 18:18:57 +02:00
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.
2018-01-15 22:41:06 +01:00
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.
2018-06-27 19:20:52 +02:00
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.
2018-01-15 22:41:06 +01:00
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.
2014-08-05 18:18:57 +02:00
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.
2018-01-15 22:41:06 +01:00
endforeach()
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
2014-07-14 16:26:10 +02:00
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.
2018-01-15 22:41:06 +01:00
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.
2018-09-14 11:33:04 +02:00
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.
2016-11-21 01:32:04 +01:00
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.
2018-09-14 11:33:04 +02:00
message( " ${Green}CONFIGURATION_FILES:${ColorReset} ${MODULE_CONFIG_FILES} => ${_destination}" )
Allow and glob multiple .conf files in module subdirectory.
2015-09-09 18:55:08 +02:00
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.
2018-09-14 11:33:04 +02:00
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.
2018-01-15 22:41:06 +01:00
# 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
2020-05-15 14:38:45 +02:00
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.
2018-01-15 22:41:06 +01:00
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
2020-05-15 14:38:45 +02:00
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.
2018-01-15 22:41:06 +01:00
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
2017-08-15 10:34:28 +02:00
endif()
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
2014-07-14 16:26:10 +02:00
else()
module.conf ==> module.desc everywhere.
2014-08-06 16:01:39 +02:00
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.
2014-07-14 16:26:10 +02:00
message( "" )
endif()
Testing: refactor so that C++ and Python modules all get yaml-config tests
2017-10-12 18:37:54 +02:00
# 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).
2019-04-27 17:58:29 +02:00
# 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
2020-05-15 14:38:45 +02:00
# 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.
2019-04-28 15:06:10 +02:00
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.
2020-05-08 21:50:11 +02:00
# 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
2020-05-15 14:38:45 +02:00
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.
2020-05-08 21:50:11 +02:00
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
2020-05-15 14:38:45 +02:00
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.
2019-04-28 15:06:10 +02:00
endif()
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
2014-07-14 16:26:10 +02:00
endfunction()
Reference in New Issue Copy Permalink