[runtime] Unify comparison operator runtime entries.

test/unittests/runtime/runtime-interpreter-unittest.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 "src/v8.h"
 
 #include "src/factory.h"
 #include "src/heap/heap.h"
 #include "src/heap/heap-inl.h"
 #include "src/runtime/runtime.h"
@@ skipping 59 matching lines @@
 }
 
 
 TEST_F(RuntimeInterpreterTest, TestOperatorsWithIntegers) {
   int32_t inputs[] = {kMinInt, Smi::kMinValue, -17,    -1, 0, 1,
                       991,     Smi::kMaxValue, kMaxInt};
   TRACED_FOREACH(int, lhs, inputs) {
     TRACED_FOREACH(int, rhs, inputs) {
 #define INTEGER_OPERATOR_CHECK(r, op, x, y) \
   CHECK(TestOperator(Runtime_Interpreter##r, x, y, x op y))
-      INTEGER_OPERATOR_CHECK(Equals, ==, lhs, rhs);
-      INTEGER_OPERATOR_CHECK(NotEquals, !=, lhs, rhs);
-      INTEGER_OPERATOR_CHECK(StrictEquals, ==, lhs, rhs);
-      INTEGER_OPERATOR_CHECK(StrictNotEquals, !=, lhs, rhs);
       INTEGER_OPERATOR_CHECK(LessThan, <, lhs, rhs);
       INTEGER_OPERATOR_CHECK(GreaterThan, >, lhs, rhs);
       INTEGER_OPERATOR_CHECK(LessThanOrEqual, <=, lhs, rhs);
       INTEGER_OPERATOR_CHECK(GreaterThanOrEqual, >=, lhs, rhs);
 #undef INTEGER_OPERATOR_CHECK
     }
   }
 }
 
 
 TEST_F(RuntimeInterpreterTest, TestOperatorsWithDoubles) {
   double inputs[] = {std::numeric_limits<double>::min(),
                      std::numeric_limits<double>::max(),
                      -0.001,
                      0.01,
                      3.14,
                      -6.02214086e23};
   TRACED_FOREACH(double, lhs, inputs) {
     TRACED_FOREACH(double, rhs, inputs) {
 #define DOUBLE_OPERATOR_CHECK(r, op, x, y) \
   CHECK(TestOperator(Runtime_Interpreter##r, x, y, x op y))
-      DOUBLE_OPERATOR_CHECK(Equals, ==, lhs, rhs);
-      DOUBLE_OPERATOR_CHECK(NotEquals, !=, lhs, rhs);
-      DOUBLE_OPERATOR_CHECK(StrictEquals, ==, lhs, rhs);
-      DOUBLE_OPERATOR_CHECK(StrictNotEquals, !=, lhs, rhs);
       DOUBLE_OPERATOR_CHECK(LessThan, <, lhs, rhs);
       DOUBLE_OPERATOR_CHECK(GreaterThan, >, lhs, rhs);
       DOUBLE_OPERATOR_CHECK(LessThanOrEqual, <=, lhs, rhs);
       DOUBLE_OPERATOR_CHECK(GreaterThanOrEqual, >=, lhs, rhs);
 #undef DOUBLE_OPERATOR_CHECK
     }
   }
 }
 
 
 TEST_F(RuntimeInterpreterTest, TestOperatorsWithString) {
   const char* inputs[] = {"abc", "a", "def", "0"};
   TRACED_FOREACH(const char*, lhs, inputs) {
     TRACED_FOREACH(const char*, rhs, inputs) {
 #define STRING_OPERATOR_CHECK(r, op, x, y)         \
   CHECK(TestOperator(Runtime_Interpreter##r, x, y, \
                      std::string(x) op std::string(y)))
-      STRING_OPERATOR_CHECK(Equals, ==, lhs, rhs);
-      STRING_OPERATOR_CHECK(NotEquals, !=, lhs, rhs);
-      STRING_OPERATOR_CHECK(StrictEquals, ==, lhs, rhs);
-      STRING_OPERATOR_CHECK(StrictNotEquals, !=, lhs, rhs);
       STRING_OPERATOR_CHECK(LessThan, <, lhs, rhs);
       STRING_OPERATOR_CHECK(GreaterThan, >, lhs, rhs);
       STRING_OPERATOR_CHECK(LessThanOrEqual, <=, lhs, rhs);
       STRING_OPERATOR_CHECK(GreaterThanOrEqual, >=, lhs, rhs);
 #undef STRING_OPERATOR_CHECK
     }
   }
 }
 
 
@@ skipping 23 matching lines @@
         Runtime_InterpreterToBoolean(1, &args_object[0], isolate()), isolate());
     CHECK(result->IsBoolean());
     CHECK_EQ(result->IsTrue(), value_expected_tuple.second);
   }
 }
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8