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

test/cctest/test-heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1849 matching lines @@
 
   v8::V8::Initialize();
 
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   LocalContext context;
 
   // Adjust source below and this check to match
   // RegExpImple::kRegExpTooLargeToOptimize.
-  DCHECK_EQ(i::RegExpImpl::kRegExpTooLargeToOptimize, 20 * KB);
+  CHECK_EQ(i::RegExpImpl::kRegExpTooLargeToOptimize, 20 * KB);
 
   // Compile a regexp that is much larger if we are using regexp optimizations.
   CompileRun(
       "var reg_exp_source = '(?:a|bc|def|ghij|klmno|pqrstu)';"
       "var half_size_reg_exp;"
       "while (reg_exp_source.length < 20 * 1024) {"
       "  half_size_reg_exp = reg_exp_source;"
       "  reg_exp_source = reg_exp_source + reg_exp_source;"
       "}"
       // Flatten string.
@@ skipping 1583 matching lines @@
   CompileRun("var root = new F;");
   Handle<JSObject> root = GetByName("root");
 
   // Count number of live transitions before marking.
   int transitions_before = CountMapTransitions(root->map());
   CHECK_EQ(transitions_count, transitions_before);
 
   CompileRun("o = new F;"
              "root = new F");
   root = GetByName("root");
-  DCHECK(TransitionArray::IsSimpleTransition(root->map()->raw_transitions()));
+  CHECK(TransitionArray::IsSimpleTransition(root->map()->raw_transitions()));
   AddPropertyTo(2, root, "happy");
 
   // Count number of live transitions after marking.  Note that one transition
   // is left, because 'o' still holds an instance of one transition target.
   int transitions_after = CountMapTransitions(
       Map::cast(root->map()->GetBackPointer()));
   CHECK_EQ(1, transitions_after);
 }
 #endif  // DEBUG
 
@@ skipping 1123 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   v8::HandleScope scope(reinterpret_cast<v8::Isolate*>(isolate));
   HandleScopeData* data = isolate->handle_scope_data();
   Handle<Object> init(heap->empty_string(), isolate);
   while (data->next < data->limit) {
     Handle<Object> obj(heap->empty_string(), isolate);
   }
   // An entire block of handles has been filled.
   // Next handle would require a new block.
-  DCHECK(data->next == data->limit);
+  CHECK(data->next == data->limit);
 
   DeferredHandleScope deferred(isolate);
   DummyVisitor visitor;
   isolate->handle_scope_implementer()->Iterate(&visitor);
   delete deferred.Detach();
 }
 
 
 TEST(IncrementalMarkingStepMakesBigProgressWithLargeObjects) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   CompileRun("function f(n) {"
              "    var a = new Array(n);"
              "    for (var i = 0; i < n; i += 100) a[i] = i;"
              "};"
              "f(10 * 1024 * 1024);");
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   if (marking->IsStopped()) {
     CcTest::heap()->StartIncrementalMarking();
   }
   // This big step should be sufficient to mark the whole array.
   marking->Step(100 * MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
-  DCHECK(marking->IsComplete() ||
-         marking->IsReadyToOverApproximateWeakClosure());
+  CHECK(marking->IsComplete() ||
+        marking->IsReadyToOverApproximateWeakClosure());
 }
 
 
 TEST(DisableInlineAllocation) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   CompileRun("function test() {"
              "  var x = [];"
              "  for (var i = 0; i < 10; i++) {"
@@ skipping 120 matching lines @@
                                            ->Get(context.local(), v8_str("bar"))
                                            .ToLocalChecked())));
     code = scope.CloseAndEscape(Handle<Code>(bar->code()));
   }
 
   // Now make sure that a gc should get rid of the function
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
 
-  DCHECK(code->marked_for_deoptimization());
+  CHECK(code->marked_for_deoptimization());
 }
 
 
 TEST(ObjectsInOptimizedCodeAreWeak) {
   if (i::FLAG_always_opt || !i::FLAG_crankshaft) return;
   i::FLAG_weak_embedded_objects_in_optimized_code = true;
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
@@ skipping 20 matching lines @@
                                            ->Get(context.local(), v8_str("bar"))
                                            .ToLocalChecked())));
     code = scope.CloseAndEscape(Handle<Code>(bar->code()));
   }
 
   // Now make sure that a gc should get rid of the function
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
 
-  DCHECK(code->marked_for_deoptimization());
+  CHECK(code->marked_for_deoptimization());
 }
 
 
 TEST(NoWeakHashTableLeakWithIncrementalMarking) {
   if (i::FLAG_always_opt || !i::FLAG_crankshaft) return;
   if (!i::FLAG_incremental_marking) return;
   i::FLAG_weak_embedded_objects_in_optimized_code = true;
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_compilation_cache = false;
   i::FLAG_retain_maps_for_n_gc = 0;
@@ skipping 668 matching lines @@
 TEST(Regress357137) {
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope hscope(isolate);
   v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
   global->Set(
       v8::String::NewFromUtf8(isolate, "interrupt", v8::NewStringType::kNormal)
           .ToLocalChecked(),
       v8::FunctionTemplate::New(isolate, RequestInterrupt));
   v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
-  DCHECK(!context.IsEmpty());
+  CHECK(!context.IsEmpty());
   v8::Context::Scope cscope(context);
 
   v8::Local<v8::Value> result = CompileRun(
       "var locals = '';"
       "for (var i = 0; i < 512; i++) locals += 'var v' + i + '= 42;';"
       "eval('function f() {' + locals + 'return function() { return v0; }; }');"
       "interrupt();"  // This triggers a fake stack overflow in f.
       "f()()");
   CHECK_EQ(42.0, result->ToNumber(context).ToLocalChecked()->Value());
 }
@@ skipping 917 matching lines @@
   isolate->IncrementJsCallsFromApiCounter();
   isolate->IncrementJsCallsFromApiCounter();
   isolate->IncrementJsCallsFromApiCounter();
   calls_per_ms = memory_reducer->SampleAndGetJsCallsPerMs(4);
   CheckDoubleEquals(2, calls_per_ms);
 }
 
 
 }  // namespace internal
 }  // namespace v8