blob: 709010ecfc4a0b7968dd1f2b43dc88604a94a661 [file] [log] [blame]
# Copyright 2018 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 unittest
import zipfile
from src.test.py.bazel import test_base
class TestWrapperTest(test_base.TestBase):
@staticmethod
def _ReadFile(path):
# Read the runfiles manifest.
contents = []
with open(path, 'rt') as f:
contents = [line.strip() for line in f.readlines()]
return contents
def _FailWithOutput(self, output):
self.fail('FAIL:\n | %s\n---' % '\n | '.join(output))
def _CreateMockWorkspace(self):
self.CreateWorkspaceWithDefaultRepos('WORKSPACE')
self.ScratchFile('foo/BUILD', [
'load(":native_test.bzl", "bat_test", "exe_test")',
'bat_test(',
' name = "passing_test",',
' content = ["@exit /B 0"],',
')',
'bat_test(',
' name = "failing_test",',
' content = ["@exit /B 1"],',
')',
'bat_test(',
' name = "printing_test",',
' content = [',
' "@echo lorem ipsum",',
' "@echo HOME=%HOME%",',
' "@echo TEST_SRCDIR=%TEST_SRCDIR%",',
' "@echo TEST_TMPDIR=%TEST_TMPDIR%",',
' "@echo USER=%USER%",',
' ]',
')',
'bat_test(',
' name = "runfiles_test",',
' content = [',
' "@echo off",',
' "echo MF=%RUNFILES_MANIFEST_FILE%",',
' "echo ONLY=%RUNFILES_MANIFEST_ONLY%",',
' "echo DIR=%RUNFILES_DIR%",',
' "echo data_path=%1",',
' "if exist %1 (echo data_exists=1) else (echo data_exists=0)",',
' ],',
' data = ["dummy.dat"],',
' args = ["$(location dummy.dat)"],',
')',
'bat_test(',
' name = "sharded_test",',
' content = [',
' "@echo STATUS=%TEST_SHARD_STATUS_FILE%",',
' "@echo INDEX=%TEST_SHARD_INDEX% TOTAL=%TEST_TOTAL_SHARDS%",',
' ],',
' shard_count = 2,',
')',
'bat_test(',
' name = "unexported_test",',
' content = [',
' "@echo GOOD=%HOME%",',
' "@echo BAD=%TEST_UNDECLARED_OUTPUTS_MANIFEST%",',
' ],',
')',
'bat_test(',
' name = "print_arg0_test",',
' content = [',
' "@echo ARG0=%0",',
' ],',
')',
'exe_test(',
' name = "testargs_test",',
' src = "testargs.exe",',
r' args = ["foo", "a b", "", "\"c d\"", "\"\"", "bar"],',
')',
'py_test(',
' name = "undecl_test",',
' srcs = ["undecl_test.py"],',
' data = ["dummy.ico", "dummy.dat"],',
' deps = ["@bazel_tools//tools/python/runfiles"],',
')',
'py_test(',
' name = "annot_test",',
' srcs = ["annot_test.py"],',
')',
'py_test(',
' name = "xml_test",',
' srcs = ["xml_test.py"],',
')',
'py_test(',
' name = "xml2_test",',
' srcs = ["xml2_test.py"],',
')',
'py_test(',
' name = "add_cur_dir_to_path_test",',
' srcs = ["add_cur_dir_to_path_test.py"],',
')'
])
self.CopyFile(
src_path=self.Rlocation('io_bazel/src/test/py/bazel/printargs.exe'),
dst_path='foo/testargs.exe',
executable=True)
# A single white pixel as an ".ico" file. /usr/bin/file should identify this
# as "image/x-icon".
# The MIME type lookup logic of the test wrapper only looks at file names,
# but the test-setup.sh calls /usr/bin/file which inspects file contents, so
# we need a valid ".ico" file.
ico_file = bytearray([
0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00,
0x18, 0x00, 0x30, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00,
0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00
])
# 16 bytes of random data. /usr/bin/file should identify this as
# "application/octet-stream".
# The MIME type lookup logic of the test wrapper only looks at file names,
# but the test-setup.sh calls /usr/bin/file which inspects file contents, so
# we need a valid ".ico" file.
dat_file = bytearray([
0x40, 0x5a, 0x2e, 0x7e, 0x53, 0x86, 0x98, 0x0e, 0x12, 0xc4, 0x92, 0x38,
0x27, 0xcd, 0x09, 0xf9
])
ico_file_path = self.ScratchFile('foo/dummy.ico').replace('/', '\\')
dat_file_path = self.ScratchFile('foo/dummy.dat').replace('/', '\\')
with open(ico_file_path, 'wb') as f:
f.write(ico_file)
with open(dat_file_path, 'wb') as f:
f.write(dat_file)
self.CopyFile(
src_path=self.Rlocation('io_bazel/src/test/py/bazel/native_test.bzl'),
dst_path='foo/native_test.bzl')
self.ScratchFile(
'foo/undecl_test.py', [
'from bazel_tools.tools.python.runfiles import runfiles',
'import os',
'import shutil',
'',
'root = os.environ.get("TEST_UNDECLARED_OUTPUTS_DIR")',
'os.mkdir(os.path.join(root, "out1"))',
'os.mkdir(os.path.join(root, "out2"))',
'os.makedirs(os.path.join(root, "empty/sub"))',
'r = runfiles.Create()',
'shutil.copyfile(r.Rlocation("__main__/foo/dummy.ico"),',
' os.path.join(root, "out1", "data1.ico"))',
'shutil.copyfile(r.Rlocation("__main__/foo/dummy.dat"),',
' os.path.join(root, "out2", "my data 2.dat"))',
],
executable=True)
self.ScratchFile(
'foo/annot_test.py', [
'import os',
'root = os.environ.get("TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR")',
'dir1 = os.path.join(root, "out1")',
'dir2 = os.path.join(root, "out2.part")',
'os.mkdir(dir1)',
'os.mkdir(dir2)',
'with open(os.path.join(root, "a.part"), "wt") as f:',
' f.write("Hello a")',
'with open(os.path.join(root, "b.txt"), "wt") as f:',
' f.write("Hello b")',
'with open(os.path.join(root, "c.part"), "wt") as f:',
' f.write("Hello c")',
'with open(os.path.join(dir1, "d.part"), "wt") as f:',
' f.write("Hello d")',
'with open(os.path.join(dir2, "e.part"), "wt") as f:',
' f.write("Hello e")',
],
executable=True)
self.ScratchFile(
'foo/xml_test.py', [
'from __future__ import print_function',
'import time',
'import sys',
'print("stdout_line_1")',
'print("stdout_line_2")',
'time.sleep(2)',
'print("stderr_line_1", file=sys.stderr)',
'print("stderr_line_2", file=sys.stderr)',
],
executable=True)
self.ScratchFile(
'foo/xml2_test.py', [
'import os',
'with open(os.environ.get("XML_OUTPUT_FILE"), "wt") as f:',
' f.write("leave this")'
],
executable=True)
self.ScratchFile(
'foo/add_cur_dir_to_path_test.py', [
'import os',
'path = os.getenv("PATH")',
'if ".;" not in path:',
' exit(1)'
],
executable=True)
def _AssertPassingTest(self, flags):
exit_code, _, stderr = self.RunBazel([
'test',
'//foo:passing_test',
'-t-',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
def _AssertFailingTest(self, flags):
exit_code, _, stderr = self.RunBazel([
'test',
'//foo:failing_test',
'-t-',
] + flags)
self.AssertExitCode(exit_code, 3, stderr)
def _AssertPrintingTest(self, flags):
exit_code, stdout, stderr = self.RunBazel([
'test',
'//foo:printing_test',
'-t-',
'--test_output=all',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
lorem = False
for line in stderr + stdout:
if line.startswith('lorem ipsum'):
lorem = True
elif line.startswith('HOME='):
home = line[len('HOME='):]
elif line.startswith('TEST_SRCDIR='):
srcdir = line[len('TEST_SRCDIR='):]
elif line.startswith('TEST_TMPDIR='):
tmpdir = line[len('TEST_TMPDIR='):]
elif line.startswith('USER='):
user = line[len('USER='):]
if not lorem:
self._FailWithOutput(stderr + stdout)
if not home:
self._FailWithOutput(stderr + stdout)
if not os.path.isabs(home):
self._FailWithOutput(stderr + stdout)
if not os.path.isdir(srcdir):
self._FailWithOutput(stderr + stdout)
if not os.path.isfile(os.path.join(srcdir, 'MANIFEST')):
self._FailWithOutput(stderr + stdout)
if not os.path.isabs(srcdir):
self._FailWithOutput(stderr + stdout)
if not os.path.isdir(tmpdir):
self._FailWithOutput(stderr + stdout)
if not os.path.isabs(tmpdir):
self._FailWithOutput(stderr + stdout)
if not user:
self._FailWithOutput(stderr + stdout)
def _AssertRunfiles(self, flags):
exit_code, stdout, stderr = self.RunBazel([
'test',
'//foo:runfiles_test',
'-t-',
'--test_output=all',
# Ensure Bazel does not create a runfiles tree.
'--enable_runfiles=no',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
mf = mf_only = rf_dir = path = exists = None
for line in stderr + stdout:
if line.startswith('MF='):
mf = line[len('MF='):]
elif line.startswith('ONLY='):
mf_only = line[len('ONLY='):]
elif line.startswith('DIR='):
rf_dir = line[len('DIR='):]
elif line.startswith('data_path='):
path = line[len('data_path='):]
elif line.startswith('data_exists='):
exists = line[len('data_exists='):]
if mf_only != '1':
self._FailWithOutput(stderr + stdout)
if not os.path.isfile(mf):
self._FailWithOutput(stderr + stdout)
mf_contents = TestWrapperTest._ReadFile(mf)
# Assert that the data dependency is listed in the runfiles manifest.
if not any(
line.split(' ', 1)[0].endswith('foo/dummy.dat')
for line in mf_contents):
self._FailWithOutput(mf_contents)
if not os.path.isdir(rf_dir):
self._FailWithOutput(stderr + stdout)
if not path:
# Expect the $(location) expansion in 'args' worked
self._FailWithOutput(stderr + stdout)
if exists != '0':
# Runfiles are disabled, expect the runfile symlink to be missing.
self._FailWithOutput(stderr + stdout)
def _AssertRunfilesSymlinks(self, flags):
exit_code, stdout, stderr = self.RunBazel([
'test',
'//foo:runfiles_test',
'-t-',
'--test_output=all',
# Ensure Bazel creates a runfiles tree.
'--enable_runfiles=yes',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
mf_only = rf_dir = path = exists = None
for line in stderr + stdout:
if line.startswith('ONLY='):
mf_only = line[len('ONLY='):]
elif line.startswith('DIR='):
rf_dir = line[len('DIR='):]
elif line.startswith('data_path='):
path = line[len('data_path='):]
elif line.startswith('data_exists='):
exists = line[len('data_exists='):]
if mf_only == '1':
self._FailWithOutput(stderr + stdout)
if not rf_dir or not os.path.isdir(rf_dir):
self._FailWithOutput(stderr + stdout)
if not path:
# Expect the $(location) expansion in 'args' worked
self._FailWithOutput(stderr + stdout)
if exists != '1':
# Runfiles are enabled, expect the runfile symlink to exist.
self._FailWithOutput(stderr + stdout)
def _AssertShardedTest(self, flags):
exit_code, stdout, stderr = self.RunBazel([
'test',
'//foo:sharded_test',
'-t-',
'--test_output=all',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
status = None
index_lines = []
for line in stderr + stdout:
if line.startswith('STATUS='):
status = line[len('STATUS='):]
elif line.startswith('INDEX='):
index_lines.append(line)
if not status:
self._FailWithOutput(stderr + stdout)
# Test test-setup.sh / test wrapper only ensure that the directory of the
# shard status file exist, not that the file itself does too.
if not os.path.isdir(os.path.dirname(status)):
self._FailWithOutput(stderr + stdout)
if sorted(index_lines) != ['INDEX=0 TOTAL=2', 'INDEX=1 TOTAL=2']:
self._FailWithOutput(stderr + stdout)
def _AssertUnexportsEnvvars(self, flags):
exit_code, stdout, stderr = self.RunBazel([
'test',
'//foo:unexported_test',
'-t-',
'--test_output=all',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
good = bad = None
for line in stderr + stdout:
if line.startswith('GOOD='):
good = line[len('GOOD='):]
elif line.startswith('BAD='):
bad = line[len('BAD='):]
if not good or bad:
self._FailWithOutput(stderr + stdout)
def _AssertTestBinaryLocation(self, flags):
exit_code, bazel_bin, stderr = self.RunBazel(['info', 'bazel-bin'])
self.AssertExitCode(exit_code, 0, stderr)
bazel_bin = bazel_bin[0].replace('/', '\\')
exit_code, stdout, stderr = self.RunBazel([
'test',
'//foo:print_arg0_test',
'--test_output=all',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
arg0 = None
for line in stderr + stdout:
if line.startswith('ARG0='):
arg0 = line[len('ARG0='):]
# Get rid of the quotes if there is any
if arg0[0] == '"' and arg0[-1] == '"':
arg0 = arg0[1:-1]
# The test binary should located at the bazel bin folder
self.assertEqual(arg0, os.path.join(bazel_bin, 'foo\\print_arg0_test.bat'))
exit_code, stdout, stderr = self.RunBazel([
'test',
'//foo:print_arg0_test',
'--test_output=all',
'--enable_runfiles',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
arg0 = None
for line in stderr + stdout:
if line.startswith('ARG0='):
arg0 = line[len('ARG0='):]
# Get rid of the quotes if there is any
if arg0[0] == '"' and arg0[-1] == '"':
arg0 = arg0[1:-1]
self.assertEqual(
arg0,
os.path.join(bazel_bin,
'foo\\print_arg0_test.bat.runfiles\\'
'__main__\\foo\\print_arg0_test.bat')
)
def _AssertTestArgs(self, flags):
exit_code, bazel_bin, stderr = self.RunBazel(['info', 'bazel-bin'])
self.AssertExitCode(exit_code, 0, stderr)
bazel_bin = bazel_bin[0]
exit_code, stdout, stderr = self.RunBazel([
'test',
'//foo:testargs_test',
'-t-',
'--test_output=all',
'--test_arg=baz',
'--test_arg="x y"',
'--test_arg=""',
'--test_arg=qux',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
actual = []
for line in stderr + stdout:
if line.startswith('arg='):
actual.append(str(line[len('arg='):]))
self.assertListEqual(
[
'(foo)',
# TODO(laszlocsomor): assert that "a b" is passed as one argument,
# not two, after https://github.com/bazelbuild/bazel/issues/6277
# is fixed.
'(a)',
'(b)',
# TODO(laszlocsomor): assert that the empty string argument is
# passed, after https://github.com/bazelbuild/bazel/issues/6276
# is fixed.
'(c d)',
'()',
'(bar)',
'(baz)',
'("x y")',
'("")',
'(qux)',
],
actual)
def _AssertUndeclaredOutputs(self, flags):
exit_code, bazel_testlogs, stderr = self.RunBazel(
['info', 'bazel-testlogs'])
self.AssertExitCode(exit_code, 0, stderr)
bazel_testlogs = bazel_testlogs[0]
exit_code, _, stderr = self.RunBazel([
'test',
'//foo:undecl_test',
'-t-',
'--test_output=errors',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
undecl_zip = os.path.join(bazel_testlogs, 'foo', 'undecl_test',
'test.outputs', 'outputs.zip')
self.assertTrue(os.path.exists(undecl_zip))
zip_content = {}
with zipfile.ZipFile(undecl_zip, 'r') as z:
zip_content = {f: z.getinfo(f).file_size for f in z.namelist()}
self.assertDictEqual(
zip_content, {
'out1/': 0,
'out2/': 0,
'empty/': 0,
'empty/sub/': 0,
'out1/data1.ico': 70,
'out2/my data 2.dat': 16
})
undecl_mf = os.path.join(bazel_testlogs, 'foo', 'undecl_test',
'test.outputs_manifest', 'MANIFEST')
self.assertTrue(os.path.exists(undecl_mf))
mf_content = []
with open(undecl_mf, 'rt') as f:
mf_content = [line.strip() for line in f.readlines()]
# Using an ".ico" file as example, because as of 2018-11-09 Bazel's CI
# machines run Windows Server 2016 core which recognizes fewer MIME types
# than desktop Windows versions, and one of the recognized types is ".ico"
# files.
# Update(2019-03-05): apparently this MIME type is now recognized on CI as
# as "image/vnd.microsoft.icon". The standard MIME type is "image/x-icon",
# but Wikipedia lists a few alterantive ones, so the test will accept all of
# them.
if len(mf_content) != 2:
self._FailWithOutput(mf_content)
tokens = mf_content[0].split('\t')
if (len(tokens) != 3 or tokens[0] != 'out1/data1.ico' or
tokens[1] != '70' or tokens[2] not in [
'image/x-icon', 'image/vnd.microsoft.icon', 'image/ico',
'image/icon', 'text/ico', 'application/ico'
]):
self._FailWithOutput(mf_content)
if mf_content[1] != 'out2/my data 2.dat\t16\tapplication/octet-stream':
self._FailWithOutput(mf_content)
def _AssertUndeclaredOutputsAnnotations(self, flags):
exit_code, bazel_testlogs, stderr = self.RunBazel(
['info', 'bazel-testlogs'])
self.AssertExitCode(exit_code, 0, stderr)
bazel_testlogs = bazel_testlogs[0]
exit_code, _, stderr = self.RunBazel([
'test',
'//foo:annot_test',
'-t-',
'--test_output=errors',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
undecl_annot = os.path.join(bazel_testlogs, 'foo', 'annot_test',
'test.outputs_manifest', 'ANNOTATIONS')
self.assertTrue(os.path.exists(undecl_annot))
annot_content = []
with open(undecl_annot, 'rt') as f:
annot_content = [line.strip() for line in f.readlines()]
self.assertListEqual(annot_content, ['Hello aHello c'])
def _AssertXmlGeneration(self, flags, split_xml=False):
exit_code, bazel_testlogs, stderr = self.RunBazel(
['info', 'bazel-testlogs'])
self.AssertExitCode(exit_code, 0, stderr)
bazel_testlogs = bazel_testlogs[0]
exit_code, _, stderr = self.RunBazel([
'test',
'//foo:xml_test',
'-t-',
'--test_output=errors',
'--%sexperimental_split_xml_generation' % ('' if split_xml else 'no'),
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
test_xml = os.path.join(bazel_testlogs, 'foo', 'xml_test', 'test.xml')
self.assertTrue(os.path.exists(test_xml))
duration = 0
xml_contents = []
stdout_lines = []
stderr_lines = []
with open(test_xml, 'rt') as f:
xml_contents = [line.strip() for line in f]
for line in xml_contents:
if 'duration=' in line:
line = line[line.find('duration="') + len('duration="'):]
line = line[:line.find('"')]
duration = int(line)
elif 'stdout_line' in line:
stdout_lines.append(line)
elif 'stderr_line' in line:
stderr_lines.append(line)
# Since stdout and stderr of the test are redirected to the same file, it's
# possible that a line L1 written to stdout before a line L2 written to
# stderr is dumped to the file later, i.e. the file will have lines L2 then
# L1. It is however true that lines printed to the same stream (stdout or
# stderr) have to preserve their ordering, i.e. if line L3 is printed to
# stdout after L1, then it must be strictly ordered after L1 (but not
# necessarily after L2).
# Therefore we only assert partial ordering of lines.
if duration <= 1:
self._FailWithOutput(xml_contents)
if (len(stdout_lines) != 2 or 'stdout_line_1' not in stdout_lines[0] or
'stdout_line_2' not in stdout_lines[1]):
self._FailWithOutput(xml_contents)
if (len(stderr_lines) != 2 or 'stderr_line_1' not in stderr_lines[0] or
'stderr_line_2' not in stderr_lines[1]):
self._FailWithOutput(xml_contents)
def _AssertXmlGeneratedByTestIsRetained(self, flags, split_xml=False):
exit_code, bazel_testlogs, stderr = self.RunBazel(
['info', 'bazel-testlogs'])
self.AssertExitCode(exit_code, 0, stderr)
bazel_testlogs = bazel_testlogs[0]
exit_code, _, stderr = self.RunBazel([
'test',
'//foo:xml2_test',
'-t-',
'--test_output=errors',
'--%sexperimental_split_xml_generation' % ('' if split_xml else 'no'),
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
test_xml = os.path.join(bazel_testlogs, 'foo', 'xml2_test', 'test.xml')
self.assertTrue(os.path.exists(test_xml))
xml_contents = []
with open(test_xml, 'rt') as f:
xml_contents = [line.strip() for line in f.readlines()]
self.assertListEqual(xml_contents, ['leave this'])
# Test that we can run tests from external repositories.
# See https://github.com/bazelbuild/bazel/issues/8088
def testRunningTestFromExternalRepo(self):
rule_definition = [
'load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")',
'local_repository(name = "a", path = "a")'
]
rule_definition.extend(self.GetDefaultRepoRules())
self.ScratchFile('WORKSPACE', rule_definition)
self.CreateWorkspaceWithDefaultRepos('a/WORKSPACE')
self.ScratchFile('BUILD', ['py_test(name = "x", srcs = ["x.py"])'])
self.ScratchFile('a/BUILD', ['py_test(name = "x", srcs = ["x.py"])'])
self.ScratchFile('x.py')
self.ScratchFile('a/x.py')
for flag in ['--legacy_external_runfiles', '--nolegacy_external_runfiles']:
for layout in [
'--experimental_sibling_repository_layout',
'--noexperimental_sibling_repository_layout',
]:
for target in ['//:x', '@a//:x']:
exit_code, _, stderr = self.RunBazel([
'test',
'-t-',
'--shell_executable=',
'--test_output=errors',
'--verbose_failures',
flag,
layout,
target,
])
self.AssertExitCode(exit_code, 0, [
'flag=%s' % flag,
'layout=%s' % layout,
'target=%s' % target,
] + stderr)
def _AssertAddCurrentDirectoryToPathTest(self, flags):
exit_code, _, stderr = self.RunBazel([
'test',
'//foo:add_cur_dir_to_path_test',
'--test_output=all',
] + flags)
self.AssertExitCode(exit_code, 0, stderr)
def testTestExecutionWithTestWrapperExe(self):
self._CreateMockWorkspace()
flags = ['--shell_executable=']
self._AssertPassingTest(flags)
self._AssertFailingTest(flags)
self._AssertPrintingTest(flags)
self._AssertRunfiles(flags)
self._AssertRunfilesSymlinks(flags)
self._AssertShardedTest(flags)
self._AssertUnexportsEnvvars(flags)
self._AssertTestBinaryLocation(flags)
self._AssertTestArgs(flags)
self._AssertUndeclaredOutputs(flags)
self._AssertUndeclaredOutputsAnnotations(flags)
self._AssertXmlGeneration(flags, split_xml=False)
self._AssertXmlGeneration(flags, split_xml=True)
self._AssertXmlGeneratedByTestIsRetained(flags, split_xml=False)
self._AssertXmlGeneratedByTestIsRetained(flags, split_xml=True)
self._AssertAddCurrentDirectoryToPathTest(flags)
if __name__ == '__main__':
unittest.main()