src/test/java/com/android/tools/r8/DeviceRunner.java - r8 - Git at Google

 // Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;

 import com.android.ddmlib.AdbCommandRejectedException;
 import com.android.ddmlib.AndroidDebugBridge;
 import com.android.ddmlib.FileListingService;
 import com.android.ddmlib.IDevice;
 import com.android.ddmlib.IShellOutputReceiver;
 import com.android.ddmlib.ShellCommandUnresponsiveException;
 import com.android.ddmlib.SyncException;
 import com.android.ddmlib.TimeoutException;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.base.Joiner;
 import java.io.BufferedReader;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;

 /**
  * This class is used to run tests on devices (or emulators)
  * using ddmlib.
  */
 public class DeviceRunner {

   private static final boolean VERBOSE = false;
   private static final long ADB_CONNECTION_TIMEOUT = 5000;
   private static final long ADB_WAIT_STEP = ADB_CONNECTION_TIMEOUT / 10;
   private static final String TEST_SCRIPT_NAME = "test-exit-status.sh";
   private static final File TEST_SCRIPT_FILE =
       new File(System.getProperty("user.dir"), "scripts/" + TEST_SCRIPT_NAME);
   private static final char PATH_SEPARATOR_CHAR = ':';
   private static final String RUNTIME_NAME = "ART";

   private List<String> vmOptions = Collections.emptyList();
   private Map<String, String> systemProperties = Collections.emptyMap();
   private List<File> classpath = Collections.emptyList();
   private List<File> bootClasspath = Collections.emptyList();
   private String mainClass;
   private List<String> programArguments = Collections.emptyList();
   private OutputStream outRedirectStream = new ByteArrayOutputStream();

   private ShellOutputReceiver hostOutput = new ShellOutputReceiver();

   public static class DeviceRunnerConfigurationException extends Exception {

     public DeviceRunnerConfigurationException(String message) {
       super(message);
     }
   }

   private static class ShellOutputReceiver implements IShellOutputReceiver {

     private final PrintStream out;

     public ShellOutputReceiver() {
       this.out = System.out;
     }

     public ShellOutputReceiver(OutputStream out) {
       this.out = new PrintStream(out);
     }

     @Override
     public void addOutput(byte[] data, int offset, int length) {
       out.print(new String(Arrays.copyOfRange(data, offset, offset + length)));
     }

     @Override
     public void flush() {
     }

     @Override
     public boolean isCancelled() {
       return false;
     }
   }

   private static class ShellOutputToStringReceiver implements IShellOutputReceiver {

     StringBuffer outBuffer = new StringBuffer();

     @Override
     public void addOutput(byte[] data, int offset, int length) {
       outBuffer.append(new String(Arrays.copyOfRange(data, offset, offset + length)));
     }

     @Override
     public void flush() {
     }

     @Override
     public boolean isCancelled() {
       return false;
     }

     public String getOutput() {
       return outBuffer.toString();
     }
   }

   public DeviceRunner() {
     try {
       AndroidDebugBridge.init(/* clientSupport */ false);
     } catch (IllegalStateException ex) {
       // ADB was already initialized, we're fine, so just ignore.
     }
   }

   public DeviceRunner setVmOptions(List<String> vmOptions) {
     this.vmOptions = vmOptions;
     return this;
   }

   public DeviceRunner setSystemProperties(Map<String, String> systemProperties) {
     this.systemProperties = systemProperties;
     return this;
   }

   public DeviceRunner setClasspath(List<File> classpath) {
     this.classpath = classpath;
     return this;
   }

   public DeviceRunner setBootClasspath(List<File> bootClasspath) {
     this.bootClasspath = bootClasspath;
     return this;
   }

   public DeviceRunner setMainClass(String mainClass) {
     this.mainClass = mainClass;
     return this;
   }

   public DeviceRunner setProgramArguments(List<String> programArguments) {
     this.programArguments = programArguments;
     return this;
   }

   public DeviceRunner setOutputStream(OutputStream outputStream) {
     outRedirectStream = outputStream;
     return this;
   }

   public ToolHelper.ProcessResult run() throws DeviceRunnerConfigurationException, IOException {

     AndroidDebugBridge adb = initializeAdb();

     IDevice[] connectedDevices = adb.getDevices();
     if (connectedDevices.length == 0) {
       throw new DeviceRunnerConfigurationException("No device found");
     }

     if (connectedDevices.length != 1) {
       throw new DeviceRunnerConfigurationException(
           "Running tests on more than one device is not yet supported. "
               + "Currently connected devices: ["
               + StringUtils.join(",", Arrays.asList(connectedDevices))
               + "]");
     }

     int exitStatus = -1;
     String uuid = java.util.UUID.randomUUID().toString();
     IDevice device = connectedDevices[0];
     try {
       checkDeviceRuntime(device);

       log("Running on device: " + device.getName());

       ensureAdbRoot(device);

       // Remove trailing '\n' returned by emulator
       File testsRootDirFile = new File(device.getMountPoint(IDevice.MNT_DATA).replace("\n", ""),
           "r8-tests-" + uuid);
       String testsRootDir = convertToTargetPath(testsRootDirFile);

       String testScriptPathOnTarget = convertToTargetPath(
           new File(testsRootDirFile, TEST_SCRIPT_NAME));

       ClasspathPair destFilePaths = installTestFiles(device, testsRootDirFile,
           testScriptPathOnTarget);

       File rootDir = new File(device.getMountPoint(IDevice.MNT_ROOT).replace("\n", ""));

       // Bug : exit code return by adb shell is wrong (always 0)
       // https://code.google.com/p/android/issues/detail?id=3254
       // Use go team hack to work this around
       // https://code.google.com/p/go/source/browse/misc/arm/a
       executeShellCommand(testScriptPathOnTarget + ' ' + uuid + ' ' + Joiner.on(' ').join(
           buildCommandLine(rootDir, testsRootDir, destFilePaths.bootclasspath,
               destFilePaths.classpath)), device, new ShellOutputReceiver(outRedirectStream),
           /* maxTimeToOutputResponse = */10000);
       exitStatus = getExitStatus(device, testsRootDir);
       log("Exit status: " + exitStatus);

       if (exitStatus != 0) {
         System.err.println("Execution failed on device '" + device.getName() + "'");
       }

     } catch (IOException t) {
       System.err.println("Error with device '" + device.getName() + "': " + t.getMessage());
       t.printStackTrace();
       throw t;
     } finally {
       deleteTestFiles(device, uuid);
     }

     // Convert target line separator to whatever host is for output comparison-based tests
     String outputAsString = outRedirectStream.toString()
         .replace("\n", ToolHelper.LINE_SEPARATOR);

     return new ToolHelper.ProcessResult(exitStatus, outputAsString, "");
   }

   private AndroidDebugBridge initializeAdb() throws DeviceRunnerConfigurationException {
     AndroidDebugBridge adb = AndroidDebugBridge.createBridge(getAdbLocation(), false);

     long start = System.currentTimeMillis();

     log("Initializing adb...");

     while (!isAdbInitialized(adb)) {
       long timeLeft = start + ADB_CONNECTION_TIMEOUT - System.currentTimeMillis();
       if (timeLeft <= 0) {
         break;
       }
       try {
         Thread.sleep(ADB_WAIT_STEP);
       } catch (InterruptedException e) {
         Thread.currentThread().interrupt();
         throw new AssertionError(e);
       }
     }

     if (!isAdbInitialized(adb)) {
       String userDefinedPathToSdk = System.getProperty("ANDROID_SDK_HOME");
       if (userDefinedPathToSdk != null) {
         throw new DeviceRunnerConfigurationException(
             "Adb not found. Check SDK location '"
                 + userDefinedPathToSdk
                 + "'");
       } else {
         throw new DeviceRunnerConfigurationException(
             "Adb not found. Set either PATH or ANDROID_SDK_HOME environment variable");
       }
     }

     log("Done");
     return adb;
   }

   private static class ClasspathPair {
     public String[] bootclasspath;
     public String[] classpath;

     ClasspathPair(String[] bootclasspath, String[] classpath) {
       this.bootclasspath = bootclasspath;
       this.classpath = classpath;
     }
   }

   /**
    * @return path of classpath and bootclasspath files on device
    */
   private ClasspathPair installTestFiles(IDevice device, File testsRootDirFile,
       String testScriptPathOnTarget) throws IOException {

     String testsRootDir = convertToTargetPath(testsRootDirFile);

     String[] desFilePaths = new String[classpath.size()];
     String[] destFileBootCpPaths = new String[bootClasspath.size()];

     executeShellCommand("mkdir " + testsRootDir, device);
     executeShellCommand(
         "rm " + testsRootDir + FileListingService.FILE_SEPARATOR + "*", device);
     executePushCommand(TEST_SCRIPT_FILE.getAbsolutePath(), testScriptPathOnTarget, device);
     executeShellCommand("chmod 777 " + testScriptPathOnTarget, device);

     int i = 0;
     for (File f : bootClasspath) {
       destFileBootCpPaths[i] = convertToTargetPath(
           new File(testsRootDirFile, "f" + i + "_" + f.getName()));
       executePushCommand(f.getAbsolutePath(), destFileBootCpPaths[i], device);
       i++;
     }
     i = 0;
     for (File f : classpath) {
       desFilePaths[i] = convertToTargetPath(
           new File(testsRootDirFile, "f" + i + "_" + f.getName()));
       executePushCommand(f.getAbsolutePath(), desFilePaths[i], device);
       i++;
     }
     return new ClasspathPair(destFileBootCpPaths, desFilePaths);
   }

   private int getExitStatus(IDevice device, String testsRootDir) throws IOException {
     File exitStatusFile = createTempFile("exitStatus", "");
     executePullCommand(
         testsRootDir + "/exitStatus", exitStatusFile.getAbsolutePath(), device);

     try (BufferedReader br = new BufferedReader(new FileReader(exitStatusFile))) {
       String readLine = br.readLine();
       if (readLine == null) {
         throw new FileNotFoundException("Exit status not found at " + exitStatusFile.getPath());
       }
       return Integer.parseInt(readLine);
     }
   }

   @SuppressWarnings("deprecation")
   private void executeShellCommand(
       String command,
       IDevice device,
       ShellOutputReceiver hostOutput,
       int maxTimeToOutputResponse) throws IOException {
     log("adb -s " + device.getSerialNumber() + " shell " + command);
     try {
       if (maxTimeToOutputResponse != -1) {
         device.executeShellCommand(command, hostOutput, maxTimeToOutputResponse);
       } else {
         device.executeShellCommand(command, hostOutput);
       }
     } catch (IOException
         | ShellCommandUnresponsiveException
         | TimeoutException
         | AdbCommandRejectedException e) {
       throw new IOException(
           "Failed to execute shell command: '" + command + "'", e);
     }
   }

   private void executeShellCommand(String command, IDevice device)
       throws IOException {
     executeShellCommand(command, device, hostOutput, -1);
   }

   private void executePushCommand(
       String srcFile, String destFile, IDevice device) throws IOException {
     log("adb -s " + device.getSerialNumber() + " push " + srcFile + " " + destFile);
     try {
       device.pushFile(srcFile, destFile);
     } catch (IOException | AdbCommandRejectedException | TimeoutException | SyncException e) {
       throw new IOException(
           "Unable to push file '" + srcFile + "' on device into '" + destFile + "'", e);
     }
   }

   private void executePullCommand(
       String srcFile, String destFile, IDevice device) throws IOException {
     log("adb -s " + device.getSerialNumber() + " pull " + srcFile + " " + destFile);
     try {
       device.pullFile(srcFile, destFile);
     } catch (IOException | AdbCommandRejectedException | TimeoutException | SyncException e) {
       throw new IOException(
           "Unable to pull file '" + srcFile + "' from device into '" + destFile + "'", e);
     }
   }

   private boolean isAdbInitialized(AndroidDebugBridge adb) {
     return adb.isConnected() && adb.hasInitialDeviceList();
   }

   private String getAdbLocation() {
     String adbLocation = "adb";
     String userSpecifiedSdkLocation = System.getenv("ANDROID_SDK_HOME");
     if (userSpecifiedSdkLocation != null) {
       adbLocation =
           userSpecifiedSdkLocation
               + File.separatorChar
               + "platform-tools"
               + File.separatorChar
               + "adb";
     }
     return adbLocation;
   }


   private void ensureAdbRoot(IDevice device) throws IOException {
     boolean isRoot;
     try {
       isRoot = device.isRoot();
     } catch (TimeoutException
         | AdbCommandRejectedException
         | IOException
         | ShellCommandUnresponsiveException e) {
       throw new IOException(
           "Cannot fetch root status for device '"
               + device.getName()
               + "("
               + device.getSerialNumber()
               + ")"
               + "': "
               + e.getMessage(),
           e);
     }

     int numberOfTries = 0;
     while (!isRoot && numberOfTries < 5) {
       try {
         isRoot = device.root();
       } catch (TimeoutException
           | AdbCommandRejectedException
           | IOException
           | ShellCommandUnresponsiveException e1) {
         // root() seems to throw an IOException: EOF, and it tends
         // to make the subsequent call to isRoot() fail with
         // AdbCommandRejectedException: device offline, until adbd is
         // restarted as root.
       } finally {
         try {
           Thread.sleep(1000);
         } catch (InterruptedException e1) {
           Thread.currentThread().interrupt();
         }
       }
       numberOfTries++;
     }

     if (!isRoot) {
       throw new IOException(
           "Cannot switch to root on device '"
               + device.getName()
               + "("
               + device.getSerialNumber()
               + ")"
               + "'");
     }
   }

   private void checkDeviceRuntime(IDevice device)
       throws DeviceRunnerConfigurationException, IOException {
     ShellOutputToStringReceiver outputToString = new ShellOutputToStringReceiver();
     try {
       device.executeShellCommand("dalvikvm -showversion", outputToString);
       if (!outputToString.getOutput().contains(RUNTIME_NAME)) {
         throw new DeviceRunnerConfigurationException(
             "The plugged device does not run the required runtime: '" + RUNTIME_NAME + "'");
       }
     } catch (TimeoutException
         | AdbCommandRejectedException
         | ShellCommandUnresponsiveException
         | IOException e) {
       throw new IOException("Could not check device runtime", e);
     }
   }

   private String convertToTargetPath(File file) {
     String path = file.getPath();
     Path root = file.toPath().getRoot();
     if (root != null) {
       path = path.replace(root.toString(), FileListingService.FILE_SEPARATOR);
     }
     return path.replace(File.separator, FileListingService.FILE_SEPARATOR);
   }

   private static File createTempFile(String prefix, String suffix) throws IOException {
     File tmp = File.createTempFile("r8-tests-" + prefix, suffix);
     tmp.deleteOnExit();
     return tmp;
   }

   private void deleteTestFiles(IDevice device, String uuid) throws IOException {
     String deleteCommand = "find data -name '*r8-tests-" + uuid + "*' -exec rm -rf {} +";
     log("adb -s " + device.getSerialNumber() + " shell " + deleteCommand);
     try {
       device.executeShellCommand(deleteCommand, hostOutput);
     } catch (TimeoutException
         | AdbCommandRejectedException
         | ShellCommandUnresponsiveException
         | IOException e) {
       throw new IOException("Error while deleting test file on device", e);
     }
   }

   private List<String> buildCommandLine(File rootDir, String testRootDir,
       String[] bootClasspathFiles, String[] classpathFiles) {
     List<String> result = new ArrayList<>();

     result.add(convertToTargetPath(new File(rootDir, "/bin/dalvikvm")));

     for (String option : vmOptions) {
       result.add(option);
     }
     for (Map.Entry<String, String> entry : systemProperties.entrySet()) {
       StringBuilder builder = new StringBuilder("-D");
       builder.append(entry.getKey());
       builder.append("=");
       builder.append(entry.getValue());
       result.add(builder.toString());
     }

     if (classpathFiles.length > 0) {
       result.add("-cp");
       result.add(Joiner.on(PATH_SEPARATOR_CHAR).join(
           Arrays.asList(classpathFiles).stream()
               .map(filePath -> convertToTargetPath(new File(filePath)))
               .collect(Collectors.toList())));
     }
     if (bootClasspathFiles.length > 0) {
       result.add("-Xbootclasspath:" + Joiner.on(PATH_SEPARATOR_CHAR).join(
           Arrays.asList(bootClasspathFiles).stream()
               .map(filePath -> convertToTargetPath(new File(filePath)))
               .collect(Collectors.toList())));
     }

     if (mainClass != null) {
       result.add(mainClass);
     }
     for (String argument : programArguments) {
       result.add(argument);
     }
     return result;
   }

   private void log(String message) {
     if (VERBOSE) {
       System.out.println(message);
     }
   }
 }
	// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.
	package com.android.tools.r8;

	import com.android.ddmlib.AdbCommandRejectedException;
	import com.android.ddmlib.AndroidDebugBridge;
	import com.android.ddmlib.FileListingService;
	import com.android.ddmlib.IDevice;
	import com.android.ddmlib.IShellOutputReceiver;
	import com.android.ddmlib.ShellCommandUnresponsiveException;
	import com.android.ddmlib.SyncException;
	import com.android.ddmlib.TimeoutException;
	import com.android.tools.r8.utils.StringUtils;
	import com.google.common.base.Joiner;
	import java.io.BufferedReader;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileNotFoundException;
	import java.io.FileReader;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.io.PrintStream;
	import java.nio.file.Path;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.List;
	import java.util.Map;
	import java.util.stream.Collectors;

	/**
	* This class is used to run tests on devices (or emulators)
	* using ddmlib.
	*/
	public class DeviceRunner {

	private static final boolean VERBOSE = false;
	private static final long ADB_CONNECTION_TIMEOUT = 5000;
	private static final long ADB_WAIT_STEP = ADB_CONNECTION_TIMEOUT / 10;
	private static final String TEST_SCRIPT_NAME = "test-exit-status.sh";
	private static final File TEST_SCRIPT_FILE =
	new File(System.getProperty("user.dir"), "scripts/" + TEST_SCRIPT_NAME);
	private static final char PATH_SEPARATOR_CHAR = ':';
	private static final String RUNTIME_NAME = "ART";

	private List<String> vmOptions = Collections.emptyList();
	private Map<String, String> systemProperties = Collections.emptyMap();
	private List<File> classpath = Collections.emptyList();
	private List<File> bootClasspath = Collections.emptyList();
	private String mainClass;
	private List<String> programArguments = Collections.emptyList();
	private OutputStream outRedirectStream = new ByteArrayOutputStream();

	private ShellOutputReceiver hostOutput = new ShellOutputReceiver();

	public static class DeviceRunnerConfigurationException extends Exception {

	public DeviceRunnerConfigurationException(String message) {
	super(message);
	}
	}

	private static class ShellOutputReceiver implements IShellOutputReceiver {

	private final PrintStream out;

	public ShellOutputReceiver() {
	this.out = System.out;
	}

	public ShellOutputReceiver(OutputStream out) {
	this.out = new PrintStream(out);
	}

	@Override
	public void addOutput(byte[] data, int offset, int length) {
	out.print(new String(Arrays.copyOfRange(data, offset, offset + length)));
	}

	@Override
	public void flush() {
	}

	@Override
	public boolean isCancelled() {
	return false;
	}
	}

	private static class ShellOutputToStringReceiver implements IShellOutputReceiver {

	StringBuffer outBuffer = new StringBuffer();

	@Override
	public void addOutput(byte[] data, int offset, int length) {
	outBuffer.append(new String(Arrays.copyOfRange(data, offset, offset + length)));
	}

	@Override
	public void flush() {
	}

	@Override
	public boolean isCancelled() {
	return false;
	}

	public String getOutput() {
	return outBuffer.toString();
	}
	}

	public DeviceRunner() {
	try {
	AndroidDebugBridge.init(/* clientSupport */ false);
	} catch (IllegalStateException ex) {
	// ADB was already initialized, we're fine, so just ignore.
	}
	}

	public DeviceRunner setVmOptions(List<String> vmOptions) {
	this.vmOptions = vmOptions;
	return this;
	}

	public DeviceRunner setSystemProperties(Map<String, String> systemProperties) {
	this.systemProperties = systemProperties;
	return this;
	}

	public DeviceRunner setClasspath(List<File> classpath) {
	this.classpath = classpath;
	return this;
	}

	public DeviceRunner setBootClasspath(List<File> bootClasspath) {
	this.bootClasspath = bootClasspath;
	return this;
	}

	public DeviceRunner setMainClass(String mainClass) {
	this.mainClass = mainClass;
	return this;
	}

	public DeviceRunner setProgramArguments(List<String> programArguments) {
	this.programArguments = programArguments;
	return this;
	}

	public DeviceRunner setOutputStream(OutputStream outputStream) {
	outRedirectStream = outputStream;
	return this;
	}

	public ToolHelper.ProcessResult run() throws DeviceRunnerConfigurationException, IOException {

	AndroidDebugBridge adb = initializeAdb();

	IDevice[] connectedDevices = adb.getDevices();
	if (connectedDevices.length == 0) {
	throw new DeviceRunnerConfigurationException("No device found");
	}

	if (connectedDevices.length != 1) {
	throw new DeviceRunnerConfigurationException(
	"Running tests on more than one device is not yet supported. "
	+ "Currently connected devices: ["
	+ StringUtils.join(",", Arrays.asList(connectedDevices))
	+ "]");
	}

	int exitStatus = -1;
	String uuid = java.util.UUID.randomUUID().toString();
	IDevice device = connectedDevices[0];
	try {
	checkDeviceRuntime(device);

	log("Running on device: " + device.getName());

	ensureAdbRoot(device);

	// Remove trailing '\n' returned by emulator
	File testsRootDirFile = new File(device.getMountPoint(IDevice.MNT_DATA).replace("\n", ""),
	"r8-tests-" + uuid);
	String testsRootDir = convertToTargetPath(testsRootDirFile);

	String testScriptPathOnTarget = convertToTargetPath(
	new File(testsRootDirFile, TEST_SCRIPT_NAME));

	ClasspathPair destFilePaths = installTestFiles(device, testsRootDirFile,
	testScriptPathOnTarget);

	File rootDir = new File(device.getMountPoint(IDevice.MNT_ROOT).replace("\n", ""));

	// Bug : exit code return by adb shell is wrong (always 0)
	// https://code.google.com/p/android/issues/detail?id=3254
	// Use go team hack to work this around
	// https://code.google.com/p/go/source/browse/misc/arm/a
	executeShellCommand(testScriptPathOnTarget + ' ' + uuid + ' ' + Joiner.on(' ').join(
	buildCommandLine(rootDir, testsRootDir, destFilePaths.bootclasspath,
	destFilePaths.classpath)), device, new ShellOutputReceiver(outRedirectStream),
	/* maxTimeToOutputResponse = */10000);
	exitStatus = getExitStatus(device, testsRootDir);
	log("Exit status: " + exitStatus);

	if (exitStatus != 0) {
	System.err.println("Execution failed on device '" + device.getName() + "'");
	}

	} catch (IOException t) {
	System.err.println("Error with device '" + device.getName() + "': " + t.getMessage());
	t.printStackTrace();
	throw t;
	} finally {
	deleteTestFiles(device, uuid);
	}

	// Convert target line separator to whatever host is for output comparison-based tests
	String outputAsString = outRedirectStream.toString()
	.replace("\n", ToolHelper.LINE_SEPARATOR);

	return new ToolHelper.ProcessResult(exitStatus, outputAsString, "");
	}

	private AndroidDebugBridge initializeAdb() throws DeviceRunnerConfigurationException {
	AndroidDebugBridge adb = AndroidDebugBridge.createBridge(getAdbLocation(), false);

	long start = System.currentTimeMillis();

	log("Initializing adb...");

	while (!isAdbInitialized(adb)) {
	long timeLeft = start + ADB_CONNECTION_TIMEOUT - System.currentTimeMillis();
	if (timeLeft <= 0) {
	break;
	}
	try {
	Thread.sleep(ADB_WAIT_STEP);
	} catch (InterruptedException e) {
	Thread.currentThread().interrupt();
	throw new AssertionError(e);
	}
	}

	if (!isAdbInitialized(adb)) {
	String userDefinedPathToSdk = System.getProperty("ANDROID_SDK_HOME");
	if (userDefinedPathToSdk != null) {
	throw new DeviceRunnerConfigurationException(
	"Adb not found. Check SDK location '"
	+ userDefinedPathToSdk
	+ "'");
	} else {
	throw new DeviceRunnerConfigurationException(
	"Adb not found. Set either PATH or ANDROID_SDK_HOME environment variable");
	}
	}

	log("Done");
	return adb;
	}

	private static class ClasspathPair {
	public String[] bootclasspath;
	public String[] classpath;

	ClasspathPair(String[] bootclasspath, String[] classpath) {
	this.bootclasspath = bootclasspath;
	this.classpath = classpath;
	}
	}

	/**
	* @return path of classpath and bootclasspath files on device
	*/
	private ClasspathPair installTestFiles(IDevice device, File testsRootDirFile,
	String testScriptPathOnTarget) throws IOException {

	String testsRootDir = convertToTargetPath(testsRootDirFile);

	String[] desFilePaths = new String[classpath.size()];
	String[] destFileBootCpPaths = new String[bootClasspath.size()];

	executeShellCommand("mkdir " + testsRootDir, device);
	executeShellCommand(
	"rm " + testsRootDir + FileListingService.FILE_SEPARATOR + "*", device);
	executePushCommand(TEST_SCRIPT_FILE.getAbsolutePath(), testScriptPathOnTarget, device);
	executeShellCommand("chmod 777 " + testScriptPathOnTarget, device);

	int i = 0;
	for (File f : bootClasspath) {
	destFileBootCpPaths[i] = convertToTargetPath(
	new File(testsRootDirFile, "f" + i + "_" + f.getName()));
	executePushCommand(f.getAbsolutePath(), destFileBootCpPaths[i], device);
	i++;
	}
	i = 0;
	for (File f : classpath) {
	desFilePaths[i] = convertToTargetPath(
	new File(testsRootDirFile, "f" + i + "_" + f.getName()));
	executePushCommand(f.getAbsolutePath(), desFilePaths[i], device);
	i++;
	}
	return new ClasspathPair(destFileBootCpPaths, desFilePaths);
	}

	private int getExitStatus(IDevice device, String testsRootDir) throws IOException {
	File exitStatusFile = createTempFile("exitStatus", "");
	executePullCommand(
	testsRootDir + "/exitStatus", exitStatusFile.getAbsolutePath(), device);

	try (BufferedReader br = new BufferedReader(new FileReader(exitStatusFile))) {
	String readLine = br.readLine();
	if (readLine == null) {
	throw new FileNotFoundException("Exit status not found at " + exitStatusFile.getPath());
	}
	return Integer.parseInt(readLine);
	}
	}

	@SuppressWarnings("deprecation")
	private void executeShellCommand(
	String command,
	IDevice device,
	ShellOutputReceiver hostOutput,
	int maxTimeToOutputResponse) throws IOException {
	log("adb -s " + device.getSerialNumber() + " shell " + command);
	try {
	if (maxTimeToOutputResponse != -1) {
	device.executeShellCommand(command, hostOutput, maxTimeToOutputResponse);
	} else {
	device.executeShellCommand(command, hostOutput);
	}
	} catch (IOException
	\| ShellCommandUnresponsiveException
	\| TimeoutException
	\| AdbCommandRejectedException e) {
	throw new IOException(
	"Failed to execute shell command: '" + command + "'", e);
	}
	}

	private void executeShellCommand(String command, IDevice device)
	throws IOException {
	executeShellCommand(command, device, hostOutput, -1);
	}

	private void executePushCommand(
	String srcFile, String destFile, IDevice device) throws IOException {
	log("adb -s " + device.getSerialNumber() + " push " + srcFile + " " + destFile);
	try {
	device.pushFile(srcFile, destFile);
	} catch (IOException \| AdbCommandRejectedException \| TimeoutException \| SyncException e) {
	throw new IOException(
	"Unable to push file '" + srcFile + "' on device into '" + destFile + "'", e);
	}
	}

	private void executePullCommand(
	String srcFile, String destFile, IDevice device) throws IOException {
	log("adb -s " + device.getSerialNumber() + " pull " + srcFile + " " + destFile);
	try {
	device.pullFile(srcFile, destFile);
	} catch (IOException \| AdbCommandRejectedException \| TimeoutException \| SyncException e) {
	throw new IOException(
	"Unable to pull file '" + srcFile + "' from device into '" + destFile + "'", e);
	}
	}

	private boolean isAdbInitialized(AndroidDebugBridge adb) {
	return adb.isConnected() && adb.hasInitialDeviceList();
	}

	private String getAdbLocation() {
	String adbLocation = "adb";
	String userSpecifiedSdkLocation = System.getenv("ANDROID_SDK_HOME");
	if (userSpecifiedSdkLocation != null) {
	adbLocation =
	userSpecifiedSdkLocation
	+ File.separatorChar
	+ "platform-tools"
	+ File.separatorChar
	+ "adb";
	}
	return adbLocation;
	}


	private void ensureAdbRoot(IDevice device) throws IOException {
	boolean isRoot;
	try {
	isRoot = device.isRoot();
	} catch (TimeoutException
	\| AdbCommandRejectedException
	\| IOException
	\| ShellCommandUnresponsiveException e) {
	throw new IOException(
	"Cannot fetch root status for device '"
	+ device.getName()
	+ "("
	+ device.getSerialNumber()
	+ ")"
	+ "': "
	+ e.getMessage(),
	e);
	}

	int numberOfTries = 0;
	while (!isRoot && numberOfTries < 5) {
	try {
	isRoot = device.root();
	} catch (TimeoutException
	\| AdbCommandRejectedException
	\| IOException
	\| ShellCommandUnresponsiveException e1) {
	// root() seems to throw an IOException: EOF, and it tends
	// to make the subsequent call to isRoot() fail with
	// AdbCommandRejectedException: device offline, until adbd is
	// restarted as root.
	} finally {
	try {
	Thread.sleep(1000);
	} catch (InterruptedException e1) {
	Thread.currentThread().interrupt();
	}
	}
	numberOfTries++;
	}

	if (!isRoot) {
	throw new IOException(
	"Cannot switch to root on device '"
	+ device.getName()
	+ "("
	+ device.getSerialNumber()
	+ ")"
	+ "'");
	}
	}

	private void checkDeviceRuntime(IDevice device)
	throws DeviceRunnerConfigurationException, IOException {
	ShellOutputToStringReceiver outputToString = new ShellOutputToStringReceiver();
	try {
	device.executeShellCommand("dalvikvm -showversion", outputToString);
	if (!outputToString.getOutput().contains(RUNTIME_NAME)) {
	throw new DeviceRunnerConfigurationException(
	"The plugged device does not run the required runtime: '" + RUNTIME_NAME + "'");
	}
	} catch (TimeoutException
	\| AdbCommandRejectedException
	\| ShellCommandUnresponsiveException
	\| IOException e) {
	throw new IOException("Could not check device runtime", e);
	}
	}

	private String convertToTargetPath(File file) {
	String path = file.getPath();
	Path root = file.toPath().getRoot();
	if (root != null) {
	path = path.replace(root.toString(), FileListingService.FILE_SEPARATOR);
	}
	return path.replace(File.separator, FileListingService.FILE_SEPARATOR);
	}

	private static File createTempFile(String prefix, String suffix) throws IOException {
	File tmp = File.createTempFile("r8-tests-" + prefix, suffix);
	tmp.deleteOnExit();
	return tmp;
	}

	private void deleteTestFiles(IDevice device, String uuid) throws IOException {
	String deleteCommand = "find data -name 'r8-tests-" + uuid + "' -exec rm -rf {} +";
	log("adb -s " + device.getSerialNumber() + " shell " + deleteCommand);
	try {
	device.executeShellCommand(deleteCommand, hostOutput);
	} catch (TimeoutException
	\| AdbCommandRejectedException
	\| ShellCommandUnresponsiveException
	\| IOException e) {
	throw new IOException("Error while deleting test file on device", e);
	}
	}

	private List<String> buildCommandLine(File rootDir, String testRootDir,
	String[] bootClasspathFiles, String[] classpathFiles) {
	List<String> result = new ArrayList<>();

	result.add(convertToTargetPath(new File(rootDir, "/bin/dalvikvm")));

	for (String option : vmOptions) {
	result.add(option);
	}
	for (Map.Entry<String, String> entry : systemProperties.entrySet()) {
	StringBuilder builder = new StringBuilder("-D");
	builder.append(entry.getKey());
	builder.append("=");
	builder.append(entry.getValue());
	result.add(builder.toString());
	}

	if (classpathFiles.length > 0) {
	result.add("-cp");
	result.add(Joiner.on(PATH_SEPARATOR_CHAR).join(
	Arrays.asList(classpathFiles).stream()
	.map(filePath -> convertToTargetPath(new File(filePath)))
	.collect(Collectors.toList())));
	}
	if (bootClasspathFiles.length > 0) {
	result.add("-Xbootclasspath:" + Joiner.on(PATH_SEPARATOR_CHAR).join(
	Arrays.asList(bootClasspathFiles).stream()
	.map(filePath -> convertToTargetPath(new File(filePath)))
	.collect(Collectors.toList())));
	}

	if (mainClass != null) {
	result.add(mainClass);
	}
	for (String argument : programArguments) {
	result.add(argument);
	}
	return result;
	}

	private void log(String message) {
	if (VERBOSE) {
	System.out.println(message);
	}
	}
	}