[Android] Reduce test logging verbosity.

build/android/pylib/base/shard.py

 # Copyright (c) 2013 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.
 
 """Implements test sharding logic."""
 
 import logging
 import threading
 
 from pylib import android_commands
@@ skipping 125 matching lines @@
         msg = 'Device %s is unresponsive.' % runner.device
         logging.warning(msg)
         raise android_commands.errors.DeviceUnresponsiveError(msg)
       result, retry = runner.RunTest(test.test)
       test.tries += 1
       if retry and test.tries <= 3:
         # Retry non-passing results, only record passing results.
         pass_results = base_test_result.TestRunResults()
         pass_results.AddResults(result.GetPass())
         out_results.append(pass_results)
-        logging.warning('****Will retry test, try #%s.' % test.tries)
+        logging.warning('Will retry test, try #%s.' % test.tries)
         test_collection.add(_Test(test=retry, tries=test.tries))
       else:
         # All tests passed or retry limit reached. Either way, record results.
         out_results.append(result)
     except android_commands.errors.DeviceUnresponsiveError:
       # Device is unresponsive, stop handling tests on this device and ensure
       # current test gets runs by another device. Don't reraise this exception
       # on the main thread.
       test_collection.add(test)
       return
@@ skipping 15 matching lines @@
 
   Args:
     runner_factory: callable that takes a device and index and returns a
       TestRunner object.
     device: the device serial number to set up.
     out_runners: list to add the successfully set up TestRunner object.
     threadsafe_counter: a _ThreadSafeCounter object used to get shard indices.
   """
   try:
     index = threadsafe_counter.GetAndIncrement()
-    logging.warning('*****Creating shard %s for device %s.', index, device)
+    logging.warning('Creating shard %s for device %s.', index, device)
     runner = runner_factory(device, index)
     runner.SetUp()
     out_runners.append(runner)
   except android_commands.errors.DeviceUnresponsiveError as e:
-    logging.warning('****Failed to create shard for %s: [%s]', device, e)
+    logging.warning('Failed to create shard for %s: [%s]', device, e)
 
 
 def _RunAllTests(runners, tests, timeout=None):
   """Run all tests using the given TestRunners.
 
   Args:
     runners: a list of TestRunner objects.
     tests: a list of Tests to run using the given TestRunners.
     timeout: watchdog timeout in seconds, defaults to the default timeout.
 
   Returns:
     A TestRunResults object.
   """
-  logging.warning('****Running %s tests with %s test runners.' %
+  logging.warning('Running %s tests with %s test runners.' %
                   (len(tests), len(runners)))
   tests_collection = _TestCollection([_Test(t) for t in tests])
   results = []
   watcher = watchdog_timer.WatchdogTimer(timeout)
   workers = reraiser_thread.ReraiserThreadGroup(
       [reraiser_thread.ReraiserThread(_RunTestsFromQueue,
                                       [r, tests_collection, results, watcher],
                                       name=r.device[-4:])
        for r in runners])
   workers.StartAll()
@@ skipping 12 matching lines @@
 
   Args:
     runner_factory: callable that takes a device and index and returns a
       TestRunner object.
     devices: list of device serial numbers as strings.
     timeout: watchdog timeout in seconds, defaults to the default timeout.
 
   Returns:
     A list of TestRunner objects.
   """
-  logging.warning('****Creating %s test runners.' % len(devices))
+  logging.warning('Creating %s test runners.' % len(devices))
   runners = []
   counter = _ThreadSafeCounter()
   threads = reraiser_thread.ReraiserThreadGroup(
       [reraiser_thread.ReraiserThread(_SetUp,
                                       [runner_factory, d, runners, counter],
                                       name=d[-4:])
        for d in devices])
   threads.StartAll()
   threads.JoinAll(watchdog_timer.WatchdogTimer(timeout))
   return runners
@@ skipping 32 matching lines @@
     A base_test_result.TestRunResults object.
   """
   forwarder.Forwarder.KillHost(build_type)
   runners = _CreateRunners(runner_factory, devices, setup_timeout)
   try:
     return _RunAllTests(runners, tests, test_timeout)
   finally:
     try:
       _TearDownRunners(runners, setup_timeout)
     except android_commands.errors.DeviceUnresponsiveError as e:
-      logging.warning('****Device unresponsive during TearDown: [%s]', e)
+      logging.warning('Device unresponsive during TearDown: [%s]', e)
     finally:
       forwarder.Forwarder.KillHost(build_type)