runtime/vm/debugger_test.cc - sdk.git - Git at Google

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 #include "vm/debugger.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_message.h"
 #include "vm/message.h"
 #include "vm/unit_test.h"

 namespace dart {

 #ifndef PRODUCT

 DECLARE_FLAG(bool, background_compilation);
 DECLARE_FLAG(bool, enable_inlining_annotations);
 DECLARE_FLAG(bool, prune_dead_locals);
 DECLARE_FLAG(bool, remove_script_timestamps_for_test);
 DECLARE_FLAG(bool, trace_rewind);
 DECLARE_FLAG(int, optimization_counter_threshold);

 // Search for the formatted string in buffer.
 //
 // TODO(turnidge): This function obscures the line number of failing
 // EXPECTs.  Rework this.
 static void ExpectSubstringF(const char* buff, const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
   intptr_t len = OS::VSNPrint(NULL, 0, fmt, args);
   va_end(args);

   char* buffer = Thread::Current()->zone()->Alloc<char>(len + 1);
   va_list args2;
   va_start(args2, fmt);
   OS::VSNPrint(buffer, (len + 1), fmt, args2);
   va_end(args2);

   EXPECT_SUBSTRING(buffer, buff);
 }

 TEST_CASE(Debugger_GetBreakpointsById) {
   const char* kScriptChars =
       "main() {\n"
       "  var x = new StringBuffer();\n"
       "  x.add('won');\n"
       "  x.add('too');\n"
       "  return x.toString();\n"
       "}\n";
   SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);

   Isolate* isolate = Isolate::Current();
   Debugger* debugger = isolate->debugger();

   // Test with one loaded breakpoint, one latent breakpoint.
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle result = Dart_SetBreakpoint(url, 2);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t bp_id1 = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &bp_id1));

   result = Dart_SetBreakpoint(NewString("not_yet_loaded_script_uri"), 4);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t bp_id2 = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &bp_id2));

   EXPECT(debugger->GetBreakpointById(bp_id1) != NULL);
   EXPECT(debugger->GetBreakpointById(bp_id2) != NULL);
 }

 static int closure_hit_count = 0;
 int64_t closure_bp_id[4];
 static void PausedInClosuresHandler(Dart_IsolateId isolate_id,
                                     intptr_t bp_id,
                                     const Dart_CodeLocation& location) {
   EXPECT(bp_id == closure_bp_id[closure_hit_count]);
   closure_hit_count++;
 }

 TEST_CASE(Debugger_SetBreakpointInPartOfLibrary) {
   const char* kMainScript = "main() {}\n";
   const char* kLib = "library test_lib;\n";
   const char* kLibPart =
       "part of test_lib;\n"
       "void func(int a, int b) {\n"
       "  return a + b;\n"
       "}\n";
   SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
   Dart_Handle root_lib = TestCase::LoadTestScript(kMainScript, NULL);
   EXPECT_VALID(root_lib);

   Dart_Handle url = NewString("test_lib_url");
   Dart_Handle lib_source = NewString(kLib);
   Dart_Handle lib = Dart_LoadLibrary(url, Dart_Null(), lib_source, 0, 0);
   EXPECT_VALID(lib);
   EXPECT(Dart_IsLibrary(lib));

   Dart_Handle part_url = NewString("part_url");
   Dart_Handle part_source = NewString(kLibPart);
   Dart_Handle result =
       Dart_LoadSource(lib, part_url, Dart_Null(), part_source, 0, 0);
   EXPECT_VALID(result);
   EXPECT(Dart_IsLibrary(result));
   EXPECT(Dart_IdentityEquals(lib, result));

   result = Dart_SetBreakpoint(part_url, 3);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
 }

 TEST_CASE(Debugger_SetBreakpointInFunctionLiteralFieldInitializers) {
   const char* kScriptChars =
       "main() {\n"
       "  var c = new MyClass();\n"
       "  c.closure(1, 2);\n"
       "  MyClass.staticClosure(7, 8);\n"
       "  closure(3, 4);\n"
       "  closureSingleLine(5, 6);\n"
       "}\n"
       "class MyClass {\n"
       "  var closure = (int a, int b) {\n"
       "    return a + b;\n"
       "  };\n"
       "  static var staticClosure = (int a, int b) {\n"
       "    return a * b;\n"
       "  };\n"
       "}\n"
       "var closure = (int a, int b) {\n"
       "  return a + b;\n"
       "};\n"
       "var closureSingleLine = (int a, int b) => a * b;\n"
       "int v = 10;\n";
   SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);

   Isolate* isolate = Isolate::Current();
   Debugger* debugger = isolate->debugger();

   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle result = Dart_SetBreakpoint(url, 10);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   EXPECT_VALID(Dart_IntegerToInt64(result, &closure_bp_id[0]));

   result = Dart_SetBreakpoint(url, 13);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   EXPECT_VALID(Dart_IntegerToInt64(result, &closure_bp_id[1]));

   result = Dart_SetBreakpoint(url, 17);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   EXPECT_VALID(Dart_IntegerToInt64(result, &closure_bp_id[2]));

   result = Dart_SetBreakpoint(url, 19);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   EXPECT_VALID(Dart_IntegerToInt64(result, &closure_bp_id[3]));

   // Cannot set breakpoint at the start of the class definition.
   // The implicit constructor token position matches that of the
   // class definition's token position. So, we do not want to
   // allow setting breakpoints in implicit consturctors.
   result = Dart_SetBreakpoint(url, 8);
   EXPECT_ERROR(result, "could not set breakpoint at line 8");

   result = Dart_SetBreakpoint(url, 20);
   EXPECT_ERROR(result, "could not set breakpoint at line 20");

   EXPECT(debugger->GetBreakpointById(closure_bp_id[0]) != NULL);
   EXPECT(debugger->GetBreakpointById(closure_bp_id[1]) != NULL);
   EXPECT(debugger->GetBreakpointById(closure_bp_id[2]) != NULL);
   EXPECT(debugger->GetBreakpointById(closure_bp_id[3]) != NULL);

   Dart_SetPausedEventHandler(PausedInClosuresHandler);
   result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(closure_hit_count == 4);
 }

 TEST_CASE(Debugger_RemoveBreakpoint) {
   const char* kScriptChars =
       "main() {\n"
       "  var x = new StringBuffer();\n"
       "  x.add('won');\n"
       "  x.add('too');\n"
       "  return x.toString();\n"
       "}\n";
   SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);

   Isolate* isolate = Isolate::Current();
   Debugger* debugger = isolate->debugger();

   // Test with one loaded breakpoint, one latent breakpoint.
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle result = Dart_SetBreakpoint(url, 2);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t bp_id1 = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &bp_id1));

   result = Dart_SetBreakpoint(NewString("not_yet_loaded_script_uri"), 4);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t bp_id2 = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &bp_id2));

   EXPECT(debugger->GetBreakpointById(bp_id1) != NULL);
   EXPECT(debugger->GetBreakpointById(bp_id2) != NULL);

   debugger->RemoveBreakpoint(bp_id1);
   debugger->RemoveBreakpoint(bp_id2);

   EXPECT(debugger->GetBreakpointById(bp_id1) == NULL);
   EXPECT(debugger->GetBreakpointById(bp_id2) == NULL);
 }

 TEST_CASE(Debugger_PrintBreakpointsToJSONArray) {
   const char* kScriptChars =
       "main() {\n"
       "  var x = new StringBuffer();\n"
       "  x.add('won');\n"
       "  x.add('too');\n"
       "  return x.toString();\n"
       "}\n";
   SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
   Library& vmlib = Library::Handle();
   vmlib ^= Api::UnwrapHandle(lib);
   EXPECT(!vmlib.IsNull());
   const String& private_key = String::Handle(vmlib.private_key());

   Isolate* isolate = Isolate::Current();
   Debugger* debugger = isolate->debugger();

   // Empty case.
   {
     JSONStream js;
     {
       JSONArray jsarr(&js);
       debugger->PrintBreakpointsToJSONArray(&jsarr);
     }
     EXPECT_STREQ("[]", js.ToCString());
   }

   // Test with a couple of loaded breakpoints, one latent breakpoint.
   Dart_Handle url = NewString(TestCase::url());
   EXPECT_VALID(Dart_SetBreakpoint(url, 2));
   EXPECT_VALID(Dart_SetBreakpoint(url, 3));
   EXPECT_VALID(Dart_SetBreakpoint(NewString("not_yet_loaded_script_uri"), 4));
   {
     JSONStream js;
     {
       JSONArray jsarr(&js);
       debugger->PrintBreakpointsToJSONArray(&jsarr);
     }
     ExpectSubstringF(
         js.ToCString(),
         "[{\"type\":\"Breakpoint\",\"fixedId\":true,\"id\":\"breakpoints\\/"
         "2\",\"breakpointNumber\":2,\"resolved\":false,\"location\":{\"type\":"
         "\"UnresolvedSourceLocation\",\"script\":{\"type\":\"@Script\","
         "\"fixedId\":true,\"id\":\"libraries\\/%s\\/scripts\\/"
         "test-lib\\/"
         "0\",\"uri\":\"test-lib\",\"_kind\":\"script\"},\"line\":3}},{\"type\":"
         "\"Breakpoint\",\"fixedId\":true,\"id\":\"breakpoints\\/"
         "1\",\"breakpointNumber\":1,\"resolved\":false,\"location\":{\"type\":"
         "\"UnresolvedSourceLocation\",\"script\":{\"type\":\"@Script\","
         "\"fixedId\":true,\"id\":\"libraries\\/%s\\/scripts\\/"
         "test-lib\\/"
         "0\",\"uri\":\"test-lib\",\"_kind\":\"script\"},\"line\":2}},{\"type\":"
         "\"Breakpoint\",\"fixedId\":true,\"id\":\"breakpoints\\/"
         "3\",\"breakpointNumber\":3,\"resolved\":false,\"location\":{\"type\":"
         "\"UnresolvedSourceLocation\",\"scriptUri\":\"not_yet_loaded_script_"
         "uri\",\"line\":4}}]",
         private_key.ToCString(), private_key.ToCString());
   }
 }

 static bool saw_paused_event = false;

 static void InspectPausedEvent(Dart_IsolateId isolate_id,
                                intptr_t bp_id,
                                const Dart_CodeLocation& loc) {
   Isolate* isolate = Isolate::Current();
   Debugger* debugger = isolate->debugger();

   // The debugger knows that it is paused, and why.
   EXPECT(debugger->IsPaused());
   const ServiceEvent* event = debugger->PauseEvent();
   EXPECT(event != NULL);
   EXPECT(event->kind() == ServiceEvent::kPauseBreakpoint);
   saw_paused_event = true;
 }

 TEST_CASE(Debugger_PauseEvent) {
   const char* kScriptChars =
       "main() {\n"
       "  var x = new StringBuffer();\n"
       "  x.write('won');\n"
       "  x.write('too');\n"
       "  return x.toString();\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);

   Isolate* isolate = Isolate::Current();
   Debugger* debugger = isolate->debugger();

   // No pause event.
   EXPECT(!debugger->IsPaused());
   EXPECT(debugger->PauseEvent() == NULL);

   saw_paused_event = false;
   Dart_SetPausedEventHandler(InspectPausedEvent);

   // Set a breakpoint and run.
   EXPECT_VALID(Dart_SetBreakpoint(NewString(TestCase::url()), 2));
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));

   // We ran the code in InspectPausedEvent.
   EXPECT(saw_paused_event);
 }

 static uint8_t* malloc_allocator(uint8_t* ptr,
                                  intptr_t old_size,
                                  intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }

 const char* rewind_frame_index = "-1";

 // Build and send a fake resume OOB message for testing purposes.
 void SendResumeMessage(Isolate* isolate) {
   // Format is: [ oob_type, port, seq, method_name, [keys], [values] ]
   Dart_CObject msg;
   Dart_CObject* list_values[6];
   msg.type = Dart_CObject_kArray;
   msg.value.as_array.length = 6;
   msg.value.as_array.values = list_values;

   Dart_CObject oob;
   oob.type = Dart_CObject_kInt32;
   oob.value.as_int32 = Message::kServiceOOBMsg;
   list_values[0] = &oob;

   Dart_CObject reply_port;
   reply_port.type = Dart_CObject_kNull;
   list_values[1] = &reply_port;

   Dart_CObject seq;
   seq.type = Dart_CObject_kNull;
   list_values[2] = &seq;

   Dart_CObject method_name;
   method_name.type = Dart_CObject_kString;
   method_name.value.as_string = const_cast<char*>("resume");
   list_values[3] = &method_name;

   const int kParamCount = 3;
   Dart_CObject param_keys;
   Dart_CObject* param_keys_list[kParamCount];
   param_keys.type = Dart_CObject_kArray;
   param_keys.value.as_array.values = param_keys_list;
   param_keys.value.as_array.length = kParamCount;
   list_values[4] = &param_keys;

   Dart_CObject param_values;
   Dart_CObject* param_values_list[kParamCount];
   param_values.type = Dart_CObject_kArray;
   param_values.value.as_array.values = param_values_list;
   param_values.value.as_array.length = kParamCount;
   list_values[5] = &param_values;

   Dart_CObject param0_name;
   param0_name.type = Dart_CObject_kString;
   param0_name.value.as_string = const_cast<char*>("isolateId");
   param_keys_list[0] = &param0_name;

   Dart_CObject param0_value;
   param0_value.type = Dart_CObject_kString;
   const char* isolate_id = Thread::Current()->zone()->PrintToString(
       ISOLATE_SERVICE_ID_FORMAT_STRING,
       static_cast<int64_t>(isolate->main_port()));
   param0_value.value.as_string = const_cast<char*>(isolate_id);
   param_values_list[0] = &param0_value;

   Dart_CObject param1_name;
   param1_name.type = Dart_CObject_kString;
   param1_name.value.as_string = const_cast<char*>("step");
   param_keys_list[1] = &param1_name;

   Dart_CObject param1_value;
   param1_value.type = Dart_CObject_kString;
   param1_value.value.as_string = const_cast<char*>("Rewind");
   param_values_list[1] = &param1_value;

   Dart_CObject param2_name;
   param2_name.type = Dart_CObject_kString;
   param2_name.value.as_string = const_cast<char*>("frameIndex");
   param_keys_list[2] = &param2_name;

   Dart_CObject param2_value;
   param2_value.type = Dart_CObject_kString;
   param2_value.value.as_string = const_cast<char*>(rewind_frame_index);
   param_values_list[2] = &param2_value;

   {
     uint8_t* buffer = NULL;
     ApiMessageWriter writer(&buffer, &malloc_allocator);
     bool success = writer.WriteCMessage(&msg);
     ASSERT(success);

     // Post the message at the given port.
     success = PortMap::PostMessage(new Message(isolate->main_port(), buffer,
                                                writer.BytesWritten(),
                                                Message::kOOBPriority));
     ASSERT(success);
   }
 }

 static void RewindOnce(Dart_IsolateId isolate_id,
                        intptr_t bp_id,
                        const Dart_CodeLocation& loc) {
   bool first_time = !saw_paused_event;
   saw_paused_event = true;
   if (first_time) {
     Thread* T = Thread::Current();
     Isolate* I = T->isolate();
     // TODO(turnidge): It is weird that the isolate can get to this
     // point in our tests without being marked runnable. Clear this up
     // at some point.
     I->set_is_runnable(true);
     SendResumeMessage(I);
     I->PauseEventHandler();
   }
 }

 TEST_CASE(Debugger_RewindOneFrame_Unoptimized) {
   SetFlagScope<bool> sfs(&FLAG_trace_rewind, true);

   // These variables are global state used by RewindOnce.
   saw_paused_event = false;
   rewind_frame_index = "1";

   const char* kScriptChars =
       "import 'dart:developer';\n"
       "\n"
       "var msg = new StringBuffer();\n"
       "\n"
       "foo() {\n"
       "  msg.write('enter(foo) ');\n"
       "  debugger();\n"
       "  msg.write('exit(foo) ');\n"
       "}\n"
       "\n"
       "main() {\n"
       "  msg.write('enter(main) ');\n"
       "  foo();\n"
       "  msg.write('exit(main) ');\n"
       "  return msg.toString();\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);

   Dart_SetPausedEventHandler(RewindOnce);
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   const char* result_cstr;
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
   EXPECT_VALID(Dart_StringToCString(result, &result_cstr));
   EXPECT_STREQ("enter(main) enter(foo) enter(foo) exit(foo) exit(main) ",
                result_cstr);
   EXPECT(saw_paused_event);
 }

 TEST_CASE(Debugger_RewindTwoFrames_Unoptimized) {
   SetFlagScope<bool> sfs(&FLAG_trace_rewind, true);

   // These variables are global state used by RewindOnce.
   saw_paused_event = false;
   rewind_frame_index = "2";

   const char* kScriptChars =
       "import 'dart:developer';\n"
       "\n"
       "var msg = new StringBuffer();\n"
       "\n"
       "foo() {\n"
       "  msg.write('enter(foo) ');\n"
       "  debugger();\n"
       "  msg.write('exit(foo) ');\n"
       "}\n"
       "\n"
       "bar() {\n"
       "  msg.write('enter(bar) ');\n"
       "  foo();\n"
       "  msg.write('exit(bar) ');\n"
       "}\n"
       "\n"
       "main() {\n"
       "  msg.write('enter(main) ');\n"
       "  bar();\n"
       "  msg.write('exit(main) ');\n"
       "  return msg.toString();\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);

   Dart_SetPausedEventHandler(RewindOnce);
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   const char* result_cstr;
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
   EXPECT_VALID(Dart_StringToCString(result, &result_cstr));
   EXPECT_STREQ(
       "enter(main) enter(bar) enter(foo) enter(bar) enter(foo) "
       "exit(foo) exit(bar) exit(main) ",
       result_cstr);
   EXPECT(saw_paused_event);
 }

 TEST_CASE(Debugger_Rewind_Optimized) {
   SetFlagScope<bool> sfs1(&FLAG_trace_rewind, true);
   SetFlagScope<bool> sfs2(&FLAG_prune_dead_locals, false);
   SetFlagScope<bool> sfs3(&FLAG_enable_inlining_annotations, true);
   SetFlagScope<bool> sfs4(&FLAG_background_compilation, false);
   SetFlagScope<int> sfs5(&FLAG_optimization_counter_threshold, 10);

   // These variables are global state used by RewindOnce.
   saw_paused_event = false;
   rewind_frame_index = "2";

   const char* kScriptChars =
       "import 'dart:developer';\n"
       "\n"
       "const alwaysInline = \"AlwaysInline\";\n"
       "const noInline = \"NeverInline\";\n"
       "\n"
       "var msg = new StringBuffer();\n"
       "int i;\n"
       "\n"
       "@noInline\n"
       "foo() {\n"
       "  msg.write('enter(foo) ');\n"
       "  if (i > 15) {\n"
       "    debugger();\n"
       "    msg.write('exit(foo) ');\n"
       "    return true;\n"
       "  } else {\n"
       "    msg.write('exit(foo) ');\n"
       "    return false;\n"
       "  }\n"
       "}\n"
       "\n"
       "@alwaysInline\n"
       "bar3() {\n"
       "  msg.write('enter(bar3) ');\n"
       "  var result = foo();\n"
       "  msg.write('exit(bar3) ');\n"
       "  return result;\n"
       "}\n"
       "\n"
       "@alwaysInline\n"
       "bar2() {\n"
       "  msg.write('enter(bar2) ');\n"
       "  var result = bar3();\n"
       "  msg.write('exit(bar2) ');\n"
       "  return result;\n"
       "}\n"
       "\n"
       "@alwaysInline\n"
       "bar1() {\n"
       "  msg.write('enter(bar1) ');\n"
       "  var result = bar2();\n"
       "  msg.write('exit(bar1) ');\n"
       "  return result;\n"
       "}\n"
       "\n"
       "main() {\n"
       "  for (i = 0; i < 20; i++) {\n"
       "    msg.clear();\n"
       "    if (bar1()) break;\n;"
       "  }\n"
       "  return msg.toString();\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);

   Dart_SetPausedEventHandler(RewindOnce);
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   const char* result_cstr;
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
   EXPECT_VALID(Dart_StringToCString(result, &result_cstr));
   EXPECT_STREQ(
       "enter(bar1) enter(bar2) enter(bar3) enter(foo) "
       "enter(bar3) enter(foo) "
       "exit(foo) exit(bar3) exit(bar2) exit(bar1) ",
       result_cstr);
   EXPECT(saw_paused_event);
 }

 #endif  // !PRODUCT

 }  // namespace dart
	// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	#include "vm/debugger.h"
	#include "vm/dart_api_impl.h"
	#include "vm/dart_api_message.h"
	#include "vm/message.h"
	#include "vm/unit_test.h"

	namespace dart {

	#ifndef PRODUCT

	DECLARE_FLAG(bool, background_compilation);
	DECLARE_FLAG(bool, enable_inlining_annotations);
	DECLARE_FLAG(bool, prune_dead_locals);
	DECLARE_FLAG(bool, remove_script_timestamps_for_test);
	DECLARE_FLAG(bool, trace_rewind);
	DECLARE_FLAG(int, optimization_counter_threshold);

	// Search for the formatted string in buffer.
	//
	// TODO(turnidge): This function obscures the line number of failing
	// EXPECTs. Rework this.
	static void ExpectSubstringF(const char* buff, const char* fmt, ...) {
	va_list args;
	va_start(args, fmt);
	intptr_t len = OS::VSNPrint(NULL, 0, fmt, args);
	va_end(args);

	char* buffer = Thread::Current()->zone()->Alloc<char>(len + 1);
	va_list args2;
	va_start(args2, fmt);
	OS::VSNPrint(buffer, (len + 1), fmt, args2);
	va_end(args2);

	EXPECT_SUBSTRING(buffer, buff);
	}

	TEST_CASE(Debugger_GetBreakpointsById) {
	const char* kScriptChars =
	"main() {\n"
	" var x = new StringBuffer();\n"
	" x.add('won');\n"
	" x.add('too');\n"
	" return x.toString();\n"
	"}\n";
	SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
	Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
	EXPECT_VALID(lib);

	Isolate* isolate = Isolate::Current();
	Debugger* debugger = isolate->debugger();

	// Test with one loaded breakpoint, one latent breakpoint.
	Dart_Handle url = NewString(TestCase::url());
	Dart_Handle result = Dart_SetBreakpoint(url, 2);
	EXPECT_VALID(result);
	EXPECT(Dart_IsInteger(result));
	int64_t bp_id1 = 0;
	EXPECT_VALID(Dart_IntegerToInt64(result, &bp_id1));

	result = Dart_SetBreakpoint(NewString("not_yet_loaded_script_uri"), 4);
	EXPECT_VALID(result);
	EXPECT(Dart_IsInteger(result));
	int64_t bp_id2 = 0;
	EXPECT_VALID(Dart_IntegerToInt64(result, &bp_id2));

	EXPECT(debugger->GetBreakpointById(bp_id1) != NULL);
	EXPECT(debugger->GetBreakpointById(bp_id2) != NULL);
	}

	static int closure_hit_count = 0;
	int64_t closure_bp_id[4];
	static void PausedInClosuresHandler(Dart_IsolateId isolate_id,
	intptr_t bp_id,
	const Dart_CodeLocation& location) {
	EXPECT(bp_id == closure_bp_id[closure_hit_count]);
	closure_hit_count++;
	}

	TEST_CASE(Debugger_SetBreakpointInPartOfLibrary) {
	const char* kMainScript = "main() {}\n";
	const char* kLib = "library test_lib;\n";
	const char* kLibPart =
	"part of test_lib;\n"
	"void func(int a, int b) {\n"
	" return a + b;\n"
	"}\n";
	SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
	Dart_Handle root_lib = TestCase::LoadTestScript(kMainScript, NULL);
	EXPECT_VALID(root_lib);

	Dart_Handle url = NewString("test_lib_url");
	Dart_Handle lib_source = NewString(kLib);
	Dart_Handle lib = Dart_LoadLibrary(url, Dart_Null(), lib_source, 0, 0);
	EXPECT_VALID(lib);
	EXPECT(Dart_IsLibrary(lib));

	Dart_Handle part_url = NewString("part_url");
	Dart_Handle part_source = NewString(kLibPart);
	Dart_Handle result =
	Dart_LoadSource(lib, part_url, Dart_Null(), part_source, 0, 0);
	EXPECT_VALID(result);
	EXPECT(Dart_IsLibrary(result));
	EXPECT(Dart_IdentityEquals(lib, result));

	result = Dart_SetBreakpoint(part_url, 3);
	EXPECT_VALID(result);
	EXPECT(Dart_IsInteger(result));
	}

	TEST_CASE(Debugger_SetBreakpointInFunctionLiteralFieldInitializers) {
	const char* kScriptChars =
	"main() {\n"
	" var c = new MyClass();\n"
	" c.closure(1, 2);\n"
	" MyClass.staticClosure(7, 8);\n"
	" closure(3, 4);\n"
	" closureSingleLine(5, 6);\n"
	"}\n"
	"class MyClass {\n"
	" var closure = (int a, int b) {\n"
	" return a + b;\n"
	" };\n"
	" static var staticClosure = (int a, int b) {\n"
	" return a * b;\n"
	" };\n"
	"}\n"
	"var closure = (int a, int b) {\n"
	" return a + b;\n"
	"};\n"
	"var closureSingleLine = (int a, int b) => a * b;\n"
	"int v = 10;\n";
	SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
	Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
	EXPECT_VALID(lib);

	Isolate* isolate = Isolate::Current();
	Debugger* debugger = isolate->debugger();

	Dart_Handle url = NewString(TestCase::url());
	Dart_Handle result = Dart_SetBreakpoint(url, 10);
	EXPECT_VALID(result);
	EXPECT(Dart_IsInteger(result));
	EXPECT_VALID(Dart_IntegerToInt64(result, &closure_bp_id[0]));

	result = Dart_SetBreakpoint(url, 13);
	EXPECT_VALID(result);
	EXPECT(Dart_IsInteger(result));
	EXPECT_VALID(Dart_IntegerToInt64(result, &closure_bp_id[1]));

	result = Dart_SetBreakpoint(url, 17);
	EXPECT_VALID(result);
	EXPECT(Dart_IsInteger(result));
	EXPECT_VALID(Dart_IntegerToInt64(result, &closure_bp_id[2]));

	result = Dart_SetBreakpoint(url, 19);
	EXPECT_VALID(result);
	EXPECT(Dart_IsInteger(result));
	EXPECT_VALID(Dart_IntegerToInt64(result, &closure_bp_id[3]));

	// Cannot set breakpoint at the start of the class definition.
	// The implicit constructor token position matches that of the
	// class definition's token position. So, we do not want to
	// allow setting breakpoints in implicit consturctors.
	result = Dart_SetBreakpoint(url, 8);
	EXPECT_ERROR(result, "could not set breakpoint at line 8");

	result = Dart_SetBreakpoint(url, 20);
	EXPECT_ERROR(result, "could not set breakpoint at line 20");

	EXPECT(debugger->GetBreakpointById(closure_bp_id[0]) != NULL);
	EXPECT(debugger->GetBreakpointById(closure_bp_id[1]) != NULL);
	EXPECT(debugger->GetBreakpointById(closure_bp_id[2]) != NULL);
	EXPECT(debugger->GetBreakpointById(closure_bp_id[3]) != NULL);

	Dart_SetPausedEventHandler(PausedInClosuresHandler);
	result = Dart_Invoke(lib, NewString("main"), 0, NULL);
	EXPECT_VALID(result);
	EXPECT(closure_hit_count == 4);
	}

	TEST_CASE(Debugger_RemoveBreakpoint) {
	const char* kScriptChars =
	"main() {\n"
	" var x = new StringBuffer();\n"
	" x.add('won');\n"
	" x.add('too');\n"
	" return x.toString();\n"
	"}\n";
	SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
	Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
	EXPECT_VALID(lib);

	Isolate* isolate = Isolate::Current();
	Debugger* debugger = isolate->debugger();

	// Test with one loaded breakpoint, one latent breakpoint.
	Dart_Handle url = NewString(TestCase::url());
	Dart_Handle result = Dart_SetBreakpoint(url, 2);
	EXPECT_VALID(result);
	EXPECT(Dart_IsInteger(result));
	int64_t bp_id1 = 0;
	EXPECT_VALID(Dart_IntegerToInt64(result, &bp_id1));

	result = Dart_SetBreakpoint(NewString("not_yet_loaded_script_uri"), 4);
	EXPECT_VALID(result);
	EXPECT(Dart_IsInteger(result));
	int64_t bp_id2 = 0;
	EXPECT_VALID(Dart_IntegerToInt64(result, &bp_id2));

	EXPECT(debugger->GetBreakpointById(bp_id1) != NULL);
	EXPECT(debugger->GetBreakpointById(bp_id2) != NULL);

	debugger->RemoveBreakpoint(bp_id1);
	debugger->RemoveBreakpoint(bp_id2);

	EXPECT(debugger->GetBreakpointById(bp_id1) == NULL);
	EXPECT(debugger->GetBreakpointById(bp_id2) == NULL);
	}

	TEST_CASE(Debugger_PrintBreakpointsToJSONArray) {
	const char* kScriptChars =
	"main() {\n"
	" var x = new StringBuffer();\n"
	" x.add('won');\n"
	" x.add('too');\n"
	" return x.toString();\n"
	"}\n";
	SetFlagScope<bool> sfs(&FLAG_remove_script_timestamps_for_test, true);
	Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
	EXPECT_VALID(lib);
	Library& vmlib = Library::Handle();
	vmlib ^= Api::UnwrapHandle(lib);
	EXPECT(!vmlib.IsNull());
	const String& private_key = String::Handle(vmlib.private_key());

	Isolate* isolate = Isolate::Current();
	Debugger* debugger = isolate->debugger();

	// Empty case.
	{
	JSONStream js;
	{
	JSONArray jsarr(&js);
	debugger->PrintBreakpointsToJSONArray(&jsarr);
	}
	EXPECT_STREQ("[]", js.ToCString());
	}

	// Test with a couple of loaded breakpoints, one latent breakpoint.
	Dart_Handle url = NewString(TestCase::url());
	EXPECT_VALID(Dart_SetBreakpoint(url, 2));
	EXPECT_VALID(Dart_SetBreakpoint(url, 3));
	EXPECT_VALID(Dart_SetBreakpoint(NewString("not_yet_loaded_script_uri"), 4));
	{
	JSONStream js;
	{
	JSONArray jsarr(&js);
	debugger->PrintBreakpointsToJSONArray(&jsarr);
	}
	ExpectSubstringF(
	js.ToCString(),
	"[{\"type\":\"Breakpoint\",\"fixedId\":true,\"id\":\"breakpoints\\/"
	"2\",\"breakpointNumber\":2,\"resolved\":false,\"location\":{\"type\":"
	"\"UnresolvedSourceLocation\",\"script\":{\"type\":\"@Script\","
	"\"fixedId\":true,\"id\":\"libraries\\/%s\\/scripts\\/"
	"test-lib\\/"
	"0\",\"uri\":\"test-lib\",\"_kind\":\"script\"},\"line\":3}},{\"type\":"
	"\"Breakpoint\",\"fixedId\":true,\"id\":\"breakpoints\\/"
	"1\",\"breakpointNumber\":1,\"resolved\":false,\"location\":{\"type\":"
	"\"UnresolvedSourceLocation\",\"script\":{\"type\":\"@Script\","
	"\"fixedId\":true,\"id\":\"libraries\\/%s\\/scripts\\/"
	"test-lib\\/"
	"0\",\"uri\":\"test-lib\",\"_kind\":\"script\"},\"line\":2}},{\"type\":"
	"\"Breakpoint\",\"fixedId\":true,\"id\":\"breakpoints\\/"
	"3\",\"breakpointNumber\":3,\"resolved\":false,\"location\":{\"type\":"
	"\"UnresolvedSourceLocation\",\"scriptUri\":\"not_yet_loaded_script_"
	"uri\",\"line\":4}}]",
	private_key.ToCString(), private_key.ToCString());
	}
	}

	static bool saw_paused_event = false;

	static void InspectPausedEvent(Dart_IsolateId isolate_id,
	intptr_t bp_id,
	const Dart_CodeLocation& loc) {
	Isolate* isolate = Isolate::Current();
	Debugger* debugger = isolate->debugger();

	// The debugger knows that it is paused, and why.
	EXPECT(debugger->IsPaused());
	const ServiceEvent* event = debugger->PauseEvent();
	EXPECT(event != NULL);
	EXPECT(event->kind() == ServiceEvent::kPauseBreakpoint);
	saw_paused_event = true;
	}

	TEST_CASE(Debugger_PauseEvent) {
	const char* kScriptChars =
	"main() {\n"
	" var x = new StringBuffer();\n"
	" x.write('won');\n"
	" x.write('too');\n"
	" return x.toString();\n"
	"}\n";
	Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
	EXPECT_VALID(lib);

	Isolate* isolate = Isolate::Current();
	Debugger* debugger = isolate->debugger();

	// No pause event.
	EXPECT(!debugger->IsPaused());
	EXPECT(debugger->PauseEvent() == NULL);

	saw_paused_event = false;
	Dart_SetPausedEventHandler(InspectPausedEvent);

	// Set a breakpoint and run.
	EXPECT_VALID(Dart_SetBreakpoint(NewString(TestCase::url()), 2));
	Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
	EXPECT_VALID(result);
	EXPECT(Dart_IsString(result));

	// We ran the code in InspectPausedEvent.
	EXPECT(saw_paused_event);
	}

	static uint8_t* malloc_allocator(uint8_t* ptr,
	intptr_t old_size,
	intptr_t new_size) {
	void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
	return reinterpret_cast<uint8_t*>(new_ptr);
	}

	const char* rewind_frame_index = "-1";

	// Build and send a fake resume OOB message for testing purposes.
	void SendResumeMessage(Isolate* isolate) {
	// Format is: [ oob_type, port, seq, method_name, [keys], [values] ]
	Dart_CObject msg;
	Dart_CObject* list_values[6];
	msg.type = Dart_CObject_kArray;
	msg.value.as_array.length = 6;
	msg.value.as_array.values = list_values;

	Dart_CObject oob;
	oob.type = Dart_CObject_kInt32;
	oob.value.as_int32 = Message::kServiceOOBMsg;
	list_values[0] = &oob;

	Dart_CObject reply_port;
	reply_port.type = Dart_CObject_kNull;
	list_values[1] = &reply_port;

	Dart_CObject seq;
	seq.type = Dart_CObject_kNull;
	list_values[2] = &seq;

	Dart_CObject method_name;
	method_name.type = Dart_CObject_kString;
	method_name.value.as_string = const_cast<char*>("resume");
	list_values[3] = &method_name;

	const int kParamCount = 3;
	Dart_CObject param_keys;
	Dart_CObject* param_keys_list[kParamCount];
	param_keys.type = Dart_CObject_kArray;
	param_keys.value.as_array.values = param_keys_list;
	param_keys.value.as_array.length = kParamCount;
	list_values[4] = &param_keys;

	Dart_CObject param_values;
	Dart_CObject* param_values_list[kParamCount];
	param_values.type = Dart_CObject_kArray;
	param_values.value.as_array.values = param_values_list;
	param_values.value.as_array.length = kParamCount;
	list_values[5] = &param_values;

	Dart_CObject param0_name;
	param0_name.type = Dart_CObject_kString;
	param0_name.value.as_string = const_cast<char*>("isolateId");
	param_keys_list[0] = &param0_name;

	Dart_CObject param0_value;
	param0_value.type = Dart_CObject_kString;
	const char* isolate_id = Thread::Current()->zone()->PrintToString(
	ISOLATE_SERVICE_ID_FORMAT_STRING,
	static_cast<int64_t>(isolate->main_port()));
	param0_value.value.as_string = const_cast<char*>(isolate_id);
	param_values_list[0] = &param0_value;

	Dart_CObject param1_name;
	param1_name.type = Dart_CObject_kString;
	param1_name.value.as_string = const_cast<char*>("step");
	param_keys_list[1] = &param1_name;

	Dart_CObject param1_value;
	param1_value.type = Dart_CObject_kString;
	param1_value.value.as_string = const_cast<char*>("Rewind");
	param_values_list[1] = &param1_value;

	Dart_CObject param2_name;
	param2_name.type = Dart_CObject_kString;
	param2_name.value.as_string = const_cast<char*>("frameIndex");
	param_keys_list[2] = &param2_name;

	Dart_CObject param2_value;
	param2_value.type = Dart_CObject_kString;
	param2_value.value.as_string = const_cast<char*>(rewind_frame_index);
	param_values_list[2] = &param2_value;

	{
	uint8_t* buffer = NULL;
	ApiMessageWriter writer(&buffer, &malloc_allocator);
	bool success = writer.WriteCMessage(&msg);
	ASSERT(success);

	// Post the message at the given port.
	success = PortMap::PostMessage(new Message(isolate->main_port(), buffer,
	writer.BytesWritten(),
	Message::kOOBPriority));
	ASSERT(success);
	}
	}

	static void RewindOnce(Dart_IsolateId isolate_id,
	intptr_t bp_id,
	const Dart_CodeLocation& loc) {
	bool first_time = !saw_paused_event;
	saw_paused_event = true;
	if (first_time) {
	Thread* T = Thread::Current();
	Isolate* I = T->isolate();
	// TODO(turnidge): It is weird that the isolate can get to this
	// point in our tests without being marked runnable. Clear this up
	// at some point.
	I->set_is_runnable(true);
	SendResumeMessage(I);
	I->PauseEventHandler();
	}
	}

	TEST_CASE(Debugger_RewindOneFrame_Unoptimized) {
	SetFlagScope<bool> sfs(&FLAG_trace_rewind, true);

	// These variables are global state used by RewindOnce.
	saw_paused_event = false;
	rewind_frame_index = "1";

	const char* kScriptChars =
	"import 'dart:developer';\n"
	"\n"
	"var msg = new StringBuffer();\n"
	"\n"
	"foo() {\n"
	" msg.write('enter(foo) ');\n"
	" debugger();\n"
	" msg.write('exit(foo) ');\n"
	"}\n"
	"\n"
	"main() {\n"
	" msg.write('enter(main) ');\n"
	" foo();\n"
	" msg.write('exit(main) ');\n"
	" return msg.toString();\n"
	"}\n";
	Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
	EXPECT_VALID(lib);

	Dart_SetPausedEventHandler(RewindOnce);
	Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
	const char* result_cstr;
	EXPECT_VALID(result);
	EXPECT(Dart_IsString(result));
	EXPECT_VALID(Dart_StringToCString(result, &result_cstr));
	EXPECT_STREQ("enter(main) enter(foo) enter(foo) exit(foo) exit(main) ",
	result_cstr);
	EXPECT(saw_paused_event);
	}

	TEST_CASE(Debugger_RewindTwoFrames_Unoptimized) {
	SetFlagScope<bool> sfs(&FLAG_trace_rewind, true);

	// These variables are global state used by RewindOnce.
	saw_paused_event = false;
	rewind_frame_index = "2";

	const char* kScriptChars =
	"import 'dart:developer';\n"
	"\n"
	"var msg = new StringBuffer();\n"
	"\n"
	"foo() {\n"
	" msg.write('enter(foo) ');\n"
	" debugger();\n"
	" msg.write('exit(foo) ');\n"
	"}\n"
	"\n"
	"bar() {\n"
	" msg.write('enter(bar) ');\n"
	" foo();\n"
	" msg.write('exit(bar) ');\n"
	"}\n"
	"\n"
	"main() {\n"
	" msg.write('enter(main) ');\n"
	" bar();\n"
	" msg.write('exit(main) ');\n"
	" return msg.toString();\n"
	"}\n";
	Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
	EXPECT_VALID(lib);

	Dart_SetPausedEventHandler(RewindOnce);
	Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
	const char* result_cstr;
	EXPECT_VALID(result);
	EXPECT(Dart_IsString(result));
	EXPECT_VALID(Dart_StringToCString(result, &result_cstr));
	EXPECT_STREQ(
	"enter(main) enter(bar) enter(foo) enter(bar) enter(foo) "
	"exit(foo) exit(bar) exit(main) ",
	result_cstr);
	EXPECT(saw_paused_event);
	}

	TEST_CASE(Debugger_Rewind_Optimized) {
	SetFlagScope<bool> sfs1(&FLAG_trace_rewind, true);
	SetFlagScope<bool> sfs2(&FLAG_prune_dead_locals, false);
	SetFlagScope<bool> sfs3(&FLAG_enable_inlining_annotations, true);
	SetFlagScope<bool> sfs4(&FLAG_background_compilation, false);
	SetFlagScope<int> sfs5(&FLAG_optimization_counter_threshold, 10);

	// These variables are global state used by RewindOnce.
	saw_paused_event = false;
	rewind_frame_index = "2";

	const char* kScriptChars =
	"import 'dart:developer';\n"
	"\n"
	"const alwaysInline = \"AlwaysInline\";\n"
	"const noInline = \"NeverInline\";\n"
	"\n"
	"var msg = new StringBuffer();\n"
	"int i;\n"
	"\n"
	"@noInline\n"
	"foo() {\n"
	" msg.write('enter(foo) ');\n"
	" if (i > 15) {\n"
	" debugger();\n"
	" msg.write('exit(foo) ');\n"
	" return true;\n"
	" } else {\n"
	" msg.write('exit(foo) ');\n"
	" return false;\n"
	" }\n"
	"}\n"
	"\n"
	"@alwaysInline\n"
	"bar3() {\n"
	" msg.write('enter(bar3) ');\n"
	" var result = foo();\n"
	" msg.write('exit(bar3) ');\n"
	" return result;\n"
	"}\n"
	"\n"
	"@alwaysInline\n"
	"bar2() {\n"
	" msg.write('enter(bar2) ');\n"
	" var result = bar3();\n"
	" msg.write('exit(bar2) ');\n"
	" return result;\n"
	"}\n"
	"\n"
	"@alwaysInline\n"
	"bar1() {\n"
	" msg.write('enter(bar1) ');\n"
	" var result = bar2();\n"
	" msg.write('exit(bar1) ');\n"
	" return result;\n"
	"}\n"
	"\n"
	"main() {\n"
	" for (i = 0; i < 20; i++) {\n"
	" msg.clear();\n"
	" if (bar1()) break;\n;"
	" }\n"
	" return msg.toString();\n"
	"}\n";
	Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
	EXPECT_VALID(lib);

	Dart_SetPausedEventHandler(RewindOnce);
	Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
	const char* result_cstr;
	EXPECT_VALID(result);
	EXPECT(Dart_IsString(result));
	EXPECT_VALID(Dart_StringToCString(result, &result_cstr));
	EXPECT_STREQ(
	"enter(bar1) enter(bar2) enter(bar3) enter(foo) "
	"enter(bar3) enter(foo) "
	"exit(foo) exit(bar3) exit(bar2) exit(bar1) ",
	result_cstr);
	EXPECT(saw_paused_event);
	}

	#endif // !PRODUCT

	} // namespace dart