rules_foreign_cc/test/cmake_text_tests.bzl

""" Unit tests for CMake script creation """

load("@bazel_skylib//lib:unittest.bzl", "asserts", "unittest")

# buildifier: disable=bzl-visibility
load("//foreign_cc/private:cc_toolchain_util.bzl", "CxxFlagsInfo", "CxxToolsInfo")

# buildifier: disable=bzl-visibility
load("//foreign_cc/private:cmake_script.bzl", "create_cmake_script", "export_for_test")

def _absolutize_test(ctx):
    env = unittest.begin(ctx)

    cases = {
        "-Lexternal/cmake/aaa": "-L$$EXT_BUILD_ROOT$$/external/cmake/aaa",
        "/abs/a12": "/abs/a12",
        "abs/a12": "abs/a12",
        "external/cmake/aaa": "$$EXT_BUILD_ROOT$$/external/cmake/aaa",
        "name=ws/cmake/aaa": "name=$$EXT_BUILD_ROOT$$/ws/cmake/aaa",
        "ws/cmake/aaa": "$$EXT_BUILD_ROOT$$/ws/cmake/aaa",
    }

    for case in cases:
        res = export_for_test.absolutize("ws", case)
        asserts.equals(env, cases[case], res)

    return unittest.end(env)

def _tail_extraction_test(ctx):
    env = unittest.begin(ctx)

    res = export_for_test.tail_if_starts_with("absolutely", "abs")
    asserts.equals(env, "olutely", res)

    res = export_for_test.tail_if_starts_with("--option=value", "-option")
    asserts.equals(env, None, res)

    res = export_for_test.tail_if_starts_with("--option=value", "--option")
    asserts.equals(env, "=value", res)

    return unittest.end(env)

def _find_flag_value_test(ctx):
    env = unittest.begin(ctx)

    found_cases = [
        ["--gcc_toolchain=/abc/def"],
        ["--gcc_toolchain =/abc/def"],
        ["--gcc_toolchain= /abc/def"],
        ["--gcc_toolchain = /abc/def"],
        ["  --gcc_toolchain = /abc/def"],
        ["--gcc_toolchain", "=/abc/def"],
        ["--gcc_toolchain", "/abc/def"],
        ["-gcc_toolchain", "/abc/def"],
        ["-gcc_toolchain=/abc/def"],
        ["-gcc_toolchain = /abc/def"],
        ["--gcc_toolchain /abc/def"],
    ]

    for case in found_cases:
        res = export_for_test.find_flag_value(case, "gcc_toolchain")
        asserts.equals(env, "/abc/def", res, msg = "Not equals: " + str(case))

    not_found_cases = [
        ["--gcc_toolchainn=/abc/def"],
        ["--gcc_toolchain abc/def"],
    ]
    for case in not_found_cases:
        res = export_for_test.find_flag_value(case, "gcc_toolchain")
        asserts.false(env, "/abc/def" == res, msg = "Equals: " + str(case))

    return unittest.end(env)

def _fill_crossfile_from_toolchain_test(ctx):
    env = unittest.begin(ctx)

    tools = CxxToolsInfo(
        cc = "/some-cc-value",
        cxx = "external/cxx-value",
        cxx_linker_static = "/cxx_linker_static",
        cxx_linker_executable = "ws/cxx_linker_executable",
    )
    flags = CxxFlagsInfo(
        cc = ["-cc-flag", "-gcc_toolchain", "cc-toolchain"],
        cxx = ["--quoted=\"abc def\"", "--sysroot=/abc/sysroot", "--gcc_toolchain", "cxx-toolchain"],
        cxx_linker_shared = ["shared1", "shared2"],
        cxx_linker_static = ["static"],
        cxx_linker_executable = ["executable"],
        assemble = ["assemble"],
    )

    res = export_for_test.fill_crossfile_from_toolchain("ws", tools, flags)

    expected = {
        "CMAKE_AR": "/cxx_linker_static",
        "CMAKE_ASM_FLAGS_INIT": "assemble",
        "CMAKE_CXX_COMPILER": "$$EXT_BUILD_ROOT$$/external/cxx-value",
        "CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN": "cxx-toolchain",
        # Quoted args are escaped when crossfile is written to a script in create_cmake_script
        "CMAKE_CXX_FLAGS_INIT": "--quoted=\"abc def\" --sysroot=/abc/sysroot --gcc_toolchain cxx-toolchain",
        "CMAKE_CXX_LINK_EXECUTABLE": "$$EXT_BUILD_ROOT$$/ws/cxx_linker_executable <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>",
        "CMAKE_C_COMPILER": "/some-cc-value",
        "CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN": "cc-toolchain",
        "CMAKE_C_FLAGS_INIT": "-cc-flag -gcc_toolchain cc-toolchain",
        "CMAKE_EXE_LINKER_FLAGS_INIT": "executable",
        "CMAKE_SHARED_LINKER_FLAGS_INIT": "shared1 shared2",
        "CMAKE_SYSROOT": "/abc/sysroot",
    }

    for key in expected:
        asserts.equals(env, expected[key], res[key])

    return unittest.end(env)

def _move_dict_values_test(ctx):
    env = unittest.begin(ctx)

    target = {
        "CMAKE_CXX_COMPILER": "$EXT_BUILD_ROOT/external/cxx-value",
        "CMAKE_CXX_LINK_EXECUTABLE": "was",
        "CMAKE_C_COMPILER": "some-cc-value",
        "CMAKE_C_FLAGS_INIT": "-cc-flag -gcc_toolchain cc-toolchain",
    }
    source_env = {
        "CC": "sink-cc-value",
        "CFLAGS": "--from-env",
        "CUSTOM": "YES",
        "CXX": "sink-cxx-value",
    }
    source_cache = {
        "CMAKE_ASM_FLAGS": "assemble",
        "CMAKE_CXX_LINK_EXECUTABLE": "became",
        "CMAKE_C_FLAGS": "--additional-flag",
        "CUSTOM": "YES",
    }
    export_for_test.move_dict_values(
        target,
        source_env,
        export_for_test.CMAKE_ENV_VARS_FOR_CROSSTOOL,
    )
    export_for_test.move_dict_values(
        target,
        source_cache,
        export_for_test.CMAKE_CACHE_ENTRIES_CROSSTOOL,
    )

    expected_target = {
        "CMAKE_ASM_FLAGS_INIT": "assemble",
        "CMAKE_CXX_COMPILER": "sink-cxx-value",
        "CMAKE_CXX_LINK_EXECUTABLE": "became",
        "CMAKE_C_COMPILER": "sink-cc-value",
        "CMAKE_C_FLAGS_INIT": "-cc-flag -gcc_toolchain cc-toolchain --from-env --additional-flag",
    }
    for key in expected_target:
        asserts.equals(env, expected_target[key], target[key])

    asserts.equals(env, "YES", source_env["CUSTOM"])
    asserts.equals(env, "YES", source_cache["CUSTOM"])
    asserts.equals(env, 1, len(source_env))
    asserts.equals(env, 1, len(source_cache))

    return unittest.end(env)

def _reverse_descriptor_dict_test(ctx):
    env = unittest.begin(ctx)

    res = export_for_test.reverse_descriptor_dict(export_for_test.CMAKE_CACHE_ENTRIES_CROSSTOOL)
    expected = {
        "CMAKE_AR": struct(value = "CMAKE_AR", replace = True),
        "CMAKE_ASM_FLAGS_INIT": struct(value = "CMAKE_ASM_FLAGS", replace = False),
        "CMAKE_CXX_FLAGS_INIT": struct(value = "CMAKE_CXX_FLAGS", replace = False),
        "CMAKE_CXX_LINK_EXECUTABLE": struct(value = "CMAKE_CXX_LINK_EXECUTABLE", replace = True),
        "CMAKE_C_FLAGS_INIT": struct(value = "CMAKE_C_FLAGS", replace = False),
        "CMAKE_EXE_LINKER_FLAGS_INIT": struct(value = "CMAKE_EXE_LINKER_FLAGS", replace = False),
        "CMAKE_SHARED_LINKER_FLAGS_INIT": struct(value = "CMAKE_SHARED_LINKER_FLAGS", replace = False),
        "CMAKE_STATIC_LINKER_FLAGS_INIT": struct(value = "CMAKE_STATIC_LINKER_FLAGS", replace = False),
    }

    for key in expected:
        asserts.equals(env, expected[key], res[key])

    return unittest.end(env)

def _merge_toolchain_and_user_values_test(ctx):
    env = unittest.begin(ctx)

    target = {
        "CMAKE_CXX_COMPILER": "$EXT_BUILD_ROOT/external/cxx-value",
        "CMAKE_CXX_FLAGS_INIT": "-ccx-flag",
        "CMAKE_CXX_LINK_EXECUTABLE": "was",
        "CMAKE_C_COMPILER": "some-cc-value",
        "CMAKE_C_FLAGS_INIT": "-cc-flag -gcc_toolchain cc-toolchain",
    }
    source_cache = {
        "CMAKE_ASM_FLAGS": "assemble",
        "CMAKE_CXX_LINK_EXECUTABLE": "became",
        "CMAKE_C_FLAGS": "--additional-flag",
        "CUSTOM": "YES",
    }

    res = export_for_test.merge_toolchain_and_user_values(
        target,
        source_cache,
        export_for_test.CMAKE_CACHE_ENTRIES_CROSSTOOL,
    )

    expected_target = {
        "CMAKE_ASM_FLAGS": "assemble",
        "CMAKE_CXX_FLAGS": "-ccx-flag",
        "CMAKE_CXX_LINK_EXECUTABLE": "became",
        "CMAKE_C_FLAGS": "-cc-flag -gcc_toolchain cc-toolchain --additional-flag",
        "CUSTOM": "YES",
    }

    for key in expected_target:
        asserts.equals(env, expected_target[key], res[key])

    return unittest.end(env)

def _merge_flag_values_no_toolchain_file_test(ctx):
    env = unittest.begin(ctx)

    tools = CxxToolsInfo(
        cc = "/usr/bin/gcc",
        cxx = "/usr/bin/gcc",
        cxx_linker_static = "/usr/bin/ar",
        cxx_linker_executable = "/usr/bin/gcc",
    )
    flags = CxxFlagsInfo(
        cc = [],
        cxx = ['foo="bar"'],
        cxx_linker_shared = [],
        cxx_linker_static = [],
        cxx_linker_executable = [],
        assemble = [],
    )
    user_env = {}
    user_cache = {
        "CMAKE_BUILD_TYPE": "RelWithDebInfo",
        "CMAKE_CXX_FLAGS": "-Fbat",
    }

    script = create_cmake_script(
        "ws",
        "Unix Makefiles",
        "cmake",
        tools,
        flags,
        "test_rule",
        "external/test_rule",
        True,
        user_cache,
        user_env,
        [],
        cmake_commands = [],
    )
    expected = r"""export CC="/usr/bin/gcc"
export CXX="/usr/bin/gcc"
export CXXFLAGS="foo=\\\"bar\\\" -Fbat"
##enable_tracing##
cmake -DCMAKE_AR="/usr/bin/ar" -DCMAKE_BUILD_TYPE="RelWithDebInfo" -DCMAKE_INSTALL_PREFIX="test_rule" -DCMAKE_PREFIX_PATH="$$EXT_BUILD_DEPS$$" -DCMAKE_RANLIB=""  -G 'Unix Makefiles' $$EXT_BUILD_ROOT$$/external/test_rule
##disable_tracing##
"""
    asserts.equals(env, expected.splitlines(), script)

    return unittest.end(env)

def _create_min_cmake_script_no_toolchain_file_test(ctx):
    env = unittest.begin(ctx)

    tools = CxxToolsInfo(
        cc = "/usr/bin/gcc",
        cxx = "/usr/bin/gcc",
        cxx_linker_static = "/usr/bin/ar",
        cxx_linker_executable = "/usr/bin/gcc",
    )
    flags = CxxFlagsInfo(
        cc = ["-U_FORTIFY_SOURCE", "-fstack-protector", "-Wall"],
        cxx = ["-U_FORTIFY_SOURCE", "-fstack-protector", "-Wall"],
        cxx_linker_shared = ["-shared", "-fuse-ld=gold"],
        cxx_linker_static = ["static"],
        cxx_linker_executable = ["-fuse-ld=gold", "-Wl", "-no-as-needed"],
        assemble = ["-U_FORTIFY_SOURCE", "-fstack-protector", "-Wall"],
    )
    user_env = {}
    user_cache = {
        "CMAKE_PREFIX_PATH": "/abc/def",
        "NOFORTRAN": "on",
    }

    script = create_cmake_script(
        "ws",
        "Ninja",
        "cmake",
        tools,
        flags,
        "test_rule",
        "external/test_rule",
        True,
        user_cache,
        user_env,
        ["--debug-output", "-Wdev"],
        cmake_commands = [],
    )
    expected = r"""export CC="/usr/bin/gcc"
export CXX="/usr/bin/gcc"
export CFLAGS="-U_FORTIFY_SOURCE -fstack-protector -Wall"
export CXXFLAGS="-U_FORTIFY_SOURCE -fstack-protector -Wall"
export ASMFLAGS="-U_FORTIFY_SOURCE -fstack-protector -Wall"
##enable_tracing##
cmake -DCMAKE_AR="/usr/bin/ar" -DCMAKE_SHARED_LINKER_FLAGS="-shared -fuse-ld=gold" -DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=gold -Wl -no-as-needed" -DNOFORTRAN="on" -DCMAKE_BUILD_TYPE="Debug" -DCMAKE_INSTALL_PREFIX="test_rule" -DCMAKE_PREFIX_PATH="$$EXT_BUILD_DEPS$$;/abc/def" -DCMAKE_RANLIB="" --debug-output -Wdev -G 'Ninja' $$EXT_BUILD_ROOT$$/external/test_rule
##disable_tracing##
"""
    asserts.equals(env, expected.splitlines(), script)

    return unittest.end(env)

def _create_min_cmake_script_wipe_toolchain_test(ctx):
    env = unittest.begin(ctx)

    tools = CxxToolsInfo(
        cc = "/usr/bin/gcc",
        cxx = "/usr/bin/gcc",
        cxx_linker_static = "/usr/bin/ar",
        cxx_linker_executable = "/usr/bin/gcc",
    )
    flags = CxxFlagsInfo(
        cc = ["-U_FORTIFY_SOURCE", "-fstack-protector", "-Wall"],
        cxx = ["-U_FORTIFY_SOURCE", "-fstack-protector", "-Wall"],
        cxx_linker_shared = ["-shared", "-fuse-ld=gold"],
        cxx_linker_static = ["static"],
        cxx_linker_executable = ["-fuse-ld=gold", "-Wl", "-no-as-needed"],
        assemble = ["-U_FORTIFY_SOURCE", "-fstack-protector", "-Wall"],
    )
    user_env = {}
    user_cache = {
        "CMAKE_PREFIX_PATH": "/abc/def",
        # These two flags/CMake cache entries must be wiped,
        # but the second is not present in toolchain flags.
        "CMAKE_SHARED_LINKER_FLAGS": "",
        "WIPE_ME_IF_PRESENT": "",
    }

    script = create_cmake_script(
        "ws",
        "Ninja",
        "cmake",
        tools,
        flags,
        "test_rule",
        "external/test_rule",
        True,
        user_cache,
        user_env,
        ["--debug-output", "-Wdev"],
        cmake_commands = [],
    )
    expected = r"""export CC="/usr/bin/gcc"
export CXX="/usr/bin/gcc"
export CFLAGS="-U_FORTIFY_SOURCE -fstack-protector -Wall"
export CXXFLAGS="-U_FORTIFY_SOURCE -fstack-protector -Wall"
export ASMFLAGS="-U_FORTIFY_SOURCE -fstack-protector -Wall"
##enable_tracing##
cmake -DCMAKE_AR="/usr/bin/ar" -DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=gold -Wl -no-as-needed" -DCMAKE_BUILD_TYPE="Debug" -DCMAKE_INSTALL_PREFIX="test_rule" -DCMAKE_PREFIX_PATH="$$EXT_BUILD_DEPS$$;/abc/def" -DCMAKE_RANLIB="" --debug-output -Wdev -G 'Ninja' $$EXT_BUILD_ROOT$$/external/test_rule
##disable_tracing##
"""
    asserts.equals(env, expected.splitlines(), script)

    return unittest.end(env)

def _create_min_cmake_script_toolchain_file_test(ctx):
    env = unittest.begin(ctx)

    tools = CxxToolsInfo(
        cc = "/usr/bin/gcc",
        cxx = "/usr/bin/gcc",
        cxx_linker_static = "/usr/bin/ar",
        cxx_linker_executable = "/usr/bin/gcc",
    )
    flags = CxxFlagsInfo(
        cc = ["-U_FORTIFY_SOURCE", "-fstack-protector", "-Wall"],
        cxx = ["-U_FORTIFY_SOURCE", "-fstack-protector", "-Wall"],
        cxx_linker_shared = ["-shared", "-fuse-ld=gold"],
        cxx_linker_static = ["static"],
        cxx_linker_executable = ["-fuse-ld=gold", "-Wl", "-no-as-needed"],
        assemble = ["-U_FORTIFY_SOURCE", "-fstack-protector", "-Wall"],
    )
    user_env = {}
    user_cache = {
        "NOFORTRAN": "on",
    }

    script = create_cmake_script(
        "ws",
        "Ninja",
        "cmake",
        tools,
        flags,
        "test_rule",
        "external/test_rule",
        False,
        user_cache,
        user_env,
        ["--debug-output", "-Wdev"],
        cmake_commands = [],
    )
    expected = r"""cat > crosstool_bazel.cmake << EOF
set(CMAKE_AR "/usr/bin/ar" CACHE FILEPATH "Archiver")
set(CMAKE_ASM_FLAGS_INIT "-U_FORTIFY_SOURCE -fstack-protector -Wall")
set(CMAKE_CXX_COMPILER "/usr/bin/gcc")
set(CMAKE_CXX_FLAGS_INIT "-U_FORTIFY_SOURCE -fstack-protector -Wall")
set(CMAKE_C_COMPILER "/usr/bin/gcc")
set(CMAKE_C_FLAGS_INIT "-U_FORTIFY_SOURCE -fstack-protector -Wall")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-fuse-ld=gold -Wl -no-as-needed")
set(CMAKE_SHARED_LINKER_FLAGS_INIT "-shared -fuse-ld=gold")
EOF

##enable_tracing##
cmake -DNOFORTRAN="on" -DCMAKE_TOOLCHAIN_FILE="crosstool_bazel.cmake" -DCMAKE_BUILD_TYPE="Debug" -DCMAKE_INSTALL_PREFIX="test_rule" -DCMAKE_PREFIX_PATH="$$EXT_BUILD_DEPS$$" -DCMAKE_RANLIB="" --debug-output -Wdev -G 'Ninja' $$EXT_BUILD_ROOT$$/external/test_rule
##disable_tracing##
"""
    asserts.equals(env, expected.splitlines(), script)

    return unittest.end(env)

def _create_cmake_script_no_toolchain_file_test(ctx):
    env = unittest.begin(ctx)

    tools = CxxToolsInfo(
        cc = "/some-cc-value",
        cxx = "external/cxx-value",
        cxx_linker_static = "/cxx_linker_static",
        cxx_linker_executable = "ws/cxx_linker_executable",
    )
    flags = CxxFlagsInfo(
        cc = ["-cc-flag", "-gcc_toolchain", "cc-toolchain"],
        cxx = [
            "--quoted=\"abc def\"",
            "--sysroot=/abc/sysroot",
            "--gcc_toolchain",
            "cxx-toolchain",
        ],
        cxx_linker_shared = ["shared1", "shared2"],
        cxx_linker_static = ["static"],
        cxx_linker_executable = ["executable"],
        assemble = ["assemble"],
    )
    user_env = {
        "CC": "sink-cc-value",
        "CFLAGS": "--from-env",
        "CUSTOM_ENV": "YES",
        "CXX": "sink-cxx-value",
    }
    user_cache = {
        "CMAKE_ASM_FLAGS": "assemble-user",
        "CMAKE_BUILD_TYPE": "user_type",
        "CMAKE_CXX_LINK_EXECUTABLE": "became",
        "CMAKE_C_FLAGS": "--additional-flag",
        "CUSTOM_CACHE": "YES",
    }

    script = create_cmake_script(
        "ws",
        "Ninja",
        "cmake",
        tools,
        flags,
        "test_rule",
        "external/test_rule",
        True,
        user_cache,
        user_env,
        ["--debug-output", "-Wdev"],
        cmake_commands = [],
    )
    expected = r"""export CC="sink-cc-value"
export CXX="sink-cxx-value"
export CFLAGS="-cc-flag -gcc_toolchain cc-toolchain --from-env --additional-flag"
export CXXFLAGS="--quoted=\\\"abc def\\\" --sysroot=/abc/sysroot --gcc_toolchain cxx-toolchain"
export ASMFLAGS="assemble assemble-user"
export CUSTOM_ENV="YES"
##enable_tracing##
cmake -DCMAKE_AR="/cxx_linker_static" -DCMAKE_CXX_LINK_EXECUTABLE="became" -DCMAKE_SHARED_LINKER_FLAGS="shared1 shared2" -DCMAKE_EXE_LINKER_FLAGS="executable" -DCMAKE_BUILD_TYPE="user_type" -DCUSTOM_CACHE="YES" -DCMAKE_INSTALL_PREFIX="test_rule" -DCMAKE_PREFIX_PATH="$$EXT_BUILD_DEPS$$" -DCMAKE_RANLIB="" --debug-output -Wdev -G 'Ninja' $$EXT_BUILD_ROOT$$/external/test_rule
##disable_tracing##
"""
    asserts.equals(env, expected.splitlines(), script)

    return unittest.end(env)

def _create_cmake_script_toolchain_file_test(ctx):
    env = unittest.begin(ctx)

    tools = CxxToolsInfo(
        cc = "some-cc-value",
        cxx = "external/cxx-value",
        cxx_linker_static = "/cxx_linker_static",
        cxx_linker_executable = "ws/cxx_linker_executable",
    )
    flags = CxxFlagsInfo(
        cc = ["-cc-flag", "-gcc_toolchain", "cc-toolchain"],
        cxx = [
            "--quoted=\"abc def\"",
            "--sysroot=/abc/sysroot",
            "--gcc_toolchain",
            "cxx-toolchain",
        ],
        cxx_linker_shared = ["shared1", "shared2"],
        cxx_linker_static = ["static"],
        cxx_linker_executable = ["executable"],
        assemble = ["assemble"],
    )
    user_env = {
        "CC": "sink-cc-value",
        "CFLAGS": "--from-env",
        "CUSTOM_ENV": "YES",
        "CXX": "sink-cxx-value",
    }
    user_cache = {
        "CMAKE_ASM_FLAGS": "assemble-user",
        "CMAKE_CXX_LINK_EXECUTABLE": "became",
        "CMAKE_C_FLAGS": "--additional-flag",
        "CUSTOM_CACHE": "YES",
    }

    script = create_cmake_script(
        "ws",
        "Ninja",
        "cmake",
        tools,
        flags,
        "test_rule",
        "external/test_rule",
        False,
        user_cache,
        user_env,
        ["--debug-output", "-Wdev"],
        cmake_commands = [],
    )
    expected = r"""cat > crosstool_bazel.cmake << EOF
set(CMAKE_AR "/cxx_linker_static" CACHE FILEPATH "Archiver")
set(CMAKE_ASM_FLAGS_INIT "assemble assemble-user")
set(CMAKE_CXX_COMPILER "sink-cxx-value")
set(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN "cxx-toolchain")
set(CMAKE_CXX_FLAGS_INIT "--quoted=\"\\\\\\"abc def\"\\\\\\" --sysroot=/abc/sysroot --gcc_toolchain cxx-toolchain")
set(CMAKE_CXX_LINK_EXECUTABLE "became")
set(CMAKE_C_COMPILER "sink-cc-value")
set(CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN "cc-toolchain")
set(CMAKE_C_FLAGS_INIT "-cc-flag -gcc_toolchain cc-toolchain --from-env --additional-flag")
set(CMAKE_EXE_LINKER_FLAGS_INIT "executable")
set(CMAKE_SHARED_LINKER_FLAGS_INIT "shared1 shared2")
set(CMAKE_SYSROOT "/abc/sysroot")
EOF

export CUSTOM_ENV="YES"
##enable_tracing##
cmake -DCUSTOM_CACHE="YES" -DCMAKE_TOOLCHAIN_FILE="crosstool_bazel.cmake" -DCMAKE_BUILD_TYPE="Debug" -DCMAKE_INSTALL_PREFIX="test_rule" -DCMAKE_PREFIX_PATH="$$EXT_BUILD_DEPS$$" -DCMAKE_RANLIB="" --debug-output -Wdev -G 'Ninja' $$EXT_BUILD_ROOT$$/external/test_rule
##disable_tracing##
"""
    asserts.equals(env, expected.splitlines(), script)

    return unittest.end(env)

absolutize_test = unittest.make(_absolutize_test)
tail_extraction_test = unittest.make(_tail_extraction_test)
find_flag_value_test = unittest.make(_find_flag_value_test)
fill_crossfile_from_toolchain_test = unittest.make(_fill_crossfile_from_toolchain_test)
move_dict_values_test = unittest.make(_move_dict_values_test)
reverse_descriptor_dict_test = unittest.make(_reverse_descriptor_dict_test)
merge_toolchain_and_user_values_test = unittest.make(_merge_toolchain_and_user_values_test)
create_min_cmake_script_no_toolchain_file_test = unittest.make(_create_min_cmake_script_no_toolchain_file_test)
create_min_cmake_script_toolchain_file_test = unittest.make(_create_min_cmake_script_toolchain_file_test)
create_cmake_script_no_toolchain_file_test = unittest.make(_create_cmake_script_no_toolchain_file_test)
create_cmake_script_toolchain_file_test = unittest.make(_create_cmake_script_toolchain_file_test)
merge_flag_values_no_toolchain_file_test = unittest.make(_merge_flag_values_no_toolchain_file_test)
create_min_cmake_script_wipe_toolchain_test = unittest.make(_create_min_cmake_script_wipe_toolchain_test)

def cmake_script_test_suite():
    unittest.suite(
        "cmake_script_test_suite",
        absolutize_test,
        tail_extraction_test,
        find_flag_value_test,
        fill_crossfile_from_toolchain_test,
        move_dict_values_test,
        reverse_descriptor_dict_test,
        merge_toolchain_and_user_values_test,
        create_min_cmake_script_no_toolchain_file_test,
        create_min_cmake_script_toolchain_file_test,
        create_cmake_script_no_toolchain_file_test,
        create_cmake_script_toolchain_file_test,
        merge_flag_values_no_toolchain_file_test,
        create_min_cmake_script_wipe_toolchain_test,
    )