Home | History | Annotate | Download | only in runtime 
      1 // Copyright 2015 the V8 project authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "src/v8.h"
      6 
      7 #include "src/factory.h"
      8 #include "src/heap/heap.h"
      9 #include "src/heap/heap-inl.h"
     10 #include "src/runtime/runtime.h"
     11 #include "test/unittests/test-utils.h"
     12 
     13 namespace v8 {
     14 namespace internal {
     15 namespace interpreter {
     16 
     17 class RuntimeInterpreterTest : public TestWithIsolateAndZone {
     18  public:
     19   typedef Object* (*RuntimeMethod)(int, Object**, Isolate*);
     20 
     21   RuntimeInterpreterTest() {}
     22   ~RuntimeInterpreterTest() override {}
     23 
     24   bool TestOperatorWithObjects(RuntimeMethod method, Handle<Object> lhs,
     25                                Handle<Object> rhs, bool expected);
     26   bool TestOperator(RuntimeMethod method, int32_t lhs, int32_t rhs,
     27                     bool expected);
     28   bool TestOperator(RuntimeMethod method, double lhs, double rhs,
     29                     bool expected);
     30   bool TestOperator(RuntimeMethod method, const char* lhs, const char* rhs,
     31                     bool expected);
     32 };
     33 
     34 
     35 bool RuntimeInterpreterTest::TestOperatorWithObjects(RuntimeMethod method,
     36                                                      Handle<Object> lhs,
     37                                                      Handle<Object> rhs,
     38                                                      bool expected) {
     39   Object* args_object[] = {*rhs, *lhs};
     40   Handle<Object> result =
     41       handle(method(2, &args_object[1], isolate()), isolate());
     42   CHECK(result->IsTrue() || result->IsFalse());
     43   return result->IsTrue() == expected;
     44 }
     45 
     46 
     47 bool RuntimeInterpreterTest::TestOperator(RuntimeMethod method, int32_t lhs,
     48                                           int32_t rhs, bool expected) {
     49   Handle<Object> x = isolate()->factory()->NewNumberFromInt(lhs);
     50   Handle<Object> y = isolate()->factory()->NewNumberFromInt(rhs);
     51   return TestOperatorWithObjects(method, x, y, expected);
     52 }
     53 
     54 
     55 bool RuntimeInterpreterTest::TestOperator(RuntimeMethod method, double lhs,
     56                                           double rhs, bool expected) {
     57   Handle<Object> x = isolate()->factory()->NewNumber(lhs);
     58   Handle<Object> y = isolate()->factory()->NewNumber(rhs);
     59   CHECK_EQ(HeapNumber::cast(*x)->value(), lhs);
     60   CHECK_EQ(HeapNumber::cast(*y)->value(), rhs);
     61   return TestOperatorWithObjects(method, x, y, expected);
     62 }
     63 
     64 
     65 bool RuntimeInterpreterTest::TestOperator(RuntimeMethod method, const char* lhs,
     66                                           const char* rhs, bool expected) {
     67   Handle<Object> x = isolate()->factory()->NewStringFromAsciiChecked(lhs);
     68   Handle<Object> y = isolate()->factory()->NewStringFromAsciiChecked(rhs);
     69   return TestOperatorWithObjects(method, x, y, expected);
     70 }
     71 
     72 
     73 TEST_F(RuntimeInterpreterTest, TestOperatorsWithIntegers) {
     74   int32_t inputs[] = {kMinInt, Smi::kMinValue, -17,    -1, 0, 1,
     75                       991,     Smi::kMaxValue, kMaxInt};
     76   TRACED_FOREACH(int, lhs, inputs) {
     77     TRACED_FOREACH(int, rhs, inputs) {
     78 #define INTEGER_OPERATOR_CHECK(r, op, x, y) \
     79   CHECK(TestOperator(Runtime_Interpreter##r, x, y, x op y))
     80       INTEGER_OPERATOR_CHECK(Equals, ==, lhs, rhs);
     81       INTEGER_OPERATOR_CHECK(NotEquals, !=, lhs, rhs);
     82       INTEGER_OPERATOR_CHECK(StrictEquals, ==, lhs, rhs);
     83       INTEGER_OPERATOR_CHECK(StrictNotEquals, !=, lhs, rhs);
     84       INTEGER_OPERATOR_CHECK(LessThan, <, lhs, rhs);
     85       INTEGER_OPERATOR_CHECK(GreaterThan, >, lhs, rhs);
     86       INTEGER_OPERATOR_CHECK(LessThanOrEqual, <=, lhs, rhs);
     87       INTEGER_OPERATOR_CHECK(GreaterThanOrEqual, >=, lhs, rhs);
     88 #undef INTEGER_OPERATOR_CHECK
     89     }
     90   }
     91 }
     92 
     93 
     94 TEST_F(RuntimeInterpreterTest, TestOperatorsWithDoubles) {
     95   double inputs[] = {std::numeric_limits<double>::min(),
     96                      std::numeric_limits<double>::max(),
     97                      -0.001,
     98                      0.01,
     99                      3.14,
    100                      -6.02214086e23};
    101   TRACED_FOREACH(double, lhs, inputs) {
    102     TRACED_FOREACH(double, rhs, inputs) {
    103 #define DOUBLE_OPERATOR_CHECK(r, op, x, y) \
    104   CHECK(TestOperator(Runtime_Interpreter##r, x, y, x op y))
    105       DOUBLE_OPERATOR_CHECK(Equals, ==, lhs, rhs);
    106       DOUBLE_OPERATOR_CHECK(NotEquals, !=, lhs, rhs);
    107       DOUBLE_OPERATOR_CHECK(StrictEquals, ==, lhs, rhs);
    108       DOUBLE_OPERATOR_CHECK(StrictNotEquals, !=, lhs, rhs);
    109       DOUBLE_OPERATOR_CHECK(LessThan, <, lhs, rhs);
    110       DOUBLE_OPERATOR_CHECK(GreaterThan, >, lhs, rhs);
    111       DOUBLE_OPERATOR_CHECK(LessThanOrEqual, <=, lhs, rhs);
    112       DOUBLE_OPERATOR_CHECK(GreaterThanOrEqual, >=, lhs, rhs);
    113 #undef DOUBLE_OPERATOR_CHECK
    114     }
    115   }
    116 }
    117 
    118 
    119 TEST_F(RuntimeInterpreterTest, TestOperatorsWithString) {
    120   const char* inputs[] = {"abc", "a", "def", "0"};
    121   TRACED_FOREACH(const char*, lhs, inputs) {
    122     TRACED_FOREACH(const char*, rhs, inputs) {
    123 #define STRING_OPERATOR_CHECK(r, op, x, y)         \
    124   CHECK(TestOperator(Runtime_Interpreter##r, x, y, \
    125                      std::string(x) op std::string(y)))
    126       STRING_OPERATOR_CHECK(Equals, ==, lhs, rhs);
    127       STRING_OPERATOR_CHECK(NotEquals, !=, lhs, rhs);
    128       STRING_OPERATOR_CHECK(StrictEquals, ==, lhs, rhs);
    129       STRING_OPERATOR_CHECK(StrictNotEquals, !=, lhs, rhs);
    130       STRING_OPERATOR_CHECK(LessThan, <, lhs, rhs);
    131       STRING_OPERATOR_CHECK(GreaterThan, >, lhs, rhs);
    132       STRING_OPERATOR_CHECK(LessThanOrEqual, <=, lhs, rhs);
    133       STRING_OPERATOR_CHECK(GreaterThanOrEqual, >=, lhs, rhs);
    134 #undef STRING_OPERATOR_CHECK
    135     }
    136   }
    137 }
    138 
    139 
    140 TEST_F(RuntimeInterpreterTest, ToBoolean) {
    141   double quiet_nan = std::numeric_limits<double>::quiet_NaN();
    142   std::pair<Handle<Object>, bool> cases[] = {
    143       std::make_pair(isolate()->factory()->NewNumberFromInt(0), false),
    144       std::make_pair(isolate()->factory()->NewNumberFromInt(1), true),
    145       std::make_pair(isolate()->factory()->NewNumberFromInt(100), true),
    146       std::make_pair(isolate()->factory()->NewNumberFromInt(-1), true),
    147       std::make_pair(isolate()->factory()->NewNumber(7.7), true),
    148       std::make_pair(isolate()->factory()->NewNumber(0.00001), true),
    149       std::make_pair(isolate()->factory()->NewNumber(quiet_nan), false),
    150       std::make_pair(isolate()->factory()->NewHeapNumber(0.0), false),
    151       std::make_pair(isolate()->factory()->undefined_value(), false),
    152       std::make_pair(isolate()->factory()->null_value(), false),
    153       std::make_pair(isolate()->factory()->true_value(), true),
    154       std::make_pair(isolate()->factory()->false_value(), false),
    155       std::make_pair(isolate()->factory()->NewStringFromStaticChars(""), false),
    156       std::make_pair(isolate()->factory()->NewStringFromStaticChars("_"), true),
    157   };
    158 
    159   for (size_t i = 0; i < arraysize(cases); i++) {
    160     auto& value_expected_tuple = cases[i];
    161     Object* args_object[] = {*value_expected_tuple.first};
    162     Handle<Object> result = handle(
    163         Runtime_InterpreterToBoolean(1, &args_object[0], isolate()), isolate());
    164     CHECK(result->IsBoolean());
    165     CHECK_EQ(result->IsTrue(), value_expected_tuple.second);
    166   }
    167 }
    168 
    169 
    170 }  // namespace interpreter
    171 }  // namespace internal
    172 }  // namespace v8
    173