| # 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 | |
| import stat | |
| import string | |
| import unittest | |
| from src.test.py.bazel import test_base | |
| class LauncherTest(test_base.TestBase): | |
| def _buildJavaTargets(self, bazel_bin, binary_suffix): | |
| exit_code, _, stderr = self.RunBazel(['build', '//foo']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| main_binary = os.path.join(bazel_bin, 'foo/foo%s' % binary_suffix) | |
| self.assertTrue(os.path.isfile(main_binary)) | |
| self.assertTrue( | |
| os.path.isdir( | |
| os.path.join(bazel_bin, 'foo/foo%s.runfiles' % binary_suffix))) | |
| if self.IsWindows(): | |
| self.assertTrue(os.path.isfile(main_binary)) | |
| self.AssertRunfilesManifestContains( | |
| os.path.join(bazel_bin, | |
| 'foo/foo%s.runfiles/MANIFEST' % binary_suffix), | |
| '__main__/bar/bar.txt') | |
| else: | |
| self.assertTrue( | |
| os.path.islink( | |
| os.path.join(bazel_bin, 'foo/foo.runfiles/__main__/bar/bar.txt'))) | |
| exit_code, stdout, stderr = self.RunProgram([main_binary]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual(len(stdout), 4) | |
| self.assertEqual(stdout[0], 'hello java') | |
| if self.IsWindows(): | |
| self.assertRegexpMatches( | |
| stdout[1], r'java_runfiles=.*foo\\foo%s.runfiles' % binary_suffix) | |
| self.assertEqual(stdout[2], 'runfiles_manifest_only=1') | |
| self.assertRegexpMatches( | |
| stdout[3], r'^runfiles_manifest_file=[a-zA-Z]:[/\\].*MANIFEST$') | |
| else: | |
| self.assertRegexpMatches(stdout[1], r'java_runfiles=.*/foo/foo.runfiles') | |
| self.assertEqual(stdout[2], 'runfiles_manifest_only=') | |
| self.assertRegexpMatches(stdout[3], r'^runfiles_manifest_file.*MANIFEST$') | |
| def _buildShBinaryTargets(self, bazel_bin, bin1_suffix): | |
| exit_code, _, stderr = self.RunBazel(['build', '//foo:bin1.sh']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bin1 = os.path.join(bazel_bin, 'foo', 'bin1.sh%s' % bin1_suffix) | |
| self.assertTrue(os.path.exists(bin1)) | |
| self.assertTrue( | |
| os.path.isdir( | |
| os.path.join(bazel_bin, 'foo/bin1.sh%s.runfiles' % bin1_suffix))) | |
| exit_code, _, stderr = self.RunBazel(['build', '//foo:bin2.cmd']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bin2 = os.path.join(bazel_bin, 'foo/bin2.cmd') | |
| self.assertTrue(os.path.exists(bin2)) | |
| self.assertTrue( | |
| os.path.isdir(os.path.join(bazel_bin, 'foo/bin2.cmd.runfiles'))) | |
| exit_code, _, stderr = self.RunBazel(['build', '//foo:bin3.bat']) | |
| if self.IsWindows(): | |
| self.AssertExitCode(exit_code, 1, stderr) | |
| self.assertIn('target name extension should match source file extension', | |
| os.linesep.join(stderr)) | |
| else: | |
| bin3 = os.path.join(bazel_bin, 'foo', 'bin3.bat') | |
| self.assertTrue(os.path.exists(bin3)) | |
| self.assertTrue( | |
| os.path.isdir(os.path.join(bazel_bin, 'foo/bin3.bat.runfiles'))) | |
| if self.IsWindows(): | |
| self.assertTrue(os.path.isfile(bin1)) | |
| self.assertTrue(os.path.isfile(bin2)) | |
| else: | |
| self.assertTrue(os.path.islink(bin1)) | |
| self.assertTrue(os.path.islink(bin2)) | |
| self.assertTrue(os.path.islink(bin3)) | |
| if self.IsWindows(): | |
| self.AssertRunfilesManifestContains( | |
| os.path.join(bazel_bin, | |
| 'foo/bin1.sh%s.runfiles/MANIFEST' % bin1_suffix), | |
| '__main__/bar/bar.txt') | |
| self.AssertRunfilesManifestContains( | |
| os.path.join(bazel_bin, 'foo/bin2.cmd.runfiles/MANIFEST'), | |
| '__main__/bar/bar.txt') | |
| else: | |
| self.assertTrue( | |
| os.path.islink( | |
| os.path.join(bazel_bin, | |
| 'foo/bin1.sh.runfiles/__main__/bar/bar.txt'))) | |
| self.assertTrue( | |
| os.path.islink( | |
| os.path.join(bazel_bin, | |
| 'foo/bin2.cmd.runfiles/__main__/bar/bar.txt'))) | |
| self.assertTrue( | |
| os.path.islink( | |
| os.path.join(bazel_bin, | |
| 'foo/bin3.bat.runfiles/__main__/bar/bar.txt'))) | |
| exit_code, stdout, stderr = self.RunProgram([bin1]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual(len(stdout), 3) | |
| self.assertEqual(stdout[0], 'hello shell') | |
| if self.IsWindows(): | |
| self.assertEqual(stdout[1], 'runfiles_manifest_only=1') | |
| self.assertRegexpMatches( | |
| stdout[2], | |
| (r'^runfiles_manifest_file=' | |
| r'[a-zA-Z]:/.*/foo/bin1.sh%s.runfiles/MANIFEST$' % bin1_suffix)) | |
| else: | |
| # TODO(laszlocsomor): Find out whether the runfiles-related envvars should | |
| # be set on Linux (e.g. $RUNFILES, $RUNFILES_MANIFEST_FILE). Currently | |
| # they aren't, and that may be a bug. If it's indeed a bug, fix that bug | |
| # and update this test. | |
| self.assertEqual(stdout[1], 'runfiles_manifest_only=') | |
| self.assertEqual(stdout[2], 'runfiles_manifest_file=') | |
| if self.IsWindows(): | |
| exit_code, stdout, stderr = self.RunProgram([bin2]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual(stdout[0], 'hello batch') | |
| def _buildPyTargets(self, bazel_bin, binary_suffix): | |
| # Verify that the build of our py_binary succeeds. | |
| exit_code, _, stderr = self.RunBazel(['build', '//foo:foo']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| # Verify that generated files exist. | |
| foo_bin = os.path.join(bazel_bin, 'foo', 'foo%s' % binary_suffix) | |
| self.assertTrue(os.path.isfile(foo_bin)) | |
| self.assertTrue( | |
| os.path.isdir( | |
| os.path.join(bazel_bin, 'foo/foo%s.runfiles' % binary_suffix))) | |
| # Verify contents of runfiles (manifest). | |
| if self.IsWindows(): | |
| self.AssertRunfilesManifestContains( | |
| os.path.join(bazel_bin, | |
| 'foo/foo%s.runfiles/MANIFEST' % binary_suffix), | |
| '__main__/bar/bar.txt') | |
| else: | |
| self.assertTrue( | |
| os.path.islink( | |
| os.path.join(bazel_bin, 'foo/foo.runfiles/__main__/bar/bar.txt'))) | |
| # Try to run the built py_binary. | |
| exit_code, stdout, stderr = self.RunProgram([foo_bin]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual(stdout[0], 'Hello World!') | |
| # Try to use the py_binary as an executable in a Skylark rule. | |
| exit_code, stdout, stderr = self.RunBazel(['build', '//foo:hello']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| # Verify that the Skylark action generated the right output. | |
| hello_path = os.path.join(bazel_bin, 'foo', 'hello.txt') | |
| self.assertTrue(os.path.isfile(hello_path)) | |
| with open(hello_path, 'r') as f: | |
| self.assertEqual(f.read(), 'Hello World!') | |
| # Verify that running py_test succeeds. | |
| exit_code, _, stderr = self.RunBazel(['test', '//foo:test']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| def _buildAndCheckArgumentPassing(self, package, target_name): | |
| exit_code, stdout, stderr = self.RunBazel(['info', 'bazel-bin']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bazel_bin = stdout[0] | |
| exit_code, _, stderr = self.RunBazel( | |
| ['build', '//%s:%s' % (package, target_name)]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bin_suffix = '.exe' if self.IsWindows() else '' | |
| bin1 = os.path.join(bazel_bin, package, '%s%s' % (target_name, bin_suffix)) | |
| self.assertTrue(os.path.exists(bin1)) | |
| self.assertTrue( | |
| os.path.isdir( | |
| os.path.join(bazel_bin, '%s/%s%s.runfiles' % (package, target_name, | |
| bin_suffix)))) | |
| arguments = ['a', 'a b', '"b"', 'C:\\a\\b\\', '"C:\\a b\\c\\"'] | |
| exit_code, stdout, stderr = self.RunProgram([bin1] + arguments) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual(stdout, arguments) | |
| def testJavaBinaryLauncher(self): | |
| self.CreateWorkspaceWithDefaultRepos('WORKSPACE') | |
| self.ScratchFile('foo/BUILD', [ | |
| 'java_binary(', | |
| ' name = "foo",', | |
| ' srcs = ["Main.java"],', | |
| ' main_class = "Main",', | |
| ' data = ["//bar:bar.txt"],', | |
| ')', | |
| ]) | |
| self.ScratchFile('foo/Main.java', [ | |
| 'public class Main {', | |
| ' public static void main(String[] args) {' | |
| ' System.out.println("hello java");', | |
| ' System.out.println("java_runfiles=" + ', | |
| ' System.getenv("JAVA_RUNFILES"));', | |
| ' System.out.println("runfiles_manifest_only=" + ', | |
| ' System.getenv("RUNFILES_MANIFEST_ONLY"));', | |
| ' System.out.println("runfiles_manifest_file=" + ', | |
| ' System.getenv("RUNFILES_MANIFEST_FILE"));', | |
| ' }', | |
| '}', | |
| ]) | |
| self.ScratchFile('bar/BUILD', ['exports_files(["bar.txt"])']) | |
| self.ScratchFile('bar/bar.txt', ['hello']) | |
| exit_code, stdout, stderr = self.RunBazel(['info', 'bazel-bin']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bazel_bin = stdout[0] | |
| self._buildJavaTargets(bazel_bin, '.exe' if self.IsWindows() else '') | |
| def testJavaBinaryArgumentPassing(self): | |
| self.CreateWorkspaceWithDefaultRepos('WORKSPACE') | |
| self.ScratchFile('foo/BUILD', [ | |
| 'java_binary(', | |
| ' name = "bin",', | |
| ' srcs = ["Main.java"],', | |
| ' main_class = "Main",', | |
| ')', | |
| ]) | |
| self.ScratchFile('foo/Main.java', [ | |
| 'public class Main {', | |
| ' public static void main(String[] args) {' | |
| ' for (String arg : args) {', | |
| ' System.out.println(arg);', | |
| ' }' | |
| ' }', | |
| '}', | |
| ]) | |
| self._buildAndCheckArgumentPassing('foo', 'bin') | |
| def testShBinaryLauncher(self): | |
| self.CreateWorkspaceWithDefaultRepos('WORKSPACE') | |
| self.ScratchFile( | |
| 'foo/BUILD', | |
| [ | |
| # On Linux/MacOS, all sh_binary rules generate an output file with | |
| # the same name as the rule, and this is a symlink to the file in | |
| # `srcs`. (Bazel allows only one file in `sh_binary.srcs`.) | |
| # On Windows, if the srcs's extension is one of ".exe", ".cmd", or | |
| # ".bat", then Bazel requires the rule's name has the same | |
| # extension, and the output file will be a copy of the source file. | |
| 'sh_binary(', | |
| ' name = "bin1.sh",', | |
| ' srcs = ["foo.sh"],', | |
| ' data = ["//bar:bar.txt"],', | |
| ')', | |
| 'sh_binary(', | |
| ' name = "bin2.cmd",', # name's extension matches that of srcs[0] | |
| ' srcs = ["foo.cmd"],', | |
| ' data = ["//bar:bar.txt"],', | |
| ')', | |
| 'sh_binary(', | |
| ' name = "bin3.bat",', # name's extension doesn't match srcs[0]'s | |
| ' srcs = ["foo.cmd"],', | |
| ' data = ["//bar:bar.txt"],', | |
| ')', | |
| ]) | |
| foo_sh = self.ScratchFile('foo/foo.sh', [ | |
| '#!/bin/bash', | |
| 'echo hello shell', | |
| 'echo runfiles_manifest_only=${RUNFILES_MANIFEST_ONLY:-}', | |
| 'echo runfiles_manifest_file=${RUNFILES_MANIFEST_FILE:-}', | |
| ]) | |
| foo_cmd = self.ScratchFile('foo/foo.cmd', ['@echo hello batch']) | |
| self.ScratchFile('bar/BUILD', ['exports_files(["bar.txt"])']) | |
| self.ScratchFile('bar/bar.txt', ['hello']) | |
| os.chmod(foo_sh, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) | |
| os.chmod(foo_cmd, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) | |
| exit_code, stdout, stderr = self.RunBazel(['info', 'bazel-bin']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bazel_bin = stdout[0] | |
| self._buildShBinaryTargets(bazel_bin, '.exe' if self.IsWindows() else '') | |
| def testShBinaryArgumentPassing(self): | |
| self.CreateWorkspaceWithDefaultRepos('WORKSPACE') | |
| self.ScratchFile('foo/BUILD', [ | |
| 'sh_binary(', | |
| ' name = "bin",', | |
| ' srcs = ["bin.sh"],', | |
| ')', | |
| ]) | |
| foo_sh = self.ScratchFile('foo/bin.sh', [ | |
| '#!/bin/bash', | |
| '# Store arguments in a array', | |
| 'args=("$@")', | |
| '# Get the number of arguments', | |
| 'N=${#args[@]}', | |
| '# Echo each argument', | |
| 'for (( i=0;i<$N;i++)); do', | |
| ' echo ${args[${i}]}', | |
| 'done', | |
| ]) | |
| os.chmod(foo_sh, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) | |
| self._buildAndCheckArgumentPassing('foo', 'bin') | |
| def testPyBinaryLauncher(self): | |
| self.CreateWorkspaceWithDefaultRepos('WORKSPACE') | |
| self.ScratchFile('foo/foo.bzl', [ | |
| 'def _impl(ctx):', | |
| ' ctx.actions.run(', | |
| ' arguments=[ctx.outputs.out.path],', | |
| ' outputs=[ctx.outputs.out],', | |
| ' executable=ctx.executable._hello_world,', | |
| ' use_default_shell_env=True)', | |
| '', | |
| 'helloworld = rule(', | |
| ' implementation=_impl,', | |
| ' attrs={', | |
| ' "srcs": attr.label_list(allow_files=True),', | |
| ' "out": attr.output(mandatory=True),', | |
| ' "_hello_world": attr.label(executable=True, cfg="host",', | |
| ' allow_files=True,', | |
| ' default=Label("//foo:foo"))', | |
| ' }', | |
| ')', | |
| ]) | |
| self.ScratchFile('foo/BUILD', [ | |
| 'load(":foo.bzl", "helloworld")', '', 'py_binary(', ' name = "foo",', | |
| ' srcs = ["foo.py"],', ' data = ["//bar:bar.txt"],', ')', '', | |
| 'py_test(', ' name = "test",', ' srcs = ["test.py"],', ')', '', | |
| 'helloworld(', ' name = "hello",', ' out = "hello.txt",', ')' | |
| ]) | |
| foo_py = self.ScratchFile('foo/foo.py', [ | |
| '#!/usr/bin/env python', | |
| 'import sys', | |
| 'if len(sys.argv) == 2:', | |
| ' with open(sys.argv[1], "w") as f:', | |
| ' f.write("Hello World!")', | |
| 'else:', | |
| ' print("Hello World!")', | |
| ]) | |
| test_py = self.ScratchFile('foo/test.py', [ | |
| '#!/usr/bin/env python', | |
| 'import unittest', | |
| 'class MyTest(unittest.TestCase):', | |
| ' def test_dummy(self):', | |
| ' pass', | |
| 'if __name__ == \'__main__\':', | |
| ' unittest.main()', | |
| ]) | |
| self.ScratchFile('bar/BUILD', ['exports_files(["bar.txt"])']) | |
| self.ScratchFile('bar/bar.txt', ['hello']) | |
| os.chmod(foo_py, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) | |
| os.chmod(test_py, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) | |
| exit_code, stdout, stderr = self.RunBazel(['info', 'bazel-bin']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bazel_bin = stdout[0] | |
| self._buildPyTargets(bazel_bin, '.exe' if self.IsWindows() else '') | |
| def testPyBinaryArgumentPassing(self): | |
| self.CreateWorkspaceWithDefaultRepos('WORKSPACE') | |
| self.ScratchFile('foo/BUILD', [ | |
| 'py_binary(', | |
| ' name = "bin",', | |
| ' srcs = ["bin.py"],', | |
| ')', | |
| ]) | |
| self.ScratchFile('foo/bin.py', [ | |
| 'import sys', | |
| 'for arg in sys.argv[1:]:', | |
| ' print(arg)', | |
| ]) | |
| self._buildAndCheckArgumentPassing('foo', 'bin') | |
| def testWindowsJavaExeLauncher(self): | |
| # Skip this test on non-Windows platforms | |
| if not self.IsWindows(): | |
| return | |
| self.CreateWorkspaceWithDefaultRepos('WORKSPACE') | |
| self.ScratchFile('foo/BUILD', [ | |
| 'java_binary(', | |
| ' name = "foo",', | |
| ' srcs = ["Main.java"],', | |
| ' main_class = "Main",', | |
| ' jvm_flags = ["--flag1", "--flag2"],', | |
| ')', | |
| ]) | |
| self.ScratchFile('foo/Main.java', [ | |
| 'public class Main {', | |
| ' public static void main(String[] args) {' | |
| ' System.out.println("helloworld");', | |
| ' }', | |
| '}', | |
| ]) | |
| exit_code, stdout, stderr = self.RunBazel(['info', 'bazel-bin']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bazel_bin = stdout[0] | |
| exit_code, _, stderr = self.RunBazel(['build', '//foo:foo']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| binary = os.path.join(bazel_bin, 'foo', 'foo.exe') | |
| self.assertTrue(os.path.exists(binary)) | |
| # Add this flag to make launcher print the command it generated instead of | |
| # launching the real program. | |
| print_cmd = '--print_launcher_command' | |
| exit_code, stdout, stderr = self.RunProgram([binary, '--debug', print_cmd]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn( | |
| '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005', | |
| stdout) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, '--debug', print_cmd], | |
| env_add={'DEFAULT_JVM_DEBUG_PORT': '12345'}) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn( | |
| '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=12345', | |
| stdout) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, '--debug=12345', print_cmd], | |
| env_add={ | |
| 'DEFAULT_JVM_DEBUG_SUSPEND': 'n', | |
| 'PERSISTENT_TEST_RUNNER': 'true' | |
| }) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn( | |
| '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=12345' | |
| ',quiet=y', stdout) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, '--main_advice=MyMain', print_cmd]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn('MyMain', stdout) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, '--main_advice_classpath=foo/bar', print_cmd]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn('-classpath', stdout) | |
| classpath = stdout[stdout.index('-classpath') + 1] | |
| self.assertIn('foo/bar', classpath) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, '--jvm_flag="--some_path="./a b/c""', print_cmd]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn('"--some_path=\\"./a b/c\\""', stdout) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, '--jvm_flags="--path1=a --path2=b"', print_cmd]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn('--path1=a', stdout) | |
| self.assertIn('--path2=b', stdout) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, print_cmd], env_add={'JVM_FLAGS': '--foo --bar'}) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn('--flag1', stdout) | |
| self.assertIn('--flag2', stdout) | |
| self.assertIn('--foo', stdout) | |
| self.assertIn('--bar', stdout) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, '--singlejar', print_cmd]) | |
| self.AssertExitCode(exit_code, 1, stderr) | |
| self.assertIn('foo_deploy.jar does not exist', ''.join(stderr)) | |
| exit_code, _, stderr = self.RunBazel(['build', '//foo:foo_deploy.jar']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, '--singlejar', print_cmd]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn('-classpath', stdout) | |
| classpath = stdout[stdout.index('-classpath') + 1] | |
| self.assertIn('foo_deploy.jar', classpath) | |
| exit_code, stdout, stderr = self.RunProgram([binary, '--print_javabin']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn('local_jdk/bin/java.exe', ''.join(stdout)) | |
| my_tmp_dir = self.ScratchDir('my/temp/dir') | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, print_cmd], env_add={'TEST_TMPDIR': my_tmp_dir}) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn('-Djava.io.tmpdir=%s' % my_tmp_dir, stdout) | |
| exit_code, stdout, stderr = self.RunProgram( | |
| [binary, '--classpath_limit=0', print_cmd]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertIn('-classpath', stdout) | |
| classpath = stdout[stdout.index('-classpath') + 1] | |
| self.assertRegexpMatches(classpath, r'foo-[A-Za-z0-9]+-classpath.jar$') | |
| def testWindowsNativeLauncherInNonEnglishPath(self): | |
| if not self.IsWindows(): | |
| return | |
| self.CreateWorkspaceWithDefaultRepos('WORKSPACE') | |
| self.ScratchFile('bin/BUILD', [ | |
| 'java_binary(', | |
| ' name = "bin_java",', | |
| ' srcs = ["Main.java"],', | |
| ' main_class = "Main",', | |
| ')', | |
| 'sh_binary(', | |
| ' name = "bin_sh",', | |
| ' srcs = ["main.sh"],', | |
| ')', | |
| ]) | |
| self.ScratchFile('bin/Main.java', [ | |
| 'public class Main {', | |
| ' public static void main(String[] args) {' | |
| ' System.out.println("helloworld");', | |
| ' }', | |
| '}', | |
| ]) | |
| self.ScratchFile('bin/main.sh', [ | |
| 'echo "helloworld"', | |
| ]) | |
| exit_code, stdout, stderr = self.RunBazel(['info', 'bazel-bin']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bazel_bin = stdout[0] | |
| exit_code, _, stderr = self.RunBazel(['build', '//bin/...']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| for f in [ | |
| 'bin_java.exe', | |
| 'bin_java.exe.runfiles_manifest', | |
| 'bin_sh.exe', | |
| 'bin_sh', | |
| 'bin_sh.exe.runfiles_manifest', | |
| ]: | |
| self.CopyFile(os.path.join(bazel_bin, 'bin', f), | |
| os.path.join(u'./\u6d4b\u8bd5', f)) | |
| unicode_binary_path = u'./\u6d4b\u8bd5/bin_java.exe' | |
| exit_code, stdout, stderr = self.RunProgram([unicode_binary_path]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual('helloworld', ''.join(stdout)) | |
| unicode_binary_path = u'./\u6d4b\u8bd5/bin_sh.exe' | |
| exit_code, stdout, stderr = self.RunProgram([unicode_binary_path]) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual('helloworld', ''.join(stdout)) | |
| def testWindowsNativeLauncherInLongPath(self): | |
| if not self.IsWindows(): | |
| return | |
| self.CreateWorkspaceWithDefaultRepos('WORKSPACE') | |
| self.ScratchFile('bin/BUILD', [ | |
| 'java_binary(', | |
| ' name = "bin_java",', | |
| ' srcs = ["Main.java"],', | |
| ' main_class = "Main",', | |
| ')', | |
| 'sh_binary(', | |
| ' name = "bin_sh",', | |
| ' srcs = ["main.sh"],', | |
| ')', | |
| 'py_binary(', | |
| ' name = "bin_py",', | |
| ' srcs = ["bin_py.py"],', | |
| ')', | |
| ]) | |
| self.ScratchFile('bin/Main.java', [ | |
| 'public class Main {', | |
| ' public static void main(String[] args) {' | |
| ' System.out.println("helloworld");', | |
| ' }', | |
| '}', | |
| ]) | |
| self.ScratchFile('bin/main.sh', [ | |
| 'echo "helloworld"', | |
| ]) | |
| self.ScratchFile('bin/bin_py.py', [ | |
| 'print("helloworld")', | |
| ]) | |
| exit_code, stdout, stderr = self.RunBazel(['info', 'bazel-bin']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| bazel_bin = stdout[0] | |
| exit_code, _, stderr = self.RunBazel(['build', '//bin/...']) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| # Create a directory with a path longer than 260 | |
| long_dir_path = './' + '/'.join( | |
| [(c * 8 + '.' + c * 3) for c in string.ascii_lowercase]) | |
| for f in [ | |
| 'bin_java.exe', | |
| 'bin_java.exe.runfiles_manifest', | |
| 'bin_sh.exe', | |
| 'bin_sh', | |
| 'bin_sh.exe.runfiles_manifest', | |
| 'bin_py.exe', | |
| 'bin_py.zip', | |
| 'bin_py.exe.runfiles_manifest', | |
| ]: | |
| self.CopyFile( | |
| os.path.join(bazel_bin, 'bin', f), os.path.join(long_dir_path, f)) | |
| long_binary_path = os.path.abspath(long_dir_path + '/bin_java.exe') | |
| # subprocess doesn't support long path without shell=True | |
| exit_code, stdout, stderr = self.RunProgram([long_binary_path], shell=True) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual('helloworld', ''.join(stdout)) | |
| long_binary_path = os.path.abspath(long_dir_path + '/bin_sh.exe') | |
| # subprocess doesn't support long path without shell=True | |
| exit_code, stdout, stderr = self.RunProgram([long_binary_path], shell=True) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual('helloworld', ''.join(stdout)) | |
| long_binary_path = os.path.abspath(long_dir_path + '/bin_py.exe') | |
| # subprocess doesn't support long path without shell=True | |
| exit_code, stdout, stderr = self.RunProgram([long_binary_path], shell=True) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| self.assertEqual('helloworld', ''.join(stdout)) | |
| def AssertRunfilesManifestContains(self, manifest, entry): | |
| with open(manifest, 'r') as f: | |
| for l in f: | |
| tokens = l.strip().split(' ', 1) | |
| if len(tokens) == 2 and tokens[0] == entry: | |
| return | |
| self.fail('Runfiles manifest "%s" did not contain "%s"' % (manifest, entry)) | |
| if __name__ == '__main__': | |
| unittest.main() |