| # pylint: disable=g-bad-file-header | |
| # Copyright 2017 The Bazel Authors. All rights reserved. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| import os | |
| from absl.testing import absltest | |
| from src.test.py.bazel import test_base | |
| class RunfilesTest(test_base.TestBase): | |
| def _AssertRunfilesLibraryInBazelToolsRepo(self, family, lang_name): | |
| for s, t, exe in [("MODULE.bazel.mock", "MODULE.bazel", | |
| False), ("foo/BUILD.mock", "foo/BUILD", | |
| False), ("foo/foo.py", "foo/foo.py", True), | |
| ("foo/Foo.java", "foo/Foo.java", | |
| False), ("foo/foo.sh", "foo/foo.sh", | |
| True), ("foo/foo.cc", "foo/foo.cc", False), | |
| ("foo/datadep/hello.txt", "foo/datadep/hello.txt", | |
| False), ("bar/BUILD.mock", "bar/BUILD", | |
| False), ("bar/bar.py", "bar/bar.py", True), | |
| ("bar/bar-py-data.txt", "bar/bar-py-data.txt", | |
| False), ("bar/Bar.java", "bar/Bar.java", | |
| False), ("bar/bar-java-data.txt", | |
| "bar/bar-java-data.txt", False), | |
| ("bar/bar.sh", "bar/bar.sh", | |
| True), ("bar/bar-sh-data.txt", "bar/bar-sh-data.txt", | |
| False), ("bar/bar.cc", "bar/bar.cc", | |
| False), ("bar/bar-cc-data.txt", | |
| "bar/bar-cc-data.txt", False)]: | |
| self.CopyFile( | |
| self.Rlocation("io_bazel/src/test/py/bazel/testdata/runfiles_test/" + | |
| s), t, exe) | |
| _, stdout, _ = self.RunBazel(["info", "bazel-bin"]) | |
| bazel_bin = stdout[0] | |
| self.RunBazel(["build", "--verbose_failures", "//foo:runfiles-" + family]) | |
| if family == "py": | |
| bin_path = self.GetTargetExecutable("//foo:runfiles-py") | |
| elif test_base.TestBase.IsWindows(): | |
| bin_path = os.path.join(bazel_bin, "foo/runfiles-%s.exe" % family) | |
| else: | |
| bin_path = os.path.join(bazel_bin, "foo/runfiles-" + family) | |
| self.assertTrue(os.path.exists(bin_path)) | |
| _, stdout, _ = self.RunProgram( | |
| [bin_path], env_add={"TEST_SRCDIR": "__ignore_me__"} | |
| ) | |
| # 10 output lines: 2 from foo-<family>, and 2 from each of bar-<lang>. | |
| if len(stdout) != 10: | |
| self.fail("stdout: %s" % stdout) | |
| self.assertEqual(stdout[0], "Hello %s Foo!" % lang_name) | |
| self.assertRegex(stdout[1], "^rloc=.*/foo/datadep/hello.txt") | |
| self.assertNotIn("__ignore_me__", stdout[1]) | |
| with open(stdout[1].split("=", 1)[1], "r") as f: | |
| lines = [l.strip() for l in f.readlines()] | |
| if len(lines) != 1: | |
| self.fail("lines: %s" % lines) | |
| self.assertEqual(lines[0], "world") | |
| i = 2 | |
| for lang in [("py", "Python", "bar.py"), ("java", "Java", "Bar.java"), | |
| ("sh", "Bash", "bar.sh"), ("cc", "C++", "bar.cc")]: | |
| self.assertEqual(stdout[i], "Hello %s Bar!" % lang[1]) | |
| self.assertRegex(stdout[i + 1], "^rloc=.*/bar/bar-%s-data.txt" % lang[0]) | |
| self.assertNotIn("__ignore_me__", stdout[i + 1]) | |
| with open(stdout[i + 1].split("=", 1)[1], "r") as f: | |
| lines = [l.strip() for l in f.readlines()] | |
| if len(lines) != 1: | |
| self.fail("lines(%s): %s" % (lang[0], lines)) | |
| self.assertEqual(lines[0], "data for " + lang[2]) | |
| i += 2 | |
| def testPythonRunfilesLibraryInBazelToolsRepo(self): | |
| self._AssertRunfilesLibraryInBazelToolsRepo("py", "Python") | |
| def testJavaRunfilesLibraryInBazelToolsRepo(self): | |
| self._AssertRunfilesLibraryInBazelToolsRepo("java", "Java") | |
| def testBashRunfilesLibraryInBazelToolsRepo(self): | |
| self._AssertRunfilesLibraryInBazelToolsRepo("sh", "Bash") | |
| def testCppRunfilesLibraryInBazelToolsRepo(self): | |
| self._AssertRunfilesLibraryInBazelToolsRepo("cc", "C++") | |
| def testRunfilesLibrariesFindRunfilesWithoutEnvvars(self): | |
| for s, t, exe in [ | |
| ("MODULE.bazel.mock", "MODULE.bazel", False), | |
| ("bar/BUILD.mock", "bar/BUILD", False), | |
| ("bar/bar.py", "bar/bar.py", True), | |
| ("bar/bar-py-data.txt", "bar/bar-py-data.txt", False), | |
| ("bar/Bar.java", "bar/Bar.java", False), | |
| ("bar/bar-java-data.txt", "bar/bar-java-data.txt", False), | |
| ("bar/bar.sh", "bar/bar.sh", True), | |
| ("bar/bar-sh-data.txt", "bar/bar-sh-data.txt", False), | |
| ("bar/bar.cc", "bar/bar.cc", False), | |
| ("bar/bar-cc-data.txt", "bar/bar-cc-data.txt", False), | |
| ]: | |
| self.CopyFile( | |
| self.Rlocation("io_bazel/src/test/py/bazel/testdata/runfiles_test/" + | |
| s), t, exe) | |
| _, stdout, _ = self.RunBazel(["info", "bazel-bin"]) | |
| bazel_bin = stdout[0] | |
| self.RunBazel([ | |
| "build", | |
| "--verbose_failures", | |
| "//bar:bar-py", | |
| "//bar:bar-java", | |
| "//bar:bar-sh", | |
| "//bar:bar-cc", | |
| ]) | |
| for lang in [("py", "Python", "bar.py"), ("java", "Java", "Bar.java"), | |
| ("sh", "Bash", "bar.sh"), ("cc", "C++", "bar.cc")]: | |
| if lang[0] == "py": | |
| bin_path = self.GetTargetExecutable("//bar:bar-py") | |
| elif test_base.TestBase.IsWindows(): | |
| bin_path = os.path.join(bazel_bin, "bar/bar-%s.exe" % lang[0]) | |
| else: | |
| bin_path = os.path.join(bazel_bin, "bar/bar-" + lang[0]) | |
| self.assertTrue(os.path.exists(bin_path)) | |
| _, stdout, _ = self.RunProgram( | |
| [bin_path], | |
| env_remove=set([ | |
| "RUNFILES_MANIFEST_FILE", | |
| "RUNFILES_MANIFEST_ONLY", | |
| "RUNFILES_DIR", | |
| "JAVA_RUNFILES", | |
| ]), | |
| env_add={"TEST_SRCDIR": "__ignore_me__"}, | |
| ) | |
| if len(stdout) < 2: | |
| self.fail("stdout(%s): %s" % (lang[0], stdout)) | |
| self.assertEqual(stdout[0], "Hello %s Bar!" % lang[1]) | |
| self.assertRegex(stdout[1], "^rloc=.*/bar/bar-%s-data.txt" % lang[0]) | |
| self.assertNotIn("__ignore_me__", stdout[1]) | |
| with open(stdout[1].split("=", 1)[1], "r") as f: | |
| lines = [l.strip() for l in f.readlines()] | |
| if len(lines) != 1: | |
| self.fail("lines(%s): %s" % (lang[0], lines)) | |
| self.assertEqual(lines[0], "data for " + lang[2]) | |
| def testRunfilesLibrariesFindRunfilesWithRunfilesManifestEnvvar(self): | |
| for s, t, exe in [ | |
| ("MODULE.bazel.mock", "MODULE.bazel", False), | |
| ("bar/BUILD.mock", "bar/BUILD", False), | |
| # Note: do not test Python here, because py_binary always needs a | |
| # runfiles tree, even on Windows, because it needs __init__.py files in | |
| # every directory where there may be importable modules, so Bazel always | |
| # needs to create a runfiles tree for py_binary. | |
| ("bar/Bar.java", "bar/Bar.java", False), | |
| ("bar/bar-java-data.txt", "bar/bar-java-data.txt", False), | |
| ("bar/bar.sh", "bar/bar.sh", True), | |
| ("bar/bar-sh-data.txt", "bar/bar-sh-data.txt", False), | |
| ("bar/bar.cc", "bar/bar.cc", False), | |
| ("bar/bar-cc-data.txt", "bar/bar-cc-data.txt", False), | |
| ]: | |
| self.CopyFile( | |
| self.Rlocation("io_bazel/src/test/py/bazel/testdata/runfiles_test/" + | |
| s), t, exe) | |
| _, stdout, _ = self.RunBazel(["info", "bazel-bin"]) | |
| bazel_bin = stdout[0] | |
| for lang in [("java", "Java"), ("sh", "Bash"), ("cc", "C++")]: | |
| self.RunBazel([ | |
| "build", | |
| "--verbose_failures", | |
| "--enable_runfiles=no", | |
| "//bar:bar-" + lang[0], | |
| ]) | |
| if test_base.TestBase.IsWindows(): | |
| bin_path = os.path.join(bazel_bin, "bar/bar-%s.exe" % lang[0]) | |
| else: | |
| bin_path = os.path.join(bazel_bin, "bar/bar-" + lang[0]) | |
| manifest_path = bin_path + ".runfiles_manifest" | |
| self.assertTrue(os.path.exists(bin_path)) | |
| self.assertTrue(os.path.exists(manifest_path)) | |
| # Create a copy of the runfiles manifest, replacing | |
| # "bar/bar-<lang>-data.txt" with a custom file. | |
| mock_bar_dep = self.ScratchFile("bar-%s-mockdata.txt" % lang[0], | |
| ["mock %s data" % lang[0]]) | |
| if test_base.TestBase.IsWindows(): | |
| # Runfiles manifests use forward slashes as path separators, even on | |
| # Windows. | |
| mock_bar_dep = mock_bar_dep.replace("\\", "/") | |
| manifest_key = "_main/bar/bar-%s-data.txt" % lang[0] | |
| mock_manifest_line = manifest_key + " " + mock_bar_dep | |
| with open(manifest_path, "rt") as f: | |
| # Only rstrip newlines. Do not rstrip() completely, because that would | |
| # remove spaces too. This is necessary in order to have at least one | |
| # space in every manifest line. | |
| # Some manifest entries don't have any path after this space, namely the | |
| # "__init__.py" entries. (Bazel writes such manifests on every | |
| # platform). The reason is that these files are never symlinks in the | |
| # runfiles tree, Bazel actually creates empty __init__.py files (again | |
| # on every platform). However to keep these manifest entries correct, | |
| # they need to have a space character. | |
| # We could probably strip these lines completely, but this test doesn't | |
| # aim to exercise what would happen in that case. | |
| mock_manifest_data = [ | |
| mock_manifest_line | |
| if line.split(" ", 1)[0] == manifest_key else line.rstrip("\n\r") | |
| for line in f | |
| ] | |
| substitute_manifest = self.ScratchFile( | |
| "mock-%s.runfiles/MANIFEST" % lang[0], mock_manifest_data) | |
| _, stdout, _ = self.RunProgram( | |
| [bin_path], | |
| env_remove=set(["RUNFILES_DIR"]), | |
| env_add={ | |
| # On Linux/macOS, the Java launcher picks up JAVA_RUNFILES and | |
| # ignores RUNFILES_MANIFEST_FILE. | |
| "JAVA_RUNFILES": substitute_manifest[: -len("/MANIFEST")], | |
| # On Windows, the Java launcher picks up RUNFILES_MANIFEST_FILE. | |
| # The C++ runfiles library picks up RUNFILES_MANIFEST_FILE on all | |
| # platforms. | |
| "RUNFILES_MANIFEST_FILE": substitute_manifest, | |
| "RUNFILES_MANIFEST_ONLY": "1", | |
| "TEST_SRCDIR": "__ignore_me__", | |
| }, | |
| ) | |
| if len(stdout) < 2: | |
| self.fail("stdout: %s" % stdout) | |
| self.assertEqual(stdout[0], "Hello %s Bar!" % lang[1]) | |
| self.assertRegex(stdout[1], "^rloc=" + mock_bar_dep) | |
| self.assertNotIn("__ignore_me__", stdout[1]) | |
| with open(stdout[1].split("=", 1)[1], "r") as f: | |
| lines = [l.strip() for l in f.readlines()] | |
| if len(lines) != 1: | |
| self.fail("lines: %s" % lines) | |
| self.assertEqual(lines[0], "mock %s data" % lang[0]) | |
| def testRunfilesLibrariesFindRlocationpathExpansion(self): | |
| self.ScratchDir("A") | |
| self.ScratchFile("A/REPO.bazel") | |
| self.ScratchFile("A/p/BUILD", ["exports_files(['foo.txt'])"]) | |
| self.ScratchFile("A/p/foo.txt", ["Hello, World!"]) | |
| self.ScratchFile( | |
| "MODULE.bazel", | |
| [ | |
| 'bazel_dep(name = "rules_python", version = "0.40.0")', | |
| "local_repository = use_repo_rule(", | |
| ' "@bazel_tools//tools/build_defs/repo:local.bzl",', | |
| ' "local_repository")', | |
| 'local_repository(name = "A", path = "A")', | |
| ], | |
| ) | |
| self.ScratchFile( | |
| "pkg/BUILD", | |
| [ | |
| 'load("@rules_python//python:py_binary.bzl", "py_binary")', | |
| "py_binary(", | |
| " name = 'bin',", | |
| " srcs = ['bin.py'],", | |
| " args = [", | |
| " '$(rlocationpath bar.txt)',", | |
| " '$(rlocationpath @A//p:foo.txt)',", | |
| " ],", | |
| " data = [", | |
| " 'bar.txt',", | |
| " '@A//p:foo.txt'", | |
| " ],", | |
| " deps = ['@bazel_tools//tools/python/runfiles'],", | |
| ")", | |
| ], | |
| ) | |
| self.ScratchFile("pkg/bar.txt", ["Hello, Bazel!"]) | |
| self.ScratchFile("pkg/bin.py", [ | |
| "import sys", | |
| "from tools.python.runfiles import runfiles", | |
| "r = runfiles.Create()", | |
| "for arg in sys.argv[1:]:", | |
| " print(open(r.Rlocation(arg)).read().strip())", | |
| ]) | |
| _, stdout, _ = self.RunBazel(["run", "//pkg:bin"]) | |
| if len(stdout) != 2: | |
| self.fail("stdout: %s" % stdout) | |
| self.assertEqual(stdout[0], "Hello, Bazel!") | |
| self.assertEqual(stdout[1], "Hello, World!") | |
| def setUpRunfilesDirectoryIncrementalityTest(self): | |
| self.ScratchFile("MODULE.bazel") | |
| self.AddBazelDep("rules_shell") | |
| self.ScratchFile( | |
| "BUILD", | |
| [ | |
| 'load("@rules_shell//shell:sh_test.bzl", "sh_test")', | |
| "sh_test(", | |
| " name = 'test',", | |
| " srcs = ['test.sh'],", | |
| " data = ['data.txt'],", | |
| ")", | |
| ], | |
| ) | |
| self.ScratchFile("data.txt") | |
| self.ScratchFile("test.sh", ["[[ -f data.txt ]]"], executable=True) | |
| self.ScratchFile( | |
| ".bazelrc", | |
| [ | |
| "startup --nowindows_enable_symlinks", | |
| "common --spawn_strategy=local", | |
| ], | |
| ) | |
| def testRunfilesDirectoryIncrementalityEnableRunfilesFlippedOn(self): | |
| self.setUpRunfilesDirectoryIncrementalityTest() | |
| exit_code, _, _ = self.RunBazel( | |
| ["test", ":test", "--noenable_runfiles"], allow_failure=True | |
| ) | |
| self.assertEqual(exit_code, 3) | |
| exit_code, _, _ = self.RunBazel(["test", ":test", "--enable_runfiles"]) | |
| self.assertEqual(exit_code, 0) | |
| def testRunfilesDirectoryIncrementalityEnableRunfilesFlippedOff(self): | |
| self.setUpRunfilesDirectoryIncrementalityTest() | |
| exit_code, _, _ = self.RunBazel(["test", ":test", "--enable_runfiles"]) | |
| self.assertEqual(exit_code, 0) | |
| exit_code, _, _ = self.RunBazel( | |
| ["test", ":test", "--noenable_runfiles"], allow_failure=True | |
| ) | |
| self.assertEqual(exit_code, 3) | |
| def testRunfilesDirectoryIncrementalityNoBuildRunfileLinksEnableRunfilesFlippedOn( | |
| self, | |
| ): | |
| self.setUpRunfilesDirectoryIncrementalityTest() | |
| exit_code, _, _ = self.RunBazel( | |
| ["test", ":test", "--nobuild_runfile_links", "--noenable_runfiles"], | |
| allow_failure=True, | |
| ) | |
| self.assertEqual(exit_code, 3) | |
| exit_code, _, _ = self.RunBazel( | |
| ["test", ":test", "--nobuild_runfile_links", "--enable_runfiles"] | |
| ) | |
| self.assertEqual(exit_code, 0) | |
| def testRunfilesDirectoryIncrementalityNoBuildRunfileLinksEnableRunfilesFlippedOff( | |
| self, | |
| ): | |
| self.setUpRunfilesDirectoryIncrementalityTest() | |
| exit_code, _, _ = self.RunBazel( | |
| ["test", ":test", "--nobuild_runfile_links", "--enable_runfiles"] | |
| ) | |
| self.assertEqual(exit_code, 0) | |
| exit_code, _, _ = self.RunBazel( | |
| ["test", ":test", "--nobuild_runfile_links", "--noenable_runfiles"], | |
| allow_failure=True, | |
| ) | |
| self.assertEqual(exit_code, 3) | |
| def testRunfilesDirectoryIncrementalityEnableRunfilesFlippedOnRun(self): | |
| self.setUpRunfilesDirectoryIncrementalityTest() | |
| exit_code, _, _ = self.RunBazel( | |
| ["run", ":test", "--noenable_runfiles"], allow_failure=True | |
| ) | |
| self.assertNotEqual(exit_code, 0) | |
| exit_code, _, _ = self.RunBazel(["run", ":test", "--enable_runfiles"]) | |
| self.assertEqual(exit_code, 0) | |
| def testRunfilesDirectoryIncrementalityEnableRunfilesFlippedOffRun(self): | |
| self.setUpRunfilesDirectoryIncrementalityTest() | |
| exit_code, _, _ = self.RunBazel(["run", ":test", "--enable_runfiles"]) | |
| self.assertEqual(exit_code, 0) | |
| exit_code, _, _ = self.RunBazel( | |
| ["run", ":test", "--noenable_runfiles"], allow_failure=True | |
| ) | |
| self.assertNotEqual(exit_code, 0) | |
| def testRunfilesDirectoryIncrementalityNoBuildRunfileLinksEnableRunfilesFlippedOnRun( | |
| self, | |
| ): | |
| self.setUpRunfilesDirectoryIncrementalityTest() | |
| exit_code, _, _ = self.RunBazel( | |
| ["run", ":test", "--nobuild_runfile_links", "--noenable_runfiles"], | |
| allow_failure=True, | |
| ) | |
| self.assertNotEqual(exit_code, 0) | |
| exit_code, _, _ = self.RunBazel( | |
| ["run", ":test", "--nobuild_runfile_links", "--enable_runfiles"] | |
| ) | |
| self.assertEqual(exit_code, 0) | |
| def testRunfilesDirectoryIncrementalityNoBuildRunfileLinksEnableRunfilesFlippedOffRun( | |
| self, | |
| ): | |
| self.setUpRunfilesDirectoryIncrementalityTest() | |
| exit_code, _, _ = self.RunBazel( | |
| ["run", ":test", "--nobuild_runfile_links", "--enable_runfiles"] | |
| ) | |
| self.assertEqual(exit_code, 0) | |
| exit_code, _, _ = self.RunBazel( | |
| ["run", ":test", "--nobuild_runfile_links", "--noenable_runfiles"], | |
| allow_failure=True, | |
| ) | |
| self.assertNotEqual(exit_code, 0) | |
| def testTestsRunWithNoBuildRunfileLinksAndNoEnableRunfiles(self): | |
| self.ScratchFile("MODULE.bazel") | |
| self.AddBazelDep("rules_shell") | |
| self.ScratchFile( | |
| "BUILD", | |
| [ | |
| 'load("@rules_shell//shell:sh_test.bzl", "sh_test")', | |
| "sh_test(", | |
| " name = 'test',", | |
| " srcs = ['test.sh'],", | |
| ")", | |
| ], | |
| ) | |
| self.ScratchFile("test.sh", executable=True) | |
| self.ScratchFile(".bazelrc", ["common --spawn_strategy=local"]) | |
| self.RunBazel( | |
| ["test", ":test", "--nobuild_runfile_links", "--noenable_runfiles"] | |
| ) | |
| def testWrappedShBinary(self): | |
| self.writeWrapperRule() | |
| self.ScratchFile("MODULE.bazel") | |
| self.AddBazelDep("rules_shell") | |
| self.ScratchFile( | |
| "BUILD", | |
| [ | |
| 'load("@rules_shell//shell:sh_binary.bzl", "sh_binary")', | |
| "sh_binary(", | |
| " name = 'binary',", | |
| " srcs = ['binary.sh'],", | |
| " visibility = ['//visibility:public'],", | |
| ")", | |
| ], | |
| ) | |
| self.ScratchFile( | |
| "binary.sh", | |
| [ | |
| "echo Hello, World!", | |
| ], | |
| executable=True, | |
| ) | |
| _, stdout, _ = self.RunBazel(["run", "//wrapped"]) | |
| self.assertEqual(stdout, ["Hello, World!"]) | |
| def disabledWrappedPyBinary(self): | |
| # https://github.com/bazelbuild/rules_python/issues/2250 | |
| # wrapping py_binary fails with rules_python 0.36.0 on Windows | |
| self.writeWrapperRule() | |
| self.ScratchFile("MODULE.bazel") | |
| self.ScratchFile( | |
| "BUILD", | |
| [ | |
| 'load("@rules_python//python:py_binary.bzl", "py_binary")', | |
| "py_binary(", | |
| " name = 'binary',", | |
| " srcs = ['binary.py'],", | |
| " visibility = ['//visibility:public'],", | |
| ")", | |
| ], | |
| ) | |
| self.ScratchFile( | |
| "binary.py", | |
| [ | |
| "print('Hello, World!')", | |
| ], | |
| ) | |
| _, stdout, _ = self.RunBazel(["run", "//wrapped"]) | |
| self.assertEqual(stdout, ["Hello, World!"]) | |
| def testWrappedJavaBinary(self): | |
| self.writeWrapperRule() | |
| self.ScratchFile( | |
| "MODULE.bazel", ['bazel_dep(name = "rules_java", version = "8.12.0")'] | |
| ) | |
| self.ScratchFile( | |
| "BUILD", | |
| [ | |
| 'load("@rules_java//java:java_binary.bzl", "java_binary")', | |
| "java_binary(", | |
| " name = 'binary',", | |
| " srcs = ['Binary.java'],", | |
| " main_class = 'Binary',", | |
| " visibility = ['//visibility:public'],", | |
| ")", | |
| ], | |
| ) | |
| self.ScratchFile( | |
| "Binary.java", | |
| [ | |
| "public class Binary {", | |
| " public static void main(String[] args) {", | |
| ' System.out.println("Hello, World!");', | |
| " }", | |
| "}", | |
| ], | |
| ) | |
| _, stdout, _ = self.RunBazel(["run", "//wrapped"]) | |
| self.assertEqual(stdout, ["Hello, World!"]) | |
| def writeWrapperRule(self): | |
| self.ScratchFile("rules/BUILD") | |
| self.ScratchFile( | |
| "rules/wrapper.bzl", | |
| [ | |
| "def _wrapper_impl(ctx):", | |
| " target = ctx.attr.target", | |
| " original_executable = (", | |
| " target[DefaultInfo].files_to_run.executable)", | |
| " executable = ctx.actions.declare_file(", | |
| " original_executable.basename)", | |
| " ctx.actions.symlink(output = executable,", | |
| " target_file = original_executable)", | |
| " data_runfiles = ctx.runfiles([executable]).merge(", | |
| " target[DefaultInfo].data_runfiles)", | |
| " default_runfiles = ctx.runfiles([executable]).merge(", | |
| " target[DefaultInfo].default_runfiles)", | |
| " return [", | |
| " DefaultInfo(", | |
| " executable = executable,", | |
| " files = target[DefaultInfo].files,", | |
| " data_runfiles = data_runfiles,", | |
| " default_runfiles = default_runfiles,", | |
| " ), ]", | |
| "wrapper = rule(", | |
| " implementation = _wrapper_impl,", | |
| " attrs = {", | |
| " 'target': attr.label(", | |
| " cfg = 'target',", | |
| " executable = True,", | |
| " ),", | |
| " },", | |
| " executable = True,", | |
| ")", | |
| ], | |
| ) | |
| self.ScratchFile( | |
| "wrapped/BUILD", | |
| [ | |
| "load('//rules:wrapper.bzl', 'wrapper')", | |
| "wrapper(", | |
| " name = 'wrapped',", | |
| " target = '//:binary',", | |
| ")", | |
| ], | |
| ) | |
| if __name__ == "__main__": | |
| absltest.main() |