Makes the code simpler by automatically deducing the root directory to use.

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
@@ skipping 101 matching lines @@
         v[u'timestamp'] = int(round(filestats.st_mtime))
 
     if self.LEVEL >= isolate.WITH_HASH:
       for filename in files:
         # Calculate our hash.
         h = hashlib.sha1()
         h.update(open(os.path.join(root_dir, filename), 'rb').read())
         files[filename][u'sha-1'] = unicode(h.hexdigest())
     return files
 
-  def _expected_result(self, args, read_only):
+  def _expected_result(self, args, read_only, extra_vars=None):
     """Verifies self.result contains the expected data."""
+    flavor = isolate.trace_inputs.get_flavor()
     expected = {
       u'files': self._gen_files(read_only),
+      u'read_only': read_only,
       u'relative_cwd': unicode(RELATIVE_CWD[self.case()]),
-      u'read_only': read_only,
+      u'resultdir': os.path.dirname(self.result),
+      u'resultfile': self.result,
+      u'variables': {
+        u'EXECUTABLE_SUFFIX': '.exe' if flavor == 'win' else '',
+        u'OS': unicode(flavor),
+      },
     }
+    expected['variables'].update(extra_vars or {})
     if args:
       expected[u'command'] = [u'python'] + [unicode(x) for x in args]
     else:
       expected[u'command'] = []
 
     self.assertEquals(expected, json.load(open(self.result, 'rb')))
     return expected
 
   def _expect_no_result(self):
     self.assertFalse(os.path.exists(self.result))
@@ skipping 97 matching lines @@
 class Isolate_check(IsolateBase):
   LEVEL = isolate.NO_INFO
 
   def test_fail(self):
     self._execute('check', 'fail.isolate', [], False)
     self._expect_no_tree()
     self._expected_result(['fail.py'], None)
 
   def test_missing_trailing_slash(self):
     try:
       self._execute('check', 'missing_trailing_slash.isolate', [], False)

[nsylvain, 2012/04/16 15:51:43]

thanks!

       self.fail()
     except subprocess.CalledProcessError:
       pass
     self._expect_no_tree()
     self._expect_no_result()
 
   def test_non_existent(self):
     try:
       self._execute('check', 'non_existent.isolate', [], False)
       self.fail()
     except subprocess.CalledProcessError:
       pass
     self._expect_no_tree()
     self._expect_no_result()
 
   def test_no_run(self):
     self._execute('check', 'no_run.isolate', [], False)
     self._expect_no_tree()
     self._expected_result([], None)
 
   def test_touch_root(self):
     self._execute('check', 'touch_root.isolate', [], False)
     self._expect_no_tree()
     self._expected_result(['touch_root.py'], None)
 
   def test_with_flag(self):
     self._execute('check', 'with_flag.isolate', ['-V', 'FLAG=gyp'], False)
     self._expect_no_tree()
-    self._expected_result(['with_flag.py', 'gyp'], None)
+    self._expected_result(['with_flag.py', 'gyp'], None, {u'FLAG': u'gyp'})
 
 
 class Isolate_hashtable(IsolateBase):
   LEVEL = isolate.WITH_HASH
 
   def _expected_hash_tree(self):
     """Verifies the files written in the temporary directory."""
     expected = [v['sha-1'] for v in self._gen_files(False).itervalues()]
     self.assertEquals(sorted(expected), self._result_tree())
 
@@ skipping 26 matching lines @@
     self._expected_result([], None)
 
   def test_touch_root(self):
     self._execute('hashtable', 'touch_root.isolate', [], False)
     self._expected_hash_tree()
     self._expected_result(['touch_root.py'], None)
 
   def test_with_flag(self):
     self._execute('hashtable', 'with_flag.isolate', ['-V', 'FLAG=gyp'], False)
     self._expected_hash_tree()
-    self._expected_result(['with_flag.py', 'gyp'], None)
+    self._expected_result(['with_flag.py', 'gyp'], None, {u'FLAG': u'gyp'})
 
 
 class Isolate_remap(IsolateBase):
   LEVEL = isolate.STATS_ONLY
 
   def test_fail(self):
     self._execute('remap', 'fail.isolate', [], False)
     self._expected_tree()
     self._expected_result(['fail.py'], None)
 
@@ skipping 21 matching lines @@
     self._expected_result([], None)
 
   def test_touch_root(self):
     self._execute('remap', 'touch_root.isolate', [], False)
     self._expected_tree()
     self._expected_result(['touch_root.py'], None)
 
   def test_with_flag(self):
     self._execute('remap', 'with_flag.isolate', ['-V', 'FLAG=gyp'], False)
     self._expected_tree()
-    self._expected_result(['with_flag.py', 'gyp'], None)
+    self._expected_result(['with_flag.py', 'gyp'], None, {u'FLAG': u'gyp'})
 
 
 class Isolate_run(IsolateBase):
   LEVEL = isolate.STATS_ONLY
 
   def _expect_empty_tree(self):
     self.assertEquals([], self._result_tree())
 
   def test_fail(self):
     try:
@@ skipping 33 matching lines @@
 
   def test_touch_root(self):
     self._execute('run', 'touch_root.isolate', [], False)
     self._expect_empty_tree()
     self._expected_result(['touch_root.py'], None)
 
   def test_with_flag(self):
     self._execute('run', 'with_flag.isolate', ['-V', 'FLAG=run'], False)
     # Not sure about the empty tree, should be deleted.
     self._expect_empty_tree()
-    self._expected_result(['with_flag.py', 'run'], None)
+    self._expected_result(['with_flag.py', 'run'], None, {u'FLAG': u'run'})
 
 
 class Isolate_trace(IsolateBase):
   LEVEL = isolate.STATS_ONLY
 
   @staticmethod
   def _to_string(values):
     buf = cStringIO.StringIO()
     isolate.trace_inputs.pretty_print(values, buf)
     return buf.getvalue()
@@ skipping 59 matching lines @@
           },
         }],
       ],
     }
     self.assertEquals(self._to_string(expected), out)
 
   def test_with_flag(self):
     out = self._execute(
         'trace', 'with_flag.isolate', ['-V', 'FLAG=trace'], True)
     self._expect_no_tree()
-    self._expected_result(['with_flag.py', 'trace'], None)
+    self._expected_result(['with_flag.py', 'trace'], None, {u'FLAG': u'trace'})
     expected = {
       'conditions': [
         ['OS=="%s"' % isolate.trace_inputs.get_flavor(), {
           'variables': {
             isolate.trace_inputs.KEY_TRACKED: [
               'with_flag.py',
             ],
             isolate.trace_inputs.KEY_UNTRACKED: [
               'files1/',
             ],
           },
         }],
       ],
     }
     self.assertEquals(self._to_string(expected), out)
 
 
 
 if __name__ == '__main__':
   VERBOSE = '-v' in sys.argv
   logging.basicConfig(level=logging.DEBUG if VERBOSE else logging.ERROR)
   unittest.main()