Rename tree_creator.py to run_test_from_archive.py

tools/isolate/isolate_smoke_test.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.
 
 import cStringIO
 import hashlib
 import json
 import logging
 import os
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 import unittest
 
 ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
 VERBOSE = False
+FILENAME = os.path.basename(__file__)
 
 
 class CalledProcessError(subprocess.CalledProcessError):
   """Makes 2.6 version act like 2.7"""
   def __init__(self, returncode, cmd, output, cwd):
     super(CalledProcessError, self).__init__(returncode, cmd)
     self.output = output
     self.cwd = cwd
 
   def __str__(self):
     return super(CalledProcessError, self).__str__() + (
         '\n'
         'cwd=%s\n%s') % (self.cwd, self.output)
 
 
 class Isolate(unittest.TestCase):
   def setUp(self):
-    # The reason is that isolate_test.py --ok is run in a temporary directory
+    # The reason is that FILENAME --ok is run in a temporary directory
     # without access to isolate.py
     import isolate
     self.isolate = isolate
     self.tempdir = tempfile.mkdtemp()
     self.result = os.path.join(self.tempdir, 'result')
     if VERBOSE:
       print
 
   def tearDown(self):
     shutil.rmtree(self.tempdir)
@@ skipping 72 matching lines @@
     expected = ('check', 'hashtable', 'remap', 'run', 'trace')
     self.assertEquals(expected, modes)
     self.assertEquals(expected, modes)
     for mode in modes:
       self.assertTrue(hasattr(self, 'test_%s' % mode), mode)
     self._expected_tree([])
 
   def test_check(self):
     cmd = [
       '--mode', 'check',
-      'isolate_test.py',
+      FILENAME,
     ]
     self._execute(cmd)
     self._expected_tree(['result'])
     self._expected_result(
         False,
-        ['isolate_test.py'],
-        [os.path.join('.', 'isolate_test.py')],
+        [FILENAME],
+        [os.path.join('.', FILENAME)],
         False)
 
   def test_check_non_existant(self):
     cmd = [
       '--mode', 'check',
       'NonExistentFile',
     ]
     try:
       self._execute(cmd)
       self.fail()
@@ skipping 10 matching lines @@
     try:
       self._execute(cmd)
       self.fail()
     except subprocess.CalledProcessError:
       pass
     self._expected_tree([])
 
   def test_check_abs_path(self):
     cmd = [
       '--mode', 'check',
-      'isolate_test.py',
+      FILENAME,
       '--',
-      os.path.join(ROOT_DIR, 'isolate_test.py'),
+      os.path.join(ROOT_DIR, FILENAME),
     ]
     self._execute(cmd)
     self._expected_tree(['result'])
     self._expected_result(
-        False, ['isolate_test.py'], ['isolate_test.py'], False)
+        False, [FILENAME], [FILENAME], False)
 
   def test_hashtable(self):
     cmd = [
       '--mode', 'hashtable',
       '--outdir', self.tempdir,
-      'isolate_test.py',
+      FILENAME,
       os.path.join('data', 'isolate') + os.path.sep,
     ]
     self._execute(cmd)
     files = [
-      'isolate_test.py',
+      FILENAME,
       os.path.join('data', 'isolate', 'test_file1.txt'),
       os.path.join('data', 'isolate', 'test_file2.txt'),
     ]
     data = self._expected_result(
-        True, files, [os.path.join('.', 'isolate_test.py')], False)
+        True, files, [os.path.join('.', FILENAME)], False)
     self._expected_tree(
         [f['sha-1'] for f in data['files'].itervalues()] + ['result'])
 
   def test_remap(self):
     cmd = [
       '--mode', 'remap',
       '--outdir', self.tempdir,
-      'isolate_test.py',
+      FILENAME,
     ]
     self._execute(cmd)
-    self._expected_tree(['isolate_test.py', 'result'])
+    self._expected_tree([FILENAME, 'result'])
     self._expected_result(
         False,
-        ['isolate_test.py'],
-        [os.path.join('.', 'isolate_test.py')],
+        [FILENAME],
+        [os.path.join('.', FILENAME)],
         False)
 
   def test_run(self):
     cmd = [
       '--mode', 'run',
-      'isolate_test.py',
+      FILENAME,
       '--',
-      sys.executable, 'isolate_test.py', '--ok',
+      sys.executable, FILENAME, '--ok',
     ]
     self._execute(cmd)
     self._expected_tree(['result'])
     # cmd[0] is not generated from infiles[0] so it's not using a relative path.
     self._expected_result(
-        False, ['isolate_test.py'], ['isolate_test.py', '--ok'], False)
+        False, [FILENAME], [FILENAME, '--ok'], False)
 
   def test_run_fail(self):
     cmd = [
       '--mode', 'run',
-      'isolate_test.py',
+      FILENAME,
       '--',
-      sys.executable, 'isolate_test.py', '--fail',
+      sys.executable, FILENAME, '--fail',
     ]
     try:
       self._execute(cmd)
       self.fail()
     except subprocess.CalledProcessError:
       pass
     self._expected_tree([])
 
   def test_trace(self):
     cmd = [
       '--mode', 'trace',
-      'isolate_test.py',
+      FILENAME,
       '--',
-      sys.executable, os.path.join(ROOT_DIR, 'isolate_test.py'), '--ok',
+      sys.executable, os.path.join(ROOT_DIR, FILENAME), '--ok',
     ]
     out = self._execute(cmd, True)
     expected_tree = ['result', 'result.log']
     if sys.platform == 'win32':
       expected_tree.append('result.log.etl')
     self._expected_tree(expected_tree)
     # The 'result.log' log is OS-specific so we can't read it but we can read
     # the gyp result.
     # cmd[0] is not generated from infiles[0] so it's not using a relative path.
     self._expected_result(
-        False, ['isolate_test.py'], ['isolate_test.py', '--ok'], False)
+        False, [FILENAME], [FILENAME, '--ok'], False)
 
     expected_value = {
       'conditions': [
         ['OS=="%s"' % self.isolate.trace_inputs.get_flavor(), {
           'variables': {
             'isolate_files': [
-              '<(DEPTH)/isolate_test.py',
+              '<(DEPTH)/%s' % FILENAME,
             ],
           },
         }],
       ],
     }
     expected_buffer = cStringIO.StringIO()
     self.isolate.trace_inputs.pretty_print(expected_value, expected_buffer)
     self.assertEquals(expected_buffer.getvalue(), out)
 
 
 def main():
   global VERBOSE
   VERBOSE = '-v' in sys.argv
   level = logging.DEBUG if VERBOSE else logging.ERROR
   logging.basicConfig(level=level)
   if len(sys.argv) == 1:
     unittest.main()
   if sys.argv[1] == '--ok':
     return 0
   if sys.argv[1] == '--fail':
     return 1
 
   unittest.main()
 
 
 if __name__ == '__main__':
   sys.exit(main())