execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
			RESULT_VARIABLE result
			WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/tracy-download
		)

add_test(NAME failtests WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/failtests COMMAND ${CMAKE_COMMAND} ${Eigen_SOURCE_DIR} -G "${CMAKE_GENERATOR}" -DEIGEN_FAILTEST=ON)

string(TOLOWER "${CMAKE_GENERATOR}" cmake_generator_tolower)

execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" ${GTEST_ARGS} .
      RESULT_VARIABLE result
      WORKING_DIRECTORY ${ZFP_BINARY_DIR}/tests/googletest-download
    )

ExternalProject_Add(${proj}
  DEPENDS ${${LOCAL_PROJECT_NAME}_DEPENDENCIES}
  DOWNLOAD_COMMAND ""
  SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
  BINARY_DIR ${LOCAL_PROJECT_NAME}-build
  CMAKE_GENERATOR ${gen}
  CMAKE_ARGS
    --no-warn-unused-cli # HACK Only expected variables should be passed down.
    ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
    ${COMMON_EXTERNAL_PROJECT_ARGS}
    -D${LOCAL_PROJECT_NAME}_SUPERBUILD:BOOL=OFF
    -DCMAKE_GENERATOR_PLATFORM:STRING=${CMAKE_GENERATOR_PLATFORM}
  INSTALL_COMMAND ""
  )

ExternalProject_Add (
            FREEGLUT-PRJ
            URL https://github.com/FreeGLUTProject/freeglut/releases/download/v3.4.0/freeglut-3.4.0.tar.gz
            URL_MD5 f1621464e6525d0368976870cab8f418
            CMAKE_GENERATOR ${CMAKE_GENERATOR}
            CMAKE_GENERATOR_TOOLSET ${CMAKE_GENERATOR_TOOLSET}
            CMAKE_GENERATOR_PLATFORM ${CMAKE_GENERATOR_PLATFORM}
            CMAKE_ARGS  -DCMAKE_BUILD_TYPE=Release
                        -DFREEGLUT_BUILD_SHARED_LIBS=OFF
                        -DFREEGLUT_BUILD_STATIC_LIBS=ON
                        -DFREEGLUT_BUILD_DEMOS=OFF
            PREFIX ${CMAKE_CURRENT_BINARY_DIR}/freeglut
            # BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/freeglut-build
            # BUILD_IN_SOURCE ON
            # UPDATE_COMMAND ""
            INSTALL_COMMAND ""
            # CONFIGURE_COMMAND ""
            # BUILD_COMMAND ""
        )

execute_process(
    COMMAND ${CMAKE_COMMAND} . -G "${CMAKE_GENERATOR}"
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/language_tests/${language}
    RESULT_VARIABLE return_code
    OUTPUT_QUIET
    ERROR_QUIET
    )

execute_process(COMMAND ${NETGEN_CMAKE_COMMAND} -G${CMAKE_GENERATOR} ${NETGEN_CMAKE_ARGS} ${SUBPROJECT_CMAKE_ARGS} ${PROJECT_SOURCE_DIR}/external_dependencies/netgen WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/netgen)

ExternalProject_Add(${ARG_TARGET_NAME}
        # Directory Options
        SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}"
        PREFIX "${CMAKE_CURRENT_BINARY_DIR}"
        BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/build"
        INSTALL_DIR "${ARG_NATIVE_INSTALL_DIR}"
        # Configure Step Options:
        CMAKE_COMMAND
            "${NATIVE_CMAKE_COMMAND}" -E env ${cmake_env}
                "${NATIVE_CMAKE_COMMAND}"
        CMAKE_ARGS
            "-DCMAKE_POLICY_DEFAULT_CMP0069=NEW"
            "-DCMAKE_INSTALL_PREFIX=${ARG_NATIVE_INSTALL_DIR}"
            ${ARG_CMAKE_ARGS}
        CMAKE_GENERATOR "${CMAKE_GENERATOR}"
        ${ARG_NATIVE_SOURCE_SUBDIR}
        # Build Step Options:
        BUILD_COMMAND
            "${NATIVE_CMAKE_COMMAND}"
                --build "${CMAKE_CURRENT_BINARY_DIR}/build"
                --config Release
                --parallel ${PROCESSOR_COUNT}
                -- ${ARG_NATIVE_TARGETS}
        # Test Step Options:
        TEST_EXCLUDE_FROM_MAIN ON
        # Target Options:
        EXCLUDE_FROM_ALL ON
    )

add_custom_command(
        COMMAND ${CMAKE_COMMAND} -E make_directory source/autodir_psivariables
        COMMAND ${PERL_EXECUTABLE} ${CCSD}/document_psivariables.pl ${CCSD}
        OUTPUT  ${CCBD}/source/autodoc_psivariables_bymodule.rst
                ${CCBD}/source/autodir_psivariables/module__scf.rst  # representative
        DEPENDS ${CCSD}/document_psivariables.pl
                $<IF:$<STREQUAL:${CMAKE_GENERATOR},"Unix Makefiles">,${psi4_SOURCE_DIR}/psi4/src/*/*/*.cc,${psi4_SOURCE_DIR}/psi4/src/psi4/fnocc/ccsd.cc>
        COMMENT "Autodoc PSI variables c-side")

ExternalProject_Add(
  build32 
  SOURCE_DIR "${CMAKE_SOURCE_DIR}"
  STAMP_DIR "${CMAKE_BINARY_DIR}/stamp32"
  BINARY_DIR "${CMAKE_BINARY_DIR}/build32"
  INSTALL_DIR "${CMAKE_BINARY_DIR}/install32"
  BUILD_ALWAYS ON
  EXCLUDE_FROM_ALL ON
  DOWNLOAD_COMMAND ""
  CONFIGURE_COMMAND
  "${CMAKE_COMMAND}"
  -S "<SOURCE_DIR>"
  -B "<BINARY_DIR>"
  -G "${CMAKE_GENERATOR}"
  "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
  -A Win32
  "-DBUILD_OUT_PREFIX=${BUILD_OUT_PREFIX}"
  -DWITH_ASAN=${WITH_ASAN}
  BUILD_COMMAND
  "${CMAKE_COMMAND}"
  --build "<BINARY_DIR>"
  --config "$<CONFIG>"
  --target build32
  --parallel
  INSTALL_COMMAND
  ""
)

add_test(
    NAME ExampleCMakeBuild
    COMMAND "${CMAKE_CTEST_COMMAND}"
            --build-and-test
            "${Minuit2_SOURCE_DIR}/examples/simple/"
            "${CMAKE_CURRENT_BINARY_DIR}/simple/"
            --build-generator "${CMAKE_GENERATOR}"
            --test-command "${CMAKE_CTEST_COMMAND}"
    )

ExternalProject_Add(${LOCAL_PROJECT_NAME}
  DEPENDS ${${LOCAL_PROJECT_NAME}_DEPENDENCIES}
  SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
        BINARY_DIR ${LOCAL_PROJECT_NAME}-${CMAKE_BUILD_TYPE}-EP${EXTERNAL_PROJECT_BUILD_TYPE}-build
        DOWNLOAD_COMMAND ""
        UPDATE_COMMAND ""
        CMAKE_GENERATOR ${gen}
        CMAKE_ARGS
        --no-warn-unused-cli    # HACK Only expected variables should be passed down.

        CMAKE_CACHE_ARGS
        -D${LOCAL_PROJECT_NAME}_SUPERBUILD:BOOL=OFF  # This must be here
        -DBUILD_TESTING:BOOL=${${LOCAL_PROJECT_NAME}_BUILD_TESTING}
        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
        -DBUILD_EXAMPLES:BOOL=${${LOCAL_PROJECT_NAME}_BUILD_TESTING}
        -DCMAKE_INSTALL_PREFIX_SET:BOOL=TRUE
        -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
        ${MYBRAINSTools_EP_ARGS}  # This appends the "mark_as_superbuild" variables to the written out cache for clion use
        #INSTALL_COMMAND ""
        LOG_CONFIGURE ON
        LOG_BUILD ON
        )

EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND}
                  -G "${CMAKE_GENERATOR}"
                  -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
                  -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
                  -DCMAKE_PREFIX_PATH=${TULIP_INSTALL_DIR}/lib/cmake
                  -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
                  ../${PLUGINS_SRC_DIR_NAME}
                WORKING_DIRECTORY ${PLUGINS_BUILD_DIR}
                RESULT_VARIABLE CMD_RESULT)

execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" .
    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/googletest-download")

cmake_print_variables(CMAKE_GENERATOR)

ExternalProject_Add(
  BUILTIN_CFITSIO
  PREFIX ${CFITSIO_PREFIX}
  URL https://lcgpackages.web.cern.ch/tarFiles/sources/cfitsio-${CFITSIO_VERSION}.tar.gz
  URL_HASH SHA256=95900cf95ae760839e7cb9678a7b2fad0858d6ac12234f934bd1cb6bfc246ba9
  CMAKE_ARGS -G ${CMAKE_GENERATOR}
             -DCMAKE_POLICY_VERSION_MINIMUM=3.5
             -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
             -DCMAKE_C_FLAGS=${CFITSIO_C_FLAGS}
             -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
             -DCMAKE_INSTALL_LIBDIR=<INSTALL_DIR>/lib
             -DBUILD_SHARED_LIBS=OFF
             -DUSE_CURL=OFF
             -DZLIB_FOUND=TRUE
             -DZLIB_INCLUDE_DIR=${ZLIB_INCLUDE_DIRS}
             -DZLIB_LIBRARIES=$<TARGET_FILE:ZLIB::ZLIB>
  # Skip the find_package(ZLIB REQUIRED), because we feed CFITSIO our own ZLIB flags.
  PATCH_COMMAND git apply --ignore-space-change --ignore-whitespace
                ${CMAKE_CURRENT_SOURCE_DIR}/cfitsio-no-find-zlib.diff
                ${CMAKE_CURRENT_SOURCE_DIR}/no-fortran-wrapper.diff
  BUILD_COMMAND ${CMAKE_COMMAND} --build . ${CFITSIO_BUILD_COMMAND_FLAGS}
  INSTALL_COMMAND ${CMAKE_COMMAND} --build . ${CFITSIO_BUILD_COMMAND_FLAGS} --target install
  LOG_DOWNLOAD 1 LOG_CONFIGURE 1 LOG_BUILD 1 LOG_INSTALL 1 LOG_OUTPUT_ON_FAILURE 1
  BUILD_BYPRODUCTS ${CFITSIO_LIBRARIES}
  TIMEOUT 600
)

add_test(compile-error-test ${CMAKE_CTEST_COMMAND}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/compile-error-test"
    "${CMAKE_CURRENT_BINARY_DIR}/compile-error-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
    "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
    "-DFMT_DIR=${CMAKE_SOURCE_DIR}"
    "-DSUPPORTS_USER_DEFINED_LITERALS=${SUPPORTS_USER_DEFINED_LITERALS}")

add_test(
      NAME find-package-testsA
      COMMAND
        ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" -A "${CMAKE_GENERATOR_PLATFORM}"
        "-DCLI11_DIR=${CMAKE_INSTALL_PREFIX}" "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
        "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
        "-DCMAKE_RUNTIME_OUTPUT_DIRECTORY=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
        "${CMAKE_CURRENT_SOURCE_DIR}/find_package_tests"
      WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/find_package_tests")

execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}"
  -DALLOW_DOWNLOADING_GOOGLETEST=${BENCHMARK_DOWNLOAD_DEPENDENCIES} -DGOOGLETEST_PATH:PATH=${GOOGLETEST_PATH} .
  RESULT_VARIABLE result
  WORKING_DIRECTORY ${GOOGLETEST_PREFIX}
)

ADD_CUSTOM_TARGET(${COPY_TARGET_NAME} ALL
    COMMAND ${CMAKE_COMMAND}
    -Dexecutable_full_filename="${executable_full_filename}"
    -Dexecutable_name="my_${executable_name}"
    -DCWD="${CMAKE_BINARY_DIR}/runtime_output_directory"
    -DAPPLE=${APPLE}
    -DLINUX=${LINUX}
    -DWIN32=${WIN32}
    -DCRYPTO_VERSION="${CRYPTO_VERSION}"
    -DOPENSSL_VERSION="${OPENSSL_VERSION}"
    -DINSTALL_PRIV_LIBDIR="${INSTALL_PRIV_LIBDIR}"
    -DPATCHELF_EXECUTABLE="${PATCHELF_EXECUTABLE}"
    -DBUILD_IS_SINGLE_CONFIG="${BUILD_IS_SINGLE_CONFIG}"
    -DCMAKE_GENERATOR="${CMAKE_GENERATOR}"
    -DCMAKE_SYSTEM_PROCESSOR="${CMAKE_SYSTEM_PROCESSOR}"
    -DCMAKE_CFG_INTDIR="${CMAKE_CFG_INTDIR}"
    -P ${CMAKE_SOURCE_DIR}/cmake/copy_openssl_binary.cmake
    WORKING_DIRECTORY
    "${CMAKE_BINARY_DIR}/runtime_output_directory"
    )

execute_process (
      COMMAND ${CMAKE_COMMAND} . -G "${CMAKE_GENERATOR}"
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/language_tests/${language}
      RESULT_VARIABLE return_code
      OUTPUT_QUIET
      ERROR_QUIET
      )

execute_process(COMMAND "${CMAKE_COMMAND}" -C "${CMAKE_CURRENT_SOURCE_DIR}/dxc/cmake/caches/PredefinedParams.cmake" -S "${CMAKE_CURRENT_SOURCE_DIR}/dxc" -B "${DXC_BUILD_DIR}" -G "${CMAKE_GENERATOR}" ${NBL_DXC_CMAKE_OPTIONS}
	RESULT_VARIABLE DXC_CMAKE_RESULT
	OUTPUT_VARIABLE DXC_CMAKE_STREAM_PIPE
)

IF(CMAKE_GENERATOR MATCHES "Visual Studio" OR CMAKE_GENERATOR STREQUAL "Xcode")

execute_process ( COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/columnar-build )

ExternalProject_Add(
    ArgParse
    GIT_REPOSITORY https://github.com/p-ranav/argparse
    GIT_TAG v2.1 # v2.2 contains invalid constexpr usage
    SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ArgParse
    USES_TERMINAL_INSTALL 0
    UPDATE_DISCONNECTED ${ThirdPartyDisconnected}
    CMAKE_ARGS
        -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/External
        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
        -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
        -DARGPARSE_BUILD_TESTS=OFF
        -G ${CMAKE_GENERATOR}
)

execute_process(COMMAND
    ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" "${${PROJECT_NAME}_SOURCE_DIR}/externals/box2d"
    -DBOX2D_BUILD_DOCS=OFF
    -DBOX2D_BUILD_TESTBED=OFF
    -DBOX2D_BUILD_UNIT_TESTS=OFF
    -DCMAKE_POSITION_INDEPENDENT_CODE=ON
    -DCMAKE_INSTALL_PREFIX=${EMBEDDED_box2d_INSTALL_DIR}
  RESULT_VARIABLE result
  WORKING_DIRECTORY "${EMBEDDED_box2d_BUILD_DIR}"
  ${echo_flag}
  )

if(${CMAKE_GENERATOR} MATCHES "Win64")

string(TOLOWER "${CMAKE_GENERATOR}" cmake_generator_tolower)

ADD_CUSTOM_TARGET(Headers_jdbc
    COMMAND ${CMAKE_COMMAND}
      -DCMAKE_GENERATOR=${CMAKE_GENERATOR}
      -DJDBC_DIR=${JDBC_DIR}
      -DJDBC_INCLUDES="${JDBC_INCLUDES}"
      -DHEADERS_DIR=${PROJECT_SOURCE_DIR}/cdk/cmake/headers
      -DCHECK_DIR=${CHECK_DIR}
      -P ${PROJECT_SOURCE_DIR}/cmake/jdbc_headers_check.cmake
    SOURCES ${all_headers}
  )

elseif(CMAKE_GENERATOR MATCHES Visual)

add_custom_command(OUTPUT ${LLVM_NATIVE_BUILD}/CMakeCache.txt
  COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" ${CMAKE_SOURCE_DIR}
  WORKING_DIRECTORY ${LLVM_NATIVE_BUILD}
  DEPENDS ${LLVM_NATIVE_BUILD}
  COMMENT "Configuring native LLVM...")

ExternalProject_Add(${PACKAGE_NAME}
                          DEPENDS ${SUPER_BUILD_TARGET_DEPENDENCIES}
                          SOURCE_DIR ${${PACKAGE_NAME}_DIR}
                          CMAKE_ARGS 
                            -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> 
                            -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} 
                            -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} 
                            -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} 
                            ${${PACKAGE_NAME}_CMAKE_MODULE_PATH}
                            ${BASIS_SUPER_BUILD_ARGS}
                          CMAKE_CHACHE_ARGS
                            -DCMAKE_PREFIX_PATH:STRING=${CMAKE_PREFIX_PATH_PIPE}
                          CMAKE_GENERATOR
                            ${CMAKE_GENERATOR}
                          CMAKE_TOOLSET
                            ${CMAKE_TOOLSET}
                          BINARY_DIR
                            ${${PACKAGE_NAME}_BINARY_DIR}
                          INSTALL_DIR
                            ${${PACKAGE_NAME}_CMAKE_INSTALL_PREFIX}
                          )

execute_process(
        COMMAND ${CMAKE_COMMAND} -G ${CMAKE_GENERATOR}
        -DAWS_NATIVE_SDK_ROOT=${AWS_NATIVE_SDK_ROOT}

        -DBUILD_CURL=${BUILD_CURL}
        -DCURL_SOURCE_DIR=${CURL_SOURCE_DIR}
        -DCURL_INSTALL_DIR=${CURL_INSTALL_DIR}
        -DCURL_OPENSSL_DEPENDENCY=${CURL_OPENSSL_DEPENDENCY}
        -DCURL_ZLIB_DEPENDENCY=${CURL_ZLIB_DEPENDENCY}
        -DCURL_CXX_FLAGS=${CURL_CXX_FLAGS}
        -DCURL_C_FLAGS=${CURL_C_FLAGS}
        -DCURL_STATIC_LINKER_FLAGS=${CURL_STATIC_LINKER_FLAGS}
        -DCURL_SHARED_LINKER_FLAGS=${CURL_SHARED_LINKER_FLAGS}
        -DCURL_EXE_LINKER_FLAGS=${CURL_EXE_LINKER_FLAGS}
        -DCURL_USE_ZLIB=${CURL_USE_ZLIB}

        -DBUILD_OPENSSL=${BUILD_OPENSSL}
        -DOPENSSL_SOURCE_DIR=${OPENSSL_SOURCE_DIR}
        -DOPENSSL_INCLUDE_DIR=${OPENSSL_INCLUDE_DIR}
        -DOPENSSL_INSTALL_DIR=${OPENSSL_INSTALL_DIR}
        -DOPENSSL_CXX_FLAGS=${OPENSSL_CXX_FLAGS}
        -DOPENSSL_C_FLAGS=${OPENSSL_C_FLAGS}
        -DOPENSSL_EXE_LINKER_FLAGS=${OPENSSL_EXE_LINKER_FLAGS}

        -DBUILD_ZLIB=${BUILD_ZLIB}
        -DZLIB_SOURCE_DIR=${ZLIB_SOURCE_DIR}
        -DZLIB_INSTALL_DIR=${ZLIB_INSTALL_DIR}

        -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
        -DCMAKE_ANDROID_NDK_TOOLCHAIN_VERSION=${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}
        -DANDROID_NATIVE_API_LEVEL=${ANDROID_NATIVE_API_LEVEL}
        -DANDROID_ABI=${ANDROID_ABI}
        -DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN}
        -DANDROID_STL=${ANDROID_STL}

        -DEXTERNAL_CXX_FLAGS=${EXTERNAL_CXX_FLAGS}
        -DEXTERNAL_C_FLAGS=${EXTERNAL_C_FLAGS}
        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
        ${CMAKE_CURRENT_SOURCE_DIR}/tools/android-build
        WORKING_DIRECTORY ${EXTERNAL_BUILD_DIR}
        RESULT_VARIABLE CONFIGURE_DEPS_EXIT_CODE)

ExternalProject_Add(${name}_project
    DOWNLOAD_DIR ${_DIR}
    SOURCE_DIR ${_DIR}
    INSTALL_DIR ${INSTALL_ROOT}
    UPDATE_COMMAND ""

    BUILD_COMMAND ${parsed_BUILD_COMMAND}

    INSTALL_COMMAND ${parsed_INSTALL_COMMAND}

    # Wrap download, configure and build steps in a script to log output
    LOG_INSTALL ON
    LOG_DOWNLOAD ON
    LOG_CONFIGURE ON
    LOG_BUILD ON
    LOG_PATCH ON
    LOG_UPDATE ON

    CMAKE_GENERATOR "Unix Makefiles"
    BUILD_BYPRODUCTS ${LIB_FILES}
    # LIST_SEPARATOR | # Use the alternate list separator.
    # Can not use | because we use it inside sh/install_cmd

    # we need those CMAKE_ARGS for cmake based 3rd party projects.
    # CMAKE_ARCHIVE_OUTPUT_DIRECTORY is for static libs
    # CMAKE_LIBRARY_OUTPUT_DIRECTORY is for shared libs
    CMAKE_ARGS -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${INSTALL_ROOT}/lib
        -DCMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${INSTALL_ROOT}/lib
        -DCMAKE_BUILD_TYPE:STRING=Release
        -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
        -DBUILD_TESTING=OFF
        "-DCMAKE_C_FLAGS:STRING=-O3" -DCMAKE_CXX_FLAGS=${THIRD_PARTY_CXX_FLAGS}
        -DCMAKE_INSTALL_PREFIX:PATH=${INSTALL_ROOT}
        ${piped_CMAKE_ARGS}
    ${parsed_UNPARSED_ARGUMENTS}
  )

add_test(NAME RunCMake.${test} COMMAND ${CMAKE_COMMAND}
    -DCMAKE_MODULE_PATH=${RunCMakeDir}
    -DRunCMake_GENERATOR_IS_MULTI_CONFIG=${_isMultiConfig}
    -DRunCMake_GENERATOR=${CMAKE_GENERATOR}
    -DRunCMake_GENERATOR_INSTANCE=${CMAKE_GENERATOR_INSTANCE}
    -DRunCMake_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
    -DRunCMake_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
    -DRunCMake_MAKE_PROGRAM=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
    -DRunCMake_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${Test_Dir}
    -DRunCMake_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/${test}
    ${${test}_ARGS}
    ${TEST_ARGS}
    -P "${QT_RUN_CMAKE_SCRIPT_PATH}"
    )

add_custom_command(OUTPUT ${LLVM_${target_name}_BUILD}/CMakeCache.txt
    COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}"
        ${CROSS_TOOLCHAIN_FLAGS_${target_name}} ${CMAKE_SOURCE_DIR}
    WORKING_DIRECTORY ${LLVM_${target_name}_BUILD}
    DEPENDS ${LLVM_${target_name}_BUILD}
    COMMENT "Configuring ${target_name} LLVM...")

if ("${CMAKE_GENERATOR}" MATCHES "Make|Ninja")

execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
                    RESULT_VARIABLE result
                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )

execute_process (COMMAND ${CMAKE_COMMAND} -E env CC=${SAVED_CC} CXX=${SAVED_CXX} ${CMAKE_COMMAND} -G${CMAKE_GENERATOR} -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM} .
            WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/generated RESULT_VARIABLE EXIT_CODE ERROR_VARIABLE ERR_VAR OUTPUT_QUIET)

ExternalProject_Add(
    KWStyle
    GIT_REPOSITORY "https://github.com/Kitware/KWStyle.git"
    GIT_TAG eb1e46d57db04a2f94a1a4709a67d8fb8f986400
    UPDATE_COMMAND
      ""
    DOWNLOAD_DIR ${KWStyle_SOURCE_DIR}
    SOURCE_DIR ${KWStyle_SOURCE_DIR}
    BINARY_DIR ${KWStyle_DIR}
    INSTALL_DIR ${KWStyle_DIR}
    LOG_DOWNLOAD 1
    LOG_UPDATE 0
    LOG_CONFIGURE 0
    LOG_BUILD 0
    LOG_TEST 0
    LOG_INSTALL 0
    CMAKE_GENERATOR ${gen}
    CMAKE_ARGS
      -DCMAKE_MAKE_PROGRAM:FILEPATH=${CMAKE_MAKE_PROGRAM}
      -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
      ${CMAKE_CXX_COMPILER_LAUNCHER_FLAG}
      -DCMAKE_C_COMPILER:STRING=${CMAKE_C_COMPILER}
      ${CMAKE_C_COMPILER_LAUNCHER_FLAG}
      -DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS}
      -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${_build_configuration_arg}
      -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
      -DBUILD_TESTING:BOOL=OFF
    INSTALL_COMMAND
      ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/ITKKWStyleConfig.cmake
  )

execute_process(
            COMMAND ${CMAKE_COMMAND}
                "-G${CMAKE_GENERATOR}"
                "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
                "-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}"
                "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
                "-Dprotobuf_BUILD_TESTS=0"
                "-Dprotobuf_BUILD_CONFORMANCE=0"
                "-Dprotobuf_BUILD_EXAMPLES=0"
                "-Dprotobuf_BUILD_PROTOC_BINARIES=1"
                "-DABSL_ROOT_DIR=${abseil_source_dir}"
                "-DABSL_ENABLE_INSTALL=0"
                "${protobuf_source_dir}"
            WORKING_DIRECTORY "${PROTOC_BUILD_DIR}"
            COMMAND_ECHO STDOUT
            COMMAND_ERROR_IS_FATAL ANY
        )

add_custom_target(test.deploy
  DEPENDS test.deploy.fakeroot
  COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/deploy/build"
  COMMAND ${CMAKE_COMMAND} -E chdir "${CMAKE_CURRENT_BINARY_DIR}/deploy/build"
            ${CMAKE_COMMAND} "${CMAKE_CURRENT_SOURCE_DIR}/deploy"
                             -DCMAKE_CXX_COMPILER="${CMAKE_CXX_COMPILER}"
                             -DCMAKE_PREFIX_PATH="${HANA_FAKE_INSTALL_DIR}"
                             -DCMAKE_GENERATOR=${CMAKE_GENERATOR}
                             -DCMAKE_TOOLCHAIN_FILE="${CMAKE_TOOLCHAIN_FILE}"
  COMMAND ${CMAKE_COMMAND} --build "${CMAKE_CURRENT_BINARY_DIR}/deploy/build"
  USES_TERMINAL
)

add_test(
  NAME cryptopp-${test_name}-configure
  COMMAND
    ${CMAKE_COMMAND}
    -G${CMAKE_GENERATOR}
    # Pass the locations for common test source files
    -D "TEST_EXAMPLE_SOURCES_DIR=${TEST_EXAMPLE_SOURCES_DIR}"
    # Set the install prefix
    -D "CRYPTOPP_CMAKE_INSTALL_ROOT=${CRYPTOPP_CMAKE_INSTALL_ROOT}"
    # Setup cmake source/build dirs
    -S "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}" -B
    "${CMAKE_BINARY_DIR}/test-dirs/${test_name}"
    # Enable verbose makefiles so we can see the full compile command line
    -D "CMAKE_VERBOSE_MAKEFILE=ON"
    # Throw the version in
    -D CRYPTOPP_MINIMUM_CMAKE_VERSION=${CRYPTOPP_MINIMUM_CMAKE_VERSION}
    # Set the build-type to what we are building
    -D CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
    # Tell the test where to find installed package
    -D cryptopp_DIR=${CRYPTOPP_SEARCH_ROOT}/share/cmake/cryptopp)

if(CMAKE_GENERATOR MATCHES "^Visual.*$")

ExternalProject_Add(adios2
  SOURCE_DIR "$ENV{SRC_DIR}"
  INSTALL_DIR "$ENV{PREFIX}"
  CMAKE_GENERATOR "$ENV{CMAKE_GENERATOR}"
  CMAKE_ARGS
    -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
    -DCMAKE_BUILD_TYPE=Release
    -DBUILD_SHARED_LIBS=ON
    -DADIOS2_USE_Python=ON
    -DPYTHON_EXECUTABLE=$ENV{PYTHON}
    -DADIOS2_USE_MPI=ON
)

execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}"
    -DALLOW_DOWNLOADING_GOOGLETEST=${ALLOW_DOWNLOADING_GOOGLETEST} -DGOOGLETEST_PATH:PATH=${GOOGLETEST_PATH} .
    RESULT_VARIABLE result
    WORKING_DIRECTORY ${GOOGLETEST_PREFIX}
  )

add_test(
  NAME cmake_fetch_content_configure
  COMMAND
    ${CMAKE_COMMAND}
      -G "${CMAKE_GENERATOR}"
      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
      -S${CMAKE_CURRENT_SOURCE_DIR}/project
      -B${CMAKE_CURRENT_BINARY_DIR}/build
)

ExternalProject_Add(godotcpp
            GIT_REPOSITORY https://github.com/godotengine/godot-cpp
            GIT_TAG 316b91c5f5d89d82ae935513c28df78f9e238e8b
            SOURCE_DIR ${CMAKE_BINARY_DIR}/godot-cpp
            BINARY_DIR ${CMAKE_BINARY_DIR}/godot-cpp-build
            CMAKE_ARGS
                -G ${CMAKE_GENERATOR}
                -D CMAKE_BUILD_TYPE=${GODOT_CPP_BUILD_TYPE}
                -D CMAKE_CONFIGURATION_TYPES=${GODOT_CPP_BUILD_TYPE}
                -D CMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
                -D CMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
                -D PYTHON_EXECUTABLE=${Python3_EXECUTABLE}
                -D Python3_EXECUTABLE=${Python3_EXECUTABLE}
                ${CL_ARGS}
            INSTALL_COMMAND ""
        )

add_custom_command (OUTPUT ${CMAKE_BINARY_DIR}/export_albany.in
                      COMMAND ${CMAKE_SOURCE_DIR}/cmake/CreateExportAlbany
                      ARGS --bin-dir ${CMAKE_BINARY_DIR}
                           --install-lib-dir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}
                           --cmake-generator ${CMAKE_GENERATOR}
                      DEPENDS ${CMAKE_BINARY_DIR}/src/Albany_GitVersion.h
                      WORKING_DIRECTORY ${WORK_DIR})

foreach(varname IN ITEMS
      "CMAKE_GENERATOR"
      "CMAKE_GENERATOR_PLATFORM"
      "CMAKE_GENERATOR_TOOLSET"
    )

add_custom_command(OUTPUT ${LLVM_${target_name}_BUILD}/CMakeCache.txt
    COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}"
        ${CROSS_TOOLCHAIN_FLAGS_${target_name}} ${CMAKE_SOURCE_DIR}
        -DLLVM_TARGET_IS_CROSSCOMPILE_HOST=TRUE
    WORKING_DIRECTORY ${LLVM_${target_name}_BUILD}
    DEPENDS ${LLVM_${target_name}_BUILD}
    COMMENT "Configuring ${target_name} LLVM...")

execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" . 
		WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/googletest-download" )

cmake_print_variables(
            CMAKE_SYSTEM_PROCESSOR
            CMAKE_SYSTEM_NAME
            CMAKE_VERSION
            CMAKE_BUILD_TYPE
            CMAKE_CXX_COMPILER
            CMAKE_CXX_COMPILER_VERSION
            CMAKE_CXX_STANDARD
            CMAKE_SYSTEM
            CMAKE_HOST_SYSTEM_NAME
            CMAKE_HOST_SYSTEM_PROCESSOR
            CMAKE_GENERATOR
            CMAKE_BINARY_DIR
            CMAKE_SOURCE_DIR
            CMAKE_LINKER
            CMAKE_CXX_FLAGS
            CMAKE_C_FLAGS
            CMAKE_CROSSCOMPILING
    )

ExternalProject_Add(
    ext_turbojpeg
    PREFIX turbojpeg
    SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libjpeg-turbo/libjpeg-turbo
    UPDATE_COMMAND ""
    CMAKE_GENERATOR ${CMAKE_GENERATOR}
    CMAKE_GENERATOR_PLATFORM ${CMAKE_GENERATOR_PLATFORM}
    CMAKE_GENERATOR_TOOLSET ${CMAKE_GENERATOR_TOOLSET}
    CMAKE_ARGS
        -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
        -DCMAKE_C_FLAGS=${DCMAKE_C_FLAGS}
        -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
        -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
        -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
        -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
        -DENABLE_STATIC=ON
        -DENABLE_SHARED=OFF
        -DWITH_SIMD=${WITH_SIMD}
        -DCMAKE_INSTALL_PREFIX=${3RDPARTY_INSTALL_PREFIX}
        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
)

foreach(varname IN ITEMS
      "CMAKE_GENERATOR"
      "CMAKE_GENERATOR_PLATFORM"
      "CMAKE_GENERATOR_TOOLSET"
    )

elseif ("${CMAKE_GENERATOR}" MATCHES "JOM|Ninja|Visual Studio")

IF(${CMAKE_GENERATOR} MATCHES "Visual Studio 7")

execute_process(
        COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
        RESULT_VARIABLE result
        WORKING_DIRECTORY ${CEF_DOWNLOAD_DIR}
    )

ExternalProject_Add(RemoteVstPlugin32
		"${EXTERNALPROJECT_ARGS}"
		CMAKE_GENERATOR "${LMMS_MSVC_GENERATOR}"
		CMAKE_GENERATOR_PLATFORM Win32
		#CMAKE_GENERATOR_TOOLSET "${CMAKE_GENERATOR_TOOLSET}"
		CMAKE_ARGS
			"${EXTERNALPROJECT_CMAKE_ARGS}"
			"-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
	)

ADD_TEST("${testname}"
		${CMAKE_CTEST_COMMAND}
		--build-and-test
		"${CMAKE_CURRENT_SOURCE_DIR}/tools/CompileFailTest"
		"${CMAKE_CURRENT_BINARY_DIR}/tools/CompileFailTest"
		--build-generator "${CMAKE_GENERATOR}"
		--build-makeprogram "${CMAKE_MAKE_PROGRAM}"
		--build-project CompileFailTest
		--build-options -DSOURCE=${sourcefile} -DINCLUDES=${TEST_INCLUDES} -DDEF_FLAG="${def_flag}"
	)

cmake_print_variables(
            CMAKE_SYSTEM_PROCESSOR
            CMAKE_SYSTEM_NAME
            CMAKE_VERSION
            CMAKE_BUILD_TYPE
            CMAKE_CXX_COMPILER
            CMAKE_CXX_COMPILER_VERSION
            CMAKE_CXX_STANDARD
            CMAKE_SYSTEM
            CMAKE_HOST_SYSTEM_NAME
            CMAKE_HOST_SYSTEM_PROCESSOR
            CMAKE_GENERATOR
            CMAKE_BINARY_DIR
            CMAKE_CURRENT_SOURCE_DIR
            CMAKE_LINKER
            CMAKE_CXX_FLAGS
            CMAKE_C_FLAGS
            CMAKE_CROSSCOMPILING
    )

ADD_CUSTOM_TARGET(${COPY_TARGET_NAME} ALL
    COMMAND ${CMAKE_COMMAND}
    -Dexecutable_full_filename="${executable_full_filename}"
    -Dexecutable_name="my_${executable_name}"
    -DCWD="${CMAKE_BINARY_DIR}/runtime_output_directory"
    -DAPPLE=${APPLE}
    -DLINUX=${LINUX}
    -DWIN32=${WIN32}
    -DCRYPTO_VERSION="${CRYPTO_VERSION}"
    -DOPENSSL_VERSION="${OPENSSL_VERSION}"
    -DINSTALL_PRIV_LIBDIR="${INSTALL_PRIV_LIBDIR}"
    -DPATCHELF_EXECUTABLE="${PATCHELF_EXECUTABLE}"
    -DCPU_PAGE_SIZE="${CPU_PAGE_SIZE}"
    -DBUILD_IS_SINGLE_CONFIG="${BUILD_IS_SINGLE_CONFIG}"
    -DCMAKE_GENERATOR="${CMAKE_GENERATOR}"
    -DCMAKE_SYSTEM_PROCESSOR="${CMAKE_SYSTEM_PROCESSOR}"
    -DCMAKE_CFG_INTDIR="${CMAKE_CFG_INTDIR}"
    -P ${CMAKE_SOURCE_DIR}/cmake/copy_openssl_binary.cmake
    WORKING_DIRECTORY
    "${CMAKE_BINARY_DIR}/runtime_output_directory"
    )

add_custom_target(
    test_build_${name}
    ${CMAKE_CTEST_COMMAND}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/${name}"
    "${CMAKE_CURRENT_BINARY_DIR}/${name}"
    --build-config
    Release
    --build-noclean
    --build-generator
    ${CMAKE_GENERATOR}
    $<$<BOOL:${CMAKE_GENERATOR_PLATFORM}>:--build-generator-platform>
    ${CMAKE_GENERATOR_PLATFORM}
    --build-makeprogram
    ${CMAKE_MAKE_PROGRAM}
    --build-target
    check_${name}
    --build-options
    ${build_options})

MESSAGE(STATUS "CMAKE_GENERATOR: ${CMAKE_GENERATOR}")

execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
        RESULT_VARIABLE result
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )

add_custom_command(TARGET ${target} POST_BUILD
                       COMMAND ${CMAKE_COMMAND}
                                #-DCMAKE_GENERATOR=${CMAKE_GENERATOR}
                                -DMSVC_VERSION=${MSVC_VERSION}
                                -DTARGET_FILE=$<TARGET_FILE:${target}>
                                #-DPROJECT_BINARY_DIR=${PROJECT_BINARY_DIR}
                                #-DCMAKE_CURRENT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}
                                #-DCONFIGURATION=$<CONFIGURATION>
                                -DOUTPUT_FILE=${outputfile}
                                -P ${_windows_create_link_header}
                        BYPRODUCTS ${outputfile}
                      )

execute_process(
          WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/Check${lang}
          COMMAND ${CMAKE_COMMAND} . -G ${CMAKE_GENERATOR}
                                     -A "${CMAKE_GENERATOR_PLATFORM}"
                                     -T "${CMAKE_GENERATOR_TOOLSET}"
                                     ${_D_CMAKE_GENERATOR_INSTANCE}
                                     ${_D_CMAKE_MAKE_PROGRAM}
                                     ${_D_CMAKE_TOOLCHAIN_FILE}
                                     ${_D_CMAKE_LANG_PLATFORM}
          OUTPUT_VARIABLE _cl_output
          ERROR_VARIABLE _cl_output
          RESULT_VARIABLE _cl_result
          )

execute_process(WORKING_DIRECTORY "${DEPS_BUILD}" COMMAND ${CMAKE_COMMAND} -G ${CMAKE_GENERATOR} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} ..)

execute_process(
    COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
    RESULT_VARIABLE results
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/azurestorage-download
  )

ExternalProject_Add(
    extern_gtest
    ${EXTERNAL_PROJECT_LOG_ARGS}
    SOURCE_DIR ${SOURCE_DIR}
    DEPENDS ${GTEST_DEPENDS}
    PREFIX ${GTEST_PREFIX_DIR}
    UPDATE_COMMAND ""
    PATCH_COMMAND ${GTEST_PATCH_COMMAND}
    CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
               -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
               -DCMAKE_CXX_FLAGS=${GTEST_CMAKE_CXX_FLAGS}
               -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
               -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
               -DCMAKE_C_FLAGS=${GTEST_CMAKE_C_FLAGS}
               -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
               -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
               -DCMAKE_INSTALL_PREFIX=${GTEST_INSTALL_DIR}
               -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR}
               -DCMAKE_POSITION_INDEPENDENT_CODE=ON
               -DBUILD_GMOCK=ON
               -Dgtest_disable_pthreads=ON
               -Dgtest_force_shared_crt=ON
               -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
               ${EXTERNAL_OPTIONAL_ARGS}
    CMAKE_CACHE_ARGS
      -DCMAKE_INSTALL_PREFIX:PATH=${GTEST_INSTALL_DIR}
      -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
      -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
    CMAKE_GENERATOR "Unix Makefiles"
    BUILD_BYPRODUCTS ${GTEST_LIBRARIES}
    BUILD_BYPRODUCTS ${GTEST_MAIN_LIBRARIES}
    BUILD_BYPRODUCTS ${GMOCK_LIBRARIES})

execute_process (
      COMMAND ${CMAKE_COMMAND} . -G "${CMAKE_GENERATOR}"
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/language_tests/${language}
      RESULT_VARIABLE return_code
      OUTPUT_QUIET
      ERROR_QUIET
      )

elseif ("${CMAKE_GENERATOR}" MATCHES "Make|Ninja")

ELSEIF(CMAKE_GENERATOR MATCHES "^Visual Studio " AND CMAKE_VS_PLATFORM_NAME)

externalproject_add(wiiu-rpc
      SOURCE_DIR "${PROJECT_SOURCE_DIR}/wiiu-rpc"
      INSTALL_COMMAND ""
      CMAKE_GENERATOR "Unix Makefiles"
      CMAKE_CACHE_ARGS
         -DDEVKITPPC:string=${DEVKITPPC}
         -DWUT_ROOT:string=${WUT_ROOT}
         -DCMAKE_TOOLCHAIN_FILE:string=${WUT_ROOT}/share/wut.toolchain.cmake)

add_test(compile-error-test ${CMAKE_CTEST_COMMAND}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/compile-error-test"
    "${CMAKE_CURRENT_BINARY_DIR}/compile-error-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
    "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
    "-DCXX_STANDARD_FLAG=${CXX_STANDARD_FLAG}"
    "-DFMT_DIR=${CMAKE_SOURCE_DIR}")

add_test(static-export-test ${CMAKE_CTEST_COMMAND}
    -C ${CMAKE_BUILD_TYPE}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/static-export-test"
    "${CMAKE_CURRENT_BINARY_DIR}/static-export-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")

execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
                    RESULT_VARIABLE result
                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-download )

execute_process(
      COMMAND
      "${CMAKE_COMMAND}"
      "-H${dir}"
      "-B${build_dir}"
      "-G${CMAKE_GENERATOR}"
      "${toolchain_arg}"
      ${make_arg}
      WORKING_DIRECTORY "${dir}"
      RESULT_VARIABLE download_result
      ${logging_params}
  )

ExternalProject_Add(
  googletest
  GIT_REPOSITORY https://github.com/google/googletest.git
  EXCLUDE_FROM_ALL 1
  GIT_SHALLOW 1
  GIT_TAG v1.16.0
  UPDATE_COMMAND ""
  # # Force separate output paths for debug and release builds to allow easy
  # # identification of correct lib in subsequent TARGET_LINK_LIBRARIES commands
  # CMAKE_ARGS -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG:PATH=DebugLibs
  #            -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE:PATH=ReleaseLibs
  #            -Dgtest_force_shared_crt=ON
  CMAKE_ARGS -G ${CMAKE_GENERATOR}
                -DCMAKE_BUILD_TYPE=Release
                -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
                -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS_NOCOV}
                -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
                -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS_NOCOV}
                -DCMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS=${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS_NOCOV}
                -DCMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS_NOCOV}
                -DCMAKE_SHARED_LINKER_FLAGS=${CMAKE_SHARED_LINKER_FLAGS_NOCOV}
                -DCMAKE_AR=${CMAKE_AR}
                -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
                ${EXTRA_GTEST_OPTS}
  BUILD_COMMAND ${CMAKE_COMMAND} --build <BINARY_DIR> --config Release -- -j6
  # Disable install step
  INSTALL_COMMAND ""
  BUILD_BYPRODUCTS ${_gtest_byproducts}
  # Wrap download, configure and build steps in a script to log output
  LOG_DOWNLOAD ON
  LOG_CONFIGURE ON
  LOG_BUILD ON
  TIMEOUT 600
  )

ADD_CUSTOM_TARGET(${COPY_TARGET_NAME} ALL
    COMMAND ${CMAKE_COMMAND}
    -Dexecutable_full_filename="${executable_full_filename}"
    -Dexecutable_name="my_${executable_name}"
    -DCWD="${CMAKE_BINARY_DIR}/runtime_output_directory"
    -DAPPLE=${APPLE}
    -DLINUX=${LINUX}
    -DWIN32=${WIN32}
    -DCRYPTO_VERSION="${CRYPTO_VERSION}"
    -DOPENSSL_VERSION="${OPENSSL_VERSION}"
    -DINSTALL_PRIV_LIBDIR="${INSTALL_PRIV_LIBDIR}"
    -DPATCHELF_EXECUTABLE="${PATCHELF_EXECUTABLE}"
    -DCPU_PAGE_SIZE="${CPU_PAGE_SIZE}"
    -DBUILD_IS_SINGLE_CONFIG="${BUILD_IS_SINGLE_CONFIG}"
    -DCMAKE_GENERATOR="${CMAKE_GENERATOR}"
    -DCMAKE_SYSTEM_PROCESSOR="${CMAKE_SYSTEM_PROCESSOR}"
    -DCMAKE_CFG_INTDIR="${CMAKE_CFG_INTDIR}"
    -P ${CMAKE_SOURCE_DIR}/cmake/copy_openssl_binary.cmake
    WORKING_DIRECTORY
    "${CMAKE_BINARY_DIR}/runtime_output_directory"
    )

add_custom_target(
    test_build_${name}
    ${CMAKE_CTEST_COMMAND}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/${name}"
    "${CMAKE_CURRENT_BINARY_DIR}/${name}"
    --build-config
    Release
    --build-noclean
    --build-generator
    ${CMAKE_GENERATOR}
    $<$<BOOL:${CMAKE_GENERATOR_PLATFORM}>:--build-generator-platform>
    ${CMAKE_GENERATOR_PLATFORM}
    --build-makeprogram
    ${CMAKE_MAKE_PROGRAM}
    --build-target
    check_${name}
    --build-options
    ${build_options})

add_test(NAME cmake_fetch_content_configure
    COMMAND ${CMAKE_COMMAND}
    -G "${CMAKE_GENERATOR}"
    -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
    -Dnlohmann_json_source=${PROJECT_SOURCE_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/project
  )

ADD_CUSTOM_COMMAND(OUTPUT "${BIN2H_COMMAND}" "${BSINCGEN_COMMAND}"
    COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" "${NATIVE_SRC_DIR}"
    COMMAND ${CMAKE_COMMAND} -E remove "${BIN2H_COMMAND}" "${BSINCGEN_COMMAND}"
    COMMAND ${CMAKE_COMMAND} --build . --config "Release"
    WORKING_DIRECTORY "${NATIVE_BIN_DIR}"
    DEPENDS "${NATIVE_SRC_DIR}CMakeLists.txt"
    IMPLICIT_DEPENDS C "${NATIVE_SRC_DIR}bin2h.c"
                     C "${NATIVE_SRC_DIR}bsincgen.c"
    VERBATIM
)

elseif ("${CMAKE_GENERATOR}" MATCHES "Make|Ninja")

string(TOLOWER "${CMAKE_GENERATOR}" cmake_generator_tolower)

elseif(${CMAKE_GENERATOR} MATCHES "Xcode.*")

add_test (NAME includes_raw_logging COMMAND ${CMAKE_CTEST_COMMAND}
    --build-config $<CONFIG>
    --build-and-test
    "${glog_SOURCE_DIR}/src/includes_unittest"
    "${glog_BINARY_DIR}/Tests/includes_raw_logging"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-target glog_includes_raw_logging
    --build-options
    -DCMAKE_BUILD_TYPE=$<CONFIG>
    -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
    -DCMAKE_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
    -DCMAKE_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
    -Dglog_DIR=${glog_BINARY_DIR}
  )

add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND}
    -C ${CMAKE_BUILD_TYPE}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/add-subdirectory-test"
    "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")

ExternalProject_Add(${proj}
  LIST_SEPARATOR ${sep}
  DOWNLOAD_COMMAND ""
  CMAKE_GENERATOR ${gen}
  CMAKE_GENERATOR_PLATFORM ${gen_platform}
  CMAKE_CACHE_ARGS
    # --------------- Build options ----------------
    -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
    -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
    -DMITK_BUILD_CONFIGURATION:STRING=${MITK_BUILD_CONFIGURATION}
    -DMITK_XVFB_TESTING_COMMAND:STRING=${MITK_XVFB_TESTING_COMMAND}
    "-DCMAKE_CONFIGURATION_TYPES:STRING=${CMAKE_CONFIGURATION_TYPES}"
    "-DCMAKE_PREFIX_PATH:PATH=${ep_prefix};${CMAKE_PREFIX_PATH}"
    "-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
    "-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
    # --------------- Compile options ----------------
    -DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
    -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
    -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
    -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
    -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
    "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${MITK_ADDITIONAL_C_FLAGS}"
    "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_ADDITIONAL_CXX_FLAGS}"
    # debug flags
    "-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} ${MITK_ADDITIONAL_CXX_FLAGS_DEBUG}"
    "-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} ${MITK_ADDITIONAL_C_FLAGS_DEBUG}"
    # release flags
    "-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} ${MITK_ADDITIONAL_CXX_FLAGS_RELEASE}"
    "-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} ${MITK_ADDITIONAL_C_FLAGS_RELEASE}"
    # relwithdebinfo
    -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
    -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
    # link flags
    "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} ${MITK_ADDITIONAL_EXE_LINKER_FLAGS}"
    "-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} ${MITK_ADDITIONAL_SHARED_LINKER_FLAGS}"
    "-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ${MITK_ADDITIONAL_MODULE_LINKER_FLAGS}"
    # Output directories
    -DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
    -DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
    -DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
    # ------------- Boolean build options --------------
    ${mitk_superbuild_boolean_args}
    ${mitk_optional_cache_args}
    -DMITK_USE_SUPERBUILD:BOOL=OFF
    -DMITK_PCH:BOOL=${MITK_PCH}
    -DMITK_FAST_TESTING:BOOL=${MITK_FAST_TESTING}
    -DMITK_XVFB_TESTING:BOOL=${MITK_XVFB_TESTING}
    -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
    # ----------------- Miscellaneous ---------------
    -DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}
    -DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}
    -DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE}
    -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
    -DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD}
    -DMITK_WHITELIST:STRING=${MITK_WHITELIST}
    -DMITK_WHITELISTS_EXTERNAL_PATH:STRING=${MITK_WHITELISTS_EXTERNAL_PATH}
    -DMITK_WHITELISTS_INTERNAL_PATH:STRING=${MITK_WHITELISTS_INTERNAL_PATH}
    -DMITK_EXTENSION_DIRS:STRING=${MITK_EXTENSION_DIRS}
    -DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}
    -DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}
    -DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
    -DMITK_ACCESSBYITK_VECTOR_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
    -DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS}
    -DMITK_CUSTOM_REVISION_DESC:STRING=${MITK_CUSTOM_REVISION_DESC}
    "-DMITK_CODESIGN_IDENTITY:STRING=${MITK_CODESIGN_IDENTITY}"
    # --------------- External project options ---------------
    -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
    -DMITK_EXTERNAL_PROJECT_PREFIX:PATH=${ep_prefix}
    -DCppMicroServices_DIR:PATH=${CppMicroServices_DIR}
    -DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=${DCMTK_CMAKE_DEBUG_POSTFIX}
    -DBoost_ROOT:PATH=${Boost_ROOT}
    -DBOOST_LIBRARYDIR:PATH=${BOOST_LIBRARYDIR}
    -DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
    -DQt6_DIR:PATH=${Qt6_DIR}
  CMAKE_ARGS
    ${mitk_initial_cache_arg}
    ${MAC_OSX_ARCHITECTURE_ARGS}
    ${mitk_superbuild_ep_args}
  SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
  BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
  BUILD_COMMAND ""
  INSTALL_COMMAND ""
  DEPENDS
    MITK-Utilities
  )

add_test(find-package-test ${CMAKE_CTEST_COMMAND}
        -C ${CMAKE_BUILD_TYPE}
        --build-and-test
        "${CMAKE_CURRENT_SOURCE_DIR}/find-package-test"
        "${CMAKE_CURRENT_BINARY_DIR}/find-package-test"
        --build-generator ${CMAKE_GENERATOR}
        --build-makeprogram ${CMAKE_MAKE_PROGRAM}
        --build-options
        "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
        "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
        "-Dcxxopts_DIR=${PROJECT_BINARY_DIR}"
    )

ExternalProject_Add(${example}
            DEPENDS ${PROJECT_NAME}
            CMAKE_GENERATOR "${CMAKE_GENERATOR}"
            CMAKE_ARGS
            ${${example}_CMAKE_ARGS}
            SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${example_directory}"
            BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/${example_directory}"
            INSTALL_COMMAND ""
            )

execute_process (
      COMMAND ${CMAKE_COMMAND} . -G "${CMAKE_GENERATOR}"
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/language_tests/${language}
      RESULT_VARIABLE return_code
      OUTPUT_QUIET
      ERROR_QUIET
      )

ExternalProject_Add(
    ext_gtest
    PREFIX gtest
    GIT_REPOSITORY ${GTEST_GIT_REPO_URL}
    GIT_TAG ${GTEST_GIT_LABEL}
    # Disable install step
    INSTALL_COMMAND ""
    UPDATE_COMMAND ""
    CMAKE_GENERATOR ${CMAKE_GENERATOR}
    CMAKE_GENERATOR_PLATFORM ${CMAKE_GENERATOR_PLATFORM}
    CMAKE_GENERATOR_TOOLSET ${CMAKE_GENERATOR_TOOLSET}
    CMAKE_ARGS
        ${NGRAPH_FORWARD_CMAKE_ARGS}
        -DCMAKE_CXX_FLAGS=${GTEST_CXX_FLAGS}
        ${GTEST_CMAKE_ARGS}
    BINARY_DIR "${EXTERNAL_PROJECTS_ROOT}/gtest/build"
    EXCLUDE_FROM_ALL TRUE
    BUILD_BYPRODUCTS ${GTEST_PATHS}
    )

add_custom_target(CopyQtDlls ${CMAKE_COMMAND}
    -D "build_configuration:STRING=$(ConfigurationName)"
    -D "SCENIX_BIN_PATH:PATH=${SCENIX_BIN_PATH}"
    -D "BUILDDIR:PATH=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
    -D "CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
    -D "CMAKE_GENERATOR=${CMAKE_GENERATOR}"
    -D "QTDIR:PATH=$ENV{QTDIR}"
    -P "${CMAKE_CURRENT_SOURCE_DIR}/copyqt.cmake"
    )

ExternalProject_Add(
      OPENBLAS
      GIT_REPOSITORY https://github.com/xianyi/OpenBLAS.git
      GIT_TAG v0.3.10
      GIT_SHALLOW YES
      PREFIX openblas
      CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> 
      CMAKE_GENERATOR "Unix Makefiles")

add_custom_command(
		OUTPUT ${NATIVE_BUILD_TARGET}
		COMMAND ${CMAKE_COMMAND}
			-G "${CMAKE_GENERATOR}"
			"${CMAKE_SOURCE_DIR}"
			"-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
			"-DCMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${NATIVE_BINARY_DIR}"
		WORKING_DIRECTORY ${NATIVE_BUILD_DIR}
		VERBATIM USES_TERMINAL
	)

if (CMAKE_GENERATOR MATCHES "Visual Studio")

ExternalProject_Add(gentables
        DOWNLOAD_COMMAND ""
        SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/gentables
        BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/src/gentables
        INSTALL_COMMAND ${CMAKE_CURRENT_BINARY_DIR}/src/gentables/make_tables.exe "${CMAKE_BINARY_DIR}/"
        CMAKE_GENERATOR "Unix Makefiles"
)

add_custom_command(OUTPUT ${LLVM_${target_name}_BUILD}/CMakeCache.txt
    COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}"
        ${CROSS_TOOLCHAIN_FLAGS_${target_name}} ${CMAKE_SOURCE_DIR}
        -DLLVM_TARGET_IS_CROSSCOMPILE_HOST=TRUE
    WORKING_DIRECTORY ${LLVM_${target_name}_BUILD}
    DEPENDS ${LLVM_${target_name}_BUILD}
    COMMENT "Configuring ${target_name} LLVM...")