Add testing of generated (ARM) baseline decoders using hand-written decoders.

src/trusted/validator_arm/dgen_test_output.py

 #!/usr/bin/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.
 #
 
 """
 Responsible for generating the testing decoders based on
 parsed table representations.
@@ skipping 357 matching lines @@
 NAMED_CLASSES_H_HEADER="""%(FILE_HEADER)s
 %(NOT_TCB_MESSAGE)s
 
 #ifndef %(IFDEF_NAME)s
 #define %(IFDEF_NAME)s
 
 #include "native_client/src/trusted/validator_arm/actual_classes.h"
 #include "native_client/src/trusted/validator_arm/baseline_classes.h"
 #include "native_client/src/trusted/validator_arm/named_class_decoder.h"
 #include "%(FILENAME_BASE)s_actuals.h"
+
 #include "%(FILENAME_BASE)s_named_bases.h"
 """
 
 RULE_CLASSES_HEADER="""
 /*
  * Define rule decoder classes.
  */
 namespace nacl_arm_dec {
 
 """
@@ skipping 357 matching lines @@
       out.write(PARSE_TABLE_METHOD_ROW % values)
       out.write(METHOD_DISPATCH_CLOSE)
     out.write(PARSE_TABLE_METHOD_FOOTER % values)
 
 # Define the source for DECODER_tests.cc
 TEST_CC_HEADER="""%(FILE_HEADER)s
 %(NOT_TCB_MESSAGE)s
 
 #include "gtest/gtest.h"
 #include "native_client/src/trusted/validator_arm/actual_vs_baseline.h"
+#include "native_client/src/trusted/validator_arm/baseline_vs_baseline.h"
 #include "native_client/src/trusted/validator_arm/actual_classes.h"
 #include "native_client/src/trusted/validator_arm/baseline_classes.h"
 #include "native_client/src/trusted/validator_arm/inst_classes_testers.h"
 #include "native_client/src/trusted/validator_arm/arm_helpers.h"
 #include "native_client/src/trusted/validator_arm/gen/arm32_decode_named_bases.h"
 
 using nacl_arm_dec::Instruction;
 using nacl_arm_dec::ClassDecoder;
 using nacl_arm_dec::Register;
 using nacl_arm_dec::RegisterList;
@@ skipping 121 matching lines @@
 
 TEST_FUNCTION_BASELINE="""
 // %(row_comment)s
 TEST_F(%(decoder_name)sTests,
        %(decoder_tester)s_Test%(test_pattern)s) {
   %(decoder_tester)s tester;
   tester.Test("%(pattern)s");
 }
 """
 
+TEST_FUNCTION_BASELINE_VS_BASELINE="""
+// %(row_comment)s
+TEST_F(%(decoder_name)sTests,
+       BvB_%(decoder_tester)s_Test%(test_pattern)s) {
+  %(decoder_tester)s old_baseline_tester;
+  Named%(gen_decoder)s gen_baseline;
+  BaselineVsBaselineTester b_vs_b_tester(gen_baseline, old_baseline_tester);
+  b_vs_b_tester.Test("%(pattern)s");
+}
+"""
+
 TEST_CC_FOOTER="""
 }  // namespace nacl_arm_test
 
 int main(int argc, char* argv[]) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
 """
 
 def generate_tests_cc(decoder, decoder_name, out, cl_args, tables):
   """Generates pattern tests for the rows in the given list of tables
      in the given decoder."""
   global _cl_args
   if not decoder.primary: raise Exception('No tables provided.')
   _cl_args = cl_args
 
   # Generate actuals from descriptions in tables, for each of the
   # tables that should automatically generate the corresponding
   # needed actual class decoders.
   actuals = cl_args.get('auto-actual')
   if actuals:
     decoder = dgen_actuals.AddAutoActualsToDecoder(decoder, actuals)
 
   decoder = dgen_baselines.AddBaselinesToDecoder(decoder, tables)
 
+  baselines = cl_args.get('test-base')
+  if not baselines: baselines = []
+
   decoder = _decoder_restricted_to_tables(decoder, tables)
 
   values = {
       'FILE_HEADER': dgen_output.HEADER_BOILERPLATE,
       'NOT_TCB_MESSAGE' : dgen_output.NOT_TCB_BOILERPLATE,
       'decoder_name': decoder_name,
       }
   out.write(TEST_CC_HEADER % values)
   _generate_constraint_testers(decoder, values, out)
   _generate_rule_testers(decoder, values, out)
   out.write(TEST_HARNESS % values)
-  _generate_test_patterns(decoder, values, out)
+  _generate_test_patterns_with_baseline_tests(decoder, values, out, baselines)
   out.write(TEST_CC_FOOTER % values)
 
 def _filter_test_action(action, with_patterns, with_rules):
   """Filters the actions to pull out relavant entries, based on whether we
      want to include patterns and rules.
      """
   action_fields = ['actual', 'baseline', 'generated_baseline',
                    'constraints'] + dgen_decoder.METHODS
   if with_patterns:
     action_fields += ['pattern' ]
@@ skipping 141 matching lines @@
      or all tables if no names are specified.
      """
   if not tables:
     return decoder
   new_decoder = dgen_core.Decoder()
   for tbl in [tbl for tbl in decoder.tables() if tbl.name in tables]:
     new_decoder.add(tbl)
   new_decoder.set_class_defs(decoder.get_class_defs())
   return new_decoder
 
-def _generate_test_patterns(decoder, values, out):
+def _generate_test_patterns_with_baseline_tests(
+    decoder, values, out, baseline_test_tables):
+  _generate_test_patterns(decoder, values, out, False)
+  _generate_test_patterns(
+      _decoder_restricted_to_tables(decoder, baseline_test_tables),
+      values, out, True)
+
+def _generate_test_patterns(decoder, values, out, add_baseline_tests):
   """Generates a test function for each row having a pattern associated
      with the table row.
      """
   rows = _rows_to_test(decoder, values, with_patterns=True)
   values['test_rows'] = _index_neutral_map(rows)
   for r in rows:
     _install_row_cases(r, values)
     row = _row_filter_interesting_patterns(r)
     action = _install_test_row(row, decoder, values, with_patterns=True)
-    if action.actual() == action.baseline():
+    if add_baseline_tests:
+      if action.find('generated_baseline'):
+        values['gen_decoder'] = action.find('generated_baseline')
+        out.write(TEST_FUNCTION_BASELINE_VS_BASELINE % values)
+    elif action.actual() == action.baseline():
       out.write(TEST_FUNCTION_BASELINE % values)
     else:
       out.write(TEST_FUNCTION_ACTUAL_VS_BASELINE % values)
 
 def _index_neutral_map(values):
   """Returns a dictionary from each neutral_repr(value) in list
      values, to its corresponding index. This is done to reduce the
      number of compares to find the index, speeding up code
      generation.
      """
   lookup_map = {}
   index = 0
   for v in values:
     lookup_map[dgen_core.neutral_repr(v)] = index
     index += 1
   return lookup_map