[Telemetry] Reorganize everything.

tools/telemetry/telemetry/core/extension_unittest.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 os
 import shutil
 import tempfile
 import unittest
 
-from telemetry import browser_finder
-from telemetry import extension_dict_backend
-from telemetry import extension_to_load
-from telemetry import options_for_unittests
+from telemetry.core import browser_finder
+from telemetry.core import extension_to_load
+from telemetry.core.chrome import extension_dict_backend
+from telemetry.test import options_for_unittests
 
 class ExtensionTest(unittest.TestCase):
   def setUp(self):
     extension_path = os.path.join(os.path.dirname(__file__),
-        '..', 'unittest_data', 'simple_extension')
+        '..', '..', 'unittest_data', 'simple_extension')
     load_extension = extension_to_load.ExtensionToLoad(extension_path)
 
     options = options_for_unittests.GetCopy()
     options.extensions_to_load = [load_extension]
     browser_to_create = browser_finder.FindBrowser(options)
 
     self._browser = None
     self._extension = None
     if not browser_to_create:
       # May not find a browser that supports extensions.
@@ skipping 19 matching lines @@
     EvaluateJavaScript should reconnect."""
     if not self._extension:
       return
     self._extension.Disconnect()
     self.assertEquals(2, self._extension.EvaluateJavaScript('1+1'))
 
 class NonExistentExtensionTest(unittest.TestCase):
   def testNonExistentExtensionPath(self):
     """Test that a non-existent extension path will raise an exception."""
     extension_path = os.path.join(os.path.dirname(__file__),
-        '..', 'unittest_data', 'foo')
+        '..', '..', 'unittest_data', 'foo')
     self.assertRaises(extension_to_load.ExtensionPathNonExistentException,
                       lambda: extension_to_load.ExtensionToLoad(extension_path))
 
   def testExtensionNotLoaded(self):
     """Querying an extension that was not loaded will return None"""
     extension_path = os.path.join(os.path.dirname(__file__),
-        '..', 'unittest_data', 'simple_extension')
+        '..', '..', 'unittest_data', 'simple_extension')
     load_extension = extension_to_load.ExtensionToLoad(extension_path)
     options = options_for_unittests.GetCopy()
     browser_to_create = browser_finder.FindBrowser(options)
     with browser_to_create.Create() as b:
       if b.supports_extensions:
         self.assertRaises(extension_dict_backend.ExtensionNotFoundException,
                           lambda: b.extensions[load_extension])
 
 class MultipleExtensionTest(unittest.TestCase):
   def setUp(self):
     """ Copy the manifest and background.js files of simple_extension to a
     number of temporary directories to load as extensions"""
     self._extension_dirs = [tempfile.mkdtemp()
                             for i in range(3)] # pylint: disable=W0612
     src_extension_dir = os.path.abspath(os.path.join(os.path.dirname(__file__),
-        '..', 'unittest_data', 'simple_extension'))
+        '..', '..', 'unittest_data', 'simple_extension'))
     manifest_path = os.path.join(src_extension_dir, 'manifest.json')
     script_path = os.path.join(src_extension_dir, 'background.js')
     for d in self._extension_dirs:
       shutil.copy(manifest_path, d)
       shutil.copy(script_path, d)
     self._extensions_to_load = [extension_to_load.ExtensionToLoad(d)
                                 for d in self._extension_dirs]
     options = options_for_unittests.GetCopy()
     options.extensions_to_load = self._extensions_to_load
     browser_to_create = browser_finder.FindBrowser(options)
@@ skipping 15 matching lines @@
     # Test contains.
     loaded_extensions = filter(lambda e: e in self._browser.extensions,
                                self._extensions_to_load)
     self.assertEqual(len(loaded_extensions), len(self._extensions_to_load))
 
     for load_extension in self._extensions_to_load:
       extension = self._browser.extensions[load_extension]
       assert extension
       extension.ExecuteJavaScript('setTestVar("abcdef")')
       self.assertEquals('abcdef', extension.EvaluateJavaScript('_testVar'))