BUILD.bazel

# -*- python -*-

load(
    "@drake//tools/skylark:drake_cc.bzl",
    "drake_cc_binary",
    "drake_cc_googletest",
    "drake_cc_library",
    "drake_cc_package_library",
)
load(
    "@drake//tools/skylark:drake_py.bzl",
    "drake_py_binary",
    "drake_py_unittest",
)
load("@drake//tools/install:install.bzl", "install")
load("//tools/lint:lint.bzl", "add_lint_tests")

package(default_visibility = ["//visibility:public"])

drake_cc_package_library(
    name = "common",
    deps = [
        ":autodiff",
        ":autodiffxd_make_coherent",
        ":cond",
        ":copyable_unique_ptr",
        ":default_scalars",
        ":double",
        ":drake_bool",
        ":drake_path",
        ":dummy_value",
        ":essential",
        ":extract_double",
        ":find_resource",
        ":hash",
        ":is_approx_equal_abstol",
        ":is_cloneable",
        ":is_less_than_comparable",
        ":nice_type_name",
        ":pointer_cast",
        ":polynomial",
        ":reset_after_move",
        ":reset_on_copy",
        ":scoped_singleton",
        ":sorted_pair",
        ":sorted_vectors_have_intersection",
        ":symbolic",
        ":symbolic_decompose",
        ":temp_directory",
        ":type_safe_index",
        ":unused",
    ],
)

# A library of things that EVERYONE should want and MUST EAT.
# Be appropriately hesitant when adding new things here.
drake_cc_library(
    name = "essential",
    srcs = [
        "drake_assert_and_throw.cc",
        "text_logging.cc",
    ],
    hdrs = [
        "constants.h",
        "drake_assert.h",
        "drake_assertion_error.h",
        "drake_copyable.h",
        "drake_deprecated.h",
        "drake_optional.h",
        "drake_throw.h",
        "drake_variant.h",
        "eigen_stl_types.h",
        "eigen_types.h",
        "never_destroyed.h",
        "text_logging.h",
    ],
    deps = [
        "@eigen",
        "@fmt",
        "@spdlog",
        "@stx",
    ],
)

# Specific traits and operators that are relevant to all ScalarTypes.
drake_cc_library(
    name = "cond",
    srcs = ["cond.cc"],
    hdrs = ["cond.h"],
    deps = [
        ":double",
    ],
)

drake_cc_library(
    name = "drake_bool",
    hdrs = [
        "drake_bool.h",
    ],
    deps = [
        ":autodiff",
        ":cond",
        ":essential",
    ],
)

drake_cc_library(
    name = "dummy_value",
    hdrs = ["dummy_value.h"],
)

# Drake's specific ScalarType-providing libraries.
drake_cc_library(
    name = "double",
    srcs = ["double_overloads.cc"],
    hdrs = ["double_overloads.h"],
)

drake_cc_library(
    name = "autodiff",
    hdrs = [
        "autodiff.h",
        "autodiff_overloads.h",
        "autodiffxd.h",
        "eigen_autodiff_limits.h",
        "eigen_autodiff_types.h",
    ],
    deps = [
        ":cond",
        ":dummy_value",
        ":essential",
    ],
)

drake_cc_library(
    name = "extract_double",
    hdrs = ["extract_double.h"],
    deps = [
        ":essential",
        ":nice_type_name",
    ],
)

drake_cc_library(
    name = "hash",
    hdrs = ["hash.h"],
    deps = [
        ":essential",
    ],
)

drake_cc_library(
    name = "autodiffxd_make_coherent",
    hdrs = ["autodiffxd_make_coherent.h"],
    deps = [
        ":autodiff",
        ":symbolic",
    ],
)

drake_cc_library(
    name = "polynomial",
    srcs = ["polynomial.cc"],
    hdrs = [
        "polynomial.h",
        "trig_poly.h",
    ],
    deps = [
        ":autodiff",
        ":essential",
    ],
)

drake_cc_library(
    name = "symbolic",
    # We only expose `symbolic.h` to the users of symbolic target and hide the
    # rest of the header files by adding them in `srcs` section.
    srcs = [
        "symbolic.cc",
        "symbolic_environment.cc",
        "symbolic_environment.h",
        "symbolic_expression.cc",
        "symbolic_expression.h",
        "symbolic_expression_cell.cc",
        "symbolic_expression_cell.h",
        "symbolic_expression_visitor.h",
        "symbolic_formula.cc",
        "symbolic_formula.h",
        "symbolic_formula_cell.cc",
        "symbolic_formula_cell.h",
        "symbolic_formula_visitor.h",
        "symbolic_monomial.cc",
        "symbolic_monomial.h",
        "symbolic_monomial_util.cc",
        "symbolic_monomial_util.h",
        "symbolic_polynomial.cc",
        "symbolic_polynomial.h",
        "symbolic_rational_function.cc",
        "symbolic_rational_function.h",
        "symbolic_simplification.cc",
        "symbolic_simplification.h",
        "symbolic_variable.cc",
        "symbolic_variable.h",
        "symbolic_variables.cc",
        "symbolic_variables.h",
    ],
    hdrs = [
        "symbolic.h",
    ],
    deps = [
        ":cond",
        ":drake_bool",
        ":dummy_value",
        ":essential",
        ":extract_double",
        ":hash",
        ":polynomial",
        "//math:matrix_util",
    ],
)

drake_cc_library(
    name = "symbolic_decompose",
    srcs = [
        "symbolic_decompose.cc",
    ],
    hdrs = [
        "symbolic_decompose.h",
    ],
    deps = [
        ":symbolic",
    ],
)

drake_cc_library(
    name = "default_scalars",
    hdrs = ["default_scalars.h"],
    deps = [
        ":autodiff",
        ":essential",
        ":symbolic",
    ],
)

# Miscellaneous utilities.

DRAKE_RESOURCE_SENTINEL = "//:.drake-find_resource-sentinel"

drake_cc_library(
    name = "is_less_than_comparable",
    hdrs = [
        "is_less_than_comparable.h",
    ],
    deps = [
        ":unused",
    ],
)

drake_cc_library(
    name = "sorted_pair",
    srcs = [
        "sorted_pair.cc",
    ],
    hdrs = [
        "sorted_pair.h",
    ],
    deps = [
        ":hash",
        ":is_less_than_comparable",
    ],
)

# Provides an anchor for finding resources.
drake_cc_binary(
    name = "libdrake_marker.so",
    srcs = [
        "drake_marker.cc",
        "drake_marker.h",
    ],
    linkshared = 1,
    linkstatic = 1,
    visibility = ["//visibility:private"],
)

drake_cc_library(
    name = "drake_marker_shared_library",
    srcs = ["libdrake_marker.so"],
    hdrs = ["drake_marker.h"],
    tags = ["exclude_from_package"],
    visibility = ["//tools/install/libdrake:__pkg__"],
)

drake_cc_library(
    name = "find_resource",
    srcs = [
        "find_loaded_library.cc",
        "find_resource.cc",
    ],
    hdrs = [
        "find_loaded_library.h",
        "find_resource.h",
    ],
    data = [
        DRAKE_RESOURCE_SENTINEL,
    ],
    # for libdrake.so path on linux
    linkopts = select({
        "//tools/cc_toolchain:linux": ["-ldl"],
        "//conditions:default": [],
    }),
    deps = [
        ":drake_marker_shared_library",
        ":essential",
        "@spruce",
    ],
)

drake_cc_library(
    name = "drake_path",
    srcs = ["drake_path.cc"],
    hdrs = ["drake_path.h"],
    data = [
        DRAKE_RESOURCE_SENTINEL,
    ],
    visibility = ["//tools/install/libdrake:__pkg__"],
    deps = [
        ":essential",
        ":find_resource",
        "@spruce",
    ],
)

drake_cc_library(
    name = "is_approx_equal_abstol",
    hdrs = ["is_approx_equal_abstol.h"],
    deps = [
        ":essential",
    ],
)

drake_cc_library(
    name = "nice_type_name",
    srcs = ["nice_type_name.cc"],
    hdrs = ["nice_type_name.h"],
    deps = [
        ":essential",
    ],
)

drake_cc_library(
    name = "is_cloneable",
    hdrs = ["is_cloneable.h"],
)

drake_cc_library(
    name = "copyable_unique_ptr",
    hdrs = ["copyable_unique_ptr.h"],
    deps = [":is_cloneable"],
)

drake_cc_library(
    name = "reset_after_move",
    hdrs = ["reset_after_move.h"],
)

drake_cc_library(
    name = "reset_on_copy",
    hdrs = ["reset_on_copy.h"],
)

drake_cc_library(
    name = "pointer_cast",
    srcs = ["pointer_cast.cc"],
    hdrs = ["pointer_cast.h"],
    deps = [
        ":nice_type_name",
    ],
)

drake_cc_library(
    name = "sorted_vectors_have_intersection",
    hdrs = ["sorted_vectors_have_intersection.h"],
    deps = [
        ":essential",
    ],
)

drake_cc_library(
    name = "temp_directory",
    srcs = ["temp_directory.cc"],
    hdrs = ["temp_directory.h"],
    deps = [
        ":essential",
        "@spruce",
    ],
)

drake_cc_library(
    name = "text_logging_gflags",
    hdrs = ["text_logging_gflags.h"],
    # TODO(jwnimmer-tri) Ideally, gflags BUILD would do this for us.  Figure
    # out what's going on.  Definitely don't let "-pthread" get copy-pasta'd
    # throughout our code.
    linkopts = select({
        "//tools/cc_toolchain:linux": ["-pthread"],
        "//conditions:default": [],
    }),
    tags = [
        # Don't add this library into the ":common" package library.
        # Only programs with a main() function should ever use this header.
        "exclude_from_package",
        # Don't install this header via this cc_library, because that would
        # introduce a dependency from libdrake onto gflags.  Similarly, we
        # can't use `install_hdrs_exclude` for this because the @gflags
        # dependency should not be part of the install.  Instead, we exclude
        # this cc_library entirely, and use a separate rule below for the
        # installation.
        "exclude_from_libdrake",
    ],
    deps = [
        ":essential",
        "@gflags",
    ],
)

# Compared to the above rule, this removes the deps attribute; we don't want to
# link against gflags for libdrake.so, we just want to publish this header for
# callers who have their own gflags to link against.
drake_cc_library(
    name = "text_logging_gflags_h",
    hdrs = ["text_logging_gflags.h"],
    tags = [
        # Don't add this library into the ":common" package library.
        # This rule should only be used for install purposes.
        "exclude_from_package",
    ],
    # This rule should only be used for install purposes, not within the
    # in-source bazel build.  We limit its visibility to enforce that.
    visibility = ["//tools/install/libdrake:__pkg__"],
)

drake_cc_library(
    name = "type_safe_index",
    hdrs = ["type_safe_index.h"],
    deps = [
        ":essential",
        ":hash",
        ":nice_type_name",
    ],
)

drake_cc_library(
    name = "unused",
    hdrs = ["unused.h"],
    deps = [
        ":essential",
    ],
)

drake_cc_library(
    name = "scoped_singleton",
    hdrs = ["scoped_singleton.h"],
    deps = [
        ":essential",
    ],
)

drake_cc_binary(
    name = "resource_tool",
    srcs = ["resource_tool.cc"],
    deps = [
        ":essential",
        ":find_resource",
        ":text_logging_gflags",
    ],
)

# This should probably move to the test_utilities package, but developers
# expect to find it here, so we'll leave it alone for now.
drake_py_binary(
    name = "cpplint_wrapper",
    testonly = 1,
    srcs = ["test/cpplint_wrapper.py"],
    data = [
        "//:CPPLINT.cfg",
        "@styleguide//:cpplint",
    ],
    main = "test/cpplint_wrapper.py",
)

install(
    name = "install",
    install_tests = [":test/resource_tool_installed_test.py"],
    targets = [
        ":libdrake_marker.so",
        ":resource_tool",
    ],
    # TODO(jwnimmer-tri) The install rule should offer more specific options
    # for programs not in bin/, and including the workspace and/or package name
    # in the installed path.  For now, we'll just specify it manually.
    runtime_dest = "share/drake/common",
    data_dest = "share/drake",
    guess_data = "WORKSPACE",
    allowed_externals = [DRAKE_RESOURCE_SENTINEL],
)

# === test/ ===

drake_cc_googletest(
    name = "autodiffxd_test",
    # The following `autodiffxd_*_test.cc` files were in a single
    # `autodiffxd_test.cc`. We found that it takes more than 150 sec to build
    # this test. So we split it into multiple .cc files. We observed about
    # 8x speed-up.
    srcs = [
        "test/autodiffxd_abs2_test.cc",
        "test/autodiffxd_abs_test.cc",
        "test/autodiffxd_acos_test.cc",
        "test/autodiffxd_addition_test.cc",
        "test/autodiffxd_asin_test.cc",
        "test/autodiffxd_atan2_test.cc",
        "test/autodiffxd_cos_test.cc",
        "test/autodiffxd_cosh_test.cc",
        "test/autodiffxd_division_test.cc",
        "test/autodiffxd_exp_test.cc",
        "test/autodiffxd_log_test.cc",
        "test/autodiffxd_max_test.cc",
        "test/autodiffxd_min_test.cc",
        "test/autodiffxd_multiplication_test.cc",
        "test/autodiffxd_pow_test.cc",
        "test/autodiffxd_sin_test.cc",
        "test/autodiffxd_sinh_test.cc",
        "test/autodiffxd_sqrt_test.cc",
        "test/autodiffxd_subtraction_test.cc",
        "test/autodiffxd_tan_test.cc",
        "test/autodiffxd_tanh_test.cc",
        "test/autodiffxd_test.h",
    ],
    deps = [
        ":autodiff",
    ],
)

drake_cc_googletest(
    name = "autodiff_overloads_test",
    deps = [
        ":autodiff",
        ":essential",
        ":extract_double",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "drake_bool_test",
    deps = [
        ":drake_bool",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "reset_after_move_test",
    deps = [
        ":reset_after_move",
    ],
)

drake_cc_googletest(
    name = "reset_on_copy_test",
    deps = [
        ":reset_on_copy",
    ],
)

drake_cc_googletest(
    name = "pointer_cast_test",
    deps = [
        ":pointer_cast",
        "//common/test_utilities",
    ],
)

drake_cc_googletest(
    name = "cond_test",
    deps = [
        ":cond",
    ],
)

drake_cc_googletest(
    name = "double_overloads_test",
    deps = [
        ":cond",
        ":double",
        ":essential",
    ],
)

# Functional test of DRAKE_ASSERT at runtime.
drake_cc_googletest(
    name = "drake_assert_test",
    deps = [
        ":essential",
    ],
)

# Same, but with assertions forced enabled.
drake_cc_googletest(
    name = "drake_assert_test_enabled",
    srcs = ["test/drake_assert_test.cc"],
    copts = [
        "-DDRAKE_ENABLE_ASSERTS",
        "-UDRAKE_DISABLE_ASSERTS",
    ],
    deps = [
        ":essential",
    ],
)

# Same, but with assertions forced disabled.
drake_cc_googletest(
    name = "drake_assert_test_disabled",
    srcs = ["test/drake_assert_test.cc"],
    copts = [
        "-UDRAKE_ENABLE_ASSERTS",
        "-DDRAKE_DISABLE_ASSERTS",
    ],
    deps = [
        ":essential",
    ],
)

# Functional test of DRAKE_ASSERT at compile time.
drake_cc_googletest(
    name = "drake_assert_test_compile",
    deps = [
        ":essential",
        ":unused",
    ],
)

# Functional test that mistyped DRAKE_ASSERTs will fail to compile.
sh_test(
    name = "drake_assert_test_compile_variants",
    size = "small",
    srcs = ["test/drake_assert_test_compile_variants.sh"],
    args = [
        "$(location //tools/cc_toolchain:capture_cc.env)",
        "$(location :test/drake_assert_test_compile.cc)",
    ],
    data = [
        "drake_assert.h",
        "test/drake_assert_test_compile.cc",
        "unused.h",
        "//tools/cc_toolchain:capture_cc.env",
        "//tools/cc_toolchain:toolchain_deps",
    ],
)

# TODO(eric.cousineau): Remove this alias and update `issue_template.md` to
# use the actual target name after 2018/10/31.
alias(
    name = "print_host_settings",
    actual = "//tools/cc_toolchain:print_host_settings",
)

drake_cc_googletest(
    name = "is_cloneable_test",
    deps = [
        ":is_cloneable",
    ],
)

drake_cc_googletest(
    name = "copyable_unique_ptr_test",
    deps = [
        ":copyable_unique_ptr",
        "//common:unused",
        "//common/test_utilities:is_dynamic_castable",
    ],
)

drake_cc_googletest(
    name = "drake_deprecated_test",
    # Remove spurious warnings from the default build output.
    copts = ["-Wno-deprecated-declarations"],
    deps = [
        ":essential",
    ],
)

drake_cc_googletest(
    name = "drake_optional_test",
    deps = [
        ":essential",
    ],
)

drake_cc_googletest(
    name = "drake_throw_test",
    deps = [
        ":essential",
    ],
)

drake_cc_googletest(
    name = "drake_variant_test",
    deps = [
        ":essential",
    ],
)

drake_cc_googletest(
    name = "dummy_value_test",
    deps = [
        ":dummy_value",
    ],
)

drake_cc_googletest(
    name = "eigen_stl_types_test",
    deps = [
        ":essential",
    ],
)

drake_cc_googletest(
    name = "eigen_types_test",
    deps = [
        ":essential",
        ":nice_type_name",
    ],
)

drake_cc_googletest(
    name = "hash_test",
    deps = [
        ":hash",
    ],
)

drake_cc_googletest(
    name = "is_less_than_comparable_test",
    deps = [
        ":is_less_than_comparable",
    ],
)

drake_cc_googletest(
    name = "sorted_pair_test",
    deps = [
        ":sorted_pair",
    ],
)

drake_cc_googletest(
    name = "extract_double_test",
    deps = [
        ":essential",
        ":extract_double",
    ],
)

drake_cc_googletest(
    name = "find_resource_test",
    data = [
        "test/find_resource_test_data.txt",
    ],
    deps = [
        ":drake_path",
        ":find_resource",
    ],
)

# Test library for `find_loaded_library_test`.
drake_cc_binary(
    name = "lib_is_real.so",
    testonly = 1,
    srcs = [
        "test/lib_is_real.cc",
    ],
    linkshared = 1,
    visibility = ["//visibility:private"],
)

drake_cc_googletest(
    name = "find_loaded_library_test",
    srcs = [
        "test/find_loaded_library_test.cc",
        ":lib_is_real.so",
    ],
    deps = [
        ":find_resource",
    ],
)

drake_cc_googletest(
    name = "is_approx_equal_abstol_test",
    deps = [
        ":essential",
        ":is_approx_equal_abstol",
    ],
)

drake_cc_googletest(
    name = "autodiffxd_make_coherent_test",
    deps = [
        ":autodiffxd_make_coherent",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "symbolic_monomial_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:expect_throws_message",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_simplification_test",
    deps = [
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "never_destroyed_test",
    deps = [
        ":essential",
    ],
)

drake_cc_googletest(
    name = "nice_type_name_test",
    deps = [
        ":autodiff",
        ":essential",
        ":nice_type_name",
    ],
)

drake_cc_googletest(
    name = "polynomial_test",
    deps = [
        ":essential",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:random_polynomial_matrix",
    ],
)

drake_cc_googletest(
    name = "sorted_vectors_have_intersection_test",
    deps = [
        ":essential",
        ":sorted_vectors_have_intersection",
    ],
)

drake_cc_googletest(
    name = "symbolic_decompose_test",
    deps = [
        ":essential",
        ":symbolic",
        ":symbolic_decompose",
    ],
)

drake_cc_googletest(
    name = "symbolic_environment_test",
    deps = [
        ":essential",
        ":symbolic",
    ],
)

drake_cc_googletest(
    name = "symbolic_expansion_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_expression_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:is_memcpy_movable",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_expression_differentiation_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_expression_jacobian_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_expression_array_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_expression_matrix_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:expect_throws_message",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_expression_transform_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:eigen_matrix_compare",
        "//math:geometric_transform",
    ],
)

drake_cc_googletest(
    name = "symbolic_mixing_scalar_types_test",
    deps = [
        ":essential",
        ":symbolic",
    ],
)

drake_cc_googletest(
    name = "symbolic_polynomial_test",
    deps = [
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_polynomial_matrix_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_rational_function_test",
    deps = [
        ":symbolic",
        "//common/test_utilities:expect_throws_message",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_rational_function_matrix_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_substitution_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_variable_overloading_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_formula_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:is_memcpy_movable",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_formula_visitor_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_variable_test",
    deps = [
        ":essential",
        ":symbolic",
        "//common/test_utilities:is_memcpy_movable",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "symbolic_variables_test",
    deps = [
        ":essential",
        ":symbolic",
    ],
)

drake_cc_googletest(
    name = "temp_directory_test",
    deps = [
        ":temp_directory",
        "@spruce",
    ],
)

# This version of text_logging_test is compiled with HAVE_SPDLOG enabled,
# because that is what Drake's WORKSPACE provides for the @spdlog external.
drake_cc_googletest(
    name = "text_logging_test",
    defines = [
        "TEXT_LOGGING_TEST_SPDLOG=1",
    ],
    use_default_main = False,
    deps = [
        ":essential",
    ],
)

# This version of text_logging_test re-compiles all source files without
# defining HAVE_SPDLOG, to ensure that the no-op stubs behave as desired.
drake_cc_googletest(
    name = "text_logging_no_spdlog_test",
    srcs = [
        "drake_copyable.h",
        "never_destroyed.h",
        "test/text_logging_test.cc",
        "text_logging.cc",
        "text_logging.h",
    ],
    defines = [
        "TEXT_LOGGING_TEST_SPDLOG=0",
    ],
    use_default_main = False,
    deps = [
        "@fmt",
    ],
)

drake_cc_googletest(
    name = "trig_poly_test",
    deps = [
        ":essential",
        ":polynomial",
    ],
)

drake_cc_googletest(
    name = "type_safe_index_test",
    deps = [
        ":type_safe_index",
        ":unused",
        "//common/test_utilities:expect_throws_message",
    ],
)

drake_cc_googletest(
    name = "eigen_autodiff_types_test",
    deps = [":autodiff"],
)

drake_cc_googletest(
    name = "scoped_singleton_test",
    deps = [
        ":scoped_singleton",
    ],
)

drake_cc_googletest(
    name = "drake_cc_googletest_main_test_device",
    args = ["--magic_number=1.0"],
)

# Run test/drake_cc_googletest_main_test.py, a unit test written in Python that
# covers the test/drake_cc_googletest_main.cc software.
drake_py_unittest(
    name = "drake_cc_googletest_main_test",
    args = ["$(location :drake_cc_googletest_main_test_device)"],
    data = [":drake_cc_googletest_main_test_device"],
)

drake_py_unittest(
    name = "cpplint_wrapper_test",
    args = [
        "$(location :cpplint_wrapper)",
        "$(location :eigen_types.h)",
    ],
    data = [
        ":cpplint_wrapper",
        ":eigen_types.h",
    ],
)

drake_py_unittest(
    name = "resource_tool_test",
    args = [
        "$(location :resource_tool)",
    ],
    data = [
        "test/resource_tool_test_data.txt",
        ":resource_tool",
        "//examples/pendulum:models",
    ],
)

# TODO(jwnimmer-tri) These tests are currently missing...
# - drake_assert_test in fancy variants
# - drake_assert_test_compile in fancy variants
# - drake_deprecated_test in fancy variants
# - cpplint_wrapper_test.py

add_lint_tests(
    python_lint_extra_srcs = [
        ":test/resource_tool_installed_test.py",
    ],
)