Remove canned hello_world binary

src/trusted/service_runtime/build.scons

 # -*- 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 platform
 import os
 
 Import('env')
 
@@ skipping 536 matching lines @@
   env.AddNodeToTestSuite(node, ['small_tests'], 'run_format_string_test')
 
 
 if env.Bit('target_x86_32'):
   arch_testdata_dir = 'testdata/x86_32'
 elif env.Bit('target_x86_64'):
   arch_testdata_dir = 'testdata/x86_64'
 else:
   arch_testdata_dir = 'testdata/' + env['TARGET_ARCHITECTURE']
 
+untrusted_env = env.MakeUntrustedNativeEnv()
+hello_world_nexe = untrusted_env.File('$STAGING_DIR/hello_world.nexe')
 
 # Doesn't work on windows under coverage.
 # TODO(bradnelson): fix this to work on windows under coverage.
-if not env.Bit('windows') or not env.Bit('coverage_enabled'):
+if ((not env.Bit('windows') or not env.Bit('coverage_enabled')) and
+    env.Bit('nacl_static_link')):
   # NOTE: uses validator
   mmap_test_objs = [env.ComponentObject('mmap_test.c')]
   mmap_test_exe = env.ComponentProgram(
       'mmap_test',
       mmap_test_objs,
       EXTRA_LIBS=['sel',
                   'env_cleanser',
                   'manifest_proxy',
                   'simple_service',
                   'thread_interface',
                   'gio_wrapped_desc',
                   'nonnacl_srpc',
                   'nrd_xfer',
                   'nacl_perf_counter',
                   'nacl_base',
                   'imc',
                   'nacl_fault_inject',
                   'nacl_interval',
                   'platform',
                   'sel_test',
                   ])
 
-  mmap_test_file = env.File(arch_testdata_dir + '/hello_world.nexe')
-  mmap_test_command = env.AddBootstrap(mmap_test_exe, [mmap_test_file])
+  mmap_test_command = env.AddBootstrap(mmap_test_exe, [hello_world_nexe])
 
   # TODO(robertm): This test emits lots of messages to stderr
   node = env.CommandTest (
       "mmap_test.out",
       command=mmap_test_command,
       # TODO(mseaborn): Extend this test to cover the case where the
       # dynamic code segment is present.
       osenv='NACL_DISABLE_DYNAMIC_LOADING=1')
   env.AddNodeToTestSuite(node, ['medium_tests'], 'run_trusted_mmap_test')
 
@@ skipping 198 matching lines @@
 
 # Test that sel_ldr does not crash if the executable file cannot be opened.
 node = env.CommandSelLdrTestNacl(
     'sel_ldr_exe_not_found.out',
     'name_of_file_that_does_not_exist.nexe',
     exit_status='1')
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_sel_ldr_exe_not_found_test')
 
 # Check that "-F" makes sel_ldr stop after loading the nexe but before running
 # it.
-if not env.Bit('bitcode') or env.Bit('target_mips32'):
-  untrusted_env = env.MakeUntrustedNativeEnv()
-  nullptr_src = env.File('${MAIN_DIR}/tests/nullptr/nullptr.c')
-  nullptr_obj = untrusted_env.ComponentObject('nullptr', nullptr_src)
-  nullptr_nexe = untrusted_env.ComponentProgram('nullptr', nullptr_obj)
+nullptr_nexe = untrusted_env.GetTranslatedNexe(
+    untrusted_env.File('$STAGING_DIR/nullptr$PROGSUFFIX'))
 
-  node = env.CommandSelLdrTestNacl(
-      'fuzz_nullptr_test.out',
-      nullptr_nexe,
-      sel_ldr_flags=['-F'])
-  env.AddNodeToTestSuite(node, ['small_tests'], 'run_fuzz_nullptr_test')
+node = env.CommandSelLdrTestNacl(
+    'fuzz_nullptr_test.out',
+    nullptr_nexe,
+    sel_ldr_flags=['-F'])
+env.AddNodeToTestSuite(node, ['small_tests'], 'run_fuzz_nullptr_test')
 
-# ----------------------------------------------------------
-# Small tests with canned binaries
-# ----------------------------------------------------------
-
-if env.Bit('target_x86_64'):
-  node = env.CommandSelLdrTestNacl(
-      'hello_x32.out',
-      env.File(os.path.join(arch_testdata_dir, 'hello_x32.nexe')),
-      stdout_golden=env.File(os.path.join('${MAIN_DIR}',
-                                          'tests/hello_world',
-                                          'hello_world.stdout'))
-      )
-  env.AddNodeToTestSuite(node, ['small_tests'], 'run_hello_x32_test')
-
-# Test canned hello_world binary with obsolete, non-ragel based validator.
-if not env.Bit('validator_ragel') and env.Bit('target_x86'):
+# Test hello_world binary with obsolete, non-ragel based validator.
+if (not env.Bit('validator_ragel') and env.Bit('target_x86')
+    and env.Bit('nacl_static_link')):
   node = env.CommandSelLdrTestNacl(
       'dfa_hwd.out',
-      env.File(arch_testdata_dir + '/hello_world.nexe'),
+      hello_world_nexe,
       stdout_golden = env.File('testdata/hello_world.stdout'),
       stderr_golden = env.File('testdata/non_dfa_validator_hello.stderr'),
       filter_regex = '"^(Hello, World!)$' + '|' +
         '^[[][^]]*[]] (USING OBSOLETE NON-DFA-BASED VALIDATOR!)$"',
       filter_group_only = 'true',
       )
   env.AddNodeToTestSuite(node, ['medium_tests', 'validator_tests'],
                          'run_dfa_validator_hello_world_test')
 
 if env.Bit('target_mips32'):
   text_region_start = 0x00020000
   # Use arbitrary non-page-aligned addresses for data and rodata.
   rodata_region_start = 0x10020094
   data_region_start = 0x10030098
-  untrusted_env = env.MakeUntrustedNativeEnv()
   untrusted_env.Append(CPPFLAGS=['--pnacl-allow-native', '-arch', 'mips32'])
   unaligned_data_objs = untrusted_env.ComponentObject(
       'arch/mips/unaligned_data_test.S')
   unaligned_data_nexe = untrusted_env.ComponentProgram(
       'unaligned_data.nexe',
       unaligned_data_objs,
       LINKFLAGS=['-nostdlib',
                  '--pnacl-allow-native', '-arch', 'mips32',
                  '-Wn,--section-start=.text=0x%x' % (text_region_start),
                  '-Wn,--section-start=.rodata=0x%x' % (rodata_region_start),
@@ skipping 21 matching lines @@
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_unaligned_data_test')
 
 node = env.CommandSelLdrTestNacl(
     'unaligned_data_irt.out',
     unaligned_data_nexe,
     sel_ldr_flags=['-B', unaligned_data_irt_nexe]
     )
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_unaligned_data_irt_test')
 
 # ----------------------------------------------------------
+# Small tests with canned binaries
+# ----------------------------------------------------------
+
+if env.Bit('target_x86_64'):
+  node = env.CommandSelLdrTestNacl(
+      'hello_x32.out',
+      env.File(os.path.join(arch_testdata_dir, 'hello_x32.nexe')),
+      stdout_golden=env.File(os.path.join('${MAIN_DIR}',
+                                          'tests/hello_world',
+                                          'hello_world.stdout'))
+      )
+  env.AddNodeToTestSuite(node, ['small_tests'], 'run_hello_x32_test')
+
+# ----------------------------------------------------------
 # Integration Tests With Canned x86 Binaries
 # ----------------------------------------------------------
 # To update the canned tests run:
 # ./scons platform=x86-64
 # cp scons-out/nacl-x86-64/staging/{mandel.nexe,fib_*} \
 #     src/trusted/service_runtime/testdata/x86_64/
 # ./scons platform=x86-32
 # cp scons-out/nacl-x86-32/staging/{mandel.nexe,fib_*} \
 #     src/trusted/service_runtime/testdata/x86_32/
 
@@ skipping 12 matching lines @@
   node = env.SelUniversalTest(
       test + '_canned.out',
       env.File(arch_testdata_dir + '/' + test + '.nexe'),
       stdin = location + '.stdin',
       stdout_golden = location + '.stdout',
       )
   env.AddNodeToTestSuite(node,
                          ['medium_tests'],
                          'run_%s_integration_test' % test)
 
-if env.Bit('target_x86'):
+if env.Bit('target_x86') and env.Bit('nacl_static_link'):
   RE_HELLO = '^(Hello, World!)$'
   RE_IDENT = '^\[[0-9,:.]*\] (e_ident\+1 = ELF)$'
 
   node = env.CommandSelLdrTestNacl(
       'nacl_log.out',
-      env.File(arch_testdata_dir + '/hello_world.nexe'),
+      hello_world_nexe,
       log_golden = env.File('testdata/hello_world.log'),
       stdout_golden = env.File('testdata/hello_world.stdout'),
       filter_regex = '"' + RE_HELLO + '|' + RE_IDENT + '"',
       filter_group_only = 'true',
       )
   env.AddNodeToTestSuite(node, ['medium_tests'],
                          'run_service_runtime_hello_world_test')
 
   assert len(INTEGRATION_TESTS_X86) == len(INTEGRATION_TESTS_X86_STDIN_OUT)
   map(AddIntegrationTest,
@@ skipping 129 matching lines @@
                        is_broken=is_broken)
 
 dyn_array_test_exe = env.ComponentProgram('dyn_array_test',
                                           ['dyn_array_test.c'],
                                           EXTRA_LIBS=sel_ldr_libs)
 
 node = env.CommandTest('dyn_array_test.out',
                        command=[dyn_array_test_exe])
 
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_dyn_array_test')