Revert "Add initial support for compiler unit tests using GTest/GMock."

test/compiler-unittests/instruction-selector-unittest.h

-// Copyright 2014 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.
-
-#ifndef V8_COMPILER_UNITTESTS_INSTRUCTION_SELECTOR_UNITTEST_H_
-#define V8_COMPILER_UNITTESTS_INSTRUCTION_SELECTOR_UNITTEST_H_
-
-#include <deque>
-
-#include "src/compiler/instruction-selector.h"
-#include "src/compiler/raw-machine-assembler.h"
-#include "test/compiler-unittests/compiler-unittests.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-class InstructionSelectorTest : public CompilerTest {
- public:
-  InstructionSelectorTest() {}
-  virtual ~InstructionSelectorTest() {}
-
- protected:
-  class Stream;
-
-  enum StreamBuilderMode { kAllInstructions, kTargetInstructions };
-
-  class StreamBuilder V8_FINAL : public RawMachineAssembler {
-   public:
-    StreamBuilder(InstructionSelectorTest* test,
-                  MachineRepresentation return_type)
-        : RawMachineAssembler(new (test->zone()) Graph(test->zone()),
-                              CallDescriptorBuilder(test->zone(), return_type)),
-          test_(test) {}
-    StreamBuilder(InstructionSelectorTest* test,
-                  MachineRepresentation return_type,
-                  MachineRepresentation parameter0_type)
-        : RawMachineAssembler(new (test->zone()) Graph(test->zone()),
-                              CallDescriptorBuilder(test->zone(), return_type,
-                                                    parameter0_type)),
-          test_(test) {}
-    StreamBuilder(InstructionSelectorTest* test,
-                  MachineRepresentation return_type,
-                  MachineRepresentation parameter0_type,
-                  MachineRepresentation parameter1_type)
-        : RawMachineAssembler(
-              new (test->zone()) Graph(test->zone()),
-              CallDescriptorBuilder(test->zone(), return_type, parameter0_type,
-                                    parameter1_type)),
-          test_(test) {}
-
-    Stream Build(CpuFeature feature) {
-      return Build(InstructionSelector::Features(feature));
-    }
-    Stream Build(CpuFeature feature1, CpuFeature feature2) {
-      return Build(InstructionSelector::Features(feature1, feature2));
-    }
-    Stream Build(StreamBuilderMode mode = kTargetInstructions) {
-      return Build(InstructionSelector::Features(), mode);
-    }
-    Stream Build(InstructionSelector::Features features,
-                 StreamBuilderMode mode = kTargetInstructions);
-
-   private:
-    MachineCallDescriptorBuilder* CallDescriptorBuilder(
-        Zone* zone, MachineRepresentation return_type) {
-      return new (zone) MachineCallDescriptorBuilder(return_type, 0, NULL);
-    }
-
-    MachineCallDescriptorBuilder* CallDescriptorBuilder(
-        Zone* zone, MachineRepresentation return_type,
-        MachineRepresentation parameter0_type) {
-      MachineRepresentation* parameter_types =
-          zone->NewArray<MachineRepresentation>(1);
-      parameter_types[0] = parameter0_type;
-      return new (zone)
-          MachineCallDescriptorBuilder(return_type, 1, parameter_types);
-    }
-
-    MachineCallDescriptorBuilder* CallDescriptorBuilder(
-        Zone* zone, MachineRepresentation return_type,
-        MachineRepresentation parameter0_type,
-        MachineRepresentation parameter1_type) {
-      MachineRepresentation* parameter_types =
-          zone->NewArray<MachineRepresentation>(2);
-      parameter_types[0] = parameter0_type;
-      parameter_types[1] = parameter1_type;
-      return new (zone)
-          MachineCallDescriptorBuilder(return_type, 2, parameter_types);
-    }
-
-   private:
-    InstructionSelectorTest* test_;
-  };
-
-  class Stream V8_FINAL {
-   public:
-    size_t size() const { return instructions_.size(); }
-    const Instruction* operator[](size_t index) const {
-      EXPECT_LT(index, size());
-      return instructions_[index];
-    }
-
-    int32_t ToInt32(const InstructionOperand* operand) const {
-      return ToConstant(operand).ToInt32();
-    }
-
-   private:
-    Constant ToConstant(const InstructionOperand* operand) const {
-      ConstantMap::const_iterator i;
-      if (operand->IsConstant()) {
-        i = constants_.find(operand->index());
-        EXPECT_NE(constants_.end(), i);
-      } else {
-        EXPECT_EQ(InstructionOperand::IMMEDIATE, operand->kind());
-        i = immediates_.find(operand->index());
-        EXPECT_NE(immediates_.end(), i);
-      }
-      EXPECT_EQ(operand->index(), i->first);
-      return i->second;
-    }
-
-    friend class StreamBuilder;
-
-    typedef std::map<int, Constant> ConstantMap;
-
-    ConstantMap constants_;
-    ConstantMap immediates_;
-    std::deque<Instruction*> instructions_;
-  };
-};
-
-}  // namespace compiler
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_COMPILER_UNITTESTS_INSTRUCTION_SELECTOR_UNITTEST_H_