cxx_test

A cxx_test() rule builds a C/C++ binary against a C/C++ testing framework and runs it as part of test.

Function Signature

def cxx_test(
    *,
    name: str,
    default_target_platform: None | str = None,
    target_compatible_with: list[str] = [],
    compatible_with: list[str] = [],
    exec_compatible_with: list[str] = [],
    visibility: list[str] = [],
    within_view: list[str] = ["PUBLIC"],
    metadata: OpaqueMetadata = {},
    tests: list[str] = [],
    modifiers: OpaqueMetadata = [],
    _apple_platforms: dict[str, str] = {},
    _build_info: dict[str, typing.Any] = {},
    _cxx_hacks: str = "prelude//cxx/tools:cxx_hacks",
    _cxx_toolchain: str = "gh_facebook_buck2_shims_meta//:cxx",
    _inject_test_env: str = "prelude//test/tools:inject_test_env",
    _remote_test_execution_toolchain: str = "gh_facebook_buck2_shims_meta//:remote_test_execution",
    _test_toolchain: str = "gh_facebook_buck2_shims_meta//:test",
    additional_coverage_targets: list[str] = [],
    allow_cache_upload: None | bool = None,
    anonymous_link_groups: bool = False,
    args: list[str] = [],
    auto_link_groups: bool = False,
    binary_linker_flags: list[str] = [],
    bolt_flags: list[str] = [],
    bolt_profile: None | str = None,
    compiler_flags: list[str] = [],
    constraint_overrides: list[None | str] = [],
    contacts: list[str] = [],
    coverage_instrumentation_compiler_flags: list[str] = [],
    cuda_compile_style: str = "mono",
    cxx_runtime_type: None | str = None,
    default_host_platform: None | str = None,
    default_platform: None | str = None,
    defaults: dict[str, str] = {},
    deps: list[str] = [],
    deps_query: None | str = None,
    devirt_enabled: bool = False,
    distributed_thinlto_partial_split_dwarf: bool = False,
    enable_distributed_thinlto: bool = False,
    env: dict[str, str] = {},
    executable_name: None | str = None,
    exported_needs_coverage_instrumentation: bool = False,
    extra_dwp_flags: list[str] = [],
    fat_lto: bool = False,
    focused_list_target: None | str = None,
    framework: None | str = None,
    frameworks: list[str] = [],
    header_namespace: None | str = None,
    headers: list[str] | dict[str, str] = [],
    headers_as_raw_headers_mode: None | str = None,
    include_directories: list[str] = [],
    labels: list[str] = [],
    lang_compiler_flags: dict[str, list[str]] = {},
    lang_platform_compiler_flags: dict[str, list[(str, list[str])]] = {},
    lang_platform_preprocessor_flags: dict[str, list[(str, list[str])]] = {},
    lang_preprocessor_flags: dict[str, list[str]] = {},
    libraries: list[str] = [],
    licenses: list[str] = [],
    link_deps_query_whole: bool = False,
    link_execution_preference: None | str = None,
    link_group: None | str = None,
    link_group_deps: list[str] = [],
    link_group_map: None | str | list[(str, list[(None | str | list[None | str], str, None | str | list[str], None | str)], None | dict[str, typing.Any])] = None,
    link_group_min_binary_node_count: None | int = None,
    link_group_public_deps_label: None | str = None,
    link_ordering: None | str = None,
    link_style: None | str = None,
    link_whole: bool = False,
    linker_extra_outputs: list[str] = [],
    linker_flags: list[str] = [],
    platform_compiler_flags: list[(str, list[str])] = [],
    platform_deps: list[(str, list[str])] = [],
    platform_headers: list[(str, list[str] | dict[str, str])] = [],
    platform_linker_flags: list[(str, list[str])] = [],
    platform_override: None | str = None,
    platform_preprocessor_flags: list[(str, list[str])] = [],
    platform_srcs: list[(str, list[str | (str, list[str])])] = [],
    post_linker_flags: list[str] = [],
    post_platform_linker_flags: list[(str, list[str])] = [],
    precompiled_header: None | str = None,
    prefer_stripped_objects: bool = False,
    prefix_header: None | str = None,
    preprocessor_flags: list[str] = [],
    raw_headers: list[str] = [],
    raw_headers_as_headers_mode: None | str = None,
    remote_execution: None | str | dict[str, None | bool | int | str | list[dict[str, str]] | dict[str, str | list[str]]] = None,
    resources: list[str] | dict[str, str] = [],
    run_test_separately: None | bool = None,
    runtime_dependency_handling: None | str = None,
    separate_debug_info: bool = False,
    srcs: list[str | (str, list[str])] = [],
    test_rule_timeout_ms: None | int = None,
    thin_lto: bool = False,
    transformation_spec: None | str = None,
    use_default_test_main: None | bool = None,
    use_fbcc_rust_wrapper: bool = False,
    use_header_units: bool = False,
    version_universe: None | str = None,
    weak_framework_names: list[str] = [],
) -> None

Parameters

• name: (required)

  name of the target

• default_target_platform: (defaults to: None)

  specifies the default target platform, used when no platforms are specified on the command line

• target_compatible_with: (defaults to: [])

  a list of constraints that are required to be satisfied for this target to be compatible with a configuration

• compatible_with: (defaults to: [])

  a list of constraints that are required to be satisfied for this target to be compatible with a configuration

• exec_compatible_with: (defaults to: [])

  a list of constraints that are required to be satisfied for this target to be compatible with an execution platform

• visibility: (defaults to: [])

  a list of visibility patterns restricting what targets can depend on this one

• within_view: (defaults to: ["PUBLIC"])

  a list of visibility patterns restricting what this target can depend on

• metadata: (defaults to: {})

  a key-value map of metadata associated with this target

• tests: (defaults to: [])

  a list of targets that provide tests for this one

• modifiers: (defaults to: [])

  an array of modifiers associated with this target

• _build_info: (defaults to: {})

  Build info that is passed along here will be late-stamped into a fb_build_info section on the output binary

• allow_cache_upload: (defaults to: None)

  Whether to allow uploading the output of this rule to be uploaded to cache when the action is executed locally if the configuration allows (i.e. there is a cache configured and the client has permission to write to it).

• args: (defaults to: [])

  A list of additional arguments to pass to the test when it's run.

  It is also possible to expand references to other rules within these arguments, using builtin string parameter macros :

  $(location //path/to:target) Expands to the location of the output of the build rule. This means that you can refer to these without needing to be aware of how Buck is storing data on the disk mid-build.

• compiler_flags: (defaults to: [])

  Flags to use when compiling any of the above sources (which require compilation).

• deps_query: (defaults to: None)

  Status: experimental/unstable. The deps query takes a query string that accepts the following query functions, and appends the output of the query to the declared deps:

  • attrfilter
  • deps
  • except
  • intersect
  • filter
  • kind
  • set
  • union

  Some example queries:

    "filter({name_regex}, deps('//foo:foo'))".format(name_regex='//.*')
    "attrfilter(annotation_processors, com.foo.Processor, deps('//foo:foo'))"
    "deps('//foo:foo', 1)"

• env: (defaults to: {})

  A map of environment names and values to set when running the test.

  It is also possible to expand references to other rules within the values of these environment variables, using builtin string parameter macros :

  $(location //path/to:target) Expands to the location of the output of the build rule. This means that you can refer to these without needing to be aware of how Buck is storing data on the disk mid-build.

• framework: (defaults to: None)

  Unused.

• headers: (defaults to: [])

  The set of header files that are made available for inclusion to the source files in this target. These should be specified as either a list of header files or a dictionary of header names to header files. The header name can contain forward slashes (/). The headers can be included with #include "$HEADER_NAMESPACE/$HEADER_NAME" or #include <$HEADER_NAMESPACE/$HEADER_NAME> , where $HEADER_NAMESPACE is the value of the target's header_namespace attribute, and $HEADER_NAME is the header name if specified, and the filename of the header file otherwise. See header_namespace for more information.

• include_directories: (defaults to: [])

  A list of include directories (with raw_headers) to be added to the compile command for compiling this target (via -I). An include directory is relative to the current package.

• link_execution_preference: (defaults to: None)

  The execution preference for linking. Options are:

  • any : No preference is set, and the link action will be performed based on buck2's executor configuration.
  • full_hybrid : The link action will execute both locally and remotely, regardless of buck2's executor configuration (if the executor is capable of hybrid execution). The use_limited_hybrid setting of the hybrid executor is ignored.
  • local : The link action will execute locally if compatible on current host platform.
  • local_only : The link action will execute locally, and error if the current platform is not compatible.
  • remote : The link action will execute remotely if a compatible remote platform exists, otherwise locally.

  The default is None, expressing that no preference has been set on the target itself.

• link_group_deps: (defaults to: [])

  Additional targets to traverse when building link groups, but which should not be direct dependencies of the main executable.

• link_group_public_deps_label: (defaults to: None)

  Surface nodes with this label as "public" nodes in the main executable when linking with with link groups.

• link_style: (defaults to: None)

  Determines whether to build and link this rule's dependencies statically or dynamically. Can be either static, static_pic or shared.

• linker_flags: (defaults to: [])

  Flags to add to the linker command line whenever the output from this rule is used in a link operation, such as linked into an executable or a shared library.

• preprocessor_flags: (defaults to: [])

  Flags to use when preprocessing any of the above sources (which require preprocessing).

• raw_headers: (defaults to: [])

  The set of header files that can be used for inclusion to the source files in the target and all targets that transitively depend on it. Buck doesn't add raw headers to the search path of a compiler/preprocessor automatically. include_directories and public_include_directories are the recommended way to add raw headers to the search path (they will be added via -I). compiler_flags, preprocessor_flags and exported_preprocessor_flags can also be used to add such raw headers to the search path if inclusion via -isystem or -iquote is needed. raw_headers cannot be used together with headers or exported_headers in the same target.

• raw_headers_as_headers_mode: (defaults to: None)

  Controls whether raw_headers and *include_directories attributes should be automatically converted to headers and symlink trees and/or header maps via headers. Only has an effect if the cxx_toolchain has explicitly opted into supporting this behavior via a non-default value, even if the value is disabled.

• runtime_dependency_handling: (defaults to: None)

  When this is set to symlink, shared library dependencies are included in a symlink tree alongside the resulting executable, even if the link style is not shared. Can be none or symlink.

• srcs: (defaults to: [])

  The set of C, C++, Objective-C, Objective-C++, or assembly source files to be preprocessed, compiled, and assembled by this rule. We determine which stages to run on each input source based on its file extension. See the GCC documentation for more detail on how file extensions are interpreted. Each element can be either a string specifying a source file (e.g. '') or a tuple of a string specifying a source file and a list of compilation flags (e.g. ('', ['-Wall', '-Werror']) ). In the latter case the specified flags will be used in addition to the rule's other flags when preprocessing and compiling that file (if applicable).

• test_rule_timeout_ms: (defaults to: None)

  If set specifies the maximum amount of time (in milliseconds) in which all of the tests in this rule should complete. This overrides the default rule_timeout if any has been specified in .buckconfig .

• use_fbcc_rust_wrapper: (defaults to: False)

  Opt-in for the rust version of the fbcode C++ Compiler wrapper (replacing the existing fbcc.py)

• use_header_units: (defaults to: False)

  If True, makes any header unit exported by a dependency (including recursively) through export_header_unit available to the compiler. If false, the compilation ignores header units, regardless of what is exported by dependencies.

Examples

# A rule that builds and runs C/C++ test using gtest.
cxx_test(
  name = 'echo_test',
  srcs = [
    'echo_test.cpp',
  ],
)