create temp avd when running tests on multiple emulators

build/android/emulator.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Provides an interface to start and stop Android emulator.
 
 Assumes system environment ANDROID_NDK_ROOT has been set.
 
@@ skipping 95 matching lines @@
   # the time to launch the emulator and a wait-for-device command.
   _LAUNCH_TIMEOUT = 120
 
   # Timeout interval of wait-for-device command before bouncing to a a
   # process life check.
   _WAITFORDEVICE_TIMEOUT = 5
 
   # Time to wait for a "wait for boot complete" (property set on device).
   _WAITFORBOOT_TIMEOUT = 300
 
-  def __init__(self, fast_and_loose=False):
+  def __init__(self, new_avd_name, fast_and_loose):
     """Init an Emulator.
 
     Args:
+      nwe_avd_name: If set, will create a new temporary AVD.
       fast_and_loose: Loosen up the rules for reliable running for speed.
         Intended for quick testing or re-testing.
 
     """
     try:
       android_sdk_root = os.environ['ANDROID_SDK_ROOT']
     except KeyError:
       logging.critical('The ANDROID_SDK_ROOT must be set to run the test on '
                        'emulator.')
       raise
     self.emulator = os.path.join(android_sdk_root, 'tools', 'emulator')
+    self.android = os.path.join(android_sdk_root, 'tools', 'android')
     self.popen = None
     self.device = None
+    self.default_avd = True
     self.fast_and_loose = fast_and_loose
+    self.abi = 'armeabi-v7a'
+    self.avd = 'avd_armeabi'
+    if 'x86' in os.environ.get('TARGET_PRODUCT', ''):
+      self.abi = 'x86'
+      self.avd = 'avd_x86'
+    if new_avd_name:
+      self.default_avd = False
+      self.avd = self._CreateAVD(new_avd_name)
 
   def _DeviceName(self):
     """Return our device name."""
     port = _GetAvailablePort()
     return ('emulator-%d' % port, port)
 
+  def _CreateAVD(self, avd_name):
+    avd_command = [
+        self.android,
+        '--silent',
+        'create', 'avd',
+        '--name', avd_name,
+        '--abi', self.abi,
+        '--target', 'android-15',
+        '-c', '64M',
+        '--force',
+    ]
+    avd_process = subprocess.Popen(args=avd_command,
+                                   stdin=subprocess.PIPE,
+                                   stdout=subprocess.PIPE,
+                                   stderr=subprocess.STDOUT)
+    avd_process.stdin.write('no\n')
+    avd_process.wait()
+    logging.info('Create AVD command: %s', ' '.join(avd_command))
+    return self.avd
+
+  def _DeleteAVD(self):
+    avd_command = [
+        self.android,
+        '--silent',
+        'delete',
+        'avd',
+        '--name', self.avd,
+    ]
+    avd_process = subprocess.Popen(args=avd_command,
+                                   stdout=subprocess.PIPE,
+                                   stderr=subprocess.STDOUT)
+    logging.info('Delete AVD command: %s', ' '.join(avd_command))
+    avd_process.wait()
+
   def Launch(self, kill_all_emulators):
     """Launches the emulator asynchronously. Call ConfirmLaunch() to ensure the
     emulator is ready for use.
 
     If fails, an exception will be raised.
     """
     if kill_all_emulators:
       _KillAllEmulators()  # just to be sure
     if not self.fast_and_loose:
       self._AggressiveImageCleanup()
     (self.device, port) = self._DeviceName()
-    abi = 'armeabi'
-    if 'x86' in os.environ.get('TARGET_PRODUCT', ''):
-      abi = 'x86'
     emulator_command = [
         self.emulator,
         # Speed up emulator launch by 40%.  Really.
         '-no-boot-anim',
         # The default /data size is 64M.
         # That's not enough for 8 unit test bundles and their data.
         '-partition-size', '512',
         # Use a familiar name and port.
-        '-avd', 'avd_' + abi,
+        '-avd', self.avd,
         '-port', str(port)]
     if not self.fast_and_loose:
       emulator_command.extend([
           # Wipe the data.  We've seen cases where an emulator
           # gets 'stuck' if we don't do this (every thousand runs or
           # so).
           '-wipe-data',
           ])
     logging.info('Emulator launch command: %s', ' '.join(emulator_command))
     self.popen = subprocess.Popen(args=emulator_command,
@@ skipping 48 matching lines @@
       raise EmulatorLaunchException('TIMEOUT with wait-for-device')
     logging.info('Seconds waited on wait-for-device: %d', seconds_waited)
     if wait_for_boot:
       # Now that we checked for obvious problems, wait for a boot complete.
       # Waiting for the package manager is sometimes problematic.
       a = android_commands.AndroidCommands(self.device)
       a.WaitForSystemBootCompleted(self._WAITFORBOOT_TIMEOUT)
 
   def Shutdown(self):
     """Shuts down the process started by launch."""
+    if not self.default_avd:
+      self._DeleteAVD()
     if self.popen:
       self.popen.poll()
       if self.popen.returncode == None:
         self.popen.kill()
       self.popen = None
 
   def _ShutdownOnSignal(self, signum, frame):
     logging.critical('emulator _ShutdownOnSignal')
     for sig in self._SIGNALS:
       signal.signal(sig, signal.SIG_DFL)
     self.Shutdown()
     raise KeyboardInterrupt  # print a stack
 
   def _InstallKillHandler(self):
     """Install a handler to kill the emulator when we exit unexpectedly."""
     for sig in self._SIGNALS:
       signal.signal(sig, self._ShutdownOnSignal)
 
 def main(argv):
-  Emulator(True).Launch(True)
+  Emulator(None, True).Launch(True)
 
 
 if __name__ == '__main__':
   main(sys.argv)