[test] Cleanup CHECK_EQ order.

test/cctest/test-api-interceptors.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 
 #include "test/cctest/test-api.h"
 
 #include "include/v8-util.h"
 #include "src/api.h"
@@ skipping 386 matching lines @@
       v8::FunctionTemplate::New(CcTest::isolate());
   templ->InstanceTemplate()->SetHandler(
       v8::NamedPropertyHandlerConfiguration(0, 0, QueryCallback));
   LocalContext env;
   env->Global()
       ->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local())
                                             .ToLocalChecked()
                                             ->NewInstance(env.local())
                                             .ToLocalChecked())
       .FromJust();
-  CHECK_EQ(query_counter_int, 0);
+  CHECK_EQ(0, query_counter_int);
   v8::Local<Value> result =
       v8_compile("Object.getOwnPropertyDescriptor(obj, 'x');")
           ->Run(env.local())
           .ToLocalChecked();
-  CHECK_EQ(query_counter_int, 1);
+  CHECK_EQ(1, query_counter_int);
   CHECK_EQ(v8::PropertyAttribute::None,
            static_cast<v8::PropertyAttribute>(
                result->Int32Value(env.local()).FromJust()));
 
   v8_compile("Object.defineProperty(obj, 'not_enum', {value: 17});")
       ->Run(env.local())
       .ToLocalChecked();
-  CHECK_EQ(query_counter_int, 2);
+  CHECK_EQ(2, query_counter_int);
 
   v8_compile(
       "Object.defineProperty(obj, 'enum', {value: 17, enumerable: true, "
       "writable: true});")
       ->Run(env.local())
       .ToLocalChecked();
-  CHECK_EQ(query_counter_int, 3);
+  CHECK_EQ(3, query_counter_int);
 
   CHECK(v8_compile("obj.propertyIsEnumerable('enum');")
             ->Run(env.local())
             .ToLocalChecked()
             ->BooleanValue(env.local())
             .FromJust());
-  CHECK_EQ(query_counter_int, 4);
+  CHECK_EQ(4, query_counter_int);
 
   CHECK(!v8_compile("obj.propertyIsEnumerable('not_enum');")
              ->Run(env.local())
              .ToLocalChecked()
              ->BooleanValue(env.local())
              .FromJust());
-  CHECK_EQ(query_counter_int, 5);
+  CHECK_EQ(5, query_counter_int);
 
   CHECK(v8_compile("obj.hasOwnProperty('enum');")
             ->Run(env.local())
             .ToLocalChecked()
             ->BooleanValue(env.local())
             .FromJust());
-  CHECK_EQ(query_counter_int, 5);
+  CHECK_EQ(5, query_counter_int);
 
   CHECK(v8_compile("obj.hasOwnProperty('not_enum');")
             ->Run(env.local())
             .ToLocalChecked()
             ->BooleanValue(env.local())
             .FromJust());
-  CHECK_EQ(query_counter_int, 5);
+  CHECK_EQ(5, query_counter_int);
 
   CHECK(!v8_compile("obj.hasOwnProperty('x');")
              ->Run(env.local())
              .ToLocalChecked()
              ->BooleanValue(env.local())
              .FromJust());
-  CHECK_EQ(query_counter_int, 6);
+  CHECK_EQ(6, query_counter_int);
 
   CHECK(!v8_compile("obj.propertyIsEnumerable('undef');")
              ->Run(env.local())
              .ToLocalChecked()
              ->BooleanValue(env.local())
              .FromJust());
-  CHECK_EQ(query_counter_int, 7);
+  CHECK_EQ(7, query_counter_int);
 
   v8_compile("Object.defineProperty(obj, 'enum', {value: 42});")
       ->Run(env.local())
       .ToLocalChecked();
-  CHECK_EQ(query_counter_int, 8);
+  CHECK_EQ(8, query_counter_int);
 
   v8_compile("Object.isFrozen('obj.x');")->Run(env.local()).ToLocalChecked();
-  CHECK_EQ(query_counter_int, 8);
+  CHECK_EQ(8, query_counter_int);
 }
 
 namespace {
 
 bool get_was_called = false;
 bool set_was_called = false;
 
 int set_was_called_counter = 0;
 
 void GetterCallback(Local<Name> property,
@@ skipping 23 matching lines @@
                                             ->NewInstance(env.local())
                                             .ToLocalChecked())
       .FromJust();
 
   get_was_called = false;
   set_was_called = false;
 
   v8_compile("Object.defineProperty(obj, 'x', {set: function() {return 17;}});")
       ->Run(env.local())
       .ToLocalChecked();
-  CHECK_EQ(get_was_called, true);
-  CHECK_EQ(set_was_called, false);
+  CHECK_EQ(true, get_was_called);
+  CHECK_EQ(false, set_was_called);
 }
 
 // Check that set callback is called for function declarations.
 THREADED_TEST(SetterCallbackFunctionDeclarationInterceptor) {
   v8::HandleScope scope(CcTest::isolate());
   LocalContext env;
   v8::Local<v8::FunctionTemplate> templ =
       v8::FunctionTemplate::New(CcTest::isolate());
 
   v8::Local<ObjectTemplate> object_template = templ->InstanceTemplate();
   object_template->SetHandler(
       v8::NamedPropertyHandlerConfiguration(nullptr, SetterCallback));
   v8::Local<v8::Context> ctx =
       v8::Context::New(CcTest::isolate(), nullptr, object_template);
 
   set_was_called_counter = 0;
 
   // Declare function.
   v8::Local<v8::String> code = v8_str("function x() {return 42;}; x();");
   CHECK_EQ(42, v8::Script::Compile(ctx, code)
                    .ToLocalChecked()
                    ->Run(ctx)
                    .ToLocalChecked()
                    ->Int32Value(ctx)
                    .FromJust());
-  CHECK_EQ(set_was_called_counter, 1);
+  CHECK_EQ(1, set_was_called_counter);
 
   // Redeclare function.
   code = v8_str("function x() {return 43;}; x();");
   CHECK_EQ(43, v8::Script::Compile(ctx, code)
                    .ToLocalChecked()
                    ->Run(ctx)
                    .ToLocalChecked()
                    ->Int32Value(ctx)
                    .FromJust());
-  CHECK_EQ(set_was_called_counter, 2);
+  CHECK_EQ(2, set_was_called_counter);
 
   // Redefine function.
   code = v8_str("x = function() {return 44;}; x();");
   CHECK_EQ(44, v8::Script::Compile(ctx, code)
                    .ToLocalChecked()
                    ->Run(ctx)
                    .ToLocalChecked()
                    ->Int32Value(ctx)
                    .FromJust());
-  CHECK_EQ(set_was_called_counter, 3);
+  CHECK_EQ(3, set_was_called_counter);
 }
 
 namespace {
 void QueryCallbackSetDontDelete(
     Local<Name> property, const v8::PropertyCallbackInfo<v8::Integer>& info) {
   info.GetReturnValue().Set(v8::PropertyAttribute::DontDelete);
 }
 
 }  // namespace
 
@@ skipping 38 matching lines @@
       "configurable: false, "
       "writable: false});"
       "x();");
   CHECK_EQ(42, v8::Script::Compile(ctx, code)
                    .ToLocalChecked()
                    ->Run(ctx)
                    .ToLocalChecked()
                    ->Int32Value(ctx)
                    .FromJust());
 
-  CHECK_EQ(set_was_called, true);
+  CHECK_EQ(true, set_was_called);
 
   v8::TryCatch try_catch(CcTest::isolate());
   set_was_called = false;
 
   // Redeclare function that is read-only.
   code = v8_str("function x() {return 43;};");
   CHECK(v8::Script::Compile(ctx, code).ToLocalChecked()->Run(ctx).IsEmpty());
   CHECK(try_catch.HasCaught());
 
-  CHECK_EQ(set_was_called, false);
+  CHECK_EQ(false, set_was_called);
 }
 
 
 namespace {
 
 bool get_was_called_in_order = false;
 bool define_was_called_in_order = false;
 
 void GetterCallbackOrder(Local<Name> property,
                          const v8::PropertyCallbackInfo<v8::Value>& info) {
   get_was_called_in_order = true;
-  CHECK_EQ(define_was_called_in_order, true);
+  CHECK_EQ(true, define_was_called_in_order);
   info.GetReturnValue().Set(property);
 }
 
 void DefinerCallbackOrder(Local<Name> property,
                           const v8::PropertyDescriptor& desc,
                           const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CHECK_EQ(get_was_called_in_order, false);  // Define called before get.
+  CHECK_EQ(false, get_was_called_in_order);  // Define called before get.
   define_was_called_in_order = true;
 }
 
 }  // namespace
 
 // Check that definer callback is called before getter callback.
 THREADED_TEST(DefinerCallbackGetAndDefine) {
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::FunctionTemplate> templ =
       v8::FunctionTemplate::New(CcTest::isolate());
   templ->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(
       GetterCallbackOrder, SetterCallback, 0, 0, 0, DefinerCallbackOrder));
   LocalContext env;
   env->Global()
       ->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local())
                                             .ToLocalChecked()
                                             ->NewInstance(env.local())
                                             .ToLocalChecked())
       .FromJust();
 
-  CHECK_EQ(get_was_called_in_order, false);
-  CHECK_EQ(define_was_called_in_order, false);
+  CHECK_EQ(false, get_was_called_in_order);
+  CHECK_EQ(false, define_was_called_in_order);
 
   v8_compile("Object.defineProperty(obj, 'x', {set: function() {return 17;}});")
       ->Run(env.local())
       .ToLocalChecked();
-  CHECK_EQ(get_was_called_in_order, true);
-  CHECK_EQ(define_was_called_in_order, true);
+  CHECK_EQ(true, get_was_called_in_order);
+  CHECK_EQ(true, define_was_called_in_order);
 }
 
 namespace {  //  namespace for InObjectLiteralDefinitionWithInterceptor
 
 // Workaround for no-snapshot builds: only intercept once Context::New() is
 // done, otherwise we'll intercept
 // bootstrapping like defining array on the global object.
 bool context_is_done = false;
 bool getter_callback_was_called = false;
 
@@ skipping 775 matching lines @@
       v8::FunctionTemplate::New(CcTest::isolate());
   templ->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(
       EchoNamedProperty, 0, 0, 0, 0, v8_str("data")));
   LocalContext env;
   env->Global()
       ->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local())
                                             .ToLocalChecked()
                                             ->NewInstance(env.local())
                                             .ToLocalChecked())
       .FromJust();
-  CHECK_EQ(echo_named_call_count, 0);
+  CHECK_EQ(0, echo_named_call_count);
   v8_compile("obj.x")->Run(env.local()).ToLocalChecked();
-  CHECK_EQ(echo_named_call_count, 1);
+  CHECK_EQ(1, echo_named_call_count);
   const char* code = "var str = 'oddle'; obj[str] + obj.poddle;";
   v8::Local<Value> str = CompileRun(code);
   String::Utf8Value value(str);
   CHECK_EQ(0, strcmp(*value, "oddlepoddle"));
   // Check default behavior
   CHECK_EQ(10, v8_compile("obj.flob = 10;")
                    ->Run(env.local())
                    .ToLocalChecked()
                    ->Int32Value(env.local())
                    .FromJust());
@@ skipping 529 matching lines @@
   templ->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(
       EchoIndexedProperty, 0, 0, 0, 0, v8_num(637)));
   LocalContext env;
   env->Global()
       ->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local())
                                             .ToLocalChecked()
                                             ->NewInstance(env.local())
                                             .ToLocalChecked())
       .FromJust();
   Local<Script> script = v8_compile("obj[900]");
-  CHECK_EQ(script->Run(env.local())
-               .ToLocalChecked()
-               ->Int32Value(env.local())
-               .FromJust(),
-           900);
+  CHECK_EQ(900, script->Run(env.local())
+                    .ToLocalChecked()
+                    ->Int32Value(env.local())
+                    .FromJust());
 }
 
 
 THREADED_TEST(PropertyHandlerInPrototype) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
   templ->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(
@@ skipping 605 matching lines @@
       v8::NamedPropertyHandlerConfiguration(SetXOnPrototypeGetter));
   LocalContext context;
   context->Global()
       ->Set(context.local(), v8_str("F"),
             function_template->GetFunction(context.local()).ToLocalChecked())
       .FromJust();
   // Create an instance of F and introduce a map transition for x.
   CompileRun("var o = new F(); o.x = 23;");
   // Create an instance of F and invoke the getter. The result should be 23.
   Local<Value> result = CompileRun("o = new F(); o.x");
-  CHECK_EQ(result->Int32Value(context.local()).FromJust(), 23);
+  CHECK_EQ(23, result->Int32Value(context.local()).FromJust());
 }
 
 
 static void IndexedPropertyGetter(
     uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (index == 37) {
     info.GetReturnValue().Set(v8_num(625));
   }
 }
@@ skipping 2272 matching lines @@
             ->Set(env.local(), v8_str("Fun"),
                   fun_templ->GetFunction(env.local()).ToLocalChecked())
             .FromJust());
 
   CompileRun(
       "var f = new Fun();"
       "Number.prototype.__proto__ = f;"
       "var a = 42;"
       "for (var i = 0; i<3; i++) { a.foo; }");
 }