Changed the ASSERT's in the cctest's to CHECK's

test/cctest/test-debug.cc

 // Copyright 2007-2008 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 214 matching lines @@
     // Column not specified set script break point on line.
     OS::SNPrintF(buffer,
                  "debug.Debug.setScriptBreakPointById(%d,%d)",
                  script_id, line);
   }
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
   {
     v8::TryCatch try_catch;
     v8::Handle<v8::String> str = v8::String::New(buffer.start());
     v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();
-    ASSERT(!try_catch.HasCaught());
+    CHECK(!try_catch.HasCaught());
     return value->Int32Value();
   }
 }
 
 
 // Set a break point in a script identified by name using the global Debug
 // object.
 static int SetScriptBreakPointByNameFromJS(const char* script_name,
                                            int line, int column) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
   if (column >= 0) {
     // Column specified set script break point on precise location.
     OS::SNPrintF(buffer,
                  "debug.Debug.setScriptBreakPointByName(\"%s\",%d,%d)",
                  script_name, line, column);
   } else {
     // Column not specified set script break point on line.
     OS::SNPrintF(buffer,
                  "debug.Debug.setScriptBreakPointByName(\"%s\",%d)",
                  script_name, line);
   }
   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
   {
     v8::TryCatch try_catch;
     v8::Handle<v8::String> str = v8::String::New(buffer.start());
     v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();
-    ASSERT(!try_catch.HasCaught());
+    CHECK(!try_catch.HasCaught());
     return value->Int32Value();
   }
 }
 
 
 // Clear a break point.
 static void ClearBreakPoint(int break_point) {
   Debug::ClearBreakPoint(
       Handle<Object>(v8::internal::Smi::FromInt(break_point)));
 }
@@ skipping 2665 matching lines @@
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 TEST(DebugBreak) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
-  // This test should be run with option --verify-heap. This is an ASSERT and
-  // not a CHECK as --verify-heap is only available in debug mode.
-  ASSERT(v8::internal::FLAG_verify_heap);
+  // This test should be run with option --verify-heap. As --verify-heap is
+  // only available in debug mode only check for it in that case.
+#ifdef DEBUG
+  CHECK(v8::internal::FLAG_verify_heap);
+#endif
 
   // Register a debug event listener which sets the break flag and counts.
   v8::Debug::SetDebugEventListener(DebugEventBreak);
 
   // Create a function for testing stepping.
   const char* src = "function f0() {}"
                     "function f1(x1) {}"
                     "function f2(x1,x2) {}"
                     "function f3(x1,x2,x3) {}";
   v8::Local<v8::Function> f0 = CompileFunction(&env, src, "f0");
@@ skipping 393 matching lines @@
 // Do not call, due to race condition with Wait().
 // Could be resolved with Pthread condition variables.
 ThreadBarrier::~ThreadBarrier() {
   lock_->Lock();
   delete lock_;
   delete sem_;
 }
 
 void ThreadBarrier::Wait() {
   lock_->Lock();
-  ASSERT(!invalid_);
+  CHECK(!invalid_);
   if (num_blocked_ == num_threads_ - 1) {
     // Signal and unblock all waiting threads.
     for (int i = 0; i < num_threads_ - 1; ++i) {
       sem_->Signal();
     }
     invalid_ = true;
     printf("BARRIER\n\n");
     fflush(stdout);
     lock_->Unlock();
   } else {  // Wait for the semaphore.
@@ skipping 184 matching lines @@
 TEST(MessageQueueExpandAndDestroy) {
   TestClientData::ResetCounters();
   { // Create a scope for the queue.
     CommandMessageQueue queue(1);
     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
                                   new TestClientData()));
     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
                                   new TestClientData()));
     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
                                   new TestClientData()));
-    ASSERT_EQ(0, TestClientData::destructor_call_counter);
+    CHECK_EQ(0, TestClientData::destructor_call_counter);
     queue.Get().Dispose();
-    ASSERT_EQ(1, TestClientData::destructor_call_counter);
+    CHECK_EQ(1, TestClientData::destructor_call_counter);
     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
                                   new TestClientData()));
     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
                                   new TestClientData()));
     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
                                   new TestClientData()));
     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
                                   new TestClientData()));
     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
                                   new TestClientData()));
-    ASSERT_EQ(1, TestClientData::destructor_call_counter);
+    CHECK_EQ(1, TestClientData::destructor_call_counter);
     queue.Get().Dispose();
-    ASSERT_EQ(2, TestClientData::destructor_call_counter);
+    CHECK_EQ(2, TestClientData::destructor_call_counter);
   }
   // All the client data should be destroyed when the queue is destroyed.
-  ASSERT_EQ(TestClientData::destructor_call_counter,
-            TestClientData::destructor_call_counter);
+  CHECK_EQ(TestClientData::destructor_call_counter,
+           TestClientData::destructor_call_counter);
 }
 
 
 static int handled_client_data_instances_count = 0;
 static void MessageHandlerCountingClientData(
     const uint16_t* message,
     int length,
     v8::Debug::ClientData* client_data) {
   if (client_data) {
     handled_client_data_instances_count++;
@@ skipping 29 matching lines @@
 
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_1, buffer),
                          new TestClientData());
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer), NULL);
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer),
                          new TestClientData());
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer),
                          new TestClientData());
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_continue, buffer));
   CompileRun(source_1);
-  ASSERT_EQ(3, TestClientData::constructor_call_counter);
-  ASSERT_EQ(TestClientData::constructor_call_counter,
-            handled_client_data_instances_count);
-  ASSERT_EQ(TestClientData::constructor_call_counter,
-            TestClientData::destructor_call_counter);
+  CHECK_EQ(3, TestClientData::constructor_call_counter);
+  CHECK_EQ(TestClientData::constructor_call_counter,
+           handled_client_data_instances_count);
+  CHECK_EQ(TestClientData::constructor_call_counter,
+           TestClientData::destructor_call_counter);
 }
 
 
 /* Test ThreadedDebugging */
 /* This test interrupts a running infinite loop that is
  * occupying the v8 thread by a break command from the
  * debugger thread.  It then changes the value of a
  * global object, to make the loop terminate.
  */
 
@@ skipping 916 matching lines @@
   v8::ScriptOrigin origin2 = v8::ScriptOrigin(v8::String::New("new name"));
   v8::Handle<v8::Script> script2 = v8::Script::Compile(script, &origin2);
   script2->Run();
   script2->SetData(data_obj);
   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
   CHECK_EQ("new name", last_script_name_hit);
   CHECK_EQ("abc 123", last_script_data_hit);
 }