Finish separation of testing from sel_ldr validation. Also, automate

src/trusted/validator_arm/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 os
 Import('env')
 
 if not env.Bit('linux'): Return()
 
@@ skipping 21 matching lines @@
 gen_env = env.Clone();
 
 # Defines this source directory.
 GEN_SRC_DIR = '${MAIN_DIR}/src/trusted/validator_arm/gen'
 
 # Defines the full file name for a generated file.
 def _gen_file(filename):
   return '%s/%s' % (GEN_SRC_DIR, filename)
 
 # Set of generated source files.
-GEN_LIST = map(_gen_file, ['arm32_decode.cc', 'arm32_decode.h',
-                           'arm32_decode_named.cc' , 'arm32_decode_named.h'])
+GEN_LIST = [_gen_file(x) for x in
+            ['arm32_decode.cc', 'arm32_decode.h',
+             'arm32_decode_named.cc' ,
+             'arm32_decode_named_classes.h',
+             'arm32_decode_named_decoder.h',
+             'arm32_decode_tests.cc']]
 
 generate = False
 gen_env = env.Clone();
 if 'valgen' in COMMAND_LINE_TARGETS: generate = True
 if 'valclean' in COMMAND_LINE_TARGETS: generate = True
 
 if generate:
   gen_env.AlwaysBuild(gen_env.Alias('valgen', GEN_LIST))
   gen_env.AlwaysBuild(
     gen_env.Alias('valclean', action=[Delete(x) for x in GEN_LIST]))
 
 def _generate_source(filename):
   env.Command(target=filename,
               source=['armv7.table',
                       'generate_decoder.py',
                       'dgen_core.py',
                       'dgen_input.py',
                       'dgen_opt.py',
-                      'dgen_output.py'],
+                      'dgen_output.py',
+                      'dgen_decoder_output.py',
+                      'dgen_test_output.py',
+                      ],
               action=['${SOURCES[1].abspath} ${SOURCES[0].abspath} '
                       '${TARGET.abspath} Arm32DecoderState'])
 
 for f in GEN_LIST:
   _generate_source(f)
 
 env.ComponentLibrary('arm_validator_core',
                      ['address_set.cc',
                       'inst_classes.cc',
                       'inst_classes_statics.cc',
                       'validator.cc',
                       'gen/arm32_decode.cc'])
 
 env.ComponentLibrary('ncvalidate_arm_v2',
                      ['ncvalidate.cc'],
                      LIBS=['arm_validator_core',
                            '${OPTIONAL_COVERAGE_LIBS}'])
 
 ncval = env.ComponentProgram(
     'arm-ncval-core',
     ['ncval.cc'],
     LIBS=['arm_validator_core',
           env.NaClTargetArchSuffix('ncfileutils'),
           '${OPTIONAL_COVERAGE_LIBS}'])
 
 env.SDKInstallBin('ncval', ncval, target='arm')
 
-env.ComponentProgram('address_set_test_binary',
-                     ['address_set_test.cc'],
-                     LIBS=['arm_validator_core',
-                           '${OPTIONAL_COVERAGE_LIBS}'])
+# Build test environment to show that we are compiling in the test
+# environment (rather than for the TCB).
+gtest_env = env.MakeGTestEnv()
+gtest_env.Append(CCFLAGS=['-DNACL_TRUSTED_BUT_NOT_TCB'])
 
-address_set_test = env.Command(target='address_set_test.out',
-                               source=['address_set_test_binary'],
-                               action=['${SOURCES[0].abspath}'])
+gtest_env.ComponentProgram('address_set_test_binary',
+                           ['address_set_test.cc'],
+                           LIBS=['arm_validator_core',
+                                 '${OPTIONAL_COVERAGE_LIBS}'])
+
+address_set_test = gtest_env.Command(target='address_set_test.out',
+                                     source=['address_set_test_binary'],
+                                     action=['${SOURCES[0].abspath}'])
 
 # TODO(cbiffle): get this wrapped in QEMU.
 #env.AddNodeToTestSuite(address_set_test, ['small_tests'], 'address_set_test')
 
 validator_tests = {
   'test_external_jumps': 1,
   'test_forbidden_instructions': 1,
   'test_internal_jumps': 1,
   'test_sp_updates': 1,
   'test_stores': 1,
   'test_vector_stores': 1,
   'test_loads': 1,
   'test_vector_loads': 1,
 }
 
 for test, exit_status in validator_tests.iteritems():
-  node = env.CommandTest(
+  node = gtest_env.CommandTest(
       test + '_actual.out',
-      [ncval, env.File('testdata/' + test + '.nexe')],
+      [ncval, gtest_env.File('testdata/' + test + '.nexe')],
       exit_status = str(exit_status),
       filter_regex = "'^ncval'",
       # NOTE: all stdout_golden are currently empty
-      stdout_golden = env.File('testdata/' + test + '.out'),
-      stderr_golden = env.File('testdata/' + test + '.err'))
+      stdout_golden = gtest_env.File('testdata/' + test + '.out'),
+      stderr_golden = gtest_env.File('testdata/' + test + '.err'))
 
-  env.AddNodeToTestSuite(node, ['small_tests', 'validator_tests'],
-                         "run_arm_" + test)
-
-gtest_env = env.MakeGTestEnv()
+  gtest_env.AddNodeToTestSuite(node, ['small_tests', 'validator_tests'],
+                               "run_arm_" + test)
 
 gtest_env.ComponentLibrary('decoder_test_tools',
                            ['decoder_tester.cc',
                             'inst_classes_testers.cc',
                             'gen/arm32_decode_named.cc']);
 
 # Do NOT name this program 'validator_tests' because this is the same name as
 # a test suite, and scons will run that test suite if it ever builds
 # a program of the same name.
 validator_tests_exe = gtest_env.ComponentProgram('arm_validator_tests',
                                ['validator_tests.cc'],
                                EXTRA_LIBS=['arm_validator_core'])
 
 test_node = gtest_env.CommandTest(
     'validator_tests.out',
     command=[validator_tests_exe])
 gtest_env.AddNodeToTestSuite(test_node, ['small_tests'],
     'run_arm_validator_tests')
 
 # Test ARM (32-bit) instruction decoding.
 decoder_tests_exe = gtest_env.ComponentProgram(
-    'decoder_tests',
-    ['decoder_tests.cc'],
+    'arm32_decode_tests',
+    ['gen/arm32_decode_tests.cc'],
     EXTRA_LIBS=['decoder_test_tools', 'arm_validator_core'])
 
 decoder_test_node = gtest_env.CommandTest(
-    'decoder_tests.out',
+    'arm32_decode_tests.out',
     command=[decoder_tests_exe],
-    scale_timeout=10)
+    scale_timeout=100)
 
 gtest_env.AddNodeToTestSuite(decoder_test_node,
                              ['huge_tests', 'arm_decoder_tests'],
                               'run_arm_decoder_tests')