Restore logging level after test is finished.

tools/telemetry/telemetry/unittest/run_tests.py

 # 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.
 import logging
 import unittest
 
 from telemetry.core import browser_options
 from telemetry.core import discover
 from telemetry.core import util
 from telemetry.unittest import gtest_testrunner
@@ skipping 64 matching lines @@
 
     return True
 
   filtered_suite = FilterSuite(suite, IsTestSelected)
   test_result = runner.run(filtered_suite)
   return test_result
 
 
 def Main(args, start_dir, top_level_dir, runner=None):
   """Unit test suite that collects all test cases for telemetry."""
+  # Cache the current logging level, this needs to be done before calling
+  # parser.parse_args, which changes logging level based on verbosity setting.
+  logging_level = logging.getLogger().getEffectiveLevel()
   # Add unittest_data to the path so we can import packages from it.
   util.AddDirToPythonPath(util.GetUnittestDataDir())
 
   default_options = browser_options.BrowserFinderOptions()
   default_options.browser_type = 'any'
 
   parser = default_options.CreateParser('run_tests [options] [test names]')
   parser.add_option('--repeat-count', dest='run_test_repeat_count',
                     type='int', default=1,
                     help='Repeats each a provided number of times.')
   parser.add_option('-d', '--also-run-disabled-tests',
                     dest='run_disabled_tests',
                     action='store_true', default=False,
                     help='Also run tests decorated with @DisabledTest.')
 
   _, args = parser.parse_args(args)
 
-  logging_level = logging.getLogger().getEffectiveLevel()
   if default_options.verbosity == 0:
     logging.getLogger().setLevel(logging.WARN)
 
   from telemetry.core import browser_finder
   try:
     browser_to_create = browser_finder.FindBrowser(default_options)
   except browser_finder.BrowserFinderException, ex:
     logging.error(str(ex))
     return 1
 
   if browser_to_create == None:
     logging.error('No browser found of type %s. Cannot run tests.',
                   default_options.browser_type)
     logging.error('Re-run with --browser=list to see available browser types.')
     return 1
 
   options_for_unittests.Set(default_options,
                             browser_to_create.browser_type)
   try:
     success = True
     for _ in range(
         default_options.run_test_repeat_count): # pylint: disable=E1101
       success = success and DiscoverAndRunTests(
         start_dir, args, top_level_dir,
         runner, default_options.run_disabled_tests)
     if success:
       return 0
   finally:
     options_for_unittests.Set(None, None)
-    if default_options.verbosity == 0:
-      # Restore logging level.
-      logging.getLogger().setLevel(logging_level)
+    # Restore logging level, which may be changed in parser.parse_args.
+    logging.getLogger().setLevel(logging_level)

[dtu, 2013/09/12 21:45:51]

Theoretically, you want this try/finally to go around everything, right? If an
error happens in this file before this try block, your logging level will still
be messed up. Maybe add a wrapper function to do this without changing the
indent level.

[dshi, 2013/09/13 20:28:34]

Done.

 
   return 1