Fix error reporting with ASSERT_NOT_EQUAL_64.

Change-Id: I67b03979693bcbfbcb7cadf4fb6b197b8a36c914

3 files changed, 69 insertions, 14 deletions

diff --git a/test/aarch64/test-assembler-aarch64.cc b/test/aarch64/test-assembler-aarch64.cc
index b9bff921..49429e78 100644
--- a/test/aarch64/test-assembler-aarch64.cc
+++ b/test/aarch64/test-assembler-aarch64.cc
@@ -328,7 +328,7 @@ const CPUFeatures kInfrastructureCPUFeatures(CPUFeatures::kNEON);
   VIXL_CHECK(Equal64(expected, &core, result))
 
 #define ASSERT_NOT_EQUAL_64(expected, result) \
-  VIXL_CHECK(!Equal64(expected, &core, result))
+  VIXL_CHECK(NotEqual64(expected, &core, result))
 
 #define ASSERT_EQUAL_FP64(expected, result) \
   VIXL_CHECK(EqualFP64(expected, &core, result))
diff --git a/test/aarch64/test-utils-aarch64.cc b/test/aarch64/test-utils-aarch64.cc
index c241fbca..d2d2ae71 100644
--- a/test/aarch64/test-utils-aarch64.cc
+++ b/test/aarch64/test-utils-aarch64.cc
@@ -63,14 +63,26 @@ bool Equal32(uint32_t expected, const RegisterDump*, uint32_t result) {
 }
 
 
-bool Equal64(uint64_t expected, const RegisterDump*, uint64_t result) {
-  if (result != expected) {
-    printf("Expected 0x%016" PRIx64 "\t Found 0x%016" PRIx64 "\n",
-           expected,
-           result);
+bool Equal64(uint64_t reference,
+             const RegisterDump*,
+             uint64_t result,
+             ExpectedResult option) {
+  switch (option) {
+    case kExpectEqual:
+      if (result != reference) {
+        printf("Expected 0x%016" PRIx64 "\t Found 0x%016" PRIx64 "\n",
+               reference,
+               result);
+      }
+      break;
+    case kExpectNotEqual:
+      if (result == reference) {
+        printf("Expected a result not equal to 0x%016" PRIx64 "\n", reference);
+      }
+      break;
   }
 
-  return expected == result;
+  return reference == result;
 }
 
 
@@ -173,10 +185,22 @@ bool Equal32(uint32_t expected, const RegisterDump* core, const Register& reg) {
 }
 
 
-bool Equal64(uint64_t expected, const RegisterDump* core, const Register& reg) {
+bool Equal64(uint64_t reference,
+             const RegisterDump* core,
+             const Register& reg,
+             ExpectedResult option) {
   VIXL_ASSERT(reg.Is64Bits());
   uint64_t result = core->xreg(reg.GetCode());
-  return Equal64(expected, core, result);
+  return Equal64(reference, core, result, option);
+}
+
+
+bool NotEqual64(uint64_t reference,
+                const RegisterDump* core,
+                const Register& reg) {
+  VIXL_ASSERT(reg.Is64Bits());
+  uint64_t result = core->xreg(reg.GetCode());
+  return NotEqual64(reference, core, result);
 }
 
 
@@ -238,11 +262,22 @@ bool EqualFP64(double expected,
 
 bool Equal64(const Register& reg0,
              const RegisterDump* core,
-             const Register& reg1) {
+             const Register& reg1,
+             ExpectedResult option) {
+  VIXL_ASSERT(reg0.Is64Bits() && reg1.Is64Bits());
+  int64_t reference = core->xreg(reg0.GetCode());
+  int64_t result = core->xreg(reg1.GetCode());
+  return Equal64(reference, core, result, option);
+}
+
+
+bool NotEqual64(const Register& reg0,
+                const RegisterDump* core,
+                const Register& reg1) {
   VIXL_ASSERT(reg0.Is64Bits() && reg1.Is64Bits());
   int64_t expected = core->xreg(reg0.GetCode());
   int64_t result = core->xreg(reg1.GetCode());
-  return Equal64(expected, core, result);
+  return NotEqual64(expected, core, result);
 }
 
 
diff --git a/test/aarch64/test-utils-aarch64.h b/test/aarch64/test-utils-aarch64.h
index 09697554..d43685ae 100644
--- a/test/aarch64/test-utils-aarch64.h
+++ b/test/aarch64/test-utils-aarch64.h
@@ -204,17 +204,31 @@ class RegisterDump {
   } dump_;
 };
 
+// Some tests want to check that a value is _not_ equal to a reference value.
+// These enum values can be used to control the error reporting behaviour.
+enum ExpectedResult { kExpectEqual, kExpectNotEqual };
+
+// The Equal* methods return true if the result matches the reference value.
+// They all print an error message to the console if the result is incorrect
+// (according to the ExpectedResult argument, or kExpectEqual if it is absent).
+//
 // Some of these methods don't use the RegisterDump argument, but they have to
 // accept them so that they can overload those that take register arguments.
 bool Equal32(uint32_t expected, const RegisterDump*, uint32_t result);
-bool Equal64(uint64_t expected, const RegisterDump*, uint64_t result);
+bool Equal64(uint64_t reference,
+             const RegisterDump*,
+             uint64_t result,
+             ExpectedResult option = kExpectEqual);
 
 bool EqualFP16(Float16 expected, const RegisterDump*, uint16_t result);
 bool EqualFP32(float expected, const RegisterDump*, float result);
 bool EqualFP64(double expected, const RegisterDump*, double result);
 
 bool Equal32(uint32_t expected, const RegisterDump* core, const Register& reg);
-bool Equal64(uint64_t expected, const RegisterDump* core, const Register& reg);
+bool Equal64(uint64_t reference,
+             const RegisterDump* core,
+             const Register& reg,
+             ExpectedResult option = kExpectEqual);
 bool Equal64(uint64_t expected,
              const RegisterDump* core,
              const VRegister& vreg);
@@ -231,7 +245,8 @@ bool EqualFP64(double expected,
 
 bool Equal64(const Register& reg0,
              const RegisterDump* core,
-             const Register& reg1);
+             const Register& reg1,
+             ExpectedResult option = kExpectEqual);
 bool Equal128(uint64_t expected_h,
               uint64_t expected_l,
               const RegisterDump* core,
@@ -241,6 +256,11 @@ bool EqualNzcv(uint32_t expected, uint32_t result);
 
 bool EqualRegisters(const RegisterDump* a, const RegisterDump* b);
 
+template <typename T0, typename T1>
+bool NotEqual64(T0 reference, const RegisterDump* core, T1 result) {
+  return !Equal64(reference, core, result, kExpectNotEqual);
+}
+
 // Populate the w, x and r arrays with registers from the 'allowed' mask. The
 // r array will be populated with <reg_size>-sized registers,
 //