| #!/usr/bin/env fuchsia-vendored-python |
| # Copyright 2022 The Fuchsia Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import unittest |
| import sys |
| from pathlib import Path |
| from unittest import mock |
| from typing import Any, Sequence |
| |
| import cxx |
| |
| |
| def _strs(items: Sequence[Any]) -> list[str]: |
| return [str(i) for i in items] |
| |
| |
| class CxxActionTests(unittest.TestCase): |
| def test_help_unwanted(self) -> None: |
| source = Path("hello.cc") |
| output = Path("hello.o") |
| for opt in ( |
| "-h", |
| "--help", |
| "-hwasan-record-stack-history=libcall", |
| "-hello-world-is-ignored", |
| ): |
| with mock.patch.object(sys, "exit") as mock_exit: |
| c = cxx.CxxAction( |
| _strs(["clang++", opt, "-c", source, "-o", output]) |
| ) |
| preprocess, compile = c.split_preprocessing() |
| mock_exit.assert_not_called() |
| |
| def test_simple_clang_cxx(self) -> None: |
| source = Path("hello.cc") |
| ii_file = Path("hello.ii") |
| output = Path("hello.o") |
| clang = Path("clang++") |
| c = cxx.CxxAction(_strs([clang, "-c", source, "-o", output])) |
| self.assertEqual(c.output_file, output) |
| self.assertEqual( |
| c.compiler, |
| cxx.CompilerTool(tool=clang, type=cxx.Compiler.CLANG), |
| ) |
| self.assertFalse(c.save_temps) |
| self.assertTrue(c.compiler_is_clang) |
| self.assertFalse(c.compiler_is_gcc) |
| self.assertEqual(c.target, "") |
| self.assertEqual( |
| c.sources, [cxx.Source(file=source, dialect=cxx.SourceLanguage.CXX)] |
| ) |
| self.assertTrue(c.dialect_is_cxx) |
| self.assertFalse(c.dialect_is_c) |
| self.assertIsNone(c.use_ld) |
| self.assertIsNone(c.lto) |
| self.assertIsNone(c.rtlib) |
| self.assertIsNone(c.unwindlib) |
| self.assertFalse(c.static_libstdcxx) |
| self.assertEqual(c.linker_driver_flags, []) |
| self.assertIsNone(c.linker_retain_symbols_file) |
| self.assertIsNone(c.linker_version_script) |
| self.assertIsNone(c.linker_just_symbols) |
| self.assertIsNone(c.depfile) |
| self.assertIsNone(c.sysroot) |
| self.assertEqual(c.libdirs, []) |
| self.assertIsNone(c.profile_list) |
| self.assertIsNone(c.profile_generate) |
| self.assertIsNone(c.profile_instr_generate) |
| self.assertFalse(c.shared) |
| self.assertEqual(c.sanitizers, set()) |
| self.assertFalse(c.using_asan) |
| self.assertFalse(c.using_ubsan) |
| self.assertEqual(c.uninterpreted_args, _strs([clang, "-c", source])) |
| self.assertEqual(list(c.input_files()), [source]) |
| self.assertEqual(list(c.output_files()), [output]) |
| self.assertEqual(list(c.output_dirs()), []) |
| self.assertFalse(c.uses_macos_sdk) |
| self.assertIsNone(c.crash_diagnostics_dir) |
| self.assertEqual(c.preprocessed_output, ii_file) |
| preprocess, compile = c.split_preprocessing() |
| self.assertEqual( |
| preprocess, |
| _strs( |
| ["clang++", "-c", source, "-o", ii_file, "-E", "-fno-blocks"] |
| ), |
| ) |
| self.assertEqual( |
| compile, |
| _strs(["clang++", "-c", ii_file, "-o", output]), |
| ) |
| |
| def test_all_unknown_flags_ignored(self) -> None: |
| command = ["clang", "--yolo", "foobar", "-q", "-k", "-quack"] |
| c = cxx.CxxAction(command + ["-o", "required.o"]) |
| self.assertEqual(c.uninterpreted_args, command) |
| |
| def test_output_flag_not_matched(self) -> None: |
| command_pieces = ( |
| ["clang"], |
| ["-octopus"], |
| ) # not to be interpreted as "-o" |
| output = Path("required.o") |
| c = cxx.CxxAction( |
| command_pieces[0] + _strs(["-o", output]) + command_pieces[1] |
| ) |
| self.assertEqual(c.output_file, output) |
| self.assertEqual( |
| c.uninterpreted_args, command_pieces[0] + command_pieces[1] |
| ) |
| |
| def test_clang_cxx_save_temps(self) -> None: |
| source = Path("hello.cc") |
| ii_file = Path("obj/path/to/hello.cc.ii") |
| output = Path("obj/path/to/hello.cc.o") |
| c = cxx.CxxAction( |
| _strs(["clang++", "-c", source, "-o", output, "--save-temps"]) |
| ) |
| self.assertTrue(c.save_temps) |
| self.assertEqual(c.output_file, output) |
| self.assertEqual( |
| c.compiler, |
| cxx.CompilerTool(tool=Path("clang++"), type=cxx.Compiler.CLANG), |
| ) |
| self.assertTrue(c.compiler_is_clang) |
| self.assertFalse(c.compiler_is_gcc) |
| self.assertEqual(c.target, "") |
| self.assertEqual( |
| c.sources, [cxx.Source(file=source, dialect=cxx.SourceLanguage.CXX)] |
| ) |
| self.assertTrue(c.dialect_is_cxx) |
| self.assertFalse(c.dialect_is_c) |
| self.assertIsNone(c.depfile) |
| self.assertIsNone(c.sysroot) |
| self.assertIsNone(c.profile_list) |
| self.assertEqual(list(c.input_files()), [source]) |
| self.assertEqual( |
| list(c.output_files()), |
| [ |
| output, |
| # This .ii file is implicitly output by the compiler, |
| # but not the same as what we explicitly choose with ii_file. |
| Path("hello.ii"), |
| Path("hello.bc"), |
| Path("hello.s"), |
| ], |
| ) |
| self.assertEqual(list(c.output_dirs()), []) |
| self.assertFalse(c.uses_macos_sdk) |
| self.assertIsNone(c.crash_diagnostics_dir) |
| self.assertEqual(c.preprocessed_output, ii_file) |
| preprocess, compile = c.split_preprocessing() |
| self.assertEqual( |
| preprocess, |
| _strs( |
| ["clang++", "-c", source, "-o", ii_file, "-E", "-fno-blocks"] |
| ), |
| ) |
| self.assertEqual( |
| compile, |
| _strs(["clang++", "-c", ii_file, "-o", output, "--save-temps"]), |
| ) |
| |
| def test_simple_clang_c(self) -> None: |
| source = Path("hello.c") |
| i_file = Path("hello.i") |
| output = Path("hello.o") |
| c = cxx.CxxAction(_strs(["clang", "-c", source, "-o", output])) |
| self.assertEqual(c.output_file, output) |
| self.assertEqual( |
| c.compiler, |
| cxx.CompilerTool(tool=Path("clang"), type=cxx.Compiler.CLANG), |
| ) |
| self.assertTrue(c.compiler_is_clang) |
| self.assertFalse(c.compiler_is_gcc) |
| self.assertFalse(c.save_temps) |
| self.assertEqual(c.target, "") |
| self.assertEqual( |
| c.sources, [cxx.Source(file=source, dialect=cxx.SourceLanguage.C)] |
| ) |
| self.assertFalse(c.dialect_is_cxx) |
| self.assertTrue(c.dialect_is_c) |
| self.assertIsNone(c.depfile) |
| self.assertIsNone(c.sysroot) |
| self.assertIsNone(c.profile_list) |
| self.assertEqual(list(c.input_files()), [source]) |
| self.assertEqual(list(c.output_files()), [output]) |
| self.assertEqual(list(c.output_dirs()), []) |
| self.assertIsNone(c.crash_diagnostics_dir) |
| self.assertEqual(c.preprocessed_output, i_file) |
| preprocess, compile = c.split_preprocessing() |
| self.assertEqual( |
| preprocess, |
| _strs(["clang", "-c", source, "-o", i_file, "-E", "-fno-blocks"]), |
| ) |
| self.assertEqual( |
| compile, |
| _strs(["clang", "-c", i_file, "-o", output]), |
| ) |
| |
| def test_clang_c_save_temps(self) -> None: |
| source = Path("hello.c") |
| i_file = Path("obj/path/to/hello.i") |
| output = Path("obj/path/to/hello.o") |
| c = cxx.CxxAction( |
| _strs(["clang", "-c", source, "-o", output, "--save-temps"]) |
| ) |
| self.assertEqual(c.output_file, output) |
| self.assertEqual( |
| c.compiler, |
| cxx.CompilerTool(tool=Path("clang"), type=cxx.Compiler.CLANG), |
| ) |
| self.assertTrue(c.compiler_is_clang) |
| self.assertFalse(c.compiler_is_gcc) |
| self.assertTrue(c.save_temps) |
| self.assertEqual(c.target, "") |
| self.assertEqual( |
| c.sources, [cxx.Source(file=source, dialect=cxx.SourceLanguage.C)] |
| ) |
| self.assertFalse(c.dialect_is_cxx) |
| self.assertTrue(c.dialect_is_c) |
| self.assertIsNone(c.depfile) |
| self.assertIsNone(c.sysroot) |
| self.assertIsNone(c.profile_list) |
| self.assertEqual(list(c.input_files()), [source]) |
| self.assertEqual( |
| list(c.output_files()), |
| [ |
| output, |
| # This .i file is implicitly output by the compiler, |
| # but not the same as what we explicitly choose with ii_file. |
| Path("hello.i"), |
| Path("hello.bc"), |
| Path("hello.s"), |
| ], |
| ) |
| self.assertEqual(list(c.output_dirs()), []) |
| self.assertIsNone(c.crash_diagnostics_dir) |
| self.assertEqual(c.preprocessed_output, i_file) |
| preprocess, compile = c.split_preprocessing() |
| self.assertEqual( |
| preprocess, |
| _strs(["clang", "-c", source, "-o", i_file, "-E", "-fno-blocks"]), |
| ) |
| self.assertEqual( |
| compile, |
| _strs(["clang", "-c", i_file, "-o", output, "--save-temps"]), |
| ) |
| |
| def test_simple_clang_asm(self) -> None: |
| source = Path("hello.s") |
| i_file = Path("hello.i") |
| output = Path("hello.o") |
| c = cxx.CxxAction(_strs(["clang", "-c", source, "-o", output])) |
| self.assertEqual(c.output_file, output) |
| self.assertEqual( |
| c.compiler, |
| cxx.CompilerTool(tool=Path("clang"), type=cxx.Compiler.CLANG), |
| ) |
| self.assertTrue(c.compiler_is_clang) |
| self.assertFalse(c.compiler_is_gcc) |
| self.assertEqual(c.target, "") |
| self.assertEqual( |
| c.sources, [cxx.Source(file=source, dialect=cxx.SourceLanguage.ASM)] |
| ) |
| self.assertFalse(c.dialect_is_cxx) |
| self.assertFalse(c.dialect_is_c) |
| self.assertIsNone(c.crash_diagnostics_dir) |
| |
| def test_simple_clang_asm_pp(self) -> None: |
| source = Path("hello.S") |
| i_file = Path("hello.i") |
| output = Path("hello.o") |
| c = cxx.CxxAction(_strs(["clang", "-c", source, "-o", output])) |
| self.assertEqual(c.output_file, output) |
| self.assertEqual( |
| c.compiler, |
| cxx.CompilerTool(tool=Path("clang"), type=cxx.Compiler.CLANG), |
| ) |
| self.assertTrue(c.compiler_is_clang) |
| self.assertFalse(c.compiler_is_gcc) |
| self.assertEqual(c.target, "") |
| self.assertEqual( |
| c.sources, [cxx.Source(file=source, dialect=cxx.SourceLanguage.ASM)] |
| ) |
| self.assertFalse(c.dialect_is_cxx) |
| self.assertFalse(c.dialect_is_c) |
| self.assertIsNone(c.crash_diagnostics_dir) |
| |
| def test_shared(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello.so") |
| c = cxx.CxxAction(_strs(["clang++", "-shared", source, "-o", output])) |
| self.assertTrue(c.shared) |
| self.assertEqual(c.linker_inputs, [source]) |
| |
| def test_flto_default(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction(_strs(["clang++", "-flto", source, "-o", output])) |
| self.assertEqual(c.lto, "full") |
| |
| def test_flto_full(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs(["clang++", "-flto=full", source, "-o", output]) |
| ) |
| self.assertEqual(c.lto, "full") |
| |
| def test_flto_thin(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs(["clang++", "-flto=thin", source, "-o", output]) |
| ) |
| self.assertEqual(c.lto, "thin") |
| |
| def test_fuse_ld(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| linker = "lld" |
| c = cxx.CxxAction( |
| _strs(["clang++", f"-fuse-ld={linker}", source, "-o", output]) |
| ) |
| self.assertEqual(c.use_ld, linker) |
| self.assertEqual(c.linker_inputs, [source]) |
| self.assertEqual(c.clang_linker_executable, "ld.lld") |
| |
| def test_fuse_ld_windows(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| linker = "lld" |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "--target=x64_64-windows-msvc", |
| f"-fuse-ld={linker}", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.use_ld, linker) |
| self.assertEqual(c.linker_inputs, [source]) |
| self.assertEqual(c.clang_linker_executable, "lld-link") |
| |
| def test_asan(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs(["clang++", "-fsanitize=address", source, "-o", output]) |
| ) |
| self.assertEqual(c.sanitizers, {"address"}) |
| self.assertTrue(c.using_asan) |
| self.assertFalse(c.using_ubsan) |
| self.assertEqual(c.linker_inputs, [source]) |
| |
| def test_no_sanitize(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "-fsanitize=address", |
| "-fno-sanitize=address", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.sanitizers, set()) |
| self.assertFalse(c.using_asan) |
| self.assertFalse(c.using_ubsan) |
| self.assertEqual(c.linker_inputs, [source]) |
| |
| def test_ubsan(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs(["clang++", "-fsanitize=undefined", source, "-o", output]) |
| ) |
| self.assertEqual(c.sanitizers, {"undefined"}) |
| self.assertFalse(c.using_asan) |
| self.assertTrue(c.using_ubsan) |
| self.assertEqual(c.linker_inputs, [source]) |
| |
| def test_libdirs(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs( |
| ["clang++", "-L../foo/foo", "-Lbar/bar", source, "-o", output] |
| ) |
| ) |
| self.assertEqual(c.libdirs, [Path("../foo/foo"), Path("bar/bar")]) |
| |
| def test_unwindlib_equals_arg(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs(["clang++", "-unwindlib=libunwind", source, "-o", output]) |
| ) |
| self.assertEqual(c.unwindlib, "libunwind") |
| |
| def test_unwindlib_separate_arg(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs(["clang++", "-unwindlib", "libunwind", source, "-o", output]) |
| ) |
| self.assertEqual(c.unwindlib, "libunwind") |
| |
| def test_not_a_prefix_for_unwindlib(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| for unknown_flag in ("-u", "--u", "--un", "-un", "-uu"): |
| c = cxx.CxxAction( |
| _strs(["clang++", unknown_flag, source, "-o", output]) |
| ) |
| self.assertIsNone(c.unwindlib) |
| self.assertIn(unknown_flag, c.uninterpreted_args) |
| |
| def test_not_a_prefix_for_rtlib(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| for unknown_flag in ("-r", "--r", "--rt", "-rt", "-rx"): |
| c = cxx.CxxAction( |
| _strs(["clang++", unknown_flag, source, "-o", output]) |
| ) |
| self.assertIsNone(c.rtlib) |
| self.assertIn(unknown_flag, c.uninterpreted_args) |
| |
| def test_rtlib_equals_arg(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs(["clang++", "-rtlib=compiler-rt", source, "-o", output]) |
| ) |
| self.assertEqual(c.rtlib, "compiler-rt") |
| |
| def test_rtlib_separate_arg(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "-rtlib", |
| "different-compiler-rt", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.rtlib, "different-compiler-rt") |
| |
| def test_static_libstdcxx(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| c = cxx.CxxAction( |
| _strs(["clang++", "-static-libstdc++", source, "-o", output]) |
| ) |
| self.assertTrue(c.static_libstdcxx) |
| |
| def test_unknown_linker_driver_flag(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| flag = "--unknown-flag=foobar" |
| c = cxx.CxxAction( |
| _strs(["clang++", f"-Wl,{flag}", source, "-o", output]) |
| ) |
| self.assertEqual(c.linker_driver_flags, [flag]) |
| |
| def test_linker_mapfile_double_dash(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| mapfile = Path("hello.map") |
| c = cxx.CxxAction( |
| _strs(["clang++", f"-Wl,--Map={mapfile}", source, "-o", output]) |
| ) |
| self.assertEqual(c.linker_mapfile, mapfile) |
| self.assertEqual(list(c.linker_output_files()), [output, mapfile]) |
| |
| def test_linker_mapfile_single_dash(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| mapfile = Path("hello.map") |
| c = cxx.CxxAction( |
| _strs(["clang++", f"-Wl,-Map={mapfile}", source, "-o", output]) |
| ) |
| self.assertEqual(c.linker_mapfile, mapfile) |
| self.assertEqual(list(c.linker_output_files()), [output, mapfile]) |
| |
| def test_linker_depfile(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| depfile = Path("hello.d") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| f"-Wl,--dependency-file={depfile}", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.linker_depfile, depfile) |
| self.assertEqual(list(c.linker_output_files()), [output, depfile]) |
| |
| def test_linker_pdb_output(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello.efi") |
| pdb = Path("hello.pdb") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "--target=x86_x64-windows-msvc", |
| f"-Wl,/debug:full", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.pdb, pdb) |
| self.assertEqual(list(c.linker_output_files()), [output, pdb]) |
| |
| def test_linker_retain_symbols_file(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| retain_file = Path("hello.allowlist") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| f"-Wl,--retain-symbols-file={retain_file}", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.linker_retain_symbols_file, retain_file) |
| self.assertEqual(list(c.linker_inputs_from_flags()), [retain_file]) |
| |
| def test_linker_version_script(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| version_script = Path("hello.ld") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| f"-Wl,--version-script={version_script}", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.linker_version_script, version_script) |
| self.assertEqual(list(c.linker_inputs_from_flags()), [version_script]) |
| |
| def test_linker_version_script_with_response_file(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| version_script = Path("hello.ld") |
| rsp_file = Path("hello.rsp") |
| with mock.patch.object( |
| Path, "read_text", return_value=str(version_script) |
| ) as mock_read: |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| f"-Wl,--version-script,@{rsp_file}", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.linker_version_script, version_script) |
| self.assertEqual(list(c.linker_inputs_from_flags()), [version_script]) |
| self.assertEqual(c.linker_response_files, [rsp_file]) |
| |
| def test_linker_just_symbols(self) -> None: |
| source = Path("hello.o") |
| output = Path("hello") |
| symbols = Path("hello.elf") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| f"-Wl,--just-symbols={symbols}", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.linker_just_symbols, symbols) |
| self.assertEqual(list(c.linker_inputs_from_flags()), [symbols]) |
| |
| def test_simple_gcc_cxx(self) -> None: |
| source = Path("hello.cc") |
| output = Path("hello.o") |
| ii_file = Path("hello.ii") |
| c = cxx.CxxAction(_strs(["g++", "-c", source, "-o", output])) |
| self.assertEqual(c.output_file, output) |
| self.assertEqual( |
| c.compiler, |
| cxx.CompilerTool(tool=Path("g++"), type=cxx.Compiler.GCC), |
| ) |
| self.assertFalse(c.compiler_is_clang) |
| self.assertTrue(c.compiler_is_gcc) |
| self.assertEqual(c.target, "") |
| self.assertEqual( |
| c.sources, [cxx.Source(file=source, dialect=cxx.SourceLanguage.CXX)] |
| ) |
| self.assertTrue(c.dialect_is_cxx) |
| self.assertFalse(c.dialect_is_c) |
| self.assertIsNone(c.depfile) |
| self.assertIsNone(c.crash_diagnostics_dir) |
| self.assertEqual(c.preprocessed_output, ii_file) |
| preprocess, compile = c.split_preprocessing() |
| self.assertEqual( |
| preprocess, |
| _strs(["g++", "-c", source, "-o", ii_file, "-E"]), |
| ) |
| self.assertEqual( |
| compile, |
| _strs(["g++", "-c", ii_file, "-o", output]), |
| ) |
| |
| def test_simple_gcc_c(self) -> None: |
| source = Path("hello.c") |
| i_file = Path("hello.i") |
| output = Path("hello.o") |
| c = cxx.CxxAction(_strs(["gcc", "-c", source, "-o", output])) |
| self.assertEqual(c.output_file, output) |
| self.assertEqual( |
| c.compiler, |
| cxx.CompilerTool(tool=Path("gcc"), type=cxx.Compiler.GCC), |
| ) |
| self.assertFalse(c.compiler_is_clang) |
| self.assertTrue(c.compiler_is_gcc) |
| self.assertEqual(c.target, "") |
| self.assertEqual( |
| c.sources, [cxx.Source(file=source, dialect=cxx.SourceLanguage.C)] |
| ) |
| self.assertFalse(c.dialect_is_cxx) |
| self.assertTrue(c.dialect_is_c) |
| self.assertIsNone(c.depfile) |
| self.assertIsNone(c.crash_diagnostics_dir) |
| self.assertEqual(c.preprocessed_output, i_file) |
| preprocess, compile = c.split_preprocessing() |
| self.assertEqual( |
| preprocess, |
| _strs(["gcc", "-c", source, "-o", i_file, "-E"]), |
| ) |
| self.assertEqual( |
| compile, |
| _strs(["gcc", "-c", i_file, "-o", output]), |
| ) |
| |
| def test_clang_target(self) -> None: |
| c = cxx.CxxAction( |
| [ |
| "clang++", |
| "--target=powerpc-apple-darwin8", |
| "-c", |
| "hello.cc", |
| "-o", |
| "hello.o", |
| ] |
| ) |
| self.assertEqual(c.target, "powerpc-apple-darwin8") |
| |
| def test_clang_crash_diagnostics_dir(self) -> None: |
| crash_dir = Path("/tmp/graveyard") |
| c = cxx.CxxAction( |
| [ |
| "clang++", |
| f"-fcrash-diagnostics-dir={crash_dir}", |
| "-c", |
| "hello.cc", |
| "-o", |
| "hello.o", |
| ] |
| ) |
| self.assertEqual(c.crash_diagnostics_dir, crash_dir) |
| self.assertEqual(set(c.output_dirs()), {crash_dir}) |
| |
| def test_profile_list(self) -> None: |
| source = Path("hello.cc") |
| ii_file = Path("hello.ii") |
| output = Path("hello.o") |
| profile = Path("my/online/profile.list") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "-c", |
| source, |
| "-o", |
| output, |
| f"-fprofile-list={profile}", |
| ] |
| ) |
| ) |
| self.assertEqual(c.profile_list, profile) |
| self.assertEqual(set(c.input_files()), {source, profile}) |
| |
| def test_profile_generate(self) -> None: |
| source = Path("hello.cc") |
| ii_file = Path("hello.ii") |
| output = Path("hello.o") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "-c", |
| source, |
| "-o", |
| output, |
| "-fprofile-generate", |
| ] |
| ) |
| ) |
| self.assertEqual(c.profile_generate, Path(".")) |
| |
| def test_profile_generate_with_dir(self) -> None: |
| source = Path("hello.cc") |
| ii_file = Path("hello.ii") |
| output = Path("hello.o") |
| pdir = Path("my/pg/dir") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "-c", |
| source, |
| "-o", |
| output, |
| f"-fprofile-generate={pdir}", |
| ] |
| ) |
| ) |
| self.assertEqual(c.profile_generate, pdir) |
| |
| def test_profile_instr_generate(self) -> None: |
| source = Path("hello.cc") |
| ii_file = Path("hello.ii") |
| output = Path("hello.o") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "-c", |
| source, |
| "-o", |
| output, |
| "-fprofile-instr-generate", |
| ] |
| ) |
| ) |
| self.assertEqual(c.profile_instr_generate, Path("default.profraw")) |
| |
| def test_profile_instr_generate_with_file(self) -> None: |
| source = Path("hello.cc") |
| ii_file = Path("hello.ii") |
| output = Path("hello.o") |
| pfile = Path("pg/path/to/file.profraw") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "-c", |
| source, |
| "-o", |
| output, |
| f"-fprofile-instr-generate={pfile}", |
| ] |
| ) |
| ) |
| self.assertEqual(c.profile_instr_generate, pfile) |
| |
| def test_uses_macos_sdk(self) -> None: |
| sysroot = Path("/Library/Developer/blah") |
| c = cxx.CxxAction( |
| [ |
| "clang++", |
| f"--sysroot={sysroot}", |
| "-c", |
| "hello.cc", |
| "-o", |
| "hello.o", |
| ] |
| ) |
| self.assertEqual(c.sysroot, sysroot) |
| self.assertTrue(c.uses_macos_sdk) |
| |
| def test_split_preprocessing(self) -> None: |
| source = Path("hello.cc") |
| ii_file = Path("hello.ii") |
| output = Path("hello.o") |
| depfile = Path("hello.d") |
| c = cxx.CxxAction( |
| _strs( |
| [ |
| "clang++", |
| "-DNDEBUG", |
| "-I/opt/include", |
| "-stdlib=libc++", |
| "-M", |
| "-MF", |
| depfile, |
| "-c", |
| source, |
| "-o", |
| output, |
| ] |
| ) |
| ) |
| self.assertEqual(c.depfile, depfile) |
| preprocess, compile = c.split_preprocessing() |
| self.assertEqual( |
| preprocess, |
| _strs( |
| [ |
| "clang++", |
| "-DNDEBUG", |
| "-I/opt/include", |
| "-stdlib=libc++", |
| "-M", |
| "-MF", |
| depfile, |
| "-c", |
| source, |
| "-o", |
| ii_file, |
| "-E", |
| "-fno-blocks", |
| ] |
| ), |
| ) |
| self.assertEqual( |
| compile, |
| _strs(["clang++", "-c", ii_file, "-o", output]), |
| ) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
