Make the debugger completely unload when the debug event listener is unregist...

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 345 matching lines @@
 
   return debugged_functions;
 }
 
 
 static Handle<Code> ComputeCallDebugBreak(int argc) {
   CALL_HEAP_FUNCTION(v8::internal::StubCache::ComputeCallDebugBreak(argc),
                      Code);
 }
 
+
+// Check that the debugger is loaded.
+static void CheckDebuggerLoaded() {
+  CHECK(Debug::debug_context().is_null());
+}
+
+
+// Check that the debugger has been fully unloaded. 
+static void CheckDebuggerUnloaded(bool check_functions) {
+  // Check that the debugger context is cleared and that there is no debug
+  // information stored for the debugger.
+  CHECK(Debug::debug_context().is_null());
+  CHECK_EQ(NULL, Debug::debug_info_list_);
+
+  // Collect garbage to ensure weak handles are cleared.
+  Heap::CollectAllGarbage();
+  Heap::CollectAllGarbage();
+
+  // Iterate the head and check that there are no debugger related objects left.
+  HeapIterator iterator;
+  while (iterator.has_next()) {
+    HeapObject* obj = iterator.next();
+    CHECK(obj != NULL);
+    CHECK(!obj->IsDebugInfo());
+    CHECK(!obj->IsBreakPointInfo());
+
+    // If deep check of functions is requested check that no debug break code
+    // is left in all functions.
+    if (check_functions) {
+      if (obj->IsJSFunction()) {
+        JSFunction* fun = JSFunction::cast(obj);
+        for (RelocIterator it(fun->shared()->code()); !it.done(); it.next()) {
+          RelocInfo::Mode rmode = it.rinfo()->rmode();
+          if (RelocInfo::IsCodeTarget(rmode)) {
+            CHECK(!Debug::IsDebugBreak(it.rinfo()->target_address()));
+          } else if (RelocInfo::IsJSReturn(rmode)) {
+            CHECK(!Debug::IsDebugBreakAtReturn(it.rinfo()));
+          }
+        }
+      }
+    }
+  }
+}
+
+
 } }  // namespace v8::internal
 
+
+// Check that the debugger is loaded.
+static void CheckDebuggerLoaded() {
+  v8::internal::CheckDebuggerLoaded();
+}
+
+
+// Check that the debugger has been fully unloaded.
+static void CheckDebuggerUnloaded(bool check_functions = false) {
+  v8::internal::CheckDebuggerUnloaded(check_functions);
+}
+
+
 // Inherit from BreakLocationIterator to get access to protected parts for
 // testing.
 class TestBreakLocationIterator: public v8::internal::BreakLocationIterator {
  public:
   explicit TestBreakLocationIterator(Handle<v8::internal::DebugInfo> debug_info)
     : BreakLocationIterator(debug_info, v8::internal::SOURCE_BREAK_LOCATIONS) {}
   v8::internal::RelocIterator* it() { return reloc_iterator_; }
   v8::internal::RelocIterator* it_original() {
     return reloc_iterator_original_;
   }
@@ skipping 438 matching lines @@
   CHECK(!HasDebugInfo(foo));
   CHECK(!HasDebugInfo(bar));
 }
 
 
 // Test that a break point can be set at an IC store location.
 TEST(BreakPointICStore) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
+
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Script::Compile(v8::String::New("function foo(){bar=0;}"))->Run();
   v8::Local<v8::Function> foo =
       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
 
   // Run without breakpoints.
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test that a break point can be set at an IC load location.
 TEST(BreakPointICLoad) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
@@ skipping 12 matching lines @@
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test that a break point can be set at an IC call location.
 TEST(BreakPointICCall) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
@@ skipping 12 matching lines @@
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test that a break point can be set at a return store location.
 TEST(BreakPointReturn) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
@@ skipping 11 matching lines @@
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 static void CallWithBreakPoints(v8::Local<v8::Object> recv,
                                 v8::Local<v8::Function> f,
                                 int break_point_count,
                                 int call_count) {
   break_point_hit_count = 0;
   for (int i = 0; i < call_count; i++) {
     f->Call(recv, 0, NULL);
@@ skipping 25 matching lines @@
   foo = CompileFunction(&env, "function bar(){};function foo(){bar();}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(env->Global(), foo, 1, 10);
 
   // Test return break point with garbage collection.
   foo = CompileFunction(&env, "function foo(){}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(env->Global(), foo, 1, 25);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Call the function three times with different garbage collections in between
 // and make sure that the break point survives.
 static void CallAndGC(v8::Local<v8::Object> recv, v8::Local<v8::Function> f) {
   break_point_hit_count = 0;
 
   for (int i = 0; i < 3; i++) {
     // Call function.
@@ skipping 37 matching lines @@
   foo = CompileFunction(&env, "function bar(){};function foo(){bar();}", "foo");
   SetBreakPoint(foo, 0);
   CallAndGC(env->Global(), foo);
 
   // Test return break point with garbage collection.
   foo = CompileFunction(&env, "function foo(){}", "foo");
   SetBreakPoint(foo, 0);
   CallAndGC(env->Global(), foo);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test that break points can be set using the global Debug object.
 TEST(BreakPointThroughJavaScript) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
@@ skipping 30 matching lines @@
   CHECK_EQ(7, break_point_hit_count);
   foo->Run();
   CHECK_EQ(8, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPointFromJS(bp1);
   foo->Run();
   CHECK_EQ(8, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, bp1);
   CHECK_EQ(2, bp2);
 }
 
 
 // Test that break points can be set using the global Debug object.
 TEST(ScriptBreakPointThroughJavaScript) {
   break_point_hit_count = 0;
@@ skipping 94 matching lines @@
 
   // Reload the script and get g again checking that the break point survives.
   // This tests that the function break point was converted to a script break
   // point.
   v8::Script::Compile(script, &origin)->Run();
   g = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, sbp1);
   CHECK_EQ(2, sbp2);
   CHECK_EQ(3, sbp3);
   CHECK_EQ(4, sbp4);
   CHECK_EQ(5, sbp5);
   CHECK_EQ(6, sbp6);
   CHECK_EQ(7, bp7);
 }
@@ skipping 45 matching lines @@
   v8::Script::Compile(script, &origin)->Run();
   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);
 
   EnableScriptBreakPointFromJS(sbp);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(3, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test conditional script break points.
 TEST(ConditionalScriptBreakPoint) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
@@ skipping 41 matching lines @@
   v8::Script::Compile(script, &origin)->Run();
   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
 
   break_point_hit_count = 0;
   for (int i = 0; i < 10; i++) {
     f->Call(env->Global(), 0, NULL);
   }
   CHECK_EQ(5, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test ignore count on script break points.
 TEST(ScriptBreakPointIgnoreCount) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
@@ skipping 34 matching lines @@
   v8::Script::Compile(script, &origin)->Run();
   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
 
   break_point_hit_count = 0;
   for (int i = 0; i < 10; i++) {
     f->Call(env->Global(), 0, NULL);
   }
   CHECK_EQ(5, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test that script break points survive when a script is reloaded.
 TEST(ScriptBreakPointReload) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
@@ skipping 38 matching lines @@
   // Compile the script again and get the function.
   v8::Script::Compile(script, &origin_1)->Run();
   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
 
   // Call f and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test when several scripts has the same script data
 TEST(ScriptBreakPointMultiple) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
@@ skipping 45 matching lines @@
   sbp = SetScriptBreakPointFromJS("test", 1, 0);
 
   // Call f and g and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test the script origin which has both name and line offset.
 TEST(ScriptBreakPointLineOffset) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
@@ skipping 35 matching lines @@
 
   // Set a script break point with the script loaded.
   sbp1 = SetScriptBreakPointFromJS("test.html", 9, 0);
 
   // Call f and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test script break points set on lines.
 TEST(ScriptBreakPointLine) {
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
   // Create a function for checking the function when hitting a break point.
@@ skipping 85 matching lines @@
   // Clear the last break points, and reload the script which should not hit any
   // break points.
   ClearBreakPointFromJS(sbp1);
   ClearBreakPointFromJS(sbp5);
   ClearBreakPointFromJS(sbp6);
   break_point_hit_count = 0;
   v8::Script::Compile(script, &origin)->Run();
   CHECK_EQ(0, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test that it is possible to remove the last break point for a function
 // inside the break handling of that break point.
 TEST(RemoveBreakPointInBreak) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   v8::Local<v8::Function> foo =
       CompileFunction(&env, "function foo(){a=1;}", "foo");
   debug_event_remove_break_point = SetBreakPoint(foo, 0);
 
   // Register the debug event listener pasing the function
   v8::Debug::SetDebugEventListener(DebugEventRemoveBreakPoint, foo);
 
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test that the debugger statement causes a break.
 TEST(DebuggerStatement) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Script::Compile(v8::String::New("function bar(){debugger}"))->Run();
   v8::Script::Compile(v8::String::New(
       "function foo(){debugger;debugger;}"))->Run();
   v8::Local<v8::Function> foo =
       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
   v8::Local<v8::Function> bar =
       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("bar")));
 
   // Run function with debugger statement
   bar->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   // Run function with two debugger statement
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(3, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Thest that the evaluation of expressions when a break point is hit generates
 // the correct results.
 TEST(DebugEvaluate) {
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
@@ skipping 94 matching lines @@
   // Call bar setting breakpoint after a=x in barbar and parameter
   // "Hello, world!".
   checks = checks_hh;
   v8::Handle<v8::Value> argv_bar_3[2] = {
     v8::String::New("Hello, world!"),
     v8::Number::New(barbar_break_position + 1)
   };
   bar->Call(env->Global(), 2, argv_bar_3);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Simple test of the stepping mechanism using only store ICs.
 TEST(DebugStepLinear) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for testing stepping.
   v8::Local<v8::Function> foo = CompileFunction(&env,
                                                 "function foo(){a=1;b=1;c=1;}",
                                                 "foo");
   SetBreakPoint(foo, 3);
 
   // Register a debug event listener which steps and counts.
   v8::Debug::SetDebugEventListener(DebugEventStep);
 
   step_action = StepIn;
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // With stepping all break locations are hit.
   CHECK_EQ(4, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 
   // Register a debug event listener which just counts.
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
 
+  SetBreakPoint(foo, 3);
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // Without stepping only active break points are hit.
   CHECK_EQ(1, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test the stepping mechanism with different ICs.
 TEST(DebugStepLinearMixedICs) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for testing stepping.
   v8::Local<v8::Function> foo = CompileFunction(&env,
@@ skipping 14 matching lines @@
 
   // With stepping all break locations are hit. For ARM the keyed load/store
   // is not hit as they are not implemented as ICs.
 #if defined (__arm__) || defined(__thumb__)
   CHECK_EQ(6, break_point_hit_count);
 #else
   CHECK_EQ(8, break_point_hit_count);
 #endif
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 
   // Register a debug event listener which just counts.
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
 
+  SetBreakPoint(foo, 0);
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // Without stepping only active break points are hit.
   CHECK_EQ(1, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 TEST(DebugStepIf) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Register a debug event listener which steps and counts.
   v8::Debug::SetDebugEventListener(DebugEventStep);
 
@@ skipping 20 matching lines @@
 
   // Stepping through the false part.
   step_action = StepIn;
   break_point_hit_count = 0;
   v8::Handle<v8::Value> argv_false[argc] = { v8::False() };
   foo->Call(env->Global(), argc, argv_false);
   CHECK_EQ(4, break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 TEST(DebugStepSwitch) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Register a debug event listener which steps and counts.
   v8::Debug::SetDebugEventListener(DebugEventStep);
 
@@ skipping 32 matching lines @@
 
   // Last case.
   step_action = StepIn;
   break_point_hit_count = 0;
   v8::Handle<v8::Value> argv_3[argc] = { v8::Number::New(3) };
   foo->Call(env->Global(), argc, argv_3);
   CHECK_EQ(4, break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 TEST(DebugStepFor) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Register a debug event listener which steps and counts.
   v8::Debug::SetDebugEventListener(DebugEventStep);
 
@@ skipping 17 matching lines @@
 
   // Looping 100 times.
   step_action = StepIn;
   break_point_hit_count = 0;
   v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(100) };
   foo->Call(env->Global(), argc, argv_100);
   CHECK_EQ(203, break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 TEST(StepInOutSimple) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
@@ skipping 25 matching lines @@
 
   // Step through invocation of a with step out.
   step_action = StepOut;
   break_point_hit_count = 0;
   expected_step_sequence = "a";
   a->Call(env->Global(), 0, NULL);
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 TEST(StepInOutTree) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
@@ skipping 26 matching lines @@
 
   // Step through invocation of a with step out.
   step_action = StepOut;
   break_point_hit_count = 0;
   expected_step_sequence = "a";
   a->Call(env->Global(), 0, NULL);
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded(true);
 }
 
 
 TEST(StepInOutBranch) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
@@ skipping 11 matching lines @@
 
   // Step through invocation of a.
   step_action = StepIn;
   break_point_hit_count = 0;
   expected_step_sequence = "abaca";
   a->Call(env->Global(), 0, NULL);
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test that step in does not step into native functions.
 TEST(DebugStepNatives) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for testing stepping.
   v8::Local<v8::Function> foo = CompileFunction(
       &env,
       "function foo(){debugger;Math.sin(1);}",
       "foo");
 
   // Register a debug event listener which steps and counts.
   v8::Debug::SetDebugEventListener(DebugEventStep);
 
   step_action = StepIn;
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // With stepping all break locations are hit.
   CHECK_EQ(3, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 
   // Register a debug event listener which just counts.
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
 
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // Without stepping only active break points are hit.
   CHECK_EQ(1, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test break on exceptions. For each exception break combination the number
 // of debug event exception callbacks and message callbacks are collected. The
 // number of debug event exception callbacks are used to check that the
 // debugger is called correctly and the number of message callbacks is used to
 // check that uncaught exceptions are still returned even if there is a break
 // for them.
 TEST(BreakOnException) {
@@ skipping 126 matching lines @@
   caught->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, exception_hit_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   notCaught->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, exception_hit_count);
   CHECK_EQ(1, uncaught_exception_hit_count);
   CHECK_EQ(1, message_callback_count);
 
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
   v8::V8::RemoveMessageListeners(MessageCallbackCount);
 }
 
 
 // Test break on exception from compiler errors. When compiling using
 // v8::Script::Compile there is no JavaScript stack whereas when compiling using
 // eval there are JavaScript frames.
 TEST(BreakOnCompileException) {
   v8::HandleScope scope;
   DebugLocalContext env;
@@ skipping 116 matching lines @@
   // Step through invocation of f + g + h now with break on caught exceptions.
   ChangeBreakOnException(true, true);
   step_action = StepIn;
   break_point_hit_count = 0;
   expected_step_sequence = "ffghhf";
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // 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);
@@ skipping 33 matching lines @@
     f1->Call(env->Global(), i, argv);
     f2->Call(env->Global(), i, argv);
     f3->Call(env->Global(), i, argv);
   }
 
   // One break for each function called.
   CHECK_EQ(4 * ARRAY_SIZE(argv), break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Test to ensure that JavaScript code keeps running while the debug break
 // through the stack limit flag is set but breaks are disabled.
 TEST(DisableBreak) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Register a debug event listener which sets the break flag and counts.
@@ skipping 16 matching lines @@
     v8::internal::DisableBreak disable_break(true);
     f->Call(env->Global(), 0, NULL);
     CHECK_EQ(1, break_point_hit_count);
   }
 
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 static v8::Handle<v8::Array> NamedEnum(const v8::AccessorInfo&) {
   v8::Handle<v8::Array> result = v8::Array::New(3);
   result->Set(v8::Integer::New(0), v8::String::New("a"));
   result->Set(v8::Integer::New(1), v8::String::New("b"));
   result->Set(v8::Integer::New(2), v8::String::New("c"));
   return result;
 }
@@ skipping 911 matching lines @@
                                       "  CheckSourceLine(2)\n"
                                       "  CheckSourceLine(3)\n"
                                       "}; f()"))->Run();
 
   // Test that a parameter can be passed to a function called in the debugger.
   v8::Script::Compile(v8::String::New("CheckDataParameter()"))->Run();
 
   // Test that a function with closure can be run in the debugger.
   v8::Script::Compile(v8::String::New("CheckClosure()"))->Run();
 }
+
+
+// Test that clearing the debug event listener actually clears all break points
+// and related information.
+TEST(DebuggerUnload) {
+  v8::HandleScope scope;
+  DebugLocalContext env;
+
+  // Check debugger is unloaded before it is used.
+  CheckDebuggerUnloaded();
+
+  // Add debug event listener.
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
+                                   v8::Undefined());
+  CheckDebuggerLoaded();
+
+  // Create a couple of functions for the test.
+  v8::Local<v8::Function> foo =
+      CompileFunction(&env, "function foo(){x=1}", "foo");
+  v8::Local<v8::Function> bar =
+      CompileFunction(&env, "function bar(){y=2}", "bar");
+
+  // Set some break points.
+  SetBreakPoint(foo, 0);
+  SetBreakPoint(foo, 4);
+  SetBreakPoint(bar, 0);
+  SetBreakPoint(bar, 4);
+
+  // Make sure that the break points are there.
+  break_point_hit_count = 0;
+  foo->Call(env->Global(), 0, NULL);
+  CHECK_EQ(2, break_point_hit_count);
+  bar->Call(env->Global(), 0, NULL);
+  CHECK_EQ(4, break_point_hit_count);
+
+  // Remove the debug event listener without clearing breakpoints.
+  v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded(true);
+
+  // Set a new debug event listener.
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
+                                   v8::Undefined());
+  CheckDebuggerLoaded();
+
+  // Check that the break points was actually cleared.
+  break_point_hit_count = 0;
+  foo->Call(env->Global(), 0, NULL);
+  CHECK_EQ(0, break_point_hit_count);
+
+  // Set break points and run again.
+  SetBreakPoint(foo, 0);
+  SetBreakPoint(foo, 4);
+  foo->Call(env->Global(), 0, NULL);
+  CHECK_EQ(2, break_point_hit_count);
+
+  // Remove the debug event listener without clearing breakpoints again.
+  v8::Debug::SetDebugEventListener(NULL);
+  CheckDebuggerUnloaded(true);
+}