[test] Test expectations in cctest should use CHECK and not DCHECK.

test/cctest/compiler/graph-builder-tester.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_CCTEST_COMPILER_GRAPH_BUILDER_TESTER_H_
 #define V8_CCTEST_COMPILER_GRAPH_BUILDER_TESTER_H_
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/linkage.h"
@@ skipping 50 matching lines @@
         effect_(NULL),
         return_(NULL),
         parameters_(main_zone()->template NewArray<Node*>(parameter_count())) {
     Begin(static_cast<int>(parameter_count()));
     InitParameters();
   }
   virtual ~GraphBuilderTester() {}
 
   void GenerateCode() { Generate(); }
   Node* Parameter(size_t index) {
-    DCHECK(index < parameter_count());
+    CHECK_LT(index, parameter_count());
     return parameters_[index];
   }
 
   Isolate* isolate() { return main_isolate(); }
   Factory* factory() { return isolate()->factory(); }
 
   // Initialize graph and builder.
   void Begin(int num_parameters) {
-    DCHECK(graph()->start() == NULL);
+    CHECK_NULL(graph()->start());
     Node* start = graph()->NewNode(common()->Start(num_parameters + 3));
     graph()->SetStart(start);
     effect_ = start;
   }
 
   void Return(Node* value) {
     return_ =
         graph()->NewNode(common()->Return(), value, effect_, graph()->start());
     effect_ = NULL;
   }
@@ skipping 137 matching lines @@
   }
 
   Handle<Code> GetCode() {
     Generate();
     return code_.ToHandleChecked();
   }
 
  protected:
   Node* MakeNode(const Operator* op, int value_input_count,
                  Node** value_inputs) {
-    DCHECK(op->ValueInputCount() == value_input_count);
+    CHECK_EQ(op->ValueInputCount(), value_input_count);
 
-    DCHECK(!OperatorProperties::HasContextInput(op));
-    DCHECK_EQ(0, OperatorProperties::GetFrameStateInputCount(op));
+    CHECK(!OperatorProperties::HasContextInput(op));
+    CHECK_EQ(0, OperatorProperties::GetFrameStateInputCount(op));
     bool has_control = op->ControlInputCount() == 1;
     bool has_effect = op->EffectInputCount() == 1;
 
-    DCHECK(op->ControlInputCount() < 2);
-    DCHECK(op->EffectInputCount() < 2);
+    CHECK_LT(op->ControlInputCount(), 2);
+    CHECK_LT(op->EffectInputCount(), 2);
 
     Node* result = NULL;
     if (!has_control && !has_effect) {
       result = graph()->NewNode(op, value_input_count, value_inputs);
     } else {
       int input_count_with_deps = value_input_count;
       if (has_control) ++input_count_with_deps;
       if (has_effect) ++input_count_with_deps;
       Node** buffer = zone()->template NewArray<Node*>(input_count_with_deps);
       memcpy(buffer, value_inputs, kPointerSize * value_input_count);
@@ skipping 46 matching lines @@
   Node* return_;
   Node** parameters_;
   MaybeHandle<Code> code_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CCTEST_COMPILER_GRAPH_BUILDER_TESTER_H_