You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
458 lines
14 KiB
458 lines
14 KiB
#!/bin/bash
|
|
#
|
|
# Copyright (C) 2015 The Android Open Source Project
|
|
#
|
|
# 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.
|
|
|
|
if [ ! -d libcore ]; then
|
|
echo "Script needs to be run at the root of the android tree"
|
|
exit 1
|
|
fi
|
|
|
|
source build/envsetup.sh >&/dev/null # for get_build_var, setpaths
|
|
setpaths # include platform prebuilt java, javac, etc in $PATH.
|
|
|
|
if [ -z "$ANDROID_HOST_OUT" ] ; then
|
|
ANDROID_HOST_OUT=${OUT_DIR-$ANDROID_BUILD_TOP/out}/host/linux-x86
|
|
fi
|
|
|
|
# "Root" (actually "system") directory on device (in the case of
|
|
# target testing).
|
|
android_root=${ART_TEST_ANDROID_ROOT:-/system}
|
|
|
|
java_lib_location="${ANDROID_HOST_OUT}/../common/obj/JAVA_LIBRARIES"
|
|
make_target_name="apache-harmony-jdwp-tests-hostdex"
|
|
|
|
function boot_classpath_arg {
|
|
local dir="$1"
|
|
local suffix="$2"
|
|
shift 2
|
|
local separator=""
|
|
for var
|
|
do
|
|
if [ "$var" = "conscrypt" ] && [ "$mode" = "target" ]; then
|
|
printf -- "${separator}/apex/com.android.conscrypt/javalib/conscrypt.jar";
|
|
elif [ "$var" = "core-icu4j" ] && [ "$mode" = "target" ]; then
|
|
printf -- "${separator}/apex/com.android.i18n/javalib/core-icu4j.jar";
|
|
else
|
|
printf -- "${separator}${dir}/${var}${suffix}.jar";
|
|
fi
|
|
separator=":"
|
|
done
|
|
}
|
|
|
|
# Note: This must start with the CORE_IMG_JARS in Android.common_path.mk
|
|
# because that's what we use for compiling the boot.art image.
|
|
# It may contain additional modules from TEST_CORE_JARS.
|
|
BOOT_CLASSPATH_JARS="core-oj core-libart okhttp bouncycastle apache-xml core-icu4j conscrypt"
|
|
|
|
vm_args=""
|
|
art="$android_root/bin/art"
|
|
mode="target"
|
|
art_debugee="sh $android_root/bin/art"
|
|
args=$@
|
|
chroot_option=
|
|
debuggee_args="-Xcompiler-option --debuggable"
|
|
device_dir="--device-dir=/data/local/tmp"
|
|
# We use the art script on target to ensure the runner and the debuggee share the same
|
|
# image.
|
|
vm_command="--vm-command=$art"
|
|
image_compiler_option=""
|
|
plugin=""
|
|
debug="no"
|
|
explicit_debug="no"
|
|
verbose="no"
|
|
image="-Ximage:/apex/com.android.art/javalib/boot.art"
|
|
boot_classpath="$(boot_classpath_arg /apex/com.android.art/javalib "" $BOOT_CLASSPATH_JARS)"
|
|
boot_classpath_locations=""
|
|
with_jdwp_path=""
|
|
agent_wrapper=""
|
|
vm_args=""
|
|
# By default, we run the whole JDWP test suite.
|
|
has_specific_test="no"
|
|
test="org.apache.harmony.jpda.tests.share.AllTests"
|
|
# Use JIT compiling by default.
|
|
use_jit=true
|
|
instant_jit=false
|
|
variant_cmdline_parameter="--variant=X32"
|
|
dump_command="/bin/true"
|
|
called_from_libjdwp=${RUN_JDWP_TESTS_CALLED_FROM_LIBJDWP:-false}
|
|
run_internal_jdwp_test=false
|
|
# Let LUCI bots do what they want.
|
|
if test -v LUCI_CONTEXT; then
|
|
run_internal_jdwp_test=true
|
|
fi
|
|
# Timeout of JDWP test in ms.
|
|
#
|
|
# Note: some tests expect a timeout to check that *no* reply/event is received for a specific case.
|
|
# A lower timeout can save up several minutes when running the whole test suite, especially for
|
|
# continuous testing. This value can be adjusted to fit the configuration of the host machine(s).
|
|
jdwp_test_timeout=10000
|
|
|
|
skip_tests=
|
|
gdb_target=
|
|
has_gdb="no"
|
|
|
|
while true; do
|
|
if [[ "$1" == "--mode=host" ]]; then
|
|
mode="host"
|
|
# Specify bash explicitly since the art script cannot, since it has to run on the device
|
|
# with mksh.
|
|
art="bash ${OUT_DIR-out}/host/linux-x86/bin/art"
|
|
art_debugee="bash ${OUT_DIR-out}/host/linux-x86/bin/art"
|
|
# We force generation of a new image to avoid build-time and run-time classpath differences.
|
|
image="-Ximage:/system/non/existent/vogar.art"
|
|
# Pass the host boot classpath.
|
|
if [ "${ANDROID_HOST_OUT:0:${#ANDROID_BUILD_TOP}+1}" = "${ANDROID_BUILD_TOP}/" ]; then
|
|
framework_location="${ANDROID_HOST_OUT:${#ANDROID_BUILD_TOP}+1}/framework"
|
|
else
|
|
echo "error: ANDROID_BUILD_TOP/ is not a prefix of ANDROID_HOST_OUT"
|
|
echo "ANDROID_BUILD_TOP=${ANDROID_BUILD_TOP}"
|
|
echo "ANDROID_HOST_OUT=${ANDROID_HOST_OUT}"
|
|
exit
|
|
fi
|
|
boot_classpath="$(boot_classpath_arg ${ANDROID_HOST_OUT}/framework -hostdex $BOOT_CLASSPATH_JARS)"
|
|
boot_classpath_locations="$(boot_classpath_arg ${framework_location} -hostdex $BOOT_CLASSPATH_JARS)"
|
|
# We do not need a device directory on host.
|
|
device_dir=""
|
|
# Vogar knows which VM to use on host.
|
|
vm_command=""
|
|
shift
|
|
elif [[ "$1" == "--mode=jvm" ]]; then
|
|
mode="ri"
|
|
make_target_name="apache-harmony-jdwp-tests"
|
|
run_internal_jdwp_test=true
|
|
art="$(which java)"
|
|
art_debugee="$(which java)"
|
|
# No need for extra args.
|
|
debuggee_args=""
|
|
# No image. On the RI.
|
|
image=""
|
|
boot_classpath=""
|
|
boot_classpath_locations=""
|
|
# We do not need a device directory on RI.
|
|
device_dir=""
|
|
# Vogar knows which VM to use on RI.
|
|
vm_command=""
|
|
# We don't care about jit with the RI
|
|
use_jit=false
|
|
shift
|
|
elif [[ $1 == --skip-test ]]; then
|
|
skip_tests="${skip_tests},${2}"
|
|
# remove the --skip-test
|
|
args=${args/$1}
|
|
shift
|
|
# remove the arg
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ $1 == --force-run-test ]]; then
|
|
run_internal_jdwp_test=true
|
|
# remove the --force-run-test
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ $1 == --test-timeout-ms ]]; then
|
|
# Remove the --test-timeout-ms from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
jdwp_test_timeout=$1
|
|
# Remove the argument
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ $1 == --agent-wrapper ]]; then
|
|
# Remove the --agent-wrapper from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
agent_wrapper=${agent_wrapper}${1},
|
|
# Remove the argument
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ $1 == -Ximage:* ]]; then
|
|
image="$1"
|
|
shift
|
|
elif [[ "$1" == "--instant-jit" ]]; then
|
|
instant_jit=true
|
|
# Remove the --instant-jit from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ "$1" == "--no-jit" ]]; then
|
|
use_jit=false
|
|
# Remove the --no-jit from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ $1 == "--no-debug" ]]; then
|
|
explicit_debug="yes"
|
|
debug="no"
|
|
# Remove the --no-debug from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ $1 == "--debug" ]]; then
|
|
explicit_debug="yes"
|
|
debug="yes"
|
|
# Remove the --debug from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ $1 == "--verbose" ]]; then
|
|
verbose="yes"
|
|
# Remove the --verbose from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ $1 == "--gdbserver" ]]; then
|
|
# Remove the --gdbserver from the arguments.
|
|
args=${args/$1}
|
|
has_gdb="yes"
|
|
shift
|
|
gdb_target=$1
|
|
# Remove the target from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ $1 == "--test" ]]; then
|
|
# Remove the --test from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
has_specific_test="yes"
|
|
test=$1
|
|
# Remove the test from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ "$1" == "--jdwp-path" ]]; then
|
|
# Remove the --jdwp-path from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
with_jdwp_path=$1
|
|
# Remove the path from the arguments.
|
|
args=${args/$1}
|
|
shift
|
|
elif [[ "$1" == "" ]]; then
|
|
break
|
|
elif [[ $1 == --variant=* ]]; then
|
|
variant_cmdline_parameter=$1
|
|
shift
|
|
elif [[ $1 == -Xplugin:* ]]; then
|
|
plugin="$1"
|
|
args=${args/$1}
|
|
shift
|
|
else
|
|
shift
|
|
fi
|
|
done
|
|
|
|
if [ ! -t 1 ] ; then
|
|
# Suppress color codes if not attached to a terminal
|
|
args="$args --no-color"
|
|
fi
|
|
|
|
if [[ $mode == "target" ]]; then
|
|
# Honor environment variable ART_TEST_CHROOT.
|
|
if [[ -n "$ART_TEST_CHROOT" ]]; then
|
|
# Set Vogar's `--chroot` option.
|
|
chroot_option="--chroot $ART_TEST_CHROOT"
|
|
# Adjust settings for chroot environment.
|
|
art="/system/bin/art"
|
|
art_debugee="sh /system/bin/art"
|
|
vm_command="--vm-command=$art"
|
|
device_dir="--device-dir=/tmp"
|
|
fi
|
|
fi
|
|
|
|
if [[ $called_from_libjdwp != "true" ]]; then
|
|
if [[ $run_internal_jdwp_test = "false" ]]; then
|
|
echo "Calling run_jdwp_tests.sh directly is probably not what you want. You probably want to"
|
|
echo "run ./art/tools/run-libjdwp-tests.sh instead in order to test the JDWP implementation"
|
|
echo "used by apps. If you really wish to run these tests using the deprecated internal JDWP"
|
|
echo "implementation pass the '--force-run-test' flag."
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
if [[ $has_gdb = "yes" ]]; then
|
|
if [[ $explicit_debug = "no" ]]; then
|
|
debug="yes"
|
|
fi
|
|
fi
|
|
|
|
if [[ $mode == "ri" ]]; then
|
|
if [[ "x$with_jdwp_path" != "x" ]]; then
|
|
vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentArgument=-agentpath:${agent_wrapper}"
|
|
vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentName=$with_jdwp_path"
|
|
fi
|
|
if [[ "x$image" != "x" ]]; then
|
|
echo "Cannot use -Ximage: with --mode=jvm"
|
|
exit 1
|
|
elif [[ $has_gdb = "yes" ]]; then
|
|
echo "Cannot use --gdbserver with --mode=jvm"
|
|
exit 1
|
|
elif [[ $debug == "yes" ]]; then
|
|
echo "Cannot use --debug with --mode=jvm"
|
|
exit 1
|
|
fi
|
|
else
|
|
if [[ "$mode" == "host" ]]; then
|
|
dump_command="/bin/kill -3"
|
|
else
|
|
# Note that this dumping command won't work when `$android_root`
|
|
# is different from `/system` (e.g. on ART Buildbot devices) when
|
|
# the device is running Android N, as the debuggerd protocol
|
|
# changed in an incompatible way in Android O (see b/32466479).
|
|
dump_command="$android_root/xbin/su root $android_root/bin/debuggerd"
|
|
fi
|
|
if [[ $has_gdb = "yes" ]]; then
|
|
if [[ $mode == "target" ]]; then
|
|
echo "Cannot use --gdbserver with --mode=target"
|
|
exit 1
|
|
else
|
|
art_debugee="$art_debugee --gdbserver $gdb_target"
|
|
# The tests absolutely require some timeout. We set a ~2 week timeout since we can kill the
|
|
# test with gdb if it goes on too long.
|
|
jdwp_test_timeout="1000000000"
|
|
fi
|
|
fi
|
|
if [[ "x$with_jdwp_path" != "x" ]]; then
|
|
vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentArgument=-agentpath:${agent_wrapper}"
|
|
vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentName=${with_jdwp_path}"
|
|
fi
|
|
vm_args="$vm_args --vm-arg -Xcompiler-option --vm-arg --debuggable"
|
|
# we don't want to be trying to connect to adbconnection which might not have
|
|
# been built.
|
|
vm_args="${vm_args} --vm-arg -XjdwpProvider:none"
|
|
# Make sure the debuggee doesn't re-generate, nor clean up what the debugger has generated.
|
|
art_debugee="$art_debugee --no-compile --no-clean"
|
|
fi
|
|
|
|
function jlib_name {
|
|
local path=$1
|
|
local str="classes"
|
|
local suffix="jar"
|
|
if [[ $mode == "ri" ]]; then
|
|
str="javalib"
|
|
fi
|
|
echo "$path/$str.$suffix"
|
|
}
|
|
|
|
# Jar containing all the tests.
|
|
test_jar=$(jlib_name "${java_lib_location}/${make_target_name}_intermediates")
|
|
|
|
if [[ ! -f $test_jar ]]; then
|
|
echo "Before running, you must build jdwp tests and vogar:" \
|
|
"m ${make_target_name} vogar"
|
|
exit 1
|
|
fi
|
|
|
|
# For the host:
|
|
#
|
|
# If, on the other hand, there is a variant set, use it to modify the art_debugee parameter to
|
|
# force the fork to have the same bitness as the controller. This should be fine and not impact
|
|
# testing (cross-bitness), as the protocol is always 64-bit anyways (our implementation).
|
|
#
|
|
# Note: this isn't necessary for the device as the BOOTCLASSPATH environment variable is set there
|
|
# and used as a fallback.
|
|
if [[ $mode == "host" ]]; then
|
|
variant=${variant_cmdline_parameter:10}
|
|
if [[ $variant == "x32" || $variant == "X32" ]]; then
|
|
art_debugee="$art_debugee --32"
|
|
elif [[ $variant == "x64" || $variant == "X64" ]]; then
|
|
art_debugee="$art_debugee --64"
|
|
else
|
|
echo "Error, do not understand variant $variant_cmdline_parameter."
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
if [[ "$image" != "" ]]; then
|
|
vm_args="$vm_args --vm-arg $image"
|
|
debuggee_args="$debuggee_args $image"
|
|
fi
|
|
if [[ "$boot_classpath" != "" ]]; then
|
|
vm_args="$vm_args --vm-arg -Xbootclasspath:${boot_classpath}"
|
|
debuggee_args="$debuggee_args -Xbootclasspath:${boot_classpath}"
|
|
fi
|
|
if [[ "$boot_classpath_locations" != "" ]]; then
|
|
vm_args="$vm_args --vm-arg -Xbootclasspath-locations:${boot_classpath_locations}"
|
|
debuggee_args="$debuggee_args -Xbootclasspath-locations:${boot_classpath_locations}"
|
|
fi
|
|
|
|
if [[ "$plugin" != "" ]]; then
|
|
vm_args="$vm_args --vm-arg $plugin"
|
|
fi
|
|
|
|
if [[ $mode != "ri" ]]; then
|
|
# Because we're running debuggable, we discard any AOT code.
|
|
# Therefore we run de2oat with 'quicken' to avoid spending time compiling.
|
|
vm_args="$vm_args --vm-arg -Xcompiler-option --vm-arg --compiler-filter=quicken"
|
|
debuggee_args="$debuggee_args -Xcompiler-option --compiler-filter=quicken"
|
|
|
|
if $instant_jit; then
|
|
debuggee_args="$debuggee_args -Xjitthreshold:0"
|
|
fi
|
|
|
|
vm_args="$vm_args --vm-arg -Xusejit:$use_jit"
|
|
debuggee_args="$debuggee_args -Xusejit:$use_jit"
|
|
fi
|
|
|
|
if [[ $debug == "yes" ]]; then
|
|
art="$art -d"
|
|
art_debugee="$art_debugee -d"
|
|
vm_args="$vm_args --vm-arg -XXlib:libartd.so --vm-arg -XX:SlowDebug=true"
|
|
fi
|
|
if [[ $verbose == "yes" ]]; then
|
|
# Enable JDWP logs in the debuggee.
|
|
art_debugee="$art_debugee -verbose:jdwp"
|
|
fi
|
|
|
|
if [[ $mode != "ri" ]]; then
|
|
toolchain_args="--toolchain d8 --language CUR"
|
|
if [[ "x$with_jdwp_path" == "x" ]]; then
|
|
# Need to enable the internal jdwp implementation.
|
|
art_debugee="${art_debugee} -XjdwpProvider:internal"
|
|
else
|
|
# need to disable the jdwpProvider since we give the agent explicitly on the
|
|
# cmdline.
|
|
art_debugee="${art_debugee} -XjdwpProvider:none"
|
|
fi
|
|
else
|
|
toolchain_args="--toolchain javac --language CUR"
|
|
fi
|
|
|
|
# Run the tests using vogar.
|
|
vogar $vm_command \
|
|
$vm_args \
|
|
--verbose \
|
|
$args \
|
|
$chroot_option \
|
|
$device_dir \
|
|
$image_compiler_option \
|
|
--timeout 800 \
|
|
--vm-arg -Djpda.settings.verbose=true \
|
|
--vm-arg -Djpda.settings.timeout=$jdwp_test_timeout \
|
|
--vm-arg -Djpda.settings.waitingTime=$jdwp_test_timeout \
|
|
--vm-arg -Djpda.settings.transportAddress=127.0.0.1:55107 \
|
|
--vm-arg -Djpda.settings.dumpProcess="$dump_command" \
|
|
--vm-arg -Djpda.settings.debuggeeJavaPath="$art_debugee $plugin $debuggee_args" \
|
|
--vm-arg -Djpda.settings.badTestCases="$skip_tests" \
|
|
--classpath "$test_jar" \
|
|
$toolchain_args \
|
|
$test
|
|
|
|
vogar_exit_status=$?
|
|
|
|
echo "Killing stalled dalvikvm processes..."
|
|
if [[ $mode == "host" ]]; then
|
|
pkill -9 -f /bin/dalvikvm
|
|
else
|
|
# Tests may run on older Android versions where pkill requires "-l SIGNAL"
|
|
# rather than "-SIGNAL".
|
|
adb shell pkill -l 9 -f /bin/dalvikvm
|
|
fi
|
|
echo "Done."
|
|
|
|
exit $vogar_exit_status
|