def test_visibility(self): """Confirm that SNOPT's symbols are not exported in the installed libdrake.so. See comments in //tools/workspace/snopt/... for details. """ # The shared library to be tested. libdrake = os.path.join( install_test_helper.get_install_dir(), "lib/libdrake.so" ) self.assertTrue(os.path.exists(libdrake)) # Dump the symbol names to an output string. if sys.platform == "linux2": command = ["readelf", "--wide", "--symbols"] undefined_marker = " UND " else: command = ["nm", "-a"] undefined_marker = " U " output = subprocess.check_output(command + [libdrake]).decode("utf8") for line in output.splitlines(): if undefined_marker in line: # Ignore undefined references (like snprintf). continue # Most of snopt's symbols are 'snfoo' or 'f_snfoo' or '_snfoo'. If # we don't find any of those, it seems unlikely that we would find # any others like the s08foo ones, etc. self.assertNotIn(" sn", line) self.assertNotIn(" f_sn", line) self.assertNotIn(" _sn", line)
def test_install(self): # Get install directory. install_dir = install_test_helper.get_install_dir() executable_folder = os.path.join(install_dir, "bin") install_test_helper.check_call( [os.path.join(executable_folder, "lcm-gen"), "--help"], )
def test_install(self): # Fail (on purpose) if not given exactly one command line argument. self.assertEqual(len(sys.argv), 2) with open(sys.argv[1], 'r') as f: lines = f.readlines() # Install into bazel read-only temporary directory. The temporary # directory does not need to be removed as bazel tests are run in a # scratch space. install_test_helper.install() installation_folder = install_test_helper.get_install_dir() self.assertTrue(os.path.isdir(installation_folder)) # Verify install directory content. content = set(os.listdir(installation_folder)) self.assertSetEqual(set(['bin', 'include', 'lib', 'share']), content) # Our launched processes should be independent, not inherit their # runfiles from the install_test.py runner. cmd_env = dict(os.environ) for key in ["RUNFILES_MANIFEST_FILE", "RUNFILES_DIR", "TEST_SRCDIR"]: if key in cmd_env: del cmd_env[key] # Execute the install actions. for cmd in lines: cmd = cmd.strip() print("+ {}".format(cmd)) install_test_helper.check_call( [os.path.join(os.getcwd(), cmd)], env=cmd_env)
def test_visibility(self): """Confirm that SNOPT's symbols are not exported in the installed libdrake.so. See comments in //tools/workspace/snopt/... for details. """ # The shared library to be tested. libdrake = os.path.join(install_test_helper.get_install_dir(), "lib/libdrake.so") self.assertTrue(os.path.exists(libdrake)) # Dump the symbol names to an output string. if sys.platform == "linux2": command = ["readelf", "--wide", "--symbols"] undefined_marker = " UND " else: command = ["nm", "-a"] undefined_marker = " U " output = subprocess.check_output(command + [libdrake]) for line in output.splitlines(): if undefined_marker in line: # Ignore undefined references (like snprintf). continue # Most of snopt's symbols are 'snfoo' or 'f_snfoo' or '_snfoo'. If # we don't find any of those, it seems unlikely that we would find # any others like the s08foo ones, etc. self.assertNotIn(" sn", line) self.assertNotIn(" f_sn", line) self.assertNotIn(" _sn", line)
def test_install_and_run(self): install_dir = install_test_helper.get_install_dir() resource_subfolder = "share/drake/" installed_sentinel = os.path.join(install_dir, resource_subfolder, ".drake-find_resource-sentinel") # Verifies that the sentinel file exists in the installed directory. # If it has been removed, we need to update this test. self.assertTrue(os.path.isfile(installed_sentinel)) # Create a resource in the temporary directory. tmp_dir = install_test_helper.create_temporary_dir() resource_folder = os.path.join(tmp_dir, resource_subfolder) test_folder = os.path.join(resource_folder, "common/test") os.makedirs(test_folder) # Create sentinel file. sentinel = os.path.join(resource_folder, os.path.basename(installed_sentinel)) os.symlink(installed_sentinel, sentinel) # Create resource file. resource = os.path.join(test_folder, "tmp_resource") resource_data = "tmp_resource" with open(resource, "w") as f: f.write(resource_data) # Cross-check the resource root environment variable name. env_name = "DRAKE_RESOURCE_ROOT" resource_tool = os.path.join(install_dir, "share/drake/common/resource_tool") output_name = install_test_helper.check_output([ resource_tool, "--print_resource_root_environment_variable_name", ], ).strip() self.assertEqual(output_name, env_name) # Use the installed resource_tool to find a resource. tool_env = dict(os.environ) tool_env[env_name] = os.path.join(tmp_dir, "share") absolute_path = install_test_helper.check_output( [ resource_tool, "--print_resource_path", "drake/common/test/tmp_resource", ], env=tool_env, ).strip() with open(absolute_path, 'r') as data: self.assertEqual(data.read(), resource_data) # Use --add_resource_search_path instead of environment variable # to find resources. absolute_path = install_test_helper.check_output([ resource_tool, "--print_resource_path", "drake/common/test/tmp_resource", "--add_resource_search_path", os.path.join(tmp_dir, "share"), ], ).strip() with open(absolute_path, 'r') as data: self.assertEqual(data.read(), resource_data)
def setUpClass(cls): # Install into bazel read-only temporary directory. We expect this # method to be called exactly once, so we assert that the install # directory must not exist beforehand, but must exist afterward. cls._installation_folder = install_test_helper.get_install_dir() assert not os.path.exists(cls._installation_folder) install_test_helper.install() assert os.path.isdir(cls._installation_folder)
def test_install(self): # Get install directory install_dir = install_test_helper.get_install_dir() # Make sure the simulation can run without error. simulation = os.path.join( install_dir, "share/drake/examples/kuka_iiwa_arm/kuka_simulation") self.assertTrue(os.path.exists(simulation), "Can't find " + simulation) install_test_helper.check_call([simulation, "--simulation_sec=0.01"])
def test_find_package_drake(self): cmake_source_dir = install_test_helper.create_temporary_dir("src") cc_content_drake = """ #include <drake/common/symbolic.h> int main() { drake::symbolic::Environment environment; return 0; } """ cc_filename_drake = os.path.join(cmake_source_dir, "main_drake.cc") with open(cc_filename_drake, "w") as f: f.write(textwrap.dedent(cc_content_drake)) cc_content_drake_common_text_logging_gflags = """ #include <drake/common/text_logging_gflags.h> int main() { drake::logging::HandleSpdlogGflags(); return 0; } """ cc_filename_drake_common_text_logging_gflags = os.path.join( cmake_source_dir, "main_drake_common_text_logging_gflags.cc") with open(cc_filename_drake_common_text_logging_gflags, "w") as f: f.write(textwrap.dedent( cc_content_drake_common_text_logging_gflags)) cmake_prefix_path = install_test_helper.get_install_dir() cmake_content = """ cmake_minimum_required(VERSION 3.10) project(find_package_drake_install_test) set(CMAKE_PREFIX_PATH {cmake_prefix_path}) find_package(drake CONFIG REQUIRED) add_executable(main_drake main_drake.cc) target_link_libraries(main_drake drake::drake) add_executable(main_drake_common_text_logging_gflags main_drake_common_text_logging_gflags.cc) target_link_libraries(main_drake_common_text_logging_gflags drake::drake-common-text-logging-gflags) """.format(cmake_prefix_path=cmake_prefix_path) cmake_filename = os.path.join(cmake_source_dir, "CMakeLists.txt") with open(cmake_filename, "w") as f: f.write(textwrap.dedent(cmake_content)) cmake_binary_dir = install_test_helper.create_temporary_dir("build") subprocess.check_call(["cmake", cmake_source_dir], cwd=cmake_binary_dir) subprocess.check_call("make", cwd=cmake_binary_dir)
def testDrakeFindResourceOrThrowInInstall(self): # Override PYTHONPATH to only use the installed `pydrake` module. env_python_path = "PYTHONPATH" tool_env = dict(os.environ) tool_env[env_python_path] = os.path.abspath( os.path.join(install_test_helper.get_install_dir(), "lib", "python2.7", "site-packages")) data_folder = os.path.join(install_test_helper.get_install_dir(), "share", "drake") # Calling `pydrake.getDrakePath()` twice verifies that there # is no memory allocation issue in the C code. output_path = install_test_helper.check_output( [ install_test_helper.get_python_executable(), "-c", "import pydrake; print(pydrake.getDrakePath());\ import pydrake; print(pydrake.getDrakePath())" ], env=tool_env, ).strip() found_install_path = (data_folder in output_path) self.assertTrue(found_install_path)
def testDrakeFindResourceOrThrowInInstall(self): # Override PYTHONPATH to only use the installed `pydrake` module. env_python_path = "PYTHONPATH" tool_env = dict(os.environ) tool_env[env_python_path] = os.path.abspath( os.path.join(install_test_helper.get_install_dir(), "lib", "python2.7", "site-packages") ) data_folder = os.path.join(install_test_helper.get_install_dir(), "share", "drake") # Calling `pydrake.getDrakePath()` twice verifies that there # is no memory allocation issue in the C code. output_path = install_test_helper.check_output( [install_test_helper.get_python_executable(), "-c", "import pydrake; print(pydrake.getDrakePath());\ import pydrake; print(pydrake.getDrakePath())" ], env=tool_env, ).strip() found_install_path = (data_folder in output_path) self.assertTrue(found_install_path)
def test_install(self): # Get install directory. install_dir = install_test_helper.get_install_dir() # Override PYTHONPATH to only use the installed `pydrake` module. env_python_path = "PYTHONPATH" tool_env = dict(os.environ) tool_env[env_python_path] = \ install_test_helper.get_python_site_packages_dir(install_dir) # Ensure we can import all user-visible modules. script = "import pydrake.all" install_test_helper.check_call( [install_test_helper.get_python_executable(), "-c", script], env=tool_env)
def test_install(self): # Get install directory. install_dir = install_test_helper.get_install_dir() # Override PYTHONPATH to only use the installed `pydrake` module. env_python_path = "PYTHONPATH" tool_env = dict(os.environ) tool_env[env_python_path] = \ install_test_helper.get_python_site_packages_dir(install_dir) # Ensure we can import all user-visible modules. script = "import pydrake.all" install_test_helper.check_call( [install_test_helper.get_python_executable(), "-c", script], env=tool_env )
def test_install(self): # Get install directory. install_dir = install_test_helper.get_install_dir() executable_folder = os.path.join(install_dir, "bin") try: install_test_helper.check_output( [os.path.join(executable_folder, "drake-lcm-spy"), "--help"], stderr=subprocess.STDOUT) # If the process doesn't fail, we cannot test the string # returned in the exception output. Since this should not # happen, we fail here. If lcm is updated to return 0 when # "--help" is called, this test will fail and will need to be # updated. self.fail( "drake-lcm-spy execution passed instead of failing. Update test" # noqa ) except subprocess.CalledProcessError as e: self.assertIn("usage: lcm-spy [options]", e.output.decode("utf8"))
def test_install(self): # Get install directory. install_dir = install_test_helper.get_install_dir() executable_folder = os.path.join(install_dir, "bin") try: install_test_helper.check_output( [os.path.join(executable_folder, "drake-lcm-spy"), "--help"], stderr=subprocess.STDOUT ) # If the process doesn't fail, we cannot test the string # returned in the exception output. Since this should not # happen, we fail here. If lcm is updated to return 0 when # "--help" is called, this test will fail and will need to be # updated. self.fail( "drake-lcm-spy execution passed instead of failing. Update test" # noqa ) except subprocess.CalledProcessError as e: self.assertIn("usage: lcm-spy [options]", e.output)
def test_help(self): """Ensures we can call `./bin/drake-visualizer --help` from install.""" # Get install directory. install_dir = install_test_helper.get_install_dir() # N.B. Do not update PYTHONPATH, as the script should handle that # itself. bin_path = join(install_dir, "bin", "drake-visualizer") text = install_test_helper.check_output([bin_path, "--help"]) # N.B. This should be kept in sync with # `drake_visualizer_bazel_test`. print(text) # Test for nominal help string. self.assertIn("usage: drake-visualizer ", text) self.assertNotIn("drake-visualizer: error: unrecognized arguments", text) # Test for modifications in help text. self.assertIn("--use_builtin_scripts", text) self.assertIn("Options: all,", text)
def test_install(self): # Fail (on purpose) if not given exactly one command line argument. self.assertEqual(len(sys.argv), 2) with open(sys.argv[1], 'r') as f: lines = f.readlines() # Install into bazel read-only temporary directory. The temporary # directory does not need to be removed as bazel tests are run in a # scratch space. install_test_helper.install() installation_folder = install_test_helper.get_install_dir() self.assertTrue(os.path.isdir(installation_folder)) # Verify install directory content. content = set(os.listdir(installation_folder)) self.assertSetEqual(set(['bin', 'include', 'lib', 'share']), content) # Execute the install actions. for cmd in lines: cmd = cmd.strip() print("+ {}".format(cmd)) install_test_helper.check_call([os.path.join(os.getcwd(), cmd)])
def test_get_install_dir(self): self.assertIn("TEST_TMPDIR", os.environ) self.assertIn('installation', install_test_helper.get_install_dir())
def main(): install_dir = install_test_helper.get_install_dir() # In scratch, mock up a drake_bazel_installed workspace. scratch_dir = install_test_helper.create_temporary_dir("scratch") # The commit (version) here should be identical to the commit listed in # drake/tools/workspace/rules_python/repository.bzl. rules_python_commit = "0.10.2" rules_python_url = f"https://github.com/bazelbuild/rules_python/archive/{rules_python_commit}.tar.gz" # noqa rules_python_sha256 = "a3a6e99f497be089f81ec082882e40246bfd435f52f4e82f37e89449b04573f6" # noqa with open(join(scratch_dir, "WORKSPACE"), "w") as f: f.write(f""" workspace(name = "scratch") load( "@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive", ) http_archive( name = "rules_python", sha256 = "{rules_python_sha256}", strip_prefix = "rules_python-{rules_python_commit}", url = "{rules_python_url}", ) new_local_repository( name = "drake_binary", path = "{install_dir}", build_file_content = "#", ) load( "@drake_binary//:share/drake/repo.bzl", "drake_repository", ) drake_repository(name = "drake") """) with open(join(scratch_dir, "BUILD.bazel"), "w") as f: f.write(f""" load("@rules_python//python:defs.bzl", "py_test") load("@drake//:.os.bzl", OS_NAME = "NAME") cc_test( name = "text_logging_test", srcs = ["text_logging_test.cc"], # TODO(jwnimmer-tri) On macOS, we need to pkg-config fmt for this to pass. # For the moment, we'll say that :drake_shared_library is Ubuntu-only. tags = ["manual"] if OS_NAME == "mac os x" else [], deps = ["@drake//:drake_shared_library"], ) py_test( name = "find_resource_test", srcs = ["find_resource_test.py"], size = "small", deps = ["@drake//bindings/pydrake"], ) py_test( name = "import_all_test", srcs = ["import_all_test.py"], size = "small", deps = ["@drake//bindings/pydrake"], ) # A stub for unit testing; not required for end users. filegroup(name = "dummy_filegroup") """) with open(join(scratch_dir, "text_logging_test.cc"), "w") as f: f.write(""" #include <drake/common/text_logging.h> int main(int argc, char** argv) { drake::log()->info("Hello {}", "world"); return 0; } """) with open(join(scratch_dir, "find_resource_test.py"), "w") as f: f.write(""" from pydrake.common import FindResourceOrThrow, set_log_level set_log_level("trace") FindResourceOrThrow("drake/examples/pendulum/Pendulum.urdf") """) with open(join(scratch_dir, "import_all_test.py"), "w") as f: f.write(""" import pydrake.all """) # Check that a full `bazel test` passes. command = "test" if sys.platform.startswith("darwin"): # TODO(jwnimmer-tri) A `test //...` doesn't pass yet on macOS. command = "build" subprocess.check_call( cwd=scratch_dir, args=[ "bazel", # Use "release engineering" options for hermeticity. # https://docs.bazel.build/versions/master/user-manual.html#bazel-releng "--bazelrc=/dev/null", # Encourage the server to exit after the test completes. "--max_idle_secs=1", # Run all of the tests from the BUILD.bazel generated above. command, "//...", "--jobs=1", # Enable verbosity. "--announce_rc", "--test_output=streamed", # Use "release engineering" options for hermeticity. "--nokeep_state_after_build", # Nerf the coverage reporter to avoid downloading the entire JDK afresh # from the internet every time we run this test. "--coverage_report_generator=//:dummy_filegroup", ])
def test_get_install_dir(self): self.assertIn("TEST_TMPDIR", os.environ) self.assertIn('installation', install_test_helper.get_install_dir())
def main(): install_dir = install_test_helper.get_install_dir() # In scratch, mock up a drake_bazel_installed workspace. scratch_dir = install_test_helper.create_temporary_dir("scratch") # TODO(jamiesnape): Automatically keep this synchronized with the version # used by @drake (or the nearest stable version). rules_python_commit = "0.2.0" rules_python_url = f"https://github.com/bazelbuild/rules_python/archive/{rules_python_commit}.tar.gz" # noqa rules_python_sha256 = "0d25ab1c7b18b3f48d1bff97bfa70c1625438b40c5f661946fb43eca4ba9d9dd" # noqa with open(join(scratch_dir, "WORKSPACE"), "w") as f: f.write(f""" workspace(name = "scratch") load( "@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive", ) http_archive( name = "rules_python", sha256 = "{rules_python_sha256}", strip_prefix = "rules_python-{rules_python_commit}", url = "{rules_python_url}", ) load( "@rules_python//python:repositories.bzl", "py_repositories", ) py_repositories() new_local_repository( name = "drake_binary", path = "{install_dir}", build_file_content = "#", ) load( "@drake_binary//:share/drake/repo.bzl", "drake_repository", ) drake_repository(name = "drake") """) with open(join(scratch_dir, "BUILD.bazel"), "w") as f: f.write(f""" load("@rules_python//python:defs.bzl", "py_test") py_test( name = "find_resource_test", srcs = ["find_resource_test.py"], size = "small", deps = ["@drake//bindings/pydrake"], ) py_test( name = "import_all_test", srcs = ["import_all_test.py"], size = "small", deps = ["@drake//bindings/pydrake"], ) # A stub for unit testing; not required for end users. filegroup(name = "dummy_filegroup") """) with open(join(scratch_dir, "find_resource_test.py"), "w") as f: f.write(f""" from pydrake.common import FindResourceOrThrow, set_log_level set_log_level("trace") FindResourceOrThrow("drake/examples/pendulum/Pendulum.urdf") """) with open(join(scratch_dir, "import_all_test.py"), "w") as f: f.write(f""" import pydrake.all """) # Check that a full `bazel test` passes. command = "test" if sys.platform.startswith("darwin"): # TODO(jwnimmer-tri) A `test //...` doesn't pass yet on macOS. command = "build" subprocess.check_call( cwd=scratch_dir, args=[ "bazel", # Use "release engineering" options for hermeticity. # https://docs.bazel.build/versions/master/user-manual.html#bazel-releng "--bazelrc=/dev/null", # Encourage the server to exit after the test completes. "--max_idle_secs=1", # Run all of the tests from the BUILD.bazel generated above. command, "//...", "--jobs=1", # Enable verbosity. "--announce_rc", # Use "release engineering" options for hermeticity. "--nokeep_state_after_build", # Nerf the coverage reporter to avoid downloading the entire JDK afresh # from the internet every time we run this test. "--coverage_report_generator=//:dummy_filegroup", ])
import os import sys import install_test_helper # Install into bazel read-only temporary directory. The temporary # directory does not need to be removed as bazel tests are run in a # scratch space. install_test_helper.install() installation_folder = install_test_helper.get_install_dir() assert os.path.isdir(installation_folder) # Verify install directory content. content = os.listdir(installation_folder) assert set(['bin', 'include', 'lib', 'share']) == set(content) # Will fail (on purpose) if not exactly one command line argument given. assert len(sys.argv) == 2 with open(sys.argv[1], "r") as f: lines = f.readlines() # Execute the install actions. for cmd in lines: cmd = cmd.strip() install_test_helper.check_call(os.path.join(os.getcwd(), cmd))
def test_install_and_run(self): install_dir = install_test_helper.get_install_dir() resource_subfolder = "share/drake/" installed_sentinel = os.path.join(install_dir, resource_subfolder, ".drake-find_resource-sentinel") # Verifies that the sentinel file exists in the installed directory. # If it has been removed, we need to update this test. self.assertTrue(os.path.isfile(installed_sentinel)) # Create a resource in the temporary directory. tmp_dir = install_test_helper.create_temporary_dir() resource_folder = os.path.join(tmp_dir, resource_subfolder) test_folder = os.path.join(resource_folder, "common/test") os.makedirs(test_folder) # Create sentinel file. sentinel = os.path.join(resource_folder, os.path.basename(installed_sentinel)) os.symlink(installed_sentinel, sentinel) # Create resource file. resource = os.path.join(test_folder, "tmp_resource") resource_data = "tmp_resource" with open(resource, "w") as f: f.write(resource_data) # Cross-check the resource root environment variable name. env_name = "DRAKE_RESOURCE_ROOT" resource_tool = os.path.join( install_dir, "share/drake/common/resource_tool") output_name = install_test_helper.check_output( [resource_tool, "--print_resource_root_environment_variable_name", ], ).strip() self.assertEqual(output_name, env_name) # Use the installed resource_tool to find a resource. tool_env = dict(os.environ) tool_env[env_name] = os.path.join(tmp_dir, "share") absolute_path = install_test_helper.check_output( [resource_tool, "--print_resource_path", "drake/common/test/tmp_resource", ], env=tool_env, ).strip() with open(absolute_path, 'r') as data: self.assertEqual(data.read(), resource_data) # Use the installed resource_tool to find a directory. # (This feature is deprecated and will eventually be removed.) absolute_path = install_test_helper.check_output( [resource_tool, "--print_resource_path", "drake/common/test", ], env=tool_env, ).strip() with open(absolute_path + '/tmp_resource', 'r') as data: self.assertEqual(data.read(), resource_data) # Use the installed resource_tool to find a resource, but with a bogus # DRAKE_RESOURCE_ROOT that should be ignored. tool_env[env_name] = os.path.join(tmp_dir, "share", "drake") full_text = install_test_helper.check_output( [resource_tool, "--print_resource_path", "drake/examples/pendulum/Pendulum.urdf", ], env=tool_env, stderr=subprocess.STDOUT, ).strip() warning = full_text.splitlines()[0] absolute_path = full_text.splitlines()[-1] self.assertIn("FindResource ignoring DRAKE_RESOURCE_ROOT", warning) self.assertTrue(os.path.exists(absolute_path), absolute_path + " does not exist") # Use --add_resource_search_path instead of environment variable # to find resources. # (This feature is deprecated and will eventually be removed.) absolute_path = install_test_helper.check_output( [resource_tool, "--print_resource_path", "drake/common/test/tmp_resource", "--add_resource_search_path", os.path.join(tmp_dir, "share"), ], ).strip() with open(absolute_path, 'r') as data: self.assertEqual(data.read(), resource_data)
def main(): install_dir = install_test_helper.get_install_dir() # In scratch, mock up a drake_bazel_installed workspace. scratch_dir = install_test_helper.create_temporary_dir("scratch") with open(join(scratch_dir, "WORKSPACE"), "w") as f: f.write(f""" workspace(name = "scratch") new_local_repository( name = "drake_binary", path = "{install_dir}", build_file_content = "#", ) load( "@drake_binary//:share/drake/repo.bzl", "drake_repository", ) drake_repository(name = "drake") """) with open(join(scratch_dir, "BUILD.bazel"), "w") as f: f.write(f""" py_test( name = "find_resource_test", srcs = ["find_resource_test.py"], size = "small", deps = ["@drake//bindings/pydrake"], ) py_test( name = "import_all_test", srcs = ["import_all_test.py"], size = "small", deps = ["@drake//bindings/pydrake"], ) # A stub for unit testing; not required for end users. filegroup(name = "dummy_filegroup") """) with open(join(scratch_dir, "find_resource_test.py"), "w") as f: f.write(f""" from pydrake.common import FindResourceOrThrow, set_log_level set_log_level("trace") FindResourceOrThrow("drake/examples/pendulum/Pendulum.urdf") """) with open(join(scratch_dir, "import_all_test.py"), "w") as f: f.write(f""" import pydrake.all """) # Check that a full `bazel test` passes. command = "test" if sys.platform.startswith("darwin"): # TODO(jwnimmer-tri) A `test //...` doesn't pass yet on macOS. command = "build" subprocess.check_call( cwd=scratch_dir, args=[ "bazel", # Use "release engineering" options for hermeticity. # https://docs.bazel.build/versions/master/user-manual.html#bazel-releng "--bazelrc=/dev/null", # Encourage the server to exit after the test completes. "--max_idle_secs=1", # Run all of the tests from the BUILD.bazel generated above. command, "//...", "--jobs=1", # Enable verbosity. "--announce_rc", # Use "release engineering" options for hermeticity. "--nokeep_state_after_build", # Nerf the coverage reporter to avoid downloading the entire JDK afresh # from the internet every time we run this test. "--coverage_report_generator=//:dummy_filegroup", ])
def test_install_and_run(self): install_dir = install_test_helper.get_install_dir() resource_subfolder = "share/drake/" installed_sentinel = os.path.join(install_dir, resource_subfolder, ".drake-find_resource-sentinel") # Verifies that the sentinel file exists in the installed directory. # If it has been removed, we need to update this test. self.assertTrue(os.path.isfile(installed_sentinel)) # Create a resource in the temporary directory. tmp_dir = install_test_helper.create_temporary_dir() resource_folder = os.path.join(tmp_dir, resource_subfolder) test_folder = os.path.join(resource_folder, "common/test") os.makedirs(test_folder) # Create sentinel file. sentinel = os.path.join(resource_folder, os.path.basename(installed_sentinel)) os.symlink(installed_sentinel, sentinel) # Create resource file. resource = os.path.join(test_folder, "tmp_resource") resource_data = "tmp_resource" with open(resource, "w") as f: f.write(resource_data) # Cross-check the resource root environment variable name. env_name = "DRAKE_RESOURCE_ROOT" resource_tool = os.path.join( install_dir, "share/drake/common/resource_tool") output_name = install_test_helper.check_output( [resource_tool, "--print_resource_root_environment_variable_name", ], ).strip() self.assertEqual(output_name, env_name) # Use the installed resource_tool to find a resource. tool_env = dict(os.environ) tool_env[env_name] = os.path.join(tmp_dir, "share") absolute_path = install_test_helper.check_output( [resource_tool, "--print_resource_path", "drake/common/test/tmp_resource", ], env=tool_env, ).strip() with open(absolute_path, 'r') as data: self.assertEqual(data.read(), resource_data) # Use --add_resource_search_path instead of environment variable # to find resources. absolute_path = install_test_helper.check_output( [resource_tool, "--print_resource_path", "drake/common/test/tmp_resource", "--add_resource_search_path", os.path.join(tmp_dir, "share"), ], ).strip() with open(absolute_path, 'r') as data: self.assertEqual(data.read(), resource_data)
def test_install(self): # Get install directory. install_dir = install_test_helper.get_install_dir() executable_folder = os.path.join(install_dir, "bin") install_test_helper.check_call( [os.path.join(executable_folder, "lcm-gen"), "--help"], )