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.
583 lines
15 KiB
583 lines
15 KiB
#!/bin/bash
|
|
#
|
|
# Copyright 2010 Google Inc. All Rights Reserved.
|
|
# Author: bgay@google.com (Bruce Gay)
|
|
#
|
|
# The labpretest.sh script is designed to emulate a typical automated test lab
|
|
# session. It puts a device into bootloader mode, reboots into bootloader mode,
|
|
# determines device type, erases user cache, flashes a generic userdata image,
|
|
# updates the bootloader image, updates the radio image, updates the system
|
|
# image and reboots, sets up for a monkey run and finally runs a random monkey
|
|
# test. It will repeat this based on an optional parameter(-i) or default to 100
|
|
# times. It will detect if it is in a low battery situation and wait for it to
|
|
# charge again.
|
|
|
|
|
|
COUNT=100
|
|
ROOT=$(cd `dirname $0` && pwd)
|
|
ADB="$ROOT/tools/adb"
|
|
FASTBOOT="$ROOT/tools/fastboot"
|
|
MEVENTS=200
|
|
NOMONKEY=0
|
|
|
|
buildfile=''
|
|
device=''
|
|
product=''
|
|
bootpart=''
|
|
bootfile=''
|
|
|
|
while getopts "d:i::m:xh" optionName; do
|
|
case "$optionName" in
|
|
d) device="$OPTARG";;
|
|
i) COUNT=$OPTARG;;
|
|
m) MEVENTS=$OPTARG;;
|
|
x) NOMONKEY=1;;
|
|
h) echo "options: [-d <device ID>, -i <loop count>, -m <monkey events> -x (skips monkey)]"; exit;;
|
|
*) echo "invalid parameter -$optionName"; exit -1;;
|
|
esac
|
|
done
|
|
|
|
declare -r COUNT
|
|
declare -r MEVENTS
|
|
declare -r NOMONKEY
|
|
|
|
|
|
################################################
|
|
# Prints output to console with time stamp
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
log_print()
|
|
{
|
|
if [ -z "$1" ]; then
|
|
echo "# $(date +'%D %T')"
|
|
else
|
|
echo "# $(date +'%D %T'): $1"
|
|
fi
|
|
}
|
|
|
|
################################################
|
|
# Blocks until battery level is at least
|
|
# above TARGET if below LIMIT
|
|
# Globals:
|
|
# ADB
|
|
# device
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
wait_for_battery()
|
|
{
|
|
TARGET=80
|
|
LIMIT=20
|
|
local battery
|
|
local tick
|
|
log_print "checking battery level"
|
|
while [ "$battery" = "" ]; do
|
|
battery=`$ADB -s $device shell dumpsys battery | tr -d '\r' | awk '/level:/ {print $2}'`
|
|
sleep 2
|
|
done
|
|
if [ $battery -lt $LIMIT ]; then
|
|
log_print "Battery is low, waiting for charge"
|
|
while true; do
|
|
battery=`$ADB -s $device shell dumpsys battery | tr -d '\r' | awk '/level:/ {print $2}'`
|
|
if (( $battery >= $TARGET )); then break; fi
|
|
tick=$[$TARGET - $battery]
|
|
echo "battery charge level is $battery, sleeping for $tick seconds"
|
|
sleep $[$TARGET - $battery * 10]
|
|
done
|
|
log_print "resuming test run with battery level at $battery%"
|
|
else
|
|
log_print "resuming test run with battery level at $battery%"
|
|
fi
|
|
}
|
|
|
|
################################################
|
|
# Blocks until device is in fastboot mode or
|
|
# time out is reached
|
|
# Globals:
|
|
# loop
|
|
# device
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
fastboot_wait_for_device()
|
|
{
|
|
local fdevice=""
|
|
local n=0
|
|
while [ "$device" != "$fdevice" -a $n -le 30 ]; do
|
|
sleep 6
|
|
fdevice=`$FASTBOOT devices | sed -n "s/\($device\).*/\1/ p"`
|
|
let n+=1
|
|
done
|
|
if [ $n -gt 30 ]; then
|
|
log_print "device time out after $loop iterations"
|
|
exit
|
|
else
|
|
log_print "device returned and available"
|
|
fi
|
|
}
|
|
|
|
################################################
|
|
# reboots device into fastboot mode or
|
|
# time out is reached
|
|
# Globals:
|
|
# device
|
|
# ADB
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
reboot_into_fastboot_from_adb()
|
|
{
|
|
log_print "rebooting into bootloader and waiting for availability via fastboot"
|
|
$ADB -s $device reboot bootloader
|
|
fastboot_wait_for_device
|
|
}
|
|
|
|
################################################
|
|
# reboots device into fastboot mode or
|
|
# times out
|
|
# Globals:
|
|
# device
|
|
# FASTBOOT
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
reboot_into_fastboot_from_fastboot()
|
|
{
|
|
log_print "rebooting into bootloader and waiting for availability via fastboot"
|
|
$FASTBOOT -s $device reboot-bootloader
|
|
fastboot_wait_for_device
|
|
}
|
|
|
|
################################################
|
|
# reboots device from fastboot to adb or
|
|
# times out
|
|
# Globals:
|
|
# device
|
|
# FASTBOOT
|
|
# ADB
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
reboot_into_adb_from_fastboot()
|
|
{
|
|
log_print "rebooting and waiting for availability via adb"
|
|
$FASTBOOT -s $device reboot
|
|
$ADB -s $device wait-for-device
|
|
}
|
|
|
|
################################################
|
|
# reboots device from fastboot to adb or
|
|
# times out
|
|
# Globals:
|
|
# device
|
|
# ADB
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
wait_for_boot_complete()
|
|
{
|
|
log_print "waiting for device to finish booting"
|
|
local result=$($ADB -s $device shell getprop dev.bootcomplete)
|
|
local result_test=${result:1:1}
|
|
echo -n "."
|
|
while [ -z $result_test ]; do
|
|
sleep 1
|
|
echo -n "."
|
|
result=$($ADB -s $device shell getprop dev.bootcomplete)
|
|
result_test=${result:0:1}
|
|
done
|
|
log_print "finished booting"
|
|
}
|
|
|
|
################################################
|
|
# fastboot flashes partition
|
|
#
|
|
# Globals:
|
|
# device
|
|
# FASTBOOT
|
|
# Arguments:
|
|
# command_name
|
|
# command_parameters
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
fastboot_command()
|
|
{
|
|
$FASTBOOT -s $device $1 $2 $3
|
|
sleep 5
|
|
}
|
|
|
|
################################################
|
|
# fastboot command wrapper
|
|
#
|
|
# Globals:
|
|
# device
|
|
# FASTBOOT
|
|
# Arguments:
|
|
# partition_name
|
|
# file_name
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
flash_partition()
|
|
{
|
|
$FASTBOOT -s $device flash $1 $2
|
|
sleep 5
|
|
}
|
|
|
|
################################################
|
|
# adb command wrapper
|
|
#
|
|
# Globals:
|
|
# device
|
|
# ADB
|
|
# Arguments:
|
|
# command_name
|
|
# command_parameters
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
adb_command()
|
|
{
|
|
$ADB -s $device $1 $2 $3 $4 $5
|
|
sleep 5
|
|
}
|
|
|
|
################################################
|
|
# sets the name of the boot partition and
|
|
# bootfile, then flashes device
|
|
#
|
|
# Globals:
|
|
# product
|
|
# ROOT
|
|
# bootloaderfile
|
|
# bootpart
|
|
# device
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
flash_bootloader_image()
|
|
{
|
|
if [ "$bootpart" == '' ]; then
|
|
log_print "bootpart not defined"
|
|
exit
|
|
fi
|
|
if [ "$bootloaderfile" == '' ]; then
|
|
log_print "getting bootloader file for $product"
|
|
bootloaderfile=`ls -1 $ROOT/$product | sed -n 's/\(.*boot[0-9._]\+img\)/\1/ p'`
|
|
if [ "$bootloaderfile" == '' ]; then
|
|
log_print "bootloader file empty: $bootloaderfile"
|
|
exit
|
|
fi
|
|
if [ ! -e "$ROOT/$product/$bootloaderfile" ]; then
|
|
log_print "bootloader file not found: ./$product/$bootloaderfile"
|
|
exit
|
|
fi
|
|
log_print "using $ROOT/$product/$bootloaderfile as the bootloader image file"
|
|
fi
|
|
log_print "downloading bootloader image to $device"
|
|
flash_partition $bootpart $ROOT/$product/$bootloaderfile
|
|
reboot_into_fastboot_from_fastboot
|
|
}
|
|
|
|
################################################
|
|
# sets the name of the radio partition and
|
|
# radiofile and flashes device
|
|
#
|
|
# Globals:
|
|
# product
|
|
# ROOT
|
|
# radiofile
|
|
# radiopart
|
|
# device
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
flash_radio_image()
|
|
{
|
|
if [ "$radiopart" == '' ]; then
|
|
log_print "setting radio partion to 'radio'"
|
|
radiopart='radio'
|
|
fi
|
|
if [ "$radiofile" == "" ]; then
|
|
log_print "getting radio file for $product"
|
|
radiofile=`ls -1 $ROOT/$product | sed -n 's/\(radio[0-9._A-Za-z]\+img\)/\1/ p'`
|
|
if [ "$radiofile" == "" ]; then
|
|
log_print "radio file empty: $radiofile"
|
|
exit
|
|
fi
|
|
if [ ! -e "$ROOT/$product/$radiofile" ]; then
|
|
log_print "radio file not found: ./$product/$radiofile"
|
|
exit
|
|
fi
|
|
log_print "using $ROOT/$product/$radiofile as the radio image file"
|
|
fi
|
|
log_print "downloading radio image to $device"
|
|
flash_partition $radiopart $ROOT/$product/$radiofile
|
|
reboot_into_fastboot_from_fastboot
|
|
}
|
|
|
|
################################################
|
|
# sets the name of the boot partition and
|
|
# bootfile
|
|
#
|
|
# Globals:
|
|
# product
|
|
# ROOT
|
|
# buildfile
|
|
# device
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
flash_system_image()
|
|
{
|
|
if [ "$buildfile" == "" ]; then
|
|
log_print "getting build file for $product"
|
|
buildfile=`\ls -1 $ROOT/$product 2>&1 | sed -n 's/\([a-z]\+-img-[0-9]\+.zip\)/\1/ p'`
|
|
if [ "$buildfile" == "" ]; then
|
|
log_print "build file empty: $buildfile"
|
|
exit
|
|
fi
|
|
if [ ! -e "$ROOT/$product/$buildfile" ]; then
|
|
log_print "build file not found: ./$product/$buildfile"
|
|
exit
|
|
fi
|
|
log_print "using $ROOT/$product/$buildfile as the system image file"
|
|
fi
|
|
log_print "downloading system image to $device"
|
|
fastboot_command update $ROOT/$product/$buildfile
|
|
|
|
}
|
|
################################################
|
|
# flashes the userdata partition
|
|
#
|
|
# Globals:
|
|
# product
|
|
# ROOT
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
flash_userdata_image()
|
|
{
|
|
log_print "flashing userdata..."
|
|
if [ -e $ROOT/$product/userdata.img ];then
|
|
flash_partition userdata $ROOT/$product/userdata.img
|
|
else
|
|
log_print "userdata.img file not found: $ROOT/$product/userdata.img"
|
|
exit
|
|
fi
|
|
}
|
|
|
|
|
|
################################################
|
|
# flashes the device
|
|
#
|
|
# Globals:
|
|
# product
|
|
# ROOT
|
|
# FASTBOOT
|
|
# bootfile
|
|
# bootpart
|
|
# radiofile
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
flash_device()
|
|
{
|
|
log_print "erasing cache..."
|
|
fastboot_command erase cache
|
|
flash_userdata_image
|
|
flash_bootloader_image
|
|
flash_radio_image
|
|
flash_system_image
|
|
#device has been rebooted
|
|
adb_command wait-for-device
|
|
}
|
|
|
|
################################################
|
|
# gets the device product type and sets product
|
|
#
|
|
# Globals:
|
|
# product
|
|
# ROOT
|
|
# FASTBOOT
|
|
# device
|
|
# Arguments:
|
|
# None
|
|
# Returns:
|
|
# None
|
|
################################################
|
|
set_product_type()
|
|
{
|
|
if [ "$product" == "" ]; then
|
|
log_print "getting device product type"
|
|
product=`$FASTBOOT -s $device getvar product 2>&1 | sed -n 's/product: \([a-z]*\)\n*/\1/ p'`
|
|
if [ ! -e "$ROOT/$product" ]; then
|
|
log_print "device product id not supported: $product"
|
|
exit
|
|
fi
|
|
fi
|
|
log_print "using $product as device product id"
|
|
}
|
|
|
|
|
|
|
|
#start of script
|
|
#test for dependencies
|
|
if [ ! -e $ADB ]; then
|
|
echo "Error: adb not in path! Please correct this."
|
|
exit
|
|
fi
|
|
if [ ! -e $FASTBOOT ]; then
|
|
echo "Error: fastboot not in path! Please correct this."
|
|
exit
|
|
fi
|
|
#checks to see if the called device is available
|
|
if [ "$device" != "" ]; then
|
|
tmpdevice=`$ADB devices | sed -n "s/\($device\).*/\1/ p"`
|
|
if [ "$device" != "$tmpdevice" ]; then
|
|
tmpdevice=`$FASTBOOT devices | sed -n "s/\($device\).*/\1/ p"`
|
|
if [ "$device" != "$tmpdevice" ]; then
|
|
echo "Warning: device not found... $device"
|
|
exit
|
|
else
|
|
echo "'Device '$device' found!'"
|
|
reboot_into_adb_from_fastboot
|
|
wait_for_boot_complete
|
|
fi
|
|
fi
|
|
else
|
|
device=`$ADB devices | sed -n 's/.*\(^[0-9A-Z]\{2\}[0-9A-Z]*\).*/\1/ p'`
|
|
if [ `echo $device | wc -w` -ne 1 ]; then
|
|
echo 'There is more than one device found,'
|
|
echo 'please pass the correct device ID in as a parameter.'
|
|
exit
|
|
fi
|
|
fi
|
|
if [ "$device" == "" ]; then
|
|
echo 'Device not found via adb'
|
|
device=`$FASTBOOT devices | sed -n 's/.*\(^[0-9A-Z]\{2\}[0-9A-Z]*\).*/\1/ p'`
|
|
if [ `echo $device | wc -w` -ne 1 ]; then
|
|
echo "There is more than one device available,"
|
|
echo "please pass the correct device ID in as a parameter."
|
|
exit
|
|
fi
|
|
if [ "$device" == "" ]; then
|
|
echo 'Device not found via fastboot, please investigate'
|
|
exit
|
|
else
|
|
echo 'Device '$device' found!'
|
|
reboot_into_adb_from_fastboot
|
|
wait_for_boot_complete
|
|
echo 'Hammering on '$device
|
|
fi
|
|
else
|
|
echo 'Hammering on '$device
|
|
fi
|
|
reboot_into_fastboot_from_adb
|
|
set_product_type
|
|
reboot_into_adb_from_fastboot
|
|
wait_for_boot_complete
|
|
|
|
#check for availability of a custom flash info file and retreive it
|
|
if [ -e "$ROOT/$product/custom_flash.sh" ]; then
|
|
. $ROOT/$product/custom_flash.sh
|
|
fi
|
|
echo $'\n\n'
|
|
|
|
#start of looping
|
|
for ((loop=1 ; loop <= $COUNT ; loop++ )) ; do
|
|
echo ""
|
|
echo ""
|
|
echo ________________ $(date +'%D %T') - $loop - $device ______________________
|
|
|
|
log_print "setting adb root and sleeping for 7 seconds"
|
|
adb_command root
|
|
wait_for_battery
|
|
log_print "rebooting into bootloader and waiting for availability via fastboot"
|
|
reboot_into_fastboot_from_adb
|
|
# not necessary, but useful in testing
|
|
log_print "using fastboot to reboot to bootloader for test purposes"
|
|
reboot_into_fastboot_from_fastboot
|
|
|
|
#flashing the device
|
|
flash_device
|
|
|
|
#preping device for monkey run
|
|
log_print "setting adb root"
|
|
adb_command root
|
|
log_print "setting ro.test_harness property"
|
|
adb_command shell setprop ro.test_harness 1
|
|
|
|
log_print "waiting for device to finish booting"
|
|
result=$($ADB -s $device shell getprop dev.bootcomplete)
|
|
result_test=${result:1:1}
|
|
echo -n "."
|
|
while [ -z $result_test ]; do
|
|
sleep 1
|
|
echo -n "."
|
|
result=$($ADB -s $device shell getprop dev.bootcomplete)
|
|
result_test=${result:0:1}
|
|
done
|
|
|
|
log_print "finished booting"
|
|
log_print "waiting for the Package Manager"
|
|
result=$($ADB -s $device shell pm path android)
|
|
result_test=${result:0:7}
|
|
echo -n "."
|
|
while [ $result_test != "package" ]; do
|
|
sleep 1
|
|
echo -n "."
|
|
result=$($ADB -s $device shell pm path android)
|
|
result_test=${result:0:7}
|
|
done
|
|
echo "Package Manager available"
|
|
|
|
#lets you see what's going on
|
|
log_print "setting shell svc power stayon true"
|
|
adb_command shell svc power stayon true
|
|
|
|
#calls the monkey run if not skipped
|
|
if [ $NOMONKEY == 0 ]; then
|
|
seed=$(($(date +%s) % 99))
|
|
log_print "running short monkey run..."
|
|
$ADB -s $device shell monkey -p com.android.alarmclock -p com.android.browser -p com.android.calculator2 -p com.android.calendar -p com.android.camera -p com.android.contacts -p com.google.android.gm -p com.android.im -p com.android.launcher -p com.google.android.apps.maps -p com.android.mms -p com.android.music -p com.android.phone -p com.android.settings -p com.google.android.street -p com.android.vending -p com.google.android.youtube -p com.android.email -p com.google.android.voicesearch -c android.intent.category.LAUNCHER --ignore-security-exceptions -s $seed $MEVENTS
|
|
log_print "finished running monkey, rinse, repeat..."
|
|
else
|
|
log_print "-x parameter used, skipping the monkey run"
|
|
fi
|
|
|
|
if [ $loop -eq $COUNT ]; then
|
|
log_print "device $device has returned, testing completed, count = $loop"
|
|
echo `echo "Device $device has returned, testing completed, count = $loop." > $ROOT/$device.log`
|
|
else
|
|
log_print "device $device has returned, rinse and repeat count = $loop"
|
|
echo `echo "Device $device has returned, rinse and repeat count = $loop." > $ROOT/$device.log`
|
|
fi
|
|
done
|