Add Results.Process.executable and command.

tools/isolate/trace_inputs_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 logging
 import os
 import unittest
 import sys
@@ skipping 76 matching lines @@
         "      'variables': {\n"
         "      },\n"
         "    }, {\n"
         "      'variables': {\n"
         "      },\n"
         "    }],\n"
         "  ],\n"
         "}\n")
     self._test(value, expected)
 
+  def test_process_quoted_arguments(self):
+    test_cases = (
+      ('"foo"', ['foo']),
+      ('"foo", "bar"', ['foo', 'bar']),
+      ('"foo"..., "bar"', ['foo', 'bar']),
+      ('"foo", "bar"...', ['foo', 'bar']),
+    )
+    for actual, expected in test_cases:
+      self.assertEquals(expected, trace_inputs.process_quoted_arguments(actual))
+
 
 def join_norm(*args):
   """Joins and normalizes path in a single step."""
   return unicode(os.path.normpath(os.path.join(*args)))
 
 
 if trace_inputs.get_flavor() == 'linux':
   class StraceInputs(unittest.TestCase):
     # Represents the root process pid (an arbitrary number).
     _ROOT_PID = 27
     _CHILD_PID = 14
     _GRAND_CHILD_PID = 70
 
     @staticmethod
     def _load_context(lines, initial_cwd):
       context = trace_inputs.Strace.Context(lambda _: False, initial_cwd)
       for line in lines:
         context.on_line(*line)
       return context.to_results().flatten()
 
     def _test_lines(self, lines, initial_cwd, files, command=None):
+      filepath = join_norm(initial_cwd, '../out/unittests')
       command = command or ['../out/unittests']
       expected = {
         'root': {
           'children': [],
-          'command': None,
-          'executable': None,
+          'command': command,
+          'executable': filepath,
           'files': files,
           'initial_cwd': initial_cwd,
           'pid': self._ROOT_PID,
         }
       }
       if not files:
         expected['root']['command'] = None
         expected['root']['executable'] = None
       self.assertEquals(expected, self._load_context(lines, initial_cwd))
 
@@ skipping 93 matching lines @@
         (self._ROOT_PID,
           'clone(child_stack=0, flags=CLONE_CHILD_CLEARTID'
             '|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f5350f829d0) = %d' %
             self._CHILD_PID),
         (self._CHILD_PID,
           'chdir("/home_foo_bar_user/path1") = 0'),
         (self._CHILD_PID,
           'clone(child_stack=0, flags=CLONE_CHILD_CLEARTID'
             '|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f5350f829d0) = %d' %
             self._GRAND_CHILD_PID),
+        (self._GRAND_CHILD_PID,
+          'execve("../out/unittests", '
+            '["../out/unittests"...], [/* 44 vars */])         = 0'),
         (self._ROOT_PID, 'chdir("/home_foo_bar_user/path2") = 0'),
         (self._GRAND_CHILD_PID,
           'open("random.txt", O_RDONLY)       = 76'),
       ]
       expected = {
         'root': {
           'children': [
             {
               'children': [
                 {
                   'children': [],
-                  'command': None,
-                  'executable': None,
+                  'command': ['../out/unittests'],
+                  'executable': '/home_foo_bar_user/out/unittests',
                   'files': [
                     {
+                      'path': u'/home_foo_bar_user/out/unittests',
+                      'size': -1,
+                    },
+                    {
                       'path': u'/home_foo_bar_user/path1/random.txt',
                       'size': -1,
                     },
                   ],
-                  'initial_cwd': '/home_foo_bar_user/path1',
+                  'initial_cwd': u'/home_foo_bar_user/path1',
                   'pid': self._GRAND_CHILD_PID,
                 },
               ],
+              # clone does not carry over the command and executable so it is
+              # clear if an execve() call was done or not.
               'command': None,
               'executable': None,
               # This is important, since no execve call was done, it didn't
               # touch the executable file.
               'files': [],
-              'initial_cwd': ROOT_DIR,
+              'initial_cwd': unicode(ROOT_DIR),
               'pid': self._CHILD_PID,
             },
           ],
-          'command': None,
-          'executable': None,
+          'command': ['../out/unittests'],
+          'executable': join_norm(ROOT_DIR, '../out/unittests'),
           'files': [
             {
               'path': join_norm(ROOT_DIR, '../out/unittests'),
               'size': -1,
             },
           ],
-          'initial_cwd': ROOT_DIR,
+          'initial_cwd': unicode(ROOT_DIR),
           'pid': self._ROOT_PID,
         },
       }
       self.assertEquals(expected, self._load_context(lines, ROOT_DIR))
 
     def test_open(self):
       lines = [
         (self._ROOT_PID,
           'execve("../out/unittests", '
             '["../out/unittests"...], [/* 44 vars */])         = 0'),
@@ skipping 54 matching lines @@
           'size': -1,
         },
       ]
       self._test_lines(lines, '/home/foo_bar_user/src', files)
 
 
 if __name__ == '__main__':
   VERBOSE = '-v' in sys.argv
   logging.basicConfig(level=logging.DEBUG if VERBOSE else logging.ERROR)
   unittest.main()