LCOV - code coverage report
Current view: top level - test/cctest/compiler - test-operator.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 145 145 100.0 %
Date: 2019-04-19 Functions: 17 17 100.0 %

          Line data    Source code
       1             : // Copyright 2013 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 <memory>
       6             : #include <sstream>
       7             : 
       8             : #include "src/compiler/operator.h"
       9             : #include "test/cctest/cctest.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : namespace compiler {
      14             : 
      15             : #define NONE Operator::kNoProperties
      16             : #define FOLD Operator::kFoldable
      17             : 
      18             : 
      19       26661 : TEST(TestOperator_Mnemonic) {
      20           5 :   Operator op1(10, NONE, "ThisOne", 0, 0, 0, 0, 0, 0);
      21           5 :   CHECK_EQ(0, strcmp(op1.mnemonic(), "ThisOne"));
      22             : 
      23           5 :   Operator op2(11, NONE, "ThatOne", 0, 0, 0, 0, 0, 0);
      24           5 :   CHECK_EQ(0, strcmp(op2.mnemonic(), "ThatOne"));
      25             : 
      26             :   Operator1<int> op3(12, NONE, "Mnemonic1", 0, 0, 0, 1, 0, 0, 12333);
      27           5 :   CHECK_EQ(0, strcmp(op3.mnemonic(), "Mnemonic1"));
      28             : 
      29             :   Operator1<double> op4(13, NONE, "TheOther", 0, 0, 0, 1, 0, 0, 99.9);
      30           5 :   CHECK_EQ(0, strcmp(op4.mnemonic(), "TheOther"));
      31           5 : }
      32             : 
      33             : 
      34       26661 : TEST(TestOperator_Hash) {
      35           5 :   Operator op1(17, NONE, "Another", 0, 0, 0, 0, 0, 0);
      36           5 :   CHECK_EQ(17, static_cast<int>(op1.HashCode()));
      37             : 
      38           5 :   Operator op2(18, NONE, "Falsch", 0, 0, 0, 0, 0, 0);
      39           5 :   CHECK_EQ(18, static_cast<int>(op2.HashCode()));
      40           5 : }
      41             : 
      42             : 
      43       26661 : TEST(TestOperator_Equals) {
      44           5 :   Operator op1a(19, NONE, "Another1", 0, 0, 0, 0, 0, 0);
      45           5 :   Operator op1b(19, FOLD, "Another2", 2, 0, 0, 2, 0, 0);
      46             : 
      47             :   CHECK(op1a.Equals(&op1a));
      48           5 :   CHECK(op1a.Equals(&op1b));
      49           5 :   CHECK(op1b.Equals(&op1a));
      50             :   CHECK(op1b.Equals(&op1b));
      51             : 
      52           5 :   Operator op2a(20, NONE, "Falsch1", 0, 0, 0, 0, 0, 0);
      53           5 :   Operator op2b(20, FOLD, "Falsch2", 1, 0, 0, 1, 0, 0);
      54             : 
      55             :   CHECK(op2a.Equals(&op2a));
      56           5 :   CHECK(op2a.Equals(&op2b));
      57           5 :   CHECK(op2b.Equals(&op2a));
      58             :   CHECK(op2b.Equals(&op2b));
      59             : 
      60           5 :   CHECK(!op1a.Equals(&op2a));
      61           5 :   CHECK(!op1a.Equals(&op2b));
      62           5 :   CHECK(!op1b.Equals(&op2a));
      63           5 :   CHECK(!op1b.Equals(&op2b));
      64             : 
      65           5 :   CHECK(!op2a.Equals(&op1a));
      66           5 :   CHECK(!op2a.Equals(&op1b));
      67           5 :   CHECK(!op2b.Equals(&op1a));
      68           5 :   CHECK(!op2b.Equals(&op1b));
      69           5 : }
      70             : 
      71          50 : static std::unique_ptr<char[]> OperatorToString(Operator* op) {
      72         100 :   std::ostringstream os;
      73          50 :   os << *op;
      74         150 :   return std::unique_ptr<char[]>(StrDup(os.str().c_str()));
      75             : }
      76             : 
      77             : 
      78       26661 : TEST(TestOperator_Print) {
      79           5 :   Operator op1a(19, NONE, "Another1", 0, 0, 0, 0, 0, 0);
      80           5 :   Operator op1b(19, FOLD, "Another2", 2, 0, 0, 2, 0, 0);
      81             : 
      82          15 :   CHECK_EQ(0, strcmp("Another1", OperatorToString(&op1a).get()));
      83          15 :   CHECK_EQ(0, strcmp("Another2", OperatorToString(&op1b).get()));
      84             : 
      85           5 :   Operator op2a(20, NONE, "Flog1", 0, 0, 0, 0, 0, 0);
      86           5 :   Operator op2b(20, FOLD, "Flog2", 1, 0, 0, 1, 0, 0);
      87             : 
      88          15 :   CHECK_EQ(0, strcmp("Flog1", OperatorToString(&op2a).get()));
      89          15 :   CHECK_EQ(0, strcmp("Flog2", OperatorToString(&op2b).get()));
      90           5 : }
      91             : 
      92             : 
      93       26661 : TEST(TestOperator1int_Hash) {
      94             :   Operator1<int> op1a(23, NONE, "Wolfie", 0, 0, 0, 0, 0, 0, 11);
      95             :   Operator1<int> op1b(23, FOLD, "Doggie", 2, 0, 0, 2, 0, 0, 11);
      96             : 
      97           5 :   CHECK(op1a.HashCode() == op1b.HashCode());
      98             : 
      99             :   Operator1<int> op2a(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, 3);
     100             :   Operator1<int> op2b(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, 4);
     101             : 
     102           5 :   CHECK(op1a.HashCode() != op2a.HashCode());
     103           5 :   CHECK(op2a.HashCode() != op2b.HashCode());
     104           5 : }
     105             : 
     106             : 
     107       26661 : TEST(TestOperator1int_Equals) {
     108             :   Operator1<int> op1a(23, NONE, "Scratchy", 0, 0, 0, 0, 0, 0, 11);
     109             :   Operator1<int> op1b(23, FOLD, "Scratchy", 2, 0, 0, 2, 0, 0, 11);
     110             : 
     111             :   CHECK(op1a.Equals(&op1a));
     112           5 :   CHECK(op1a.Equals(&op1b));
     113           5 :   CHECK(op1b.Equals(&op1a));
     114             :   CHECK(op1b.Equals(&op1b));
     115             : 
     116             :   Operator1<int> op2a(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 3);
     117             :   Operator1<int> op2b(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 4);
     118             : 
     119             :   CHECK(op2a.Equals(&op2a));
     120           5 :   CHECK(!op2a.Equals(&op2b));
     121           5 :   CHECK(!op2b.Equals(&op2a));
     122             :   CHECK(op2b.Equals(&op2b));
     123             : 
     124           5 :   CHECK(!op1a.Equals(&op2a));
     125           5 :   CHECK(!op1a.Equals(&op2b));
     126           5 :   CHECK(!op1b.Equals(&op2a));
     127           5 :   CHECK(!op1b.Equals(&op2b));
     128             : 
     129           5 :   CHECK(!op2a.Equals(&op1a));
     130           5 :   CHECK(!op2a.Equals(&op1b));
     131           5 :   CHECK(!op2b.Equals(&op1a));
     132           5 :   CHECK(!op2b.Equals(&op1b));
     133             : 
     134           5 :   Operator op3(25, NONE, "Weepy", 0, 0, 0, 0, 0, 0);
     135             : 
     136           5 :   CHECK(!op1a.Equals(&op3));
     137           5 :   CHECK(!op1b.Equals(&op3));
     138           5 :   CHECK(!op2a.Equals(&op3));
     139           5 :   CHECK(!op2b.Equals(&op3));
     140             : 
     141           5 :   CHECK(!op3.Equals(&op1a));
     142           5 :   CHECK(!op3.Equals(&op1b));
     143           5 :   CHECK(!op3.Equals(&op2a));
     144           5 :   CHECK(!op3.Equals(&op2b));
     145           5 : }
     146             : 
     147             : 
     148       26661 : TEST(TestOperator1int_Print) {
     149             :   Operator1<int> op1(12, NONE, "Op1Test", 0, 0, 0, 1, 0, 0, 0);
     150          15 :   CHECK_EQ(0, strcmp("Op1Test[0]", OperatorToString(&op1).get()));
     151             : 
     152             :   Operator1<int> op2(12, NONE, "Op1Test", 0, 0, 0, 1, 0, 0, 66666666);
     153          15 :   CHECK_EQ(0, strcmp("Op1Test[66666666]", OperatorToString(&op2).get()));
     154             : 
     155             :   Operator1<int> op3(12, NONE, "FooBar", 0, 0, 0, 1, 0, 0, 2347);
     156          15 :   CHECK_EQ(0, strcmp("FooBar[2347]", OperatorToString(&op3).get()));
     157             : 
     158             :   Operator1<int> op4(12, NONE, "BarFoo", 0, 0, 0, 1, 0, 0, -879);
     159          15 :   CHECK_EQ(0, strcmp("BarFoo[-879]", OperatorToString(&op4).get()));
     160           5 : }
     161             : 
     162             : 
     163       26661 : TEST(TestOperator1double_Hash) {
     164             :   Operator1<double> op1a(23, NONE, "Wolfie", 0, 0, 0, 0, 0, 0, 11.77);
     165             :   Operator1<double> op1b(23, FOLD, "Doggie", 2, 0, 0, 2, 0, 0, 11.77);
     166             : 
     167           5 :   CHECK(op1a.HashCode() == op1b.HashCode());
     168             : 
     169             :   Operator1<double> op2a(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, -6.7);
     170             :   Operator1<double> op2b(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, -6.8);
     171             : 
     172           5 :   CHECK(op1a.HashCode() != op2a.HashCode());
     173           5 :   CHECK(op2a.HashCode() != op2b.HashCode());
     174           5 : }
     175             : 
     176             : 
     177       26661 : TEST(TestOperator1doublePrint) {
     178             :   Operator1<double> op1a(23, NONE, "Canary", 0, 0, 0, 0, 0, 0, 0.5);
     179             :   Operator1<double> op1b(23, FOLD, "Finch", 2, 0, 0, 2, 0, 0, -1.5);
     180             : 
     181          15 :   CHECK_EQ(0, strcmp("Canary[0.5]", OperatorToString(&op1a).get()));
     182          15 :   CHECK_EQ(0, strcmp("Finch[-1.5]", OperatorToString(&op1b).get()));
     183           5 : }
     184             : 
     185             : 
     186       26661 : TEST(TestOperator1double_Equals) {
     187             :   Operator1<double> op1a(23, NONE, "Scratchy", 0, 0, 0, 0, 0, 0, 11.77);
     188             :   Operator1<double> op1b(23, FOLD, "Scratchy", 2, 0, 0, 2, 0, 0, 11.77);
     189             : 
     190             :   CHECK(op1a.Equals(&op1a));
     191           5 :   CHECK(op1a.Equals(&op1b));
     192           5 :   CHECK(op1b.Equals(&op1a));
     193             :   CHECK(op1b.Equals(&op1b));
     194             : 
     195             :   Operator1<double> op2a(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 3.1);
     196             :   Operator1<double> op2b(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 3.2);
     197             : 
     198             :   CHECK(op2a.Equals(&op2a));
     199           5 :   CHECK(!op2a.Equals(&op2b));
     200           5 :   CHECK(!op2b.Equals(&op2a));
     201             :   CHECK(op2b.Equals(&op2b));
     202             : 
     203           5 :   CHECK(!op1a.Equals(&op2a));
     204           5 :   CHECK(!op1a.Equals(&op2b));
     205           5 :   CHECK(!op1b.Equals(&op2a));
     206           5 :   CHECK(!op1b.Equals(&op2b));
     207             : 
     208           5 :   CHECK(!op2a.Equals(&op1a));
     209           5 :   CHECK(!op2a.Equals(&op1b));
     210           5 :   CHECK(!op2b.Equals(&op1a));
     211           5 :   CHECK(!op2b.Equals(&op1b));
     212             : 
     213           5 :   Operator op3(25, NONE, "Weepy", 0, 0, 0, 0, 0, 0);
     214             : 
     215           5 :   CHECK(!op1a.Equals(&op3));
     216           5 :   CHECK(!op1b.Equals(&op3));
     217           5 :   CHECK(!op2a.Equals(&op3));
     218           5 :   CHECK(!op2b.Equals(&op3));
     219             : 
     220           5 :   CHECK(!op3.Equals(&op1a));
     221           5 :   CHECK(!op3.Equals(&op1b));
     222           5 :   CHECK(!op3.Equals(&op2a));
     223           5 :   CHECK(!op3.Equals(&op2b));
     224             : 
     225             :   Operator1<double> op4a(24, NONE, "Bashful", 0, 0, 0, 0, 0, 0, 1.0);
     226             :   Operator1<double> op4b(24, NONE, "Bashful", 0, 0, 0, 0, 0, 0, 1.0);
     227             : 
     228             :   CHECK(op4a.Equals(&op4a));
     229           5 :   CHECK(op4a.Equals(&op4b));
     230           5 :   CHECK(op4b.Equals(&op4a));
     231             :   CHECK(op4b.Equals(&op4b));
     232             : 
     233           5 :   CHECK(!op3.Equals(&op4a));
     234           5 :   CHECK(!op3.Equals(&op4b));
     235           5 :   CHECK(!op3.Equals(&op4a));
     236           5 :   CHECK(!op3.Equals(&op4b));
     237           5 : }
     238             : 
     239             : 
     240       26661 : TEST(TestOpParameter_Operator1double) {
     241           5 :   double values[] = {7777.5, -66, 0, 11, 0.1};
     242             : 
     243          55 :   for (size_t i = 0; i < arraysize(values); i++) {
     244          25 :     Operator1<double> op(33, NONE, "Scurvy", 0, 0, 0, 0, 0, 0, values[i]);
     245          25 :     CHECK_EQ(values[i], OpParameter<double>(&op));
     246             :   }
     247           5 : }
     248             : 
     249             : 
     250       26661 : TEST(TestOpParameter_Operator1float) {
     251             :   float values[] = {// thanks C++.
     252             :                     static_cast<float>(7777.5), static_cast<float>(-66),
     253             :                     static_cast<float>(0), static_cast<float>(11),
     254           5 :                     static_cast<float>(0.1)};
     255             : 
     256          55 :   for (size_t i = 0; i < arraysize(values); i++) {
     257          25 :     Operator1<float> op(33, NONE, "Scurvy", 0, 0, 0, 0, 0, 0, values[i]);
     258          25 :     CHECK_EQ(values[i], OpParameter<float>(&op));
     259             :   }
     260           5 : }
     261             : 
     262             : 
     263       26661 : TEST(TestOpParameter_Operator1int) {
     264           5 :   int values[] = {7777, -66, 0, 11, 1, 0x666AFF};
     265             : 
     266          65 :   for (size_t i = 0; i < arraysize(values); i++) {
     267          30 :     Operator1<int> op(33, NONE, "Scurvy", 0, 0, 0, 0, 0, 0, values[i]);
     268             :     CHECK_EQ(values[i], OpParameter<int>(&op));
     269             :   }
     270           5 : }
     271             : 
     272             : 
     273       26661 : TEST(Operator_CountsOrder) {
     274           5 :   Operator op(29, NONE, "Flashy", 11, 22, 33, 44, 55, 66);
     275           5 :   CHECK_EQ(11, op.ValueInputCount());
     276           5 :   CHECK_EQ(22, op.EffectInputCount());
     277           5 :   CHECK_EQ(33, op.ControlInputCount());
     278             : 
     279           5 :   CHECK_EQ(44, op.ValueOutputCount());
     280           5 :   CHECK_EQ(55, op.EffectOutputCount());
     281           5 :   CHECK_EQ(66, op.ControlOutputCount());
     282           5 : }
     283             : 
     284             : #undef NONE
     285             : #undef FOLD
     286             : 
     287             : }  // namespace compiler
     288             : }  // namespace internal
     289       79968 : }  // namespace v8

Generated by: LCOV version 1.10