Rename ASSERT* to DCHECK*.

test/cctest/test-parsing.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 654 matching lines @@
   static const unsigned kAllUtf8CharsSizeU =
       static_cast<unsigned>(kAllUtf8CharsSize);
 
   char buffer[kAllUtf8CharsSizeU];
   unsigned cursor = 0;
   for (int i = 0; i <= kMaxUC16Char; i++) {
     cursor += unibrow::Utf8::Encode(buffer + cursor,
                                     i,
                                     unibrow::Utf16::kNoPreviousCharacter);
   }
-  ASSERT(cursor == kAllUtf8CharsSizeU);
+  DCHECK(cursor == kAllUtf8CharsSizeU);
 
   i::Utf8ToUtf16CharacterStream stream(reinterpret_cast<const i::byte*>(buffer),
                                        kAllUtf8CharsSizeU);
   for (int i = 0; i <= kMaxUC16Char; i++) {
     CHECK_EQU(i, stream.pos());
     int32_t c = stream.Advance();
     CHECK_EQ(i, c);
     CHECK_EQU(i + 1, stream.pos());
   }
   for (int i = kMaxUC16Char; i >= 0; i--) {
@@ skipping 68 matching lines @@
       i::Token::CASE,
       i::Token::DEFAULT,
       i::Token::CONST,
       i::Token::LBRACE,
       // Skipped part here
       i::Token::RBRACE,
       i::Token::DO,
       i::Token::EOS,
       i::Token::ILLEGAL
   };
-  ASSERT_EQ('{', str2[19]);
-  ASSERT_EQ('}', str2[37]);
+  DCHECK_EQ('{', str2[19]);
+  DCHECK_EQ('}', str2[37]);
   TestStreamScanner(&stream2, expectations2, 20, 37);
 
   const char* str3 = "{}}}}";
   i::Token::Value expectations3[] = {
       i::Token::LBRACE,
       i::Token::RBRACE,
       i::Token::RBRACE,
       i::Token::RBRACE,
       i::Token::RBRACE,
       i::Token::EOS,
@@ skipping 2111 matching lines @@
   i::Context* context = f->context();
   i::AstValueFactory avf(&zone, isolate->heap()->HashSeed());
   avf.Internalize(isolate);
   const i::AstRawString* name = avf.GetOneByteString("result");
   i::Handle<i::String> str = name->string();
   CHECK(str->IsInternalizedString());
   i::Scope* global_scope =
       new (&zone) i::Scope(NULL, i::GLOBAL_SCOPE, &avf, &zone);
   global_scope->Initialize();
   i::Scope* s = i::Scope::DeserializeScopeChain(context, global_scope, &zone);
-  ASSERT(s != global_scope);
-  ASSERT(name != NULL);
+  DCHECK(s != global_scope);
+  DCHECK(name != NULL);
 
   // Get result from h's function context (that is f's context)
   i::Variable* var = s->Lookup(name);
 
   CHECK(var != NULL);
   // Maybe assigned should survive deserialization
   CHECK(var->maybe_assigned() == i::kMaybeAssigned);
   // TODO(sigurds) Figure out if is_used should survive context serialization.
 }
 
@@ skipping 25 matching lines @@
   i::Handle<i::Object> o = v8::Utils::OpenHandle(*v);
   i::Handle<i::JSFunction> f = i::Handle<i::JSFunction>::cast(o);
   i::Context* context = f->context();
   i::AstValueFactory avf(&zone, isolate->heap()->HashSeed());
   avf.Internalize(isolate);
 
   i::Scope* global_scope =
       new (&zone) i::Scope(NULL, i::GLOBAL_SCOPE, &avf, &zone);
   global_scope->Initialize();
   i::Scope* s = i::Scope::DeserializeScopeChain(context, global_scope, &zone);
-  ASSERT(s != global_scope);
+  DCHECK(s != global_scope);
   const i::AstRawString* name_x = avf.GetOneByteString("x");
 
   // Get result from f's function context (that is g's outer context)
   i::Variable* var_x = s->Lookup(name_x);
   CHECK(var_x != NULL);
   CHECK(var_x->maybe_assigned() == i::kMaybeAssigned);
 }
 
 
 TEST(ExportsMaybeAssigned) {
@@ skipping 26 matching lines @@
   i::Handle<i::Object> o = v8::Utils::OpenHandle(*v);
   i::Handle<i::JSFunction> f = i::Handle<i::JSFunction>::cast(o);
   i::Context* context = f->context();
   i::AstValueFactory avf(&zone, isolate->heap()->HashSeed());
   avf.Internalize(isolate);
 
   i::Scope* global_scope =
       new (&zone) i::Scope(NULL, i::GLOBAL_SCOPE, &avf, &zone);
   global_scope->Initialize();
   i::Scope* s = i::Scope::DeserializeScopeChain(context, global_scope, &zone);
-  ASSERT(s != global_scope);
+  DCHECK(s != global_scope);
   const i::AstRawString* name_x = avf.GetOneByteString("x");
   const i::AstRawString* name_f = avf.GetOneByteString("f");
   const i::AstRawString* name_y = avf.GetOneByteString("y");
   const i::AstRawString* name_B = avf.GetOneByteString("B");
   const i::AstRawString* name_C = avf.GetOneByteString("C");
 
   // Get result from h's function context (that is f's context)
   i::Variable* var_x = s->Lookup(name_x);
   CHECK(var_x != NULL);
   CHECK(var_x->maybe_assigned() == i::kMaybeAssigned);
@@ skipping 338 matching lines @@
 
     // Arrow has more precedence, this is the same as: foo ? bar : (baz = {})
     "foo ? bar : baz => {}",
     NULL
   };
 
   static const ParserFlag always_flags[] = {kAllowArrowFunctions};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, ARRAY_SIZE(always_flags));
 }