Clean up testing of instructions. Allow testing to quit if test pattern tests

src/trusted/validator_arm/decoder_tester.h

 /*
  * 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.
  */
 
 /*
  * Tests the decoder.
  */
 
@@ skipping 32 matching lines @@
 //  to separate word 1 from word 2.
 //  Also, bits are specified from the largest bit downto the smallest
 //  bit.
 class DecoderTester {
  public:
   DecoderTester();
   virtual ~DecoderTester() {}
 
   // Once an instruction is decoded, this method is called to apply
   // sanity checks on the matched decoder. The default checks that the
-  // expected class name matches the name of the decoder, and that
-  // the safety level MAY_BE_SAFE.
-  virtual void ApplySanityChecks(
+  // expected class name matches the name of the decoder, and that the
+  // safety level is MAY_BE_SAFE. Returns whether further checking of
+  // the instruction should be performed. In particular, false is returned
+  // if there is some unencoded assumption that isn't put into the
+  // test patterns, and hence, should not be checked.
+  virtual bool ApplySanityChecks(
       nacl_arm_dec::Instruction inst,
       const NamedClassDecoder& decoder);
 
   // Returns the expected decoder.
   virtual const NamedClassDecoder& ExpectedDecoder() const = 0;
 
   // Defines what should be done once a test pattern has been generated.
   virtual void ProcessMatch() = 0;
 
   // Allows the injection of an instruction. Used one to inject the instruction
@@ skipping 40 matching lines @@
   // followed by the length-stride bits being set to the given value.
   // Note: Current implementation limits stride to less than 32.
   void TestAtIndexExpandFillAll(int index,
                                 int stride, int length, bool Value);
 
   // Fills the next length bits with the corresponding value being repeated
   // length times.
   void FillBitRange(int index, int length, bool value);
 };
 
+// Helper macro for testing if preconditions are met within the
+// ApplySanityChecks method of a DecoderTester. That is, if the
+// precondition is not met, exit the routine and return false.
+// Otherwise, the precondition of the remaining code has been met,
+// and execution continues.
+#define NC_PRECOND(test) \
+  { if (!(test)) return false; }
+
+// Helper macro for testing if an (error) precondition a != b is met
+// within the ApplySanityChecks method of a DecoderTester. That is,
+// if a == b, generate a gtest error and then stop the application
+// from doing further checks for the given instruction.
+#define NC_EXPECT_NE_PRECOND(a, b) \
+  { EXPECT_NE(a, b) << InstContents(); NC_PRECOND((a) == (b)); }
+
 // Defines a decoder tester that enumerates an Arm32 instruction pattern,
 // and tests that all of the decoded patterns match the expected class
 // decoder, and that any additional sanity checks, specific to the
 // instruction apply.
 //
 // Note: Patterns must be of length 32.
 class Arm32DecoderTester : public DecoderTester {
  public:
   explicit Arm32DecoderTester(
       const NamedClassDecoder& expected_decoder);
@@ skipping 146 matching lines @@
 
  private:
   friend class ThumbWord1DecoderTester;
   friend class ThumbWord2DecoderTester;
   NACL_DISALLOW_COPY_AND_ASSIGN(ThumbDecoderTester);
 };
 
 }  // namespace
 
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_DECODER_TESTER_H_