CSE2410 Fall 2014 Bounce

#include <stdlib.h>

#include "v8.h"

#include "api.h"

#include "platform/socket.h"

#include "stub-cache.h"

#include "utils.h"

using ::v8::internal::Mutex;

      v8::Handle<v8::ObjectTemplate> global_template =

          v8::Handle<v8::ObjectTemplate>(),

      v8::Handle<v8::Value> global_object = v8::Handle<v8::Value>())

        context_(

                           extensions,

                           global_template,

                           global_object)) {

static v8::Local<v8::Function> CompileFunction(const char* source,

                                               const char* function_name) {

  v8::Script::Compile(v8::String::New(source))->Run();

  return v8::Local<v8::Function>::Cast(

}

// Clear a break point.

static void ClearBreakPoint(int break_point) {

  v8::internal::Debug* debug = isolate->debug();

  debug->ClearBreakPoint(

      Handle<Object>(v8::internal::Smi::FromInt(break_point), isolate));

// Change break on exception.

static void ChangeBreakOnException(bool caught, bool uncaught) {

  debug->ChangeBreakOnException(v8::internal::BreakException, caught);

  debug->ChangeBreakOnException(v8::internal::BreakUncaughtException, uncaught);

}

// Prepare to step to next break location.

static void PrepareStep(StepAction step_action) {

  debug->PrepareStep(step_action, 1, StackFrame::NO_ID);

}

// Collect the currently debugged functions.

Handle<FixedArray> GetDebuggedFunctions() {

  v8::internal::DebugInfoListNode* node = debug->debug_info_list_;

  // Allocate array for the debugged functions

  Handle<FixedArray> debugged_functions =

  // Run through the debug info objects and collect all functions.

  count = 0;

static Handle<Code> ComputeCallDebugBreak(int argc) {

                                                                 Code::CALL_IC);

}

void CheckDebuggerUnloaded(bool check_functions) {

  // Check that the debugger context is cleared and that there is no debug

  // information stored for the debugger.

  // Collect garbage to ensure weak handles are cleared.

  // Iterate the head and check that there are no debugger related objects left.

  for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {

    CHECK(!obj->IsDebugInfo());

    CHECK(!obj->IsBreakPointInfo());

void ForceUnloadDebugger() {

}

                             const char* source, const char* name,

                             int position, v8::internal::RelocInfo::Mode mode,

                             Code* debug_break) {

  // Create function and set the break point.

  Handle<v8::internal::JSFunction> fun = v8::Utils::OpenHandle(

  v8::DebugEvent event = event_details.GetEvent();

  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();

  v8::Handle<v8::Object> event_data = event_details.GetEventData();

  Debug* debug = isolate->debug();

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(debug->break_id(), 0);

  v8::DebugEvent event = event_details.GetEvent();

  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();

  v8::Handle<v8::Object> event_data = event_details.GetEventData();

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(debug->break_id(), 0);

    const v8::Debug::EventDetails& event_details) {

  v8::DebugEvent event = event_details.GetEvent();

  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(debug->break_id(), 0);

    const v8::Debug::EventDetails& event_details) {

  v8::DebugEvent event = event_details.GetEvent();

  v8::Handle<v8::Value> data = event_details.GetCallbackData();

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(debug->break_id(), 0);

static void DebugEventStep(

    const v8::Debug::EventDetails& event_details) {

  v8::DebugEvent event = event_details.GetEvent();

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(debug->break_id(), 0);

    const v8::Debug::EventDetails& event_details) {

  v8::DebugEvent event = event_details.GetEvent();

  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(debug->break_id(), 0);

static void DebugEventBreakPointCollectGarbage(

    const v8::Debug::EventDetails& event_details) {

  v8::DebugEvent event = event_details.GetEvent();

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(debug->break_id(), 0);

    break_point_hit_count++;

    if (break_point_hit_count % 2 == 0) {

      // Scavenge.

    } else {

      // Mark sweep compact.

    }

  }

}

static void DebugEventBreak(

    const v8::Debug::EventDetails& event_details) {

  v8::DebugEvent event = event_details.GetEvent();

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(debug->break_id(), 0);

    // Run the garbage collector to enforce heap verification if option

    // --verify-heap is set.

    // Set the break flag again to come back here as soon as possible.

  }

}

    const v8::Debug::EventDetails& event_details) {

  v8::DebugEvent event = event_details.GetEvent();

  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();

  v8::internal::Debug* debug = isolate->debug();

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(debug->break_id(), 0);

      }

      // Set the break flag again to come back here as soon as possible.

    } else if (terminate_after_max_break_point_hit) {

      // Terminate execution after the last break if requested.

    }

    // Perform a full deoptimization when the specified number of

                          "function f2(){x=1;}", "f2",

                          0,

                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,

                              Builtins::kStoreIC_DebugBreak));

  CheckDebugBreakFunction(&env,

                          "function f3(){var a=x;}", "f3",

                          0,

                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,

                              Builtins::kLoadIC_DebugBreak));

// TODO(1240753): Make the test architecture independent or split

      "f4",

      0,

      v8::internal::RelocInfo::CODE_TARGET,

          Builtins::kKeyedStoreIC_DebugBreak));

  CheckDebugBreakFunction(

      &env,

      "f5",

      0,

      v8::internal::RelocInfo::CODE_TARGET,

          Builtins::kKeyedLoadIC_DebugBreak));

#endif

      "f6",

      0,

      v8::internal::RelocInfo::CODE_TARGET,

          Builtins::kCompareNilIC_DebugBreak));

  // Check the debug break code stubs for call ICs with different number of

    CHECK_EQ(1 + i * 3, break_point_hit_count);

    // Scavenge and call function.

    f->Call(recv, 0, NULL);

    CHECK_EQ(2 + i * 3, break_point_hit_count);

    // Mark sweep (and perhaps compact) and call function.

    f->Call(recv, 0, NULL);

    CHECK_EQ(3 + i * 3, break_point_hit_count);

  }

  }

  f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));

  SetScriptBreakPointByNameFromJS("test.html", 3, -1);

// the correct results.

TEST(DebugEvaluate) {

  DebugLocalContext env;

  env.ExposeDebug();

  // Create a function for checking the evaluation when hitting a break point.

  // Different expected vaules of x and a when in a break point (u = undefined,

  // d = Hello, world!).

  struct EvaluateCheck checks_uu[] = {

    {NULL, v8::Handle<v8::Value>()}

  };

  struct EvaluateCheck checks_hu[] = {

    {"x", v8::String::New("Hello, world!")},

    {NULL, v8::Handle<v8::Value>()}

  };

  struct EvaluateCheck checks_hh[] = {

  // parameter.

  checks = checks_uu;

  v8::Handle<v8::Value> argv_bar_1[2] = {

    v8::Number::New(barbar_break_position)

  };

  bar->Call(env->Global(), 2, argv_bar_1);

static void CheckDebugEval(const v8::Debug::EventDetails& eventDetails) {

  if (eventDetails.GetEvent() == v8::Break) {

    ++debugEventCount;

    v8::Handle<v8::Value> args[] = { eventDetails.GetExecutionState() };

    CHECK(checkGlobalEvalFunction->Call(

      "    \"expression\":\"v1\",\"disable_break\":true"

      "}}";

  const char* command_112 = "{\"seq\":112,"

      "\"type\":\"request\","

      "    \"expression\":\"getAnimal()\",\"disable_break\":true"

      "}}";

  const char* command_113 = "{\"seq\":113,"

     "\"type\":\"request\","

     "    \"expression\":\"239 + 566\",\"disable_break\":true"

     "}}";

  v8::Debug::ProcessDebugMessages();

  foo->Call(env->Global(), kArgc, args);

  // With stepping all break locations are hit.

  v8::Debug::SetDebugEventListener2(NULL);

  CheckDebuggerUnloaded();

  foo->Call(env->Global(), kArgc, args);

  // With stepping all break locations are hit.

  v8::Debug::SetDebugEventListener2(NULL);

  CheckDebuggerUnloaded();

  foo->Call(env->Global(), 0, NULL);

  // With stepping all break locations are hit.

  v8::Debug::SetDebugEventListener2(NULL);

  CheckDebuggerUnloaded();

// Test of the stepping mechanism for named load in a loop.

TEST(DebugStepNamedStoreLoop) {

}

TEST(DebugStepIf) {

  DebugLocalContext env;

  // Register a debug event listener which steps and counts.

  v8::Debug::SetDebugEventListener2(DebugEventStep);

  // Stepping through the true part.

  step_action = StepIn;

  break_point_hit_count = 0;

  foo->Call(env->Global(), argc, argv_true);

  CHECK_EQ(4, break_point_hit_count);

  // Stepping through the false part.

  step_action = StepIn;

  break_point_hit_count = 0;

  foo->Call(env->Global(), argc, argv_false);

  CHECK_EQ(5, break_point_hit_count);

  v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(10) };

  result = foo->Call(env->Global(), argc, argv_10);

  CHECK_EQ(5, result->Int32Value());

  // Looping 100 times.

  step_action = StepIn;

  v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(100) };

  result = foo->Call(env->Global(), argc, argv_100);

  CHECK_EQ(50, result->Int32Value());

  // Get rid of the debug event listener.

  v8::Debug::SetDebugEventListener2(NULL);

  v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(10) };

  result = foo->Call(env->Global(), argc, argv_10);

  CHECK_EQ(9, result->Int32Value());

  // Looping 100 times.

  step_action = StepIn;

  v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(100) };

  result = foo->Call(env->Global(), argc, argv_100);

  CHECK_EQ(99, result->Int32Value());

  // Get rid of the debug event listener.

  v8::Debug::SetDebugEventListener2(NULL);

TEST(DebugConditional) {

  DebugLocalContext env;

  // Register a debug event listener which steps and counts.

  v8::Debug::SetDebugEventListener2(DebugEventStep);

  step_action = StepIn;

  break_point_hit_count = 0;

  const int argc = 1;

  foo->Call(env->Global(), argc, argv_true);

  CHECK_EQ(5, break_point_hit_count);

// Test that step in works with function.call.

TEST(DebugStepFunctionCall) {

  DebugLocalContext env;

  // Create a function for testing stepping.

  v8::Local<v8::Function> foo = CompileFunction(

  // Check stepping where the if condition in bar is true.

  break_point_hit_count = 0;

  const int argc = 1;

  foo->Call(env->Global(), argc, argv);

  CHECK_EQ(8, break_point_hit_count);

  v8::HandleScope scope(env->GetIsolate());

  env.ExposeDebug();

  // Create functions for testing break on exception.

  CompileFunction(&env, "function throws(){throw 1;}", "throws");

  // For this test, we want to break on uncaught exceptions:

  ChangeBreakOnException(false, true);

  // Create a function for checking the function when hitting a break point.

  frame_count = CompileFunction(&env, frame_count_source, "frame_count");

  f3->Call(env->Global(), 0, NULL);

  // Set the debug break flag.

  // Call all functions with different argument count.

  break_point_hit_count = 0;

  v8::Local<v8::Function> f = CompileFunction(&env, src, "f");

  // Set the debug break flag.

  // Call all functions with different argument count.

  break_point_hit_count = 0;

  CHECK_EQ(1, break_point_hit_count);

  {

    i::Isolate* isolate = reinterpret_cast<i::Isolate*>(env->GetIsolate());

    v8::internal::DisableBreak disable_break(isolate, true);

    f->Call(env->Global(), 0, NULL);

// http://crbug.com/28933

// Test that debug break is disabled when bootstrapper is active.

TEST(NoBreakWhenBootstrapping) {

  v8::HandleScope scope(isolate);

  // Register a debug event listener which sets the break flag and counts.

  v8::Debug::SetDebugEventListener2(DebugEventCounter);

  // Set the debug break flag.

  break_point_hit_count = 0;

  {

    // Create a context with an extension to make sure that some JavaScript

  // until the execution of source_2.

  // Note: AsciiToUtf16 executes before SendCommand, so command is copied

  // to buffer before buffer is sent to SendCommand.

  message_queue_barriers.barrier_2.Wait();

  // Main thread compiles and runs source_2.

  // Queued commands are executed at the start of compilation of source_2(

  // Wait on break event from hitting "debugger" statement

  message_queue_barriers.semaphore_2.Wait();

  // These should execute after the "debugger" statement in source_2

  // Run after 2 break events, 4 responses.

  for (int i = 0; i < 6 ; ++i) {

    message_queue_barriers.semaphore_1.Signal();

  }

  // Wait on break event after a single step executes.

  message_queue_barriers.semaphore_2.Wait();

  // Run after 2 responses.

  for (int i = 0; i < 2 ; ++i) {

    message_queue_barriers.semaphore_1.Signal();

TEST(SendClientDataToHandler) {

  // Create a V8 environment

  DebugLocalContext env;

  TestClientData::ResetCounters();

  handled_client_data_instances_count = 0;

  v8::Debug::SetMessageHandler2(MessageHandlerCountingClientData);

     "\"type\":\"request\","

     "\"command\":\"continue\"}";

                         new TestClientData());

                         new TestClientData());

                         new TestClientData());

  // All the messages will be processed on beforeCompile event.

  CompileRun(source_1);

  CHECK_EQ(3, TestClientData::constructor_call_counter);

  CHECK_EQ(TestClientData::constructor_call_counter,

           handled_client_data_instances_count);

      "\n"

      "foo();\n";

  DebugLocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  v8::Debug::SetMessageHandler2(&ThreadedMessageHandler);

  v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();

  global_template->Set(v8::String::New("ThreadedAtBarrier1"),

                       v8::FunctionTemplate::New(ThreadedAtBarrier1));

                                                     NULL,

                                                     global_template);

  v8::Context::Scope context_scope(context);

      "\"type\":\"request\","

      "\"command\":\"continue\"}";

  threaded_debugging_barriers.barrier_1.Wait();

  threaded_debugging_barriers.barrier_2.Wait();

}

  const char* source_2 = "cat(17);\n"

    "cat(19);\n";

  DebugLocalContext env;

  v8::Debug::SetMessageHandler2(&BreakpointsMessageHandler);

  CompileRun(source_1);

      "\"command\":\"continue\"}";

  // v8 thread initializes, runs source_1

  breakpoints_barriers->barrier_1.Wait();

  // 1:Set breakpoint in cat() (will get id 1).

  // 2:Set breakpoint in dog() (will get id 2).

  breakpoints_barriers->barrier_2.Wait();

  // V8 thread starts compiling source_2.

  // Automatic break happens, to run queued commands

  // Must have hit breakpoint #1.

  CHECK_EQ(1, break_event_breakpoint_id);

  // 4:Evaluate dog() (which has a breakpoint).

  // V8 thread hits breakpoint in dog().

  breakpoints_barriers->semaphore_1.Wait();  // wait for break event

  // Must have hit breakpoint #2.

  CHECK_EQ(2, break_event_breakpoint_id);

  // 5:Evaluate (x + 1).

  // Evaluate (x + 1) finishes.

  breakpoints_barriers->semaphore_1.Wait();

  // Must have result 108.

  CHECK_EQ(108, evaluate_int_result);

  // 6:Continue evaluation of dog().

  // Evaluate dog() finishes.

  breakpoints_barriers->semaphore_1.Wait();

  // Must have result 107.

  CHECK_EQ(107, evaluate_int_result);

  // 7:Continue evaluation of source_2, finish cat(17), hit breakpoint

  // in cat(19).

  // Message callback gets break event.

  breakpoints_barriers->semaphore_1.Wait();  // wait for break event

  // Must have hit breakpoint #1.

  CHECK_EQ(1, break_event_breakpoint_id);

  // 8: Evaluate dog() with breaks disabled.

  // Evaluate dog() finishes.

  breakpoints_barriers->semaphore_1.Wait();

  // Must have result 116.

  CHECK_EQ(116, evaluate_int_result);

  // 9: Continue evaluation of source2, reach end.

}

}

// Source for a JavaScript function which returns the data parameter of a

// function called in the context of the debugger. If no data parameter is

// passed it throws an exception.

TEST(CallFunctionInDebugger) {

  // Create and enter a context with the functions CheckFrameCount,

  // CheckSourceLine and CheckDataParameter installed.

  v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();

  global_template->Set(v8::String::New("CheckFrameCount"),

                       v8::FunctionTemplate::New(CheckFrameCount));

                       v8::FunctionTemplate::New(CheckDataParameter));

  global_template->Set(v8::String::New("CheckClosure"),

                       v8::FunctionTemplate::New(CheckClosure));

                                                     NULL,

                                                     global_template);

  v8::Context::Scope context_scope(context);

     "\"type\":\"request\","

     "\"command\":\"continue\"}";

}

    "\n";

  const char* source_2 = "cat(17);\n";

  DebugLocalContext env;

  v8::HandleScope scope(env->GetIsolate());

      "\"type\":\"request\","

      "\"command\":\"continue\"}";

  // v8 thread initializes, runs source_1

  host_dispatch_barriers->barrier_1.Wait();

  // 1: Set breakpoint in cat().

  host_dispatch_barriers->barrier_2.Wait();

  // v8 thread starts compiling source_2.

  // Wait for host dispatch to be processed.

  host_dispatch_barriers->semaphore_1.Wait();

  // 2: Continue evaluation

}

void DebugMessageDispatchV8Thread::Run() {

  DebugLocalContext env;

  v8::HandleScope scope(env->GetIsolate());

TEST(DebuggerAgent) {

  v8::V8::Initialize();

  // Make sure these ports is not used by other tests to allow tests to run in

  // parallel.

  const int kPort1 = 5858 + FlagDependentPortOffset();

// Checks that this data is set correctly and that when the debug message

// handler is called the expected context is the one active.

TEST(ContextData) {

  v8::HandleScope scope(isolate);

  // Create two contexts.

  if (message.IsEvent() && message.GetEvent() == v8::Break) {

    message_handler_break_hit_count++;

    if (message_handler_break_hit_count == 1) {

    }

  }

    // Keep forcing breaks.

    if (break_point_hit_count < 20) {

    }

  }

}

  CHECK_EQ(12, result->Int32Value());

  v8::Debug::SetDebugEventListener2(DebugEventDebugBreak);

  result = f->Call(env->Global(), argc, argv);

  // Check that there was only one break event. Matching RegExp should not

  v8::Handle<v8::ObjectTemplate> global_template =

      v8::Handle<v8::ObjectTemplate>();

  context_1 =

  v8::Debug::SetMessageHandler2(message_handler);

// break event in an eval statement the expected context is the one returned by

// Message.GetEventContext.

TEST(EvalContextData) {

  ExecuteScriptForContextCheck(ContextCheckMessageHandler);

  v8::String::Value json(message.GetJSON());

  Utf16ToAscii(*json, json.length(), print_buffer);

  if (IsBreakEventMessage(print_buffer)) {

    break_count++;

    if (!sent_eval) {

          "\"global\":true,\"disable_break\":false}}";

      // Send evaluate command.

      return;

    } else {

      // It's a break event caused by the evaluation request above.

// Tests that context returned for break event is correct when the event occurs

// in 'evaluate' debugger request.

TEST(NestedBreakEventContextData) {

  break_count = 0;

  message_handler_hit_count = 0;

// Test that scripts collected are reported through the debug event listener.

TEST(ScriptCollectedEvent) {

  break_point_hit_count = 0;

  script_collected_count = 0;

  DebugLocalContext env;

  // Do garbage collection to ensure that only the script in this test will be

  // collected afterwards.

  script_collected_count = 0;

  v8::Debug::SetDebugEventListener2(DebugEventScriptCollectedEvent);

  // Do garbage collection to collect the script above which is no longer

  // referenced.

  CHECK_EQ(2, script_collected_count);

// ScriptCollected events.

TEST(ScriptCollectedEventContext) {

  i::FLAG_stress_compaction = false;

  v8::internal::Debug* debug =

      reinterpret_cast<v8::internal::Isolate*>(isolate)->debug();

  script_collected_message_count = 0;

  // Do garbage collection to ensure that only the script in this test will be

  // collected afterwards.

  v8::Debug::SetMessageHandler2(ScriptCollectedMessageHandler);

  v8::Script::Compile(v8::String::New("eval('a=1')"))->Run();

  // Do garbage collection to collect the script above which is no longer

  // referenced.

  CHECK_EQ(2, script_collected_message_count);

  v8::Debug::SetMessageHandler2(NULL);

  v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);

  v8::Script::Compile(v8::String::New(script))->Run();

  // Setting listener to NULL should cause debugger unload.

  v8::Debug::SetMessageHandler2(NULL);

  v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);

  v8::Local<v8::Function> f =

      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));

  f->Call(env->Global(), 0, NULL);

static void BreakMessageHandler(const v8::Debug::Message& message) {

  if (message.IsEvent() && message.GetEvent() == v8::Break) {

    // Count the number of breaks.

    break_point_hit_count++;

  v8::Debug::SetMessageHandler2(BreakMessageHandler);

  // Set the debug break flag.

  // Create a function for testing stepping.

  const char* src = "function f() { eval('var x = 10;'); } ";

  CHECK_EQ(1, break_point_hit_count);

  // Set the debug break flag again.

  f->Call(env->Global(), 0, NULL);

  // There should be one more break event when the script is evaluated in 'f'.

  CHECK_EQ(2, break_point_hit_count);

// Test that debug messages get processed when ProcessDebugMessages is called.

TEST(ProcessDebugMessages) {

  DebugLocalContext env;

  counting_message_handler_counter = 0;

     "\"command\":\"scripts\"}";

  // Send scripts command.

  CHECK_EQ(0, counting_message_handler_counter);

  v8::Debug::ProcessDebugMessages();

  counting_message_handler_counter = 0;

  CHECK_EQ(0, counting_message_handler_counter);

  v8::Debug::ProcessDebugMessages();

  // At least two messages should come

// Test that debug messages get processed when ProcessDebugMessages is called.

TEST(Backtrace) {

  DebugLocalContext env;

  v8::Debug::SetMessageHandler2(BacktraceData::MessageHandler);

  // Check backtrace from ProcessDebugMessages.

  BacktraceData::frame_counter = -10;

  v8::Debug::ProcessDebugMessages();

  CHECK_EQ(BacktraceData::frame_counter, 0);

  // Check backtrace from "void(0)" script.

  BacktraceData::frame_counter = -10;

  script->Run();

  CHECK_EQ(BacktraceData::frame_counter, 1);

  v8::Debug::SetDebugEventListener2(DebugEventBreakMax);

  // Set the debug break flag before calling the code using function.apply.

  // Limit the number of debug breaks. This is a regression test for issue 493

  // where this test would enter an infinite loop.

    v8::Local<v8::String> name,

    const v8::PropertyCallbackInfo<v8::Value>& info) {

  CHECK_EQ(0, strcmp(*v8::String::Utf8Value(name), "a"));

  CHECK(current == debugee_context);

  CHECK(current != debugger_context);

  CHECK(calling == debugee_context);

  CHECK(calling != debugger_context);

  info.GetReturnValue().Set(1);

  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();

  if (event == v8::Break) {

    break_point_hit_count++;

    v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(CompileRun(

        "(function(exec_state) {\n"

        "    return (exec_state.frame(0).argumentValue(0).property('a').\n"

TEST(CallingContextIsNotDebugContext) {

  // Create and enter a debugee context.

  DebugLocalContext env;

  v8::HandleScope scope(env->GetIsolate());

TEST(DebugContextIsPreservedBetweenAccesses) {

  v8::Local<v8::Context> context1 = v8::Debug::GetDebugContext();

  v8::Local<v8::Context> context2 = v8::Debug::GetDebugContext();

  CHECK_EQ(*context1, *context2);

// Check that event details contain context where debug event occured.

TEST(DebugEventContext) {

  v8::HandleScope scope(isolate);

  expected_callback_data = v8::Int32::New(2010);

  expected_context = v8::Context::New(isolate);

// Check that event details contain context where debug event occured.

TEST(DebugEventBreakData) {

  DebugLocalContext env;

  v8::Debug::SetDebugEventListener2(DebugEventBreakDataChecker);

  TestClientData::constructor_call_counter = 0;

  expected_break_data = NULL;

  was_debug_event_called = false;

  was_debug_break_called = false;

  v8::Script::Compile(v8::String::New("(function(x){return x;})(1);"))->Run();

  CHECK(was_debug_event_called);

  CHECK(!was_debug_break_called);

  expected_break_data = data1;

  was_debug_event_called = false;

  was_debug_break_called = false;

  v8::Script::Compile(v8::String::New("(function(x){return x+1;})(1);"))->Run();

  CHECK(was_debug_event_called);

  CHECK(!was_debug_break_called);

  expected_break_data = NULL;

  was_debug_event_called = false;

  was_debug_break_called = false;

  v8::Script::Compile(v8::String::New("(function(x){return x+2;})(1);"))->Run();

  CHECK(!was_debug_event_called);

  CHECK(was_debug_break_called);

  expected_break_data = data2;

  was_debug_event_called = false;

  was_debug_break_called = false;

  v8::Script::Compile(v8::String::New("(function(x){return x+3;})(1);"))->Run();

  CHECK(was_debug_event_called);

  CHECK(was_debug_break_called);

        v8::Handle<v8::String> function_name(result->ToString());

        function_name->WriteUtf8(fn);

        if (strcmp(fn, "bar") == 0) {

          debug_event_break_deoptimize_done = true;

        }

      }

    }

  }

}

  v8::Script::Compile(v8::String::New("function bar(){}; bar()"))->Run();

  // Set debug break and call bar again.

  v8::Script::Compile(v8::String::New("bar()"))->Run();

  CHECK(debug_event_break_deoptimize_done);

static void ScheduleBreak(const v8::FunctionCallbackInfo<v8::Value>& args) {

  v8::Debug::SetDebugEventListener2(DebugEventBreakWithOptimizedStack);

}

      CompileRun(buffer.start());

      // Set the debug break to enter the debugger as soon as possible.

      // Call function with infinite loop.

      CompileRun("f();");

  i::Handle<i::Script> source_script = i::Handle<i::Script>(i::Script::cast(

      i::JSFunction::cast(*compiled_script)->shared()->script()));

  char script[128];

  i::Vector<char> script_vector(script, sizeof(script));

  OS::SNPrintF(script_vector, "%%GetFrameCount(%d)", break_id);

             i::GetScriptLineNumber(source_script, result->Int32Value()));

  }

  v8::Debug::SetDebugEventListener2(NULL);

}

  v8::internal::FLAG_allow_natives_syntax = true;

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  CompileRun("%LiveEditCompareStrings('', '')");

}

  v8::internal::FLAG_allow_natives_syntax = true;

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  CompileRun("%LiveEditCompareStrings('', '')");

}