tools/test/test-setup.sh - bazel - Git at Google

 #!/bin/bash

 # Copyright 2015 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.

 # shift stderr to stdout.
 exec 2>&1

 no_echo=
 if [[ "$1" = "--no_echo" ]]; then
   # Don't print anything to stdout in this special case.
   # Currently needed for persistent test runner.
   no_echo="true"
   shift
 else
   echo 'exec ${PAGER:-/usr/bin/less} "$0" || exit 1'
   echo "Executing tests from ${TEST_TARGET}"
 fi

 function is_absolute {
   [[ "$1" = /* ]] || [[ "$1" =~ ^[a-zA-Z]:[/\\].* ]]
 }

 # The original execution root. Usually this script changes directory into the
 # runfiles directory, so using $PWD is not a reliable way to find the execution
 # root.
 EXEC_ROOT="$PWD"

 # Bazel sets some environment vars to relative paths to improve caching and
 # support remote execution, where the absolute path may not be known to Bazel.
 # Convert them to absolute paths here before running the actual test.
 is_absolute "$TEST_PREMATURE_EXIT_FILE" ||
   TEST_PREMATURE_EXIT_FILE="$PWD/$TEST_PREMATURE_EXIT_FILE"
 is_absolute "$TEST_WARNINGS_OUTPUT_FILE" ||
   TEST_WARNINGS_OUTPUT_FILE="$PWD/$TEST_WARNINGS_OUTPUT_FILE"
 is_absolute "$TEST_LOGSPLITTER_OUTPUT_FILE" ||
   TEST_LOGSPLITTER_OUTPUT_FILE="$PWD/$TEST_LOGSPLITTER_OUTPUT_FILE"
 is_absolute "$TEST_INFRASTRUCTURE_FAILURE_FILE" ||
   TEST_INFRASTRUCTURE_FAILURE_FILE="$PWD/$TEST_INFRASTRUCTURE_FAILURE_FILE"
 is_absolute "$TEST_UNUSED_RUNFILES_LOG_FILE" ||
   TEST_UNUSED_RUNFILES_LOG_FILE="$PWD/$TEST_UNUSED_RUNFILES_LOG_FILE"
 is_absolute "$TEST_UNDECLARED_OUTPUTS_DIR" ||
   TEST_UNDECLARED_OUTPUTS_DIR="$PWD/$TEST_UNDECLARED_OUTPUTS_DIR"
 is_absolute "$TEST_UNDECLARED_OUTPUTS_MANIFEST" ||
   TEST_UNDECLARED_OUTPUTS_MANIFEST="$PWD/$TEST_UNDECLARED_OUTPUTS_MANIFEST"
 is_absolute "$TEST_UNDECLARED_OUTPUTS_ZIP" ||
   TEST_UNDECLARED_OUTPUTS_ZIP="$PWD/$TEST_UNDECLARED_OUTPUTS_ZIP"
 is_absolute "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS" ||
   TEST_UNDECLARED_OUTPUTS_ANNOTATIONS="$PWD/$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS"
 is_absolute "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR" ||
   TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR="$PWD/$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR"

 is_absolute "$TEST_SRCDIR" || TEST_SRCDIR="$PWD/$TEST_SRCDIR"
 is_absolute "$TEST_TMPDIR" || TEST_TMPDIR="$PWD/$TEST_TMPDIR"
 is_absolute "$HOME" || HOME="$TEST_TMPDIR"
 is_absolute "$XML_OUTPUT_FILE" || XML_OUTPUT_FILE="$PWD/$XML_OUTPUT_FILE"

 # Set USER to the current user, unless passed by Bazel via --test_env.
 if [[ -z "$USER" ]]; then
   export USER=$(whoami)
 fi

 # The test shard status file is only set for sharded tests.
 if [[ -n "$TEST_SHARD_STATUS_FILE" ]]; then
   is_absolute "$TEST_SHARD_STATUS_FILE" || TEST_SHARD_STATUS_FILE="$PWD/$TEST_SHARD_STATUS_FILE"
   mkdir -p "$(dirname "$TEST_SHARD_STATUS_FILE")"
 fi

 is_absolute "$RUNFILES_DIR" || RUNFILES_DIR="$PWD/$RUNFILES_DIR"

 # TODO(ulfjack): Standardize on RUNFILES_DIR and remove the {JAVA,PYTHON}_RUNFILES vars.
 is_absolute "$JAVA_RUNFILES" || JAVA_RUNFILES="$PWD/$JAVA_RUNFILES"
 is_absolute "$PYTHON_RUNFILES" || PYTHON_RUNFILES="$PWD/$PYTHON_RUNFILES"

 # Create directories for undeclared outputs and their annotations
 mkdir -p "$(dirname "$XML_OUTPUT_FILE")" \
     "$TEST_UNDECLARED_OUTPUTS_DIR" \
     "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR"

 # Create the test temp directory, which may not exist on the remote host when
 # doing a remote build.
 mkdir -p "$TEST_TMPDIR"

 # Unexport environment variables related to undeclared test outputs that are
 # only supposed to be used in this script.
 export -n TEST_UNDECLARED_OUTPUTS_MANIFEST
 export -n TEST_UNDECLARED_OUTPUTS_ZIP
 export -n TEST_UNDECLARED_OUTPUTS_ANNOTATIONS

 # Tell googletest about Bazel sharding.
 if [[ -n "${TEST_TOTAL_SHARDS+x}" ]] && ((TEST_TOTAL_SHARDS != 0)); then
   export GTEST_SHARD_INDEX="${TEST_SHARD_INDEX}"
   export GTEST_TOTAL_SHARDS="${TEST_TOTAL_SHARDS}"
 fi
 export GTEST_TMP_DIR="${TEST_TMPDIR}"

 # TODO(ulfjack): Update Gunit to accept XML_OUTPUT_FILE and drop this env
 # variable.
 GUNIT_OUTPUT="xml:${XML_OUTPUT_FILE}"

 RUNFILES_MANIFEST_FILE="${TEST_SRCDIR}/MANIFEST"

 function rlocation() {
   if is_absolute "$1" ; then
     # If the file path is already fully specified, simply return it.
     echo "$1"
   elif [[ -e "$TEST_SRCDIR/$1" ]]; then
     # If the file exists in the $TEST_SRCDIR then just use it.
     echo "$TEST_SRCDIR/$1"
   elif [[ -e "$RUNFILES_MANIFEST_FILE" ]]; then
     # If a runfiles manifest file exists then use it.
     echo "$(grep "^$1 " "$RUNFILES_MANIFEST_FILE" | sed 's/[^ ]* //')"
   fi
 }

 export -f rlocation
 export -f is_absolute
 # If RUNFILES_MANIFEST_ONLY is set to 1 and the manifest file does exist,
 # then test programs should use manifest file to find runfiles.
 if [[ "${RUNFILES_MANIFEST_ONLY:-}" == "1" && -e "${RUNFILES_MANIFEST_FILE:-}" ]]; then
   export RUNFILES_MANIFEST_FILE
   export RUNFILES_MANIFEST_ONLY
 fi

 DIR="$TEST_SRCDIR"
 if [ ! -z "$TEST_WORKSPACE" ]; then
   DIR="$DIR"/"$TEST_WORKSPACE"
 fi
 [[ -n "$RUNTEST_PRESERVE_CWD" ]] && DIR="$PWD"


 # normal commands are run in the exec-root where they have access to
 # the entire source tree. By chdir'ing to the runfiles root, tests only
 # have direct access to their declared dependencies.
 if [ -z "$COVERAGE_DIR" ]; then
   cd "$DIR" || { echo "Could not chdir $DIR"; exit 1; }
 fi

 # This header marks where --test_output=streamed will start being printed.
 if [[ -z "$no_echo" ]]; then
   echo "-----------------------------------------------------------------------------"
 fi

 # Unused if EXPERIMENTAL_SPLIT_XML_GENERATION is set.
 function encode_output_file {
   if [ -f "$1" ]; then
     # Replace invalid XML characters and invalid sequence in CDATA
     # cf. https://stackoverflow.com/a/7774512/4717701
     perl -CSDA -pe's/[^\x9\xA\xD\x20-\x{D7FF}\x{E000}-\x{FFFD}\x{10000}-\x{10FFFF}]+/?/g;' "$1" \
       | sed 's|]]>|]]>]]<![CDATA[>|g'
   fi
 }

 # Unused if EXPERIMENTAL_SPLIT_XML_GENERATION is set.
 # Keep this in sync with generate-xml.sh!
 function write_xml_output_file {
   local duration=$(expr $(date +%s) - $start)
   local errors=0
   local error_msg=
   local signal="${1-}"
   local test_name=
   if [ -n "${XML_OUTPUT_FILE-}" -a ! -f "${XML_OUTPUT_FILE-}" ]; then
     # Create a default XML output file if the test runner hasn't generated it
     if [ -n "${signal}" ]; then
       errors=1
       if [ "${signal}" = "SIGTERM" ]; then
         error_msg="<error message=\"Timed out\"></error>"
       else
         error_msg="<error message=\"Terminated by signal ${signal}\"></error>"
       fi
     elif (( $exitCode != 0 )); then
       errors=1
       error_msg="<error message=\"exited with error code $exitCode\"></error>"
     fi
     test_name="${TEST_BINARY#./}"
     # Ensure that test shards have unique names in the xml output.
     if [[ -n "${TEST_TOTAL_SHARDS+x}" ]] && ((TEST_TOTAL_SHARDS != 0)); then
       ((shard_num=TEST_SHARD_INDEX+1))
       test_name="${test_name}"_shard_"$shard_num"/"$TEST_TOTAL_SHARDS"
     fi
     cat <<EOF >${XML_OUTPUT_FILE}
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuites>
   <testsuite name="$test_name" tests="1" failures="0" errors="${errors}">
     <testcase name="$test_name" status="run" duration="${duration}" time="${duration}">${error_msg}</testcase>
     <system-out><![CDATA[$(encode_output_file "${XML_OUTPUT_FILE}.log")]]></system-out>
   </testsuite>
 </testsuites>
 EOF
   fi
   rm -f "${XML_OUTPUT_FILE}.log"
 }

 # The path of this command-line is usually relative to the exec-root,
 # but when using --run_under it can be a "/bin/bash -c" command-line.

 # If the test is at the top of the tree, we have to add '.' to $PATH,
 PATH=".:$PATH"

 if [ -z "$COVERAGE_DIR" ]; then
   EXE="${1#./}"
   shift
 else
   EXE="${2#./}"
 fi

 if is_absolute "$EXE"; then
   TEST_PATH="$EXE"
 else
   TEST_PATH="$(rlocation $TEST_WORKSPACE/$EXE)"
 fi

 # TODO(jsharpe): Use --test_env=TEST_SHORT_EXEC_PATH=true to activate this code
 # path to workaround a bug with long executable paths when executing remote
 # tests on Windows.
 if [ ! -z "$TEST_SHORT_EXEC_PATH" ]; then
   QUALIFIER=0
   BASE="${EXEC_ROOT}/t${QUALIFIER}"
   while [[ -e "${BASE}" || -e "${BASE}.exe" || -e "${BASE}.zip" ]]; do
     ((QUALIFIER++))
     BASE="${EXEC_ROOT}/t${QUALIFIER}"
   done

   # Note for the commands below: "ln -s" is equivalent to "cp" on Windows.

   # Needs to be in the same directory for sh_test. Ignore the error when it
   # doesn't exist.
   ln -s "${TEST_PATH%.*}" "${BASE}" 2>/dev/null
   # Needs to be in the same directory for py_test. Ignore the error when it
   # doesn't exist.
   ln -s "${TEST_PATH%.*}.zip" "${BASE}.zip" 2>/dev/null
   # Needed for all tests.
   ln -s "${TEST_PATH}" "${BASE}.exe"
   TEST_PATH="${BASE}.exe"
 fi

 exitCode=0
 if [[ "${EXPERIMENTAL_SPLIT_XML_GENERATION}" != "1" ]]; then
   signals="$(trap -l | sed -E 's/[0-9]+\)//g')"
   for signal in $signals; do
     trap "write_xml_output_file ${signal}" ${signal}
   done
 fi
 start=$(date +%s)

 # Check if we have tail --pid option
 dummy=1 &
 pid=$!
 has_tail=true
 tail -fq --pid $pid -s 0.001 /dev/null &> /dev/null || has_tail=false

 if [[ "${EXPERIMENTAL_SPLIT_XML_GENERATION}" == "1" ]]; then
   if [ -z "$COVERAGE_DIR" ]; then
     "${TEST_PATH}" "$@" 2>&1 || exitCode=$?
   else
     "$1" "$TEST_PATH" "${@:3}" 2>&1 || exitCode=$?
   fi
 elif [ "$has_tail" == true ] && [  -z "$no_echo" ]; then
   touch "${XML_OUTPUT_FILE}.log"
   if [ -z "$COVERAGE_DIR" ]; then
     ("${TEST_PATH}" "$@" &>"${XML_OUTPUT_FILE}.log") &
     pid=$!
   else
     ("$1" "$TEST_PATH" "${@:3}" &> "${XML_OUTPUT_FILE}.log") &
     pid=$!
   fi
   tail -fq --pid $pid -s 0.001 "${XML_OUTPUT_FILE}.log"
   wait $pid
   exitCode=$?
 else
   if [ -z "$COVERAGE_DIR" ]; then
     "${TEST_PATH}" "$@" 2> >(tee -a "${XML_OUTPUT_FILE}.log" >&2) 1> >(tee -a "${XML_OUTPUT_FILE}.log") 2>&1 || exitCode=$?
   else
     "$1" "$TEST_PATH" "${@:3}" 2> >(tee -a "${XML_OUTPUT_FILE}.log" >&2) 1> >(tee -a "${XML_OUTPUT_FILE}.log") 2>&1 || exitCode=$?
   fi
 fi

 if [[ "${EXPERIMENTAL_SPLIT_XML_GENERATION}" != "1" ]]; then
   for signal in $signals; do
     trap - ${signal}
   done
   write_xml_output_file
 fi

 # Add all of the files from the undeclared outputs directory to the manifest.
 if [[ -n "$TEST_UNDECLARED_OUTPUTS_DIR" && -n "$TEST_UNDECLARED_OUTPUTS_MANIFEST" ]]; then
   undeclared_outputs="$(find -L "$TEST_UNDECLARED_OUTPUTS_DIR" -type f | sort)"
   # Only write the manifest if there are any undeclared outputs.
   if [[ ! -z "$undeclared_outputs" ]]; then
     # For each file, write a tab-separated line with name (relative to
     # TEST_UNDECLARED_OUTPUTS_DIR), size, and mime type to the manifest. e.g.
     # foo.txt	9	text/plain
     while read -r undeclared_output; do
       rel_path="${undeclared_output#$TEST_UNDECLARED_OUTPUTS_DIR/}"
       # stat has different flags for different systems. -c is supported by GNU,
       # and -f by BSD (and thus OSX). Try both.
       file_size="$(stat -f%z "$undeclared_output" 2>/dev/null || stat -c%s "$undeclared_output" 2>/dev/null || echo "Could not stat $undeclared_output")"
       file_type="$(file -L -b --mime-type "$undeclared_output")"

       printf "$rel_path\t$file_size\t$file_type\n"
     done <<< "$undeclared_outputs" \
       > "$TEST_UNDECLARED_OUTPUTS_MANIFEST"
     if [[ ! -s "$TEST_UNDECLARED_OUTPUTS_MANIFEST" ]]; then
       rm "$TEST_UNDECLARED_OUTPUTS_MANIFEST"
     fi
   fi
 fi

 # Add all of the custom manifest entries to the annotation file.
 if [[ -n "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS" && \
       -n "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR" && \
       -d "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR" ]]; then
   (
    shopt -s failglob
    cat "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR"/*.part > "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS"
   ) 2> /dev/null
 fi

 # Zip up undeclared outputs.
 if [[ -n "$TEST_UNDECLARED_OUTPUTS_ZIP" ]] && cd "$TEST_UNDECLARED_OUTPUTS_DIR"; then
   (
    shopt -s dotglob failglob
    zip -qr "$TEST_UNDECLARED_OUTPUTS_ZIP" -- *
   ) 2> /dev/null
 fi

 exit $exitCode
	#!/bin/bash

	# Copyright 2015 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.

	# shift stderr to stdout.
	exec 2>&1

	no_echo=
	if [[ "$1" = "--no_echo" ]]; then
	# Don't print anything to stdout in this special case.
	# Currently needed for persistent test runner.
	no_echo="true"
	shift
	else
	echo 'exec ${PAGER:-/usr/bin/less} "$0" \|\| exit 1'
	echo "Executing tests from ${TEST_TARGET}"
	fi

	function is_absolute {
	[[ "$1" = /* ]] \|\| [[ "$1" =~ ^[a-zA-Z]:[/\\].* ]]
	}

	# The original execution root. Usually this script changes directory into the
	# runfiles directory, so using $PWD is not a reliable way to find the execution
	# root.
	EXEC_ROOT="$PWD"

	# Bazel sets some environment vars to relative paths to improve caching and
	# support remote execution, where the absolute path may not be known to Bazel.
	# Convert them to absolute paths here before running the actual test.
	is_absolute "$TEST_PREMATURE_EXIT_FILE" \|\|
	TEST_PREMATURE_EXIT_FILE="$PWD/$TEST_PREMATURE_EXIT_FILE"
	is_absolute "$TEST_WARNINGS_OUTPUT_FILE" \|\|
	TEST_WARNINGS_OUTPUT_FILE="$PWD/$TEST_WARNINGS_OUTPUT_FILE"
	is_absolute "$TEST_LOGSPLITTER_OUTPUT_FILE" \|\|
	TEST_LOGSPLITTER_OUTPUT_FILE="$PWD/$TEST_LOGSPLITTER_OUTPUT_FILE"
	is_absolute "$TEST_INFRASTRUCTURE_FAILURE_FILE" \|\|
	TEST_INFRASTRUCTURE_FAILURE_FILE="$PWD/$TEST_INFRASTRUCTURE_FAILURE_FILE"
	is_absolute "$TEST_UNUSED_RUNFILES_LOG_FILE" \|\|
	TEST_UNUSED_RUNFILES_LOG_FILE="$PWD/$TEST_UNUSED_RUNFILES_LOG_FILE"
	is_absolute "$TEST_UNDECLARED_OUTPUTS_DIR" \|\|
	TEST_UNDECLARED_OUTPUTS_DIR="$PWD/$TEST_UNDECLARED_OUTPUTS_DIR"
	is_absolute "$TEST_UNDECLARED_OUTPUTS_MANIFEST" \|\|
	TEST_UNDECLARED_OUTPUTS_MANIFEST="$PWD/$TEST_UNDECLARED_OUTPUTS_MANIFEST"
	is_absolute "$TEST_UNDECLARED_OUTPUTS_ZIP" \|\|
	TEST_UNDECLARED_OUTPUTS_ZIP="$PWD/$TEST_UNDECLARED_OUTPUTS_ZIP"
	is_absolute "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS" \|\|
	TEST_UNDECLARED_OUTPUTS_ANNOTATIONS="$PWD/$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS"
	is_absolute "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR" \|\|
	TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR="$PWD/$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR"

	is_absolute "$TEST_SRCDIR" \|\| TEST_SRCDIR="$PWD/$TEST_SRCDIR"
	is_absolute "$TEST_TMPDIR" \|\| TEST_TMPDIR="$PWD/$TEST_TMPDIR"
	is_absolute "$HOME" \|\| HOME="$TEST_TMPDIR"
	is_absolute "$XML_OUTPUT_FILE" \|\| XML_OUTPUT_FILE="$PWD/$XML_OUTPUT_FILE"

	# Set USER to the current user, unless passed by Bazel via --test_env.
	if [[ -z "$USER" ]]; then
	export USER=$(whoami)
	fi

	# The test shard status file is only set for sharded tests.
	if [[ -n "$TEST_SHARD_STATUS_FILE" ]]; then
	is_absolute "$TEST_SHARD_STATUS_FILE" \|\| TEST_SHARD_STATUS_FILE="$PWD/$TEST_SHARD_STATUS_FILE"
	mkdir -p "$(dirname "$TEST_SHARD_STATUS_FILE")"
	fi

	is_absolute "$RUNFILES_DIR" \|\| RUNFILES_DIR="$PWD/$RUNFILES_DIR"

	# TODO(ulfjack): Standardize on RUNFILES_DIR and remove the {JAVA,PYTHON}_RUNFILES vars.
	is_absolute "$JAVA_RUNFILES" \|\| JAVA_RUNFILES="$PWD/$JAVA_RUNFILES"
	is_absolute "$PYTHON_RUNFILES" \|\| PYTHON_RUNFILES="$PWD/$PYTHON_RUNFILES"

	# Create directories for undeclared outputs and their annotations
	mkdir -p "$(dirname "$XML_OUTPUT_FILE")" \
	"$TEST_UNDECLARED_OUTPUTS_DIR" \
	"$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR"

	# Create the test temp directory, which may not exist on the remote host when
	# doing a remote build.
	mkdir -p "$TEST_TMPDIR"

	# Unexport environment variables related to undeclared test outputs that are
	# only supposed to be used in this script.
	export -n TEST_UNDECLARED_OUTPUTS_MANIFEST
	export -n TEST_UNDECLARED_OUTPUTS_ZIP
	export -n TEST_UNDECLARED_OUTPUTS_ANNOTATIONS

	# Tell googletest about Bazel sharding.
	if [[ -n "${TEST_TOTAL_SHARDS+x}" ]] && ((TEST_TOTAL_SHARDS != 0)); then
	export GTEST_SHARD_INDEX="${TEST_SHARD_INDEX}"
	export GTEST_TOTAL_SHARDS="${TEST_TOTAL_SHARDS}"
	fi
	export GTEST_TMP_DIR="${TEST_TMPDIR}"

	# TODO(ulfjack): Update Gunit to accept XML_OUTPUT_FILE and drop this env
	# variable.
	GUNIT_OUTPUT="xml:${XML_OUTPUT_FILE}"

	RUNFILES_MANIFEST_FILE="${TEST_SRCDIR}/MANIFEST"

	function rlocation() {
	if is_absolute "$1" ; then
	# If the file path is already fully specified, simply return it.
	echo "$1"
	elif [[ -e "$TEST_SRCDIR/$1" ]]; then
	# If the file exists in the $TEST_SRCDIR then just use it.
	echo "$TEST_SRCDIR/$1"
	elif [[ -e "$RUNFILES_MANIFEST_FILE" ]]; then
	# If a runfiles manifest file exists then use it.
	echo "$(grep "^$1 " "$RUNFILES_MANIFEST_FILE" \| sed 's/[^ ]* //')"
	fi
	}

	export -f rlocation
	export -f is_absolute
	# If RUNFILES_MANIFEST_ONLY is set to 1 and the manifest file does exist,
	# then test programs should use manifest file to find runfiles.
	if [[ "${RUNFILES_MANIFEST_ONLY:-}" == "1" && -e "${RUNFILES_MANIFEST_FILE:-}" ]]; then
	export RUNFILES_MANIFEST_FILE
	export RUNFILES_MANIFEST_ONLY
	fi

	DIR="$TEST_SRCDIR"
	if [ ! -z "$TEST_WORKSPACE" ]; then
	DIR="$DIR"/"$TEST_WORKSPACE"
	fi
	[[ -n "$RUNTEST_PRESERVE_CWD" ]] && DIR="$PWD"


	# normal commands are run in the exec-root where they have access to
	# the entire source tree. By chdir'ing to the runfiles root, tests only
	# have direct access to their declared dependencies.
	if [ -z "$COVERAGE_DIR" ]; then
	cd "$DIR" \|\| { echo "Could not chdir $DIR"; exit 1; }
	fi

	# This header marks where --test_output=streamed will start being printed.
	if [[ -z "$no_echo" ]]; then
	echo "-----------------------------------------------------------------------------"
	fi

	# Unused if EXPERIMENTAL_SPLIT_XML_GENERATION is set.
	function encode_output_file {
	if [ -f "$1" ]; then
	# Replace invalid XML characters and invalid sequence in CDATA
	# cf. https://stackoverflow.com/a/7774512/4717701
	perl -CSDA -pe's/[^\x9\xA\xD\x20-\x{D7FF}\x{E000}-\x{FFFD}\x{10000}-\x{10FFFF}]+/?/g;' "$1" \
	\| sed 's\|]]>\|]]>]]<![CDATA[>\|g'
	fi
	}

	# Unused if EXPERIMENTAL_SPLIT_XML_GENERATION is set.
	# Keep this in sync with generate-xml.sh!
	function write_xml_output_file {
	local duration=$(expr $(date +%s) - $start)
	local errors=0
	local error_msg=
	local signal="${1-}"
	local test_name=
	if [ -n "${XML_OUTPUT_FILE-}" -a ! -f "${XML_OUTPUT_FILE-}" ]; then
	# Create a default XML output file if the test runner hasn't generated it
	if [ -n "${signal}" ]; then
	errors=1
	if [ "${signal}" = "SIGTERM" ]; then
	error_msg="<error message=\"Timed out\"></error>"
	else
	error_msg="<error message=\"Terminated by signal ${signal}\"></error>"
	fi
	elif (( $exitCode != 0 )); then
	errors=1
	error_msg="<error message=\"exited with error code $exitCode\"></error>"
	fi
	test_name="${TEST_BINARY#./}"
	# Ensure that test shards have unique names in the xml output.
	if [[ -n "${TEST_TOTAL_SHARDS+x}" ]] && ((TEST_TOTAL_SHARDS != 0)); then
	((shard_num=TEST_SHARD_INDEX+1))
	test_name="${test_name}"_shard_"$shard_num"/"$TEST_TOTAL_SHARDS"
	fi
	cat <<EOF >${XML_OUTPUT_FILE}
	<?xml version="1.0" encoding="UTF-8"?>
	<testsuites>
	<testsuite name="$test_name" tests="1" failures="0" errors="${errors}">
	<testcase name="$test_name" status="run" duration="${duration}" time="${duration}">${error_msg}</testcase>
	<system-out><![CDATA[$(encode_output_file "${XML_OUTPUT_FILE}.log")]]></system-out>
	</testsuite>
	</testsuites>
	EOF
	fi
	rm -f "${XML_OUTPUT_FILE}.log"
	}

	# The path of this command-line is usually relative to the exec-root,
	# but when using --run_under it can be a "/bin/bash -c" command-line.

	# If the test is at the top of the tree, we have to add '.' to $PATH,
	PATH=".:$PATH"

	if [ -z "$COVERAGE_DIR" ]; then
	EXE="${1#./}"
	shift
	else
	EXE="${2#./}"
	fi

	if is_absolute "$EXE"; then
	TEST_PATH="$EXE"
	else
	TEST_PATH="$(rlocation $TEST_WORKSPACE/$EXE)"
	fi

	# TODO(jsharpe): Use --test_env=TEST_SHORT_EXEC_PATH=true to activate this code
	# path to workaround a bug with long executable paths when executing remote
	# tests on Windows.
	if [ ! -z "$TEST_SHORT_EXEC_PATH" ]; then
	QUALIFIER=0
	BASE="${EXEC_ROOT}/t${QUALIFIER}"
	while [[ -e "${BASE}" \|\| -e "${BASE}.exe" \|\| -e "${BASE}.zip" ]]; do
	((QUALIFIER++))
	BASE="${EXEC_ROOT}/t${QUALIFIER}"
	done

	# Note for the commands below: "ln -s" is equivalent to "cp" on Windows.

	# Needs to be in the same directory for sh_test. Ignore the error when it
	# doesn't exist.
	ln -s "${TEST_PATH%.*}" "${BASE}" 2>/dev/null
	# Needs to be in the same directory for py_test. Ignore the error when it
	# doesn't exist.
	ln -s "${TEST_PATH%.*}.zip" "${BASE}.zip" 2>/dev/null
	# Needed for all tests.
	ln -s "${TEST_PATH}" "${BASE}.exe"
	TEST_PATH="${BASE}.exe"
	fi

	exitCode=0
	if [[ "${EXPERIMENTAL_SPLIT_XML_GENERATION}" != "1" ]]; then
	signals="$(trap -l \| sed -E 's/[0-9]+\)//g')"
	for signal in $signals; do
	trap "write_xml_output_file ${signal}" ${signal}
	done
	fi
	start=$(date +%s)

	# Check if we have tail --pid option
	dummy=1 &
	pid=$!
	has_tail=true
	tail -fq --pid $pid -s 0.001 /dev/null &> /dev/null \|\| has_tail=false

	if [[ "${EXPERIMENTAL_SPLIT_XML_GENERATION}" == "1" ]]; then
	if [ -z "$COVERAGE_DIR" ]; then
	"${TEST_PATH}" "$@" 2>&1 \|\| exitCode=$?
	else
	"$1" "$TEST_PATH" "${@:3}" 2>&1 \|\| exitCode=$?
	fi
	elif [ "$has_tail" == true ] && [ -z "$no_echo" ]; then
	touch "${XML_OUTPUT_FILE}.log"
	if [ -z "$COVERAGE_DIR" ]; then
	("${TEST_PATH}" "$@" &>"${XML_OUTPUT_FILE}.log") &
	pid=$!
	else
	("$1" "$TEST_PATH" "${@:3}" &> "${XML_OUTPUT_FILE}.log") &
	pid=$!
	fi
	tail -fq --pid $pid -s 0.001 "${XML_OUTPUT_FILE}.log"
	wait $pid
	exitCode=$?
	else
	if [ -z "$COVERAGE_DIR" ]; then
	"${TEST_PATH}" "$@" 2> >(tee -a "${XML_OUTPUT_FILE}.log" >&2) 1> >(tee -a "${XML_OUTPUT_FILE}.log") 2>&1 \|\| exitCode=$?
	else
	"$1" "$TEST_PATH" "${@:3}" 2> >(tee -a "${XML_OUTPUT_FILE}.log" >&2) 1> >(tee -a "${XML_OUTPUT_FILE}.log") 2>&1 \|\| exitCode=$?
	fi
	fi

	if [[ "${EXPERIMENTAL_SPLIT_XML_GENERATION}" != "1" ]]; then
	for signal in $signals; do
	trap - ${signal}
	done
	write_xml_output_file
	fi

	# Add all of the files from the undeclared outputs directory to the manifest.
	if [[ -n "$TEST_UNDECLARED_OUTPUTS_DIR" && -n "$TEST_UNDECLARED_OUTPUTS_MANIFEST" ]]; then
	undeclared_outputs="$(find -L "$TEST_UNDECLARED_OUTPUTS_DIR" -type f \| sort)"
	# Only write the manifest if there are any undeclared outputs.
	if [[ ! -z "$undeclared_outputs" ]]; then
	# For each file, write a tab-separated line with name (relative to
	# TEST_UNDECLARED_OUTPUTS_DIR), size, and mime type to the manifest. e.g.
	# foo.txt 9 text/plain
	while read -r undeclared_output; do
	rel_path="${undeclared_output#$TEST_UNDECLARED_OUTPUTS_DIR/}"
	# stat has different flags for different systems. -c is supported by GNU,
	# and -f by BSD (and thus OSX). Try both.
	file_size="$(stat -f%z "$undeclared_output" 2>/dev/null \|\| stat -c%s "$undeclared_output" 2>/dev/null \|\| echo "Could not stat $undeclared_output")"
	file_type="$(file -L -b --mime-type "$undeclared_output")"

	printf "$rel_path\t$file_size\t$file_type\n"
	done <<< "$undeclared_outputs" \
	> "$TEST_UNDECLARED_OUTPUTS_MANIFEST"
	if [[ ! -s "$TEST_UNDECLARED_OUTPUTS_MANIFEST" ]]; then
	rm "$TEST_UNDECLARED_OUTPUTS_MANIFEST"
	fi
	fi
	fi

	# Add all of the custom manifest entries to the annotation file.
	if [[ -n "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS" && \
	-n "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR" && \
	-d "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR" ]]; then
	(
	shopt -s failglob
	cat "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR"/*.part > "$TEST_UNDECLARED_OUTPUTS_ANNOTATIONS"
	) 2> /dev/null
	fi

	# Zip up undeclared outputs.
	if [[ -n "$TEST_UNDECLARED_OUTPUTS_ZIP" ]] && cd "$TEST_UNDECLARED_OUTPUTS_DIR"; then
	(
	shopt -s dotglob failglob
	zip -qr "$TEST_UNDECLARED_OUTPUTS_ZIP" -- *
	) 2> /dev/null
	fi

	exit $exitCode