blob: 281af7171f5aaa84035704b1a24df87ab9c786b5 [file] [log] [blame]
#!/bin/sh
#
# Copyright (C) 2010 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.
#
# This shell script is used to run all NDK build tests in a row.
# "Build tests" are tests that check the building features of the NDK
# but do not run anything on target devices/emulators.
#
# You need to define the NDK
PROGDIR=`dirname $0`
PROGDIR=`cd $PROGDIR && pwd`
# Assume that we are under tests/
# and that the samples will be under samples/ and platforms/android-N/samples/
#
ROOTDIR=`cd $PROGDIR/.. && pwd`
NDK_BUILDTOOLS_PATH=$ROOTDIR/build/tools
. $ROOTDIR/build/core/ndk-common.sh
. $ROOTDIR/build/tools/prebuilt-common.sh
# The list of tests that are too long to be part of a normal run of
# run-tests.sh. Most of these do not run properly at the moment.
LONG_TESTS="prebuild-stlport test-stlport test-gnustl-full test-stlport_shared-exception test-stlport_static-exception"
#
# Parse options
#
VERBOSE=no
ABI=default
PLATFORM=""
NDK_ROOT=
JOBS=$BUILD_NUM_CPUS
find_program ADB_CMD adb
TESTABLES="samples build device awk"
FULL_TESTS=no
RUN_TESTS=
NDK_PACKAGE=
WINE=
CONTINUE_ON_BUILD_FAIL=
while [ -n "$1" ]; do
opt="$1"
optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'`
case "$opt" in
--help|-h|-\?)
OPTION_HELP=yes
;;
--verbose)
if [ "$VERBOSE" = "yes" ] ; then
VERBOSE2=yes
else
VERBOSE=yes
fi
;;
--abi=*)
ABI="$optarg"
;;
--platform=*)
PLATFORM="$optarg"
;;
--ndk=*)
NDK_ROOT="$optarg"
;;
--full)
FULL_TESTS=yes;
;;
--test=*) # Deprecated, but keep it just in case.
RUN_TESTS="$RUN_TESTS $optarg"
;;
--package=*)
NDK_PACKAGE="$optarg"
;;
-j*)
JOBS=`expr "$opt" : '-j\(.*\)'`
shift
;;
--jobs=*)
JOBS="$optarg"
;;
--adb=*)
ADB_CMD="$optarg"
;;
--only-samples)
TESTABLES=samples
;;
--only-build)
TESTABLES=build
;;
--only-device)
TESTABLES=device
;;
--only-awk)
TESTABLES=awk
;;
--wine)
WINE=yes
;;
--continue-on-build-fail)
CONTINUE_ON_BUILD_FAIL=yes
;;
-*) # unknown options
echo "ERROR: Unknown option '$opt', use --help for list of valid ones."
exit 1
;;
*) # Simply record new test name
RUN_TESTS=$RUN_TESTS" $opt"
;;
esac
shift
done
if [ "$OPTION_HELP" = "yes" ] ; then
echo "Usage: $PROGNAME [options] [testname1 [testname2...]]"
echo ""
echo "Run NDK automated tests. Without any parameter, this will try to"
echo "run all standard tests, except those are tagged broken. You can"
echo "also select/enforce specific tests by listing their name on the"
echo "command-line."
echo ""
echo "Valid options:"
echo ""
echo " --help|-h|-? Print this help"
echo " --verbose Enable verbose mode (can be used several times)"
echo " --ndk=<path> Path to NDK to test [$ROOTDIR]"
echo " --package=<path> Path to NDK package to test"
echo " -j<N> --jobs=<N> Launch parallel builds [$JOBS]"
echo " --abi=<name> Only run tests for the specific ABI [$ABI]"
echo " --platform=<name> Force API level for testing; platform=<android-x>"
echo " --adb=<file> Specify adb executable for device tests"
echo " --only-samples Only rebuild samples"
echo " --only-build Only rebuild build tests"
echo " --only-device Only rebuild & run device tests"
echo " --only-awk Only run awk tests."
echo " --full Run all device tests, even very long ones."
echo " --wine Build all tests with wine on Linux"
echo ""
echo "NOTE: You cannot use --ndk and --package at the same time."
echo ""
exit 0
fi
# Run a command in ADB.
#
# This is needed because "adb shell" does not return the proper status
# of the launched command, so we need to add it to the output, and grab
# it after that.
# $1: Device name
# $2: Variable name that will contain the result
# $3+: Command options
adb_var_shell_cmd ()
{
# We need a temporary file to store the output of our command
local ADB_SHELL_CMD_LOG RET OUT
local DEVICE=$1
local VARNAME=$2
shift; shift;
ADB_SHELL_CMD_LOG=$(mktemp -t XXXXXXXX)
# Run the command, while storing the standard output to ADB_SHELL_CMD_LOG
# and appending the exit code as the last line.
if [ $VERBOSE = "yes" ] ; then
echo "$ADB_CMD -s \"$DEVICE\" shell \"$@\""
$ADB_CMD -s "$DEVICE" shell "$@" ";" echo \$? | sed -e 's![[:cntrl:]]!!g' | tee $ADB_SHELL_CMD_LOG
else
$ADB_CMD -s "$DEVICE" shell "$@" ";" echo \$? | sed -e 's![[:cntrl:]]!!g' > $ADB_SHELL_CMD_LOG
fi
# Get last line in log, which contains the exit code from the command
RET=`sed -e '$!d' $ADB_SHELL_CMD_LOG`
# Get output, which corresponds to everything except the last line
OUT=`sed -e '$d' $ADB_SHELL_CMD_LOG`
rm -f $ADB_SHELL_CMD_LOG
if [ "$VARNAME" != "" ]; then
eval $VARNAME=\"\$OUT\"
fi
return $RET
}
# Make a directory path on device
#
# The 'mkdir' command on the Android device does not
# support the '-p' option. This function will test
# for the existence of the parent directory and recursively
# call itself until it files a parent which exists; then
# create the requested directory.
adb_shell_mkdir ()
{
local FULLDIR BASEDIR
local DEVICE=$1
local FULLDIR=$2
local BASEDIR=`dirname $FULLDIR`
adb_var_shell_cmd "$DEVICE" "" "ls $BASEDIR 1>/dev/null 2>&1"
if [ $? != 0 ] ; then
if [ $BASEDIR = "/" ] ; then
dump "ERROR: Could not find the root (/) directory on the device!"
exit 1
else
adb_shell_mkdir "$DEVICE" $BASEDIR
adb_shell_mkdir "$DEVICE" $FULLDIR
fi
else
#If the directory doesn't exist, make it
adb_var_shell_cmd "$DEVICE" "" "ls $FULLDIR 1>/dev/null 2>&1 || mkdir $FULLDIR"
if [ $? != 0 ] ; then
dump "ERROR: Could not mkdir '$FULLDIR' on the device!"
exit 1
fi
fi
}
# Returns 0 if a variable containing one or more items separated
# by spaces contains a given value.
# $1: variable name (e.g. FOO)
# $2: value to test
var_list_contains ()
{
echo `var_value $1` | tr ' ' '\n' | grep -q -F -x -e "$2"
}
#
# List of stuff to actually tests
#
is_testable () {
var_list_contains TESTABLES "$1"
}
# is_buildable returns 0 if a test should be built/run for this invocation
# $1: test path
if [ -n "$RUN_TESTS" ] ; then
is_buildable () {
[ -f $1/build.sh -o -f $1/jni/Android.mk ] &&
var_list_contains RUN_TESTS "`basename $1`"
}
elif [ "$FULL_TESTS" = "yes" ] ; then
is_buildable () {
[ -f $1/build.sh -o -f $1/jni/Android.mk ]
}
else # !FULL_TESTS
is_buildable () {
[ -f $1/build.sh -o -f $1/jni/Android.mk ] || return 1
! var_list_contains LONG_TESTS "`basename $1`" || return 1
}
fi # !FULL_TESTS
TEST_DIR="/tmp/ndk-$USER/tests"
mkdir -p $TEST_DIR
setup_default_log_file "$TEST_DIR/build-tests.log"
if [ -n "$NDK_PACKAGE" ] ; then
if [ -n "$NDK_ROOT" ] ; then
dump "ERROR: You can't use --ndk and --package at the same time!"
exit 1
fi
NDK_ROOT=/tmp/ndk-tests/install
mkdir -p "$NDK_ROOT" && rm -rf "$NDK_ROOT/*"
dump "Unpacking NDK package to $NDK_ROOT"
unpack_archive "$NDK_PACKAGE" "$NDK_ROOT"
NDK_ROOT=`ls -d $NDK_ROOT/*`
fi
#
# Check the NDK install path.
#
if [ -n "$NDK_ROOT" ] ; then
if [ ! -d "$NDK_ROOT" ] ; then
dump "ERROR: Your --ndk option does not point to a directory: $NDK_ROOT"
dump "Please use a valid path for this option."
exit 1
fi
if [ ! -f "$NDK_ROOT/ndk-build" -o ! -f "$NDK_ROOT/build/core/ndk-common.sh" ] ; then
dump "ERROR: Your --ndk option does not point to a valid NDK install: $NDK_ROOT"
dump "Please use a valid NDK install path for this option."
exit 3
fi
NDK="$NDK_ROOT"
else
NDK="$ROOTDIR"
fi
#
# Create log file
#
BUILD_DIR=$TEST_DIR/build
mkdir -p "$BUILD_DIR" && rm -rf "$BUILD_DIR/*"
###
### RUN AWK TESTS
###
# Run a simple awk script
# $1: awk script to run
# $2: input file
# $3: expected output file
# $4+: optional additional command-line arguments for the awk command
run_awk_test ()
{
local SCRIPT="$1"
local SCRIPT_NAME="`basename $SCRIPT`"
local INPUT="$2"
local INPUT_NAME="`basename $INPUT`"
local EXPECTED="$3"
local EXPECTED_NAME="`basename $EXPECTED`"
shift; shift; shift;
local OUTPUT="$BUILD_DIR/$EXPECTED_NAME"
if [ "$VERBOSE2" = "yes" ]; then
echo "### COMMAND: awk -f \"$SCRIPT\" $@ < \"$INPUT\" > \"$OUTPUT\""
fi
awk -f "$SCRIPT" $@ < "$INPUT" > "$OUTPUT"
fail_panic "Can't run awk script: $SCRIPT"
if [ "$VERBOSE2" = "yes" ]; then
echo "OUTPUT FROM SCRIPT:"
cat "$OUTPUT"
echo "EXPECTED VALUES:"
cat "$EXPECTED"
fi
cmp -s "$OUTPUT" "$EXPECTED"
if [ $? = 0 ] ; then
echo "Awk script: $SCRIPT_NAME: passed $INPUT_NAME"
if [ "$VERBOSE2" = "yes" ]; then
cat "$OUTPUT"
fi
else
if [ "$VERBOSE" = "yes" ]; then
run diff -burN "$EXPECTED" "$OUTPUT"
fi
echo "Awk script: $SCRIPT_NAME: $INPUT_NAME FAILED!!"
rm -f "$OUTPUT"
exit 1
fi
}
run_awk_test_dir ()
{
local SCRIPT_NAME="`basename \"$DIR\"`"
local SCRIPT="$ROOTDIR/build/awk/$SCRIPT_NAME.awk"
local INPUT
local OUTPUT
if [ ! -f "$SCRIPT" ]; then
echo "Awk script: $SCRIPT_NAME: Missing script: $SCRIPT"
continue
fi
for INPUT in `ls "$PROGDIR"/awk/$SCRIPT_NAME/*.in`; do
OUTPUT=`echo $INPUT | sed 's/\.in$/.out/g'`
if [ ! -f "$OUTPUT" ]; then
echo "Awk script: $SCRIPT_NAME: Missing awk output file: $OUTPUT"
continue
fi
run_awk_test "$SCRIPT" "$INPUT" "$OUTPUT"
done
}
if is_testable awk; then
AWKDIR="$ROOTDIR/build/awk"
for DIR in `ls -d "$PROGDIR"/awk/*`; do
run_awk_test_dir "$DIR"
done
fi
###
### REBUILD ALL SAMPLES FIRST
###
NDK_BUILD_FLAGS="-B"
case $ABI in
default) # Let the APP_ABI in jni/Application.mk decide what to build
;;
armeabi|armeabi-v7a|x86|mips)
NDK_BUILD_FLAGS="$NDK_BUILD_FLAGS APP_ABI=$ABI"
;;
*)
echo "ERROR: Unsupported abi value: $ABI"
exit 1
;;
esac
# Force all tests to run at one API level
if [ "$PLATFORM" != "" ]; then
NDK_BUILD_FLAGS="$NDK_BUILD_FLAGS APP_PLATFORM=$PLATFORM"
fi
# Use --verbose twice to see build commands for the tests
if [ "$VERBOSE2" = "yes" ] ; then
NDK_BUILD_FLAGS="$NDK_BUILD_FLAGS V=1"
fi
run_ndk_build ()
{
if [ "$WINE" ]; then
run wine cmd /c Z:$NDK/ndk-build.cmd -j$JOBS "$@"
else
run $NDK/ndk-build -j$JOBS "$@"
fi
}
# get build var
# $1: project directory
# $2: var
get_build_var ()
{
local PROJECT=$1
local VAR=$2
if [ -z "$GNUMAKE" ] ; then
GNUMAKE=make
fi
$GNUMAKE --no-print-dir -f $NDK/build/core/build-local.mk -C $PROJECT DUMP_$VAR | tail -1
}
# check if the project is broken and shouldn't be built
# $1: project directory
# $2: optional error message
is_broken_build ()
{
local PROJECT="$1"
local ERRMSG="$2"
if [ -z $RUN_TESTS ] ; then
if [ -f "$PROJECT/BROKEN_BUILD" ] ; then
if [ ! -s "$PROJECT/BROKEN_BUILD" ] ; then
# skip all
if [ -z "$ERRMSG" ] ; then
echo "Skipping `basename $PROJECT`: (build)"
else
echo "Skipping $ERRMSG: `basename $PROJECT`"
fi
return 0
else
# only skip listed in file
TARGET_TOOLCHAIN=`get_build_var $PROJECT TARGET_TOOLCHAIN`
TARGET_TOOLCHAIN_VERSION=`echo $TARGET_TOOLCHAIN | tr '-' '\n' | tail -1`
grep -q -w -e "$TARGET_TOOLCHAIN_VERSION" "$PROJECT/BROKEN_BUILD"
if [ $? = 0 ] ; then
if [ -z "$ERRMSG" ] ; then
echo "Skipping `basename $PROJECT`: (no build for $TARGET_TOOLCHAIN_VERSION)"
else
echo "Skipping $ERRMSG: `basename $PROJECT` (no build for $TARGET_TOOLCHAIN_VERSION)"
fi
return 0
fi
fi
fi
fi
return 1
}
# check if $ABI is incompatible and shouldn't be built
# $1: project directory
is_incompatible_abi ()
{
local PROJECT="$1"
if [ "$ABI" != "default" ] ; then
# check APP_ABI
local APP_ABIS=`get_build_var $PROJECT APP_ABI`
APP_ABIS=$APP_ABIS" "
if [ "$APP_ABIS" != "${APP_ABIS%%all*}" ] ; then
# replace the first "all" with all available ABIs
ALL_ABIS=`get_build_var $PROJECT NDK_ALL_ABIS`
APP_ABIS_FRONT="${APP_ABIS%%all*}"
APP_ABIS_BACK="${APP_ABIS#*all}"
APP_ABIS="${APP_ABIS_FRONT}${ALL_ABIS}${APP_ABIS_BACK}"
fi
if [ "$APP_ABIS" = "${APP_ABIS%$ABI *}" ] ; then
echo "Skipping `basename $PROJECT`: incompatible ABI, needs $APP_ABIS"
return 0
fi
fi
return 1
}
build_project ()
{
local NAME=`basename $1`
local CHECK_ABI=$2
local DIR="$BUILD_DIR/$NAME"
if is_broken_build $1; then
return 0;
fi
if [ "$CHECK_ABI" = "yes" ] ; then
if is_incompatible_abi $1 ; then
return 0
fi
fi
rm -rf "$DIR" && cp -r "$1" "$DIR"
# build it
(run cd "$DIR" && run_ndk_build $NDK_BUILD_FLAGS)
RET=$?
if [ -f "$1/BUILD_SHOULD_FAIL" ]; then
if [ $RET = 0 ]; then
echo "!!! FAILURE: BUILD SHOULD HAVE FAILED [$1]"
if [ "$CONTINUE_ON_BUILD_FAIL" != yes ] ; then
exit 1
fi
fi
log "!!! SUCCESS: BUILD FAILED AS EXPECTED [$(basename $1)]"
RET=0
fi
if [ $RET != 0 ] ; then
echo "!!! BUILD FAILURE [$1]!!! See $NDK_LOGFILE for details or use --verbose option!"
if [ "$CONTINUE_ON_BUILD_FAIL" != yes ] ; then
exit 1
fi
fi
}
#
# Determine list of samples directories.
#
if is_testable samples; then
if [ -f "$NDK/RELEASE.TXT" ] ; then
# This is a release package, all samples should be under $NDK/samples
SAMPLES_DIRS="$NDK/samples"
if [ ! -d "$SAMPLES_DIRS" ] ; then
dump "ERROR: Missing samples directory: $SAMPLES_DIRS"
dump "Your NDK release installation is broken!"
exit 1
fi
log "Using release NDK samples from: $SAMPLES_DIRS"
else
# This is a development work directory, we will take the samples
# directly from development/ndk.
DEVNDK_DIR=`dirname $NDK`/development/ndk
if [ ! -d "$DEVNDK_DIR" ] ; then
dump "ERROR: Could not find development NDK directory: $DEVNDK_DIR"
dump "Please clone platform/development.git from android.googlesource.com"
exit 1
fi
SAMPLES_DIRS="$DEVNDK_DIR/samples"
for DIR in `ls -d $DEVNDK_DIR/platforms/android-*/samples`; do
SAMPLES_DIRS="$SAMPLES_DIRS $DIR"
done
dump "Using development NDK samples from $DEVNDK_DIR"
if [ "$VERBOSE" = "yes" ] ; then
echo "$SAMPLES_DIRS" | tr ' ' '\n'
fi
fi
#
# Copy the samples to a temporary build directory
build_sample ()
{
echo "Building NDK sample: `basename $1`"
build_project $1 "no"
}
for DIR in $SAMPLES_DIRS; do
for SUBDIR in `ls -d $DIR/*`; do
if is_buildable $SUBDIR; then
build_sample $SUBDIR
fi
done
done
fi
###
### BUILD PROJECTS UNDER tests/build/
###
if is_testable build; then
build_build_test ()
{
local NAME="$(basename $1)"
echo "Building NDK build test: `basename $1`"
if [ -f $1/build.sh ]; then
local DIR="$BUILD_DIR/$NAME"
if [ -f "$1/jni/Android.mk" -a -f "$1/jni/Application.mk" ] ; then
# exclude jni/Android.mk with import-module because it needs NDK_MODULE_PATH
grep -q "call import-module" "$1/jni/Android.mk"
if [ $? != 0 ] ; then
if (is_broken_build $1 || is_incompatible_abi $1) then
return 0;
fi
fi
fi
rm -rf "$DIR" && cp -r "$1" "$DIR"
export NDK
(cd "$DIR" && run ./build.sh $NDK_BUILD_FLAGS)
if [ $? != 0 ]; then
echo "!!! BUILD FAILURE [$1]!!! See $NDK_LOGFILE for details or use --verbose option!"
if [ "$CONTINUE_ON_BUILD_FAIL" != yes ] ; then
exit 1
fi
fi
else
build_project $1 "yes"
fi
}
for DIR in `ls -d $ROOTDIR/tests/build/*`; do
if is_buildable $DIR; then
build_build_test $DIR
fi
done
fi
###
### BUILD PROJECTS UNDER tests/device/
###
CPU_ABIS=
if is_testable device; then
build_device_test ()
{
if is_broken_build $1 "broken device test build"; then
return 0;
fi
echo "Building NDK device test: `basename $1`"
build_project $1 "yes"
}
# $1: DEVICE
# $2: DEVICE CPU ABI
# $3: test
# $4: tmp dir
run_device_test ()
{
local DEVICE=$1
local CPU_ABI=$2
local TEST=$3
local TEST_NAME="$(basename $TEST)"
local SRCDIR
local DSTDIR="$4/ndk-tests"
local SRCFILE
local DSTFILE
local PROGRAMS=
local PROGRAM
# Do not run the test if BROKEN_RUN is defined
if [ -z "$RUN_TESTS" ]; then
if is_broken_build $TEST "NDK device test not built"; then
return 0
fi
if [ -f "$TEST/BROKEN_RUN" ] ; then
if [ ! -s "$TEST/BROKEN_RUN" ] ; then
# skip all
dump "Skipping NDK device test run: $TEST_NAME"
return 0
else
# skip all tests built by toolchain
TARGET_TOOLCHAIN=`get_build_var $TEST TARGET_TOOLCHAIN`
TARGET_TOOLCHAIN_VERSION=`echo $TARGET_TOOLCHAIN | tr '-' '\n' | tail -1`
grep -q -w -e "$TARGET_TOOLCHAIN_VERSION" "$TEST/BROKEN_RUN"
if [ $? = 0 ] ; then
dump "Skipping NDK device test run: $TEST_NAME (no run for binary built by $TARGET_TOOLCHAIN_VERSION)"
return 0
fi
# skip tests listed in file
SKIPPED_EXECUTABLES=`cat $TEST/BROKEN_RUN | tr '\n' ' '`
dump "Skipping NDK device test run: $TEST_NAME ($SKIPPED_EXECUTABLES)"
fi
fi
fi
SRCDIR="$BUILD_DIR/`basename $TEST`/libs/$CPU_ABI"
if [ ! -d "$SRCDIR" ]; then
dump "Skipping NDK device test run (no $CPU_ABI binaries): $TEST_NAME"
return 0
fi
# First, copy all files to the device, except for gdbserver, gdb.setup, and
# those declared in $TEST/BROKEN_RUN
adb_shell_mkdir "$DEVICE" $DSTDIR
for SRCFILE in `ls $SRCDIR`; do
DSTFILE=`basename $SRCFILE`
if [ "$DSTFILE" = "gdbserver" -o "$DSTFILE" = "gdb.setup" ] ; then
continue
fi
if [ -z "$RUN_TESTS" -a -f "$TEST/BROKEN_RUN" ]; then
grep -q -w -e "$DSTFILE" "$TEST/BROKEN_RUN"
if [ $? = 0 ] ; then
continue
fi
fi
SRCFILE="$SRCDIR/$SRCFILE"
if [ $HOST_OS = cygwin ]; then
SRCFILE=`cygpath -m $SRCFILE`
fi
DSTFILE="$DSTDIR/$DSTFILE"
run $ADB_CMD -s "$DEVICE" push "$SRCFILE" "$DSTFILE" &&
run $ADB_CMD -s "$DEVICE" shell chmod 0755 $DSTFILE
if [ $? != 0 ] ; then
dump "ERROR: Could not install $SRCFILE to device $DEVICE!"
exit 1
fi
# If its name doesn't end with .so, add it to PROGRAMS
echo "$DSTFILE" | grep -q -e '\.so$'
if [ $? != 0 ] ; then
PROGRAMS="$PROGRAMS `basename $DSTFILE`"
fi
done
for PROGRAM in $PROGRAMS; do
dump "Running device test [$CPU_ABI]: $TEST_NAME (`basename $PROGRAM`)"
adb_var_shell_cmd "$DEVICE" "" "cd $DSTDIR && LD_LIBRARY_PATH=$DSTDIR ./$PROGRAM"
if [ $? != 0 ] ; then
dump " ---> TEST FAILED!!"
fi
done
# Cleanup
adb_var_shell_cmd "$DEVICE" "" rm -r $DSTDIR
}
for DIR in `ls -d $ROOTDIR/tests/device/*`; do
if is_buildable $DIR; then
build_device_test $DIR
fi
done
# Do we have adb and any device connected here?
# If not, we can't run our tests.
#
SKIP_TESTS=no
if [ -z "$ADB_CMD" ] ; then
dump "WARNING: No 'adb' in your path!"
SKIP_TESTS=yes
else
# Get list of online devices, turn ' ' in device into '.'
ADB_DEVICES=`$ADB_CMD devices | grep -v offline | awk 'NR>1 {gsub(/[ \t]+device$/,""); print;}' | sed '/^$/d' | sort | tr ' ' '.'`
ADB_DEVICES=$(echo $ADB_DEVICES | tr '\n' ' ')
log2 "ADB online devices (sorted): $ADB_DEVICES"
ADB_DEVCOUNT=`echo "$ADB_DEVICES" | wc -w`
if [ "$ADB_DEVCOUNT" = "0" ]; then
dump "WARNING: No device connected to adb!"
SKIP_TESTS=yes
else
ADB_DEVICES="$ADB_DEVICES "
if [ -n "$ANDROID_SERIAL" ] ; then
ADB_SERIAL=$(echo "$ANDROID_SERIAL" | tr ' ' '.') # turn ' ' into '.'
if [ "$ADB_DEVICES" = "${ADB_DEVICES%$ADB_SERIAL *}" ] ; then
dump "WARNING: Device $ANDROID_SERIAL cannot be found or offline!"
SKIP_TESTS=yes
else
ADB_DEVICES="$ANDROID_SERIAL"
fi
fi
fi
fi
if [ "$SKIP_TESTS" = "yes" ] ; then
dump "SKIPPING RUNNING TESTS ON DEVICE!"
else
AT_LEAST_CPU_ABI_MATCH=
for DEVICE in $ADB_DEVICES; do
# undo earlier ' '-to-'.' translation
DEVICE=$(echo $DEVICE | tr '.' ' ')
# get device CPU_ABI and CPU_ABI2, each may contain list of abi, comma-delimited.
adb_var_shell_cmd "$DEVICE" CPU_ABI1 getprop ro.product.cpu.abi
adb_var_shell_cmd "$DEVICE" CPU_ABI2 getprop ro.product.cpu.abi2
CPU_ABIS="$CPU_ABI1,$CPU_ABI2"
CPU_ABIS=$(commas_to_spaces $CPU_ABIS)
if [ "$CPU_ABIS" = " " ]; then
# Very old cupcake-based Android devices don't have these properties
# defined. Fortunately, they are all armeabi-based.
CPU_ABIS=armeabi
fi
for CPU_ABI in $CPU_ABIS; do
if [ "$ABI" = "default" -o "$ABI" = "$CPU_ABI" ] ; then
AT_LEAST_CPU_ABI_MATCH="yes"
for DIR in `ls -d $ROOTDIR/tests/device/*`; do
if is_buildable $DIR; then
log "Running device test on $DEVICE [$CPU_ABI]: $DIR"
run_device_test "$DEVICE" "$CPU_ABI" "$DIR" /data/local/tmp
fi
done
fi
done
done
if [ "$AT_LEAST_CPU_ABI_MATCH" != "yes" ] ; then
dump "WARNING: No device matches ABI $ABI! SKIPPING RUNNING TESTS ON DEVICE!"
fi
fi
fi
dump "Cleaning up..."
rm -rf $BUILD_DIR
dump "Done."