tools/run-jdwp-tests.sh - LeafOS-Project/android_art - Gitiles

 #!/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

 # Prevent JDWP tests from running on the following devices running
 # Android O (they are failing because of a network-related issue), as
 # a workaround for b/74725685:
 # - FA7BN1A04406 (walleye device testing configuration aosp-poison/volantis-armv7-poison-debug)
 # - FA7BN1A04412 (walleye device testing configuration aosp-poison/volantis-armv8-poison-ndebug)
 # - FA7BN1A04433 (walleye device testing configuration aosp-poison/volantis-armv8-poison-debug)
 case "$ANDROID_SERIAL" in
   (FA7BN1A04406|FA7BN1A04412|FA7BN1A04433) exit 0;;
 esac

 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
     printf -- "${separator}${dir}/${var}${suffix}.jar";
     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 core.art image.
 # It may contain additional modules from TEST_CORE_JARS.
 BOOT_CLASSPATH_JARS="core-oj core-libart okhttp bouncycastle apache-xml conscrypt"

 vm_args=""
 art="$android_root/bin/art"
 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:/data/art-test/core.art"
 boot_classpath="$(boot_classpath_arg /system/framework -testdex $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"
 mode="target"
 # Use JIT compiling by default.
 use_jit=true
 instant_jit=false
 variant_cmdline_parameter="--variant=X32"
 dump_command="/bin/true"
 # 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

 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=device" ]]; then
     # Remove the --mode=device from the arguments and replace it with --mode=device_testdex
     args=${args/$1}
     args="$args --mode=device_testdex"
     shift
   elif [[ "$1" == "--mode=jvm" ]]; then
     mode="ri"
     make_target_name="apache-harmony-jdwp-tests-host"
     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 == --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 [[ $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 [[ $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:" \
        "make ${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" \
       --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
	#!/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

	# Prevent JDWP tests from running on the following devices running
	# Android O (they are failing because of a network-related issue), as
	# a workaround for b/74725685:
	# - FA7BN1A04406 (walleye device testing configuration aosp-poison/volantis-armv7-poison-debug)
	# - FA7BN1A04412 (walleye device testing configuration aosp-poison/volantis-armv8-poison-ndebug)
	# - FA7BN1A04433 (walleye device testing configuration aosp-poison/volantis-armv8-poison-debug)
	case "$ANDROID_SERIAL" in
	(FA7BN1A04406\|FA7BN1A04412\|FA7BN1A04433) exit 0;;
	esac

	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
	printf -- "${separator}${dir}/${var}${suffix}.jar";
	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 core.art image.
	# It may contain additional modules from TEST_CORE_JARS.
	BOOT_CLASSPATH_JARS="core-oj core-libart okhttp bouncycastle apache-xml conscrypt"

	vm_args=""
	art="$android_root/bin/art"
	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:/data/art-test/core.art"
	boot_classpath="$(boot_classpath_arg /system/framework -testdex $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"
	mode="target"
	# Use JIT compiling by default.
	use_jit=true
	instant_jit=false
	variant_cmdline_parameter="--variant=X32"
	dump_command="/bin/true"
	# 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

	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=device" ]]; then
	# Remove the --mode=device from the arguments and replace it with --mode=device_testdex
	args=${args/$1}
	args="$args --mode=device_testdex"
	shift
	elif [[ "$1" == "--mode=jvm" ]]; then
	mode="ri"
	make_target_name="apache-harmony-jdwp-tests-host"
	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 == --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 [[ $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 [[ $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:" \
	"make ${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" \
	--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