Adding untrusted crash dump / stack trace tests.

SConstruct

 #! -*- python -*-
 # Copyright (c) 2012 The Native Client 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 atexit
 import glob
 import os
 import platform
 import shutil
@@ skipping 1118 matching lines @@
                     validator)
 
 
 # Perform os.path.abspath rooted at the directory SConstruct resides in.
 def SConstructAbsPath(env, path):
   return os.path.normpath(os.path.join(env['MAIN_DIR'], path))
 
 pre_base_env.AddMethod(SConstructAbsPath)
 
 
-def GetSelLdr(env):
+def GetSelLdr(env, with_exceptions=False):
   sel_ldr = ARGUMENTS.get('force_sel_ldr')
   if sel_ldr:
     return env.File(env.SConstructAbsPath(sel_ldr))
 
   # NOTE: that the variable TRUSTED_ENV is set by ExportSpecialFamilyVars()
   if 'TRUSTED_ENV' not in env:
     return None
 
   trusted_env = env['TRUSTED_ENV']
-  return trusted_env.File('${STAGING_DIR}/${PROGPREFIX}sel_ldr${PROGSUFFIX}')
+  # TODO(bradnelson): drop once exceptions are available by default.
+  if with_exceptions:
+    return trusted_env.File(
+        '${STAGING_DIR}/${PROGPREFIX}sel_ldr_exc${PROGSUFFIX}')
+  else:
+    return trusted_env.File('${STAGING_DIR}/${PROGPREFIX}sel_ldr${PROGSUFFIX}')
 
 def GetBootstrap(env):
   if 'TRUSTED_ENV' in env:
     trusted_env = env['TRUSTED_ENV']
     if trusted_env.Bit('linux'):
       return (trusted_env.File('${STAGING_DIR}/nacl_helper_bootstrap'),
               '--r_debug=0xXXXXXXXXXXXXXXXX')
   return None, None
 
 pre_base_env.AddMethod(GetBootstrap)
@@ skipping 283 matching lines @@
   # This is "built" by src/untrusted/pnacl_support_extension/nacl.scons.
   return env.Dir('${STAGING_DIR}/pnacl_all')
 
 pre_base_env.AddMethod(GetPnaclExtensionNode)
 
 
 # Compares output_file and golden_file.
 # If they are different, prints the difference and returns 1.
 # Otherwise, returns 0.
 def CheckGoldenFile(golden_file, output_file,
-                    filter_regex, filter_inverse, filter_group_only):
+                    filter_regex=None,
+                    filter_inverse=None, filter_group_only=None):
   golden = open(golden_file).read()
   actual = open(output_file).read()
   if filter_regex is not None:
     actual = test_lib.RegexpFilterLines(
         filter_regex,
         filter_inverse,
         filter_group_only,
         actual)
   if command_tester.DifferentFromGolden(actual, golden, output_file):
     return 1
   return 0
 
 
 # Returns action that compares output_file and golden_file.
 # This action can be attached to the node with
 # env.AddPostAction(target, action)
 def GoldenFileCheckAction(env, output_file, golden_file,
                           filter_regex=None, filter_inverse=False,
                           filter_group_only=False):
   def ActionFunc(target, source, env):
     return CheckGoldenFile(env.subst(golden_file), env.subst(output_file),
                            filter_regex, filter_inverse, filter_group_only)
 
   return env.Action(ActionFunc)
 
+pre_base_env.AddMethod(GoldenFileCheckAction)
+
+
+def UntrustedCrashDumpFilter(env, target, source, nexe=None, nmf=None):
+  cmd = ('${PYTHON} ' +

[Mark Seaborn, 2012/02/06 19:44:06]

Use AutoDepsCommand() instead of concatenating the string yourself, and then
dependencies will be handled properly.

[bradn, 2012/02/06 22:27:48]

This is an action not a command, so reusing AutoDepsCommand is non-trivial. (Its
an action so it can be inserted in front of the golden file check, which is also
an action).
I briefly messed with generalizing AutoDeps, only to realize that actions can't
really have dependencies like that anyway.

I've changed it to a list for readability.

I'm game to rearrange how AutoDeps + golden files work, but am a little unsure
the desired end state, and suspect that's out of scope for this change?

+      env.File(
+          '$MAIN_DIR/tests/untrusted_crash_dump/decode_dump.py').abspath +
+      ' ' + env.subst(source) +
+      ' ' + env.subst(target) +
+      ' --addr2line ${ADDR2LINE}'
+      ' --toolchain-libs ${NACL_SDK_LIB}')
+  if nexe:
+    cmd += ' --main-nexe ' + env.subst(nexe)
+  if nmf:
+    cmd += ' --nmf ' + env.subst(nmf)
+  return env.Action(cmd)
+
+pre_base_env.AddMethod(UntrustedCrashDumpFilter)
+
 
 def PPAPIBrowserTester(env,
                        target,
                        url,
                        files,
                        nmfs=None,
                        map_files=(),
                        extensions=(),
                        mime_types=(),
                        timeout=20,
                        log_verbosity=2,
                        args=(),
                        # list of key/value pairs that are passed to the test
                        test_args=(),
                        # list of "--flag=value" pairs (no spaces!)
                        browser_flags=(),
                        # redirect streams of NaCl program to files
                        nacl_exe_stdin=None,
                        nacl_exe_stdout=None,
                        nacl_exe_stderr=None,
                        python_tester_script=None,
+                       with_exceptions=False,
                        **extra):
   if 'TRUSTED_ENV' not in env:
     return []
 
   # No browser tests run on arm-thumb2
   # Bug http://code.google.com/p/nativeclient/issues/detail?id=2224
   if env.Bit('target_arm_thumb2'):
     return []
 
   # Lint the extra arguments that are being passed to the tester.
@@ skipping 16 matching lines @@
     python_tester_script = env.File('${SCONSTRUCT_DIR}/tools/browser_tester'
                              '/browser_tester.py')
   command = GetHeadlessPrefix(env) + [
       '${PYTHON}', python_tester_script,
       '--browser_path', env.ChromeBinary(),
       '--url', url,
       # Fail if there is no response for X seconds.
       '--timeout', str(timeout)]
   if not env.Bit('disable_dynamic_plugin_loading'):
     command.extend(['--ppapi_plugin', GetPPAPIPluginPath(env['TRUSTED_ENV'])])
-    command.extend(['--sel_ldr', GetSelLdr(env)])
+    command.extend(['--sel_ldr', GetSelLdr(env, with_exceptions)])
     bootstrap, _ = GetBootstrap(env)
     if bootstrap is not None:
       command.extend(['--sel_ldr_bootstrap', bootstrap])
   if env.Bit('irt') and (not env.Bit('disable_dynamic_plugin_loading') or
                          env.Bit('override_chrome_irt')):
     command.extend(['--irt_library', env.GetIrtNexe()])
   for dep_file in files:
     command.extend(['--file', dep_file])
   for extension in extensions:
     command.extend(['--extension', extension])
   if env.Bit('bitcode'):
     pnacl_extension = env.GetPnaclExtensionNode()
     command.extend(['--extension', pnacl_extension])
   for dest_path, dep_file in map_files:
     command.extend(['--map_file', dest_path, dep_file])
   for file_ext, mime_type in mime_types:
     command.extend(['--mime_type', file_ext, mime_type])
   command.extend(['--serving_dir', '${NACL_SDK_LIB}'])
   command.extend(['--serving_dir', '${LIB_DIR}'])
+  generated_manifests = []
   if not nmfs is None:
     for nmf_file in nmfs:
       generated_manifest = GeneratedManifestNode(env, nmf_file)
+      generated_manifests.append(generated_manifest)
       # We need to add generated manifests to the list of default targets.
       # The manifests should be generated even if the tests are not run -
       # the manifests may be needed for manual testing.
       for group in env['COMPONENT_TEST_PROGRAM_GROUPS']:
         env.Alias(group, generated_manifest)
       # Generated manifests are served in the root of the HTTP server
       command.extend(['--file', generated_manifest])
   if 'browser_test_tool' in ARGUMENTS:
     command.extend(['--tool', ARGUMENTS['browser_test_tool']])
 
@@ skipping 22 matching lines @@
       ('stdout', nacl_exe_stdout),
       ('stderr', nacl_exe_stderr)):
     if params is None:
       continue
     stream_file = env.subst(params['file'])
     command.extend(['--nacl_exe_' + stream, stream_file])
     golden_file = env.subst(params['golden'])
     filter_regex = params.get('filter_regex', None)
     filter_inverse = params.get('filter_inverse', False)
     filter_group_only = params.get('filter_group_only', False)
+    decode_crash_dump = params.get('decode_crash_dump', False)
+    if decode_crash_dump:
+      if generated_manifests:
+        nmf_path = generated_manifests[0].abspath
+      else:
+        nmf_path = None
+      decoded = stream_file + '.decoded'
+      post_actions.append(
+          env.UntrustedCrashDumpFilter(
+              decoded, stream_file, nexe=files[0].abspath, nmf=nmf_path))
+      stream_file = decoded
     post_actions.append(
-        GoldenFileCheckAction(
-            env, stream_file, golden_file,
+        env.GoldenFileCheckAction(
+            stream_file, golden_file,
             filter_regex, filter_inverse, filter_group_only))
 
   if ShouldUseVerboseOptions(extra):
     env.MakeVerboseExtraOptions(target, log_verbosity, extra)
   # Heuristic for when to capture output...
   capture_output = (extra.pop('capture_output', False)
                     or 'process_output_single' in extra)
   node = env.CommandTest(target,
                          command,
                          # Set to 'huge' so that the browser tester's timeout
@@ skipping 1585 matching lines @@
     'tests/sysbasic/nacl.scons',
     'tests/syscall_return_sandboxing/nacl.scons',
     'tests/syscalls/nacl.scons',
     'tests/threads/nacl.scons',
     'tests/time/nacl.scons',
     'tests/tls/nacl.scons',
     'tests/tls_perf/nacl.scons',
     'tests/toolchain/nacl.scons',
     'tests/unittests/shared/platform/nacl.scons',
     'tests/untrusted_check/nacl.scons',
+    'tests/untrusted_crash_dump/nacl.scons',
     #### ALPHABETICALLY SORTED ####
     ]
 
 # These are tests that are not worthwhile to run in an IRT variant.
 # In some cases, that's because they are browser tests which always
 # use the IRT.  In others, it's because they are special-case tests
 # that are incompatible with having an IRT loaded.
 nonvariant_tests = [
     #### ALPHABETICALLY SORTED ####
     'tests/barebones/nacl.scons',
     'tests/chrome_extension/nacl.scons',
     'tests/exit_status/nacl.scons',
     'tests/imc_shm_mmap/nacl.scons',
     'tests/imc_sockets/nacl.scons',
     'tests/inbrowser_crash_test/nacl.scons',
+    'tests/inbrowser_untrusted_crash_dump_test/nacl.scons',
     'tests/inbrowser_test_runner/nacl.scons',
     'tests/mach_crash_filter/nacl.scons',
     'tests/minnacl/nacl.scons',
     'tests/multiple_sandboxes/nacl.scons',
     'tests/nacl.scons',
     'tests/ppapi/nacl.scons',
     'tests/ppapi_browser/bad/nacl.scons',
     'tests/ppapi_browser/crash/nacl.scons',
     'tests/ppapi_browser/extension_mime_handler/nacl.scons',
     'tests/ppapi_browser/manifest/nacl.scons',
@@ skipping 512 matching lines @@
   nacl_env.ValidateSdk()
 
 if BROKEN_TEST_COUNT > 0:
   msg = "There are %d broken tests." % BROKEN_TEST_COUNT
   if GetOption('brief_comstr'):
     msg += " Add --verbose to the command line for more information."
   print msg
 
 # separate warnings from actual build output
 Banner('B U I L D - O U T P U T:')