[test] Make CHECK_EQ calls in cctest consistent.

test/cctest/test-assembler-mips64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1571 matching lines @@
     __ jr(ra);
     __ nop();
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
-    CHECK_EQ(test.a, 1);
-    CHECK_EQ(test.b, 0);
-    CHECK_EQ(test.c, 0);
-    CHECK_EQ(test.d, 1);
+    CHECK_EQ(1, test.a);
+    CHECK_EQ(0, test.b);
+    CHECK_EQ(0, test.c);
+    CHECK_EQ(1, test.d);
 
     const int test_size = 3;
     const int input_size = 5;
 
     double inputs_D[input_size] = {0.0, 65.2, -70.32,
       18446744073709551621.0, -18446744073709551621.0};
     double outputs_D[input_size] = {0.0, 65.2, -70.32,
       18446744073709551621.0, -18446744073709551621.0};
     double tests_D[test_size*2] = {2.8, 2.9, -2.8, -2.9,
       18446744073709551616.0, 18446744073709555712.0};
     float inputs_S[input_size] = {0.0, 65.2, -70.32,
       18446744073709551621.0, -18446744073709551621.0};
     float outputs_S[input_size] = {0.0, 65.2, -70.32,
       18446744073709551621.0, -18446744073709551621.0};
     float tests_S[test_size*2] = {2.9, 2.8, -2.9, -2.8,
       18446744073709551616.0, 18446746272732807168.0};
     for (int j=0; j < test_size; j+=2) {
       for (int i=0; i < input_size; i++) {
         test.e = inputs_D[i];
         test.f = tests_D[j];
         test.i = inputs_S[i];
         test.j = tests_S[j];
         (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
-        CHECK_EQ(test.g, outputs_D[i]);
-        CHECK_EQ(test.h, 0);
-        CHECK_EQ(test.k, outputs_S[i]);
-        CHECK_EQ(test.l, 0);
+        CHECK_EQ(outputs_D[i], test.g);
+        CHECK_EQ(0, test.h);
+        CHECK_EQ(outputs_S[i], test.k);
+        CHECK_EQ(0, test.l);
 
         test.f = tests_D[j+1];
         test.j = tests_S[j+1];
         (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
-        CHECK_EQ(test.g, 0);
-        CHECK_EQ(test.h, outputs_D[i]);
-        CHECK_EQ(test.k, 0);
-        CHECK_EQ(test.l, outputs_S[i]);
+        CHECK_EQ(0, test.g);
+        CHECK_EQ(outputs_D[i], test.h);
+        CHECK_EQ(0, test.k);
+        CHECK_EQ(outputs_S[i], test.l);
       }
     }
   }
 }
 
 
 
 TEST(min_max) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
@@ skipping 1667 matching lines @@
     __ b(&done);
     __ nop();
   }
 
   __ bind(&done);
   __ ld(ra, MemOperand(sp));
   __ daddiu(sp, sp, 8);
   __ jr(ra);
   __ nop();
 
-  CHECK_EQ(assm.UnboundLabelsCount(), 0);
+  CHECK_EQ(0, assm.UnboundLabelsCount());
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   code->Print(std::cout);
 #endif
   F1 f = FUNCTION_CAST<F1>(code->entry());
   for (int i = 0; i < kNumCases; ++i) {
@@ skipping 493 matching lines @@
           / std::numeric_limits<float>::min();
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.a, std::numeric_limits<double>::max()
                  / std::numeric_limits<double>::min());
   CHECK_EQ(test.b, std::numeric_limits<float>::max()
                  / std::numeric_limits<float>::min());
 
   test.a = std::numeric_limits<double>::quiet_NaN();
   test.b = std::numeric_limits<float>::quiet_NaN();
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
-  CHECK_EQ(std::isnan(test.a), true);
-  CHECK_EQ(std::isnan(test.b), true);
+  CHECK(std::isnan(test.a));
+  CHECK(std::isnan(test.b));
 
   test.a = std::numeric_limits<double>::signaling_NaN();
   test.b = std::numeric_limits<float>::signaling_NaN();
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
-  CHECK_EQ(std::isnan(test.a), true);
-  CHECK_EQ(std::isnan(test.b), true);
+  CHECK(std::isnan(test.a));
+  CHECK(std::isnan(test.b));
 }
 
 
 TEST(ADD_FMT) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
@@ skipping 39 matching lines @@
   test.fb = -std::numeric_limits<float>::max();  // lowest()
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.c, 0.0);
   CHECK_EQ(test.fc, 0.0);
 
   test.a = std::numeric_limits<double>::max();
   test.b = std::numeric_limits<double>::max();
   test.fa = std::numeric_limits<float>::max();
   test.fb = std::numeric_limits<float>::max();
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
-  CHECK_EQ(std::isfinite(test.c), false);
-  CHECK_EQ(std::isfinite(test.fc), false);
+  CHECK(!std::isfinite(test.c));
+  CHECK(!std::isfinite(test.fc));
 
   test.a = 5.0;
   test.b = std::numeric_limits<double>::signaling_NaN();
   test.fa = 5.0;
   test.fb = std::numeric_limits<float>::signaling_NaN();
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
-  CHECK_EQ(std::isnan(test.c), true);
-  CHECK_EQ(std::isnan(test.fc), true);
+  CHECK(std::isnan(test.c));
+  CHECK(std::isnan(test.fc));
 }
 
 
 TEST(C_COND_FMT) {
   if (kArchVariant == kMips64r2) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
     MacroAssembler assm(isolate, NULL, 0,
                         v8::internal::CodeObjectRequired::kYes);
@@ skipping 499 matching lines @@
   test.cvt_s_d_in = -0.51;
   test.cvt_s_w_in = -1;
   test.cvt_s_l_in = -1;
   test.cvt_w_s_in = -0.51;
   test.cvt_w_d_in = -0.51;
 
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
   CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
-  CHECK_EQ(test.cvt_l_s_out, -1);
-  CHECK_EQ(test.cvt_l_d_out, -1);
+  CHECK_EQ(-1, test.cvt_l_s_out);
+  CHECK_EQ(-1, test.cvt_l_d_out);
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
   CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
-  CHECK_EQ(test.cvt_w_s_out, -1);
-  CHECK_EQ(test.cvt_w_d_out, -1);
-
+  CHECK_EQ(-1, test.cvt_w_s_out);
+  CHECK_EQ(-1, test.cvt_w_d_out);
 
   test.cvt_d_s_in = 0.49;
   test.cvt_d_w_in = 1;
   test.cvt_d_l_in = 1;
   test.cvt_l_s_in = 0.49;
   test.cvt_l_d_in = 0.49;
   test.cvt_s_d_in = 0.49;
   test.cvt_s_w_in = 1;
   test.cvt_s_l_in = 1;
   test.cvt_w_s_in = 0.49;
   test.cvt_w_d_in = 0.49;
 
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
   CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
-  CHECK_EQ(test.cvt_l_s_out, 0);
-  CHECK_EQ(test.cvt_l_d_out, 0);
+  CHECK_EQ(0, test.cvt_l_s_out);
+  CHECK_EQ(0, test.cvt_l_d_out);
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
   CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
-  CHECK_EQ(test.cvt_w_s_out, 0);
-  CHECK_EQ(test.cvt_w_d_out, 0);
+  CHECK_EQ(0, test.cvt_w_s_out);
+  CHECK_EQ(0, test.cvt_w_d_out);
 
   test.cvt_d_s_in = std::numeric_limits<float>::max();
   test.cvt_d_w_in = std::numeric_limits<int32_t>::max();
   test.cvt_d_l_in = std::numeric_limits<int64_t>::max();
   test.cvt_l_s_in = std::numeric_limits<float>::max();
   test.cvt_l_d_in = std::numeric_limits<double>::max();
   test.cvt_s_d_in = std::numeric_limits<double>::max();
   test.cvt_s_w_in = std::numeric_limits<int32_t>::max();
   test.cvt_s_l_in = std::numeric_limits<int64_t>::max();
   test.cvt_w_s_in = std::numeric_limits<float>::max();
@@ skipping 51 matching lines @@
   test.cvt_s_d_in = std::numeric_limits<double>::min();
   test.cvt_s_w_in = std::numeric_limits<int32_t>::min();
   test.cvt_s_l_in = std::numeric_limits<int64_t>::min();
   test.cvt_w_s_in = std::numeric_limits<float>::min();
   test.cvt_w_d_in = std::numeric_limits<double>::min();
 
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
   CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
-  CHECK_EQ(test.cvt_l_s_out, 0);
-  CHECK_EQ(test.cvt_l_d_out, 0);
+  CHECK_EQ(0, test.cvt_l_s_out);
+  CHECK_EQ(0, test.cvt_l_d_out);
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
   CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
-  CHECK_EQ(test.cvt_w_s_out, 0);
-  CHECK_EQ(test.cvt_w_d_out, 0);
+  CHECK_EQ(0, test.cvt_w_s_out);
+  CHECK_EQ(0, test.cvt_w_d_out);
 }
 
 
 TEST(DIV_FMT) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test {
@@ skipping 80 matching lines @@
     CHECK_EQ(test.dRes, dRes[i]);
     CHECK_EQ(test.fRes, fRes[i]);
   }
 
   test.dOp1 = DBL_MAX;
   test.dOp2 = -0.0;
   test.fOp1 = FLT_MAX;
   test.fOp2 = -0.0;
 
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
-  CHECK_EQ(false, std::isfinite(test.dRes));
-  CHECK_EQ(false, std::isfinite(test.fRes));
+  CHECK(!std::isfinite(test.dRes));
+  CHECK(!std::isfinite(test.fRes));
 
   test.dOp1 = 0.0;
   test.dOp2 = -0.0;
   test.fOp1 = 0.0;
   test.fOp2 = -0.0;
 
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
-  CHECK_EQ(true, std::isnan(test.dRes));
-  CHECK_EQ(true, std::isnan(test.fRes));
+  CHECK(std::isnan(test.dRes));
+  CHECK(std::isnan(test.fRes));
 
   test.dOp1 = std::numeric_limits<double>::quiet_NaN();
   test.dOp2 = -5.0;
   test.fOp1 = std::numeric_limits<float>::quiet_NaN();
   test.fOp2 = -5.0;
 
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
-  CHECK_EQ(true, std::isnan(test.dRes));
-  CHECK_EQ(true, std::isnan(test.fRes));
+  CHECK(std::isnan(test.dRes));
+  CHECK(std::isnan(test.fRes));
 }
 
 
 uint64_t run_align(uint64_t rs_value, uint64_t rt_value, uint8_t bp) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ align(v0, a0, a1, bp);
@@ skipping 1257 matching lines @@
   __ mov(v0, zero_reg);
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   int64_t res = reinterpret_cast<int64_t>(
       CALL_GENERATED_CODE(isolate, f, 42, 42, 0, 0, 0));
-  CHECK_EQ(res, 0);
+  CHECK_EQ(0, res);
 }
 
 template <class T>
 struct TestCaseMaddMsub {
   T fr, fs, ft, fd_add, fd_sub;
 };
 
 template <typename T, typename F>
 void helper_madd_msub_maddf_msubf(F func) {
   CcTest::InitializeVM();
@@ skipping 109 matching lines @@
   if (kArchVariant != kMips64r6) return;
   helper_madd_msub_maddf_msubf<double>([](MacroAssembler& assm) {
     __ maddf_d(f4, f6, f8);
     __ sdc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_add)));
     __ msubf_d(f16, f6, f8);
     __ sdc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_sub)));
   });
 }
 
 #undef __