Teach debugger to ignore breakpoints

runtime/vm/debugger_api_impl_test.cc

 // Copyright (c) 2012, 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 "include/dart_debugger_api.h"
 #include "platform/assert.h"
 #include "vm/dart_api_impl.h"
 #include "vm/unit_test.h"
 
 namespace dart {
@@ skipping 15 matching lines @@
 
 static Dart_Handle Invoke(Dart_Handle lib, const char* func_name) {
   return  Dart_InvokeStatic(lib,
                             Dart_NewString(""),
                             Dart_NewString(func_name),
                             0,
                             NULL);
 }
 
 
+static char const* ToCString(Dart_Handle str) {
+  EXPECT(Dart_IsString(str));
+  char const* c_str = NULL;
+  Dart_StringToCString(str, &c_str);
+  return c_str;
+}
+
+
+static char const* BPFunctionName(Dart_StackTrace trace) {
+  Dart_ActivationFrame frame;
+  Dart_Handle res = Dart_GetActivationFrame(trace, 0, &frame);
+  EXPECT_NOT_ERROR(res);
+  Dart_Handle func_name;
+  res = Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL);
+  EXPECT_NOT_ERROR(res);
+  return ToCString(func_name);
+}
+
+
+static char const* BreakpointInfo(Dart_StackTrace trace) {
+  static char info_str[128];
+  Dart_ActivationFrame frame;
+  Dart_Handle res = Dart_GetActivationFrame(trace, 0, &frame);
+  EXPECT_NOT_ERROR(res);
+  Dart_Handle func_name;
+  Dart_Handle url;
+  intptr_t line_number = 0;
+  res = Dart_ActivationFrameInfo(frame, &func_name, &url, &line_number);
+  EXPECT_NOT_ERROR(res);
+  OS::SNPrint(info_str, sizeof(info_str), "function %s (%s:%d)",
+              ToCString(func_name), ToCString(url), line_number);
+  return info_str;
+}
+
+
+static void PrintValue(Dart_Handle value, bool expand);
+
+static void PrintObject(Dart_Handle obj, bool expand) {
+  Dart_Handle obj_class = Dart_GetObjClass(obj);
+  EXPECT_NOT_ERROR(obj_class);
+  EXPECT(!Dart_IsNull(obj_class));
+  Dart_Handle class_name = Dart_ToString(obj_class);
+  EXPECT_NOT_ERROR(class_name);
+  EXPECT(Dart_IsString(class_name));
+  char const* class_name_str;
+  Dart_StringToCString(class_name, &class_name_str);
+  Dart_Handle fields = Dart_GetInstanceFields(obj);
+  EXPECT_NOT_ERROR(fields);
+  EXPECT(Dart_IsList(fields));
+  intptr_t list_length = 0;
+  Dart_Handle retval = Dart_ListLength(fields, &list_length);
+  EXPECT_NOT_ERROR(retval);
+  OS::Print("object of type '%s'", class_name_str);
+  for (int i = 0; i + 1 < list_length; i += 2) {
+    Dart_Handle name_handle = Dart_ListGetAt(fields, i);
+    EXPECT_NOT_ERROR(name_handle);
+    EXPECT(Dart_IsString(name_handle));
+    Dart_Handle value_handle = Dart_ListGetAt(fields, i + 1);
+    OS::Print("\n        field %s = ", ToCString(name_handle));
+    PrintValue(value_handle, false);
+  }
+}
+
+
+static void PrintValue(Dart_Handle value, bool expand) {
+  if (Dart_IsNull(value)) {
+    OS::Print("null");
+  } else if (Dart_IsString(value)) {
+    Dart_Handle str_value = Dart_ToString(value);
+    EXPECT_NOT_ERROR(str_value);
+    EXPECT(Dart_IsString(str_value));
+    OS::Print("\"%s\"", ToCString(str_value));
+  } else if (Dart_IsNumber(value) || Dart_IsBoolean(value)) {
+    Dart_Handle str_value = Dart_ToString(value);
+    EXPECT_NOT_ERROR(str_value);
+    EXPECT(Dart_IsString(str_value));
+    OS::Print("%s", ToCString(str_value));
+  } else {
+    PrintObject(value, expand);
+  }
+}
+
+
+static void PrintActivationFrame(Dart_ActivationFrame frame) {
+  Dart_Handle func_name;
+  Dart_Handle res;
+  res = Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL);
+  EXPECT_NOT_ERROR(res);
+  EXPECT(Dart_IsString(func_name));
+  const char* func_name_chars;
+  Dart_StringToCString(func_name, &func_name_chars);
+  OS::Print("    function %s\n", func_name_chars);
+  Dart_Handle locals = Dart_GetLocalVariables(frame);
+  EXPECT_NOT_ERROR(locals);
+  intptr_t list_length = 0;
+  Dart_Handle ret = Dart_ListLength(locals, &list_length);
+  EXPECT_NOT_ERROR(ret);
+  for (int i = 0; i + 1 < list_length; i += 2) {
+    Dart_Handle name_handle = Dart_ListGetAt(locals, i);
+    EXPECT_NOT_ERROR(name_handle);
+    EXPECT(Dart_IsString(name_handle));
+    OS::Print("      local var %s = ", ToCString(name_handle));
+    Dart_Handle value_handle = Dart_ListGetAt(locals, i + 1);
+    EXPECT_NOT_ERROR(value_handle);
+    PrintValue(value_handle, true);
+    OS::Print("\n");
+  }
+}
+
+
+static void PrintStackTrace(Dart_StackTrace trace) {
+  intptr_t trace_len;
+  Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
+  EXPECT_NOT_ERROR(res);
+  for (int i = 0; i < trace_len; i++) {
+    Dart_ActivationFrame frame;
+    res = Dart_GetActivationFrame(trace, i, &frame);
+    EXPECT_NOT_ERROR(res);
+    PrintActivationFrame(frame);
+  }
+}
+
+
 void TestBreakpointHandler(Dart_Breakpoint bpt, Dart_StackTrace trace) {
   const char* expected_trace[] = {"A.foo", "main"};
   const intptr_t expected_trace_length = 2;
   breakpoint_hit = true;
   breakpoint_hit_counter++;
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_NOT_ERROR(res);
   EXPECT_EQ(expected_trace_length, trace_len);
   for (int i = 0; i < trace_len; i++) {
     Dart_ActivationFrame frame;
     res = Dart_GetActivationFrame(trace, i, &frame);
     EXPECT_NOT_ERROR(res);
     Dart_Handle func_name;
     res = Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL);
     EXPECT_NOT_ERROR(res);
     EXPECT(Dart_IsString(func_name));
     const char* name_chars;
     Dart_StringToCString(func_name, &name_chars);
     EXPECT_STREQ(expected_trace[i], name_chars);
-    if (verbose) printf("  >> %d: %s\n", i, name_chars);
+    if (verbose) OS::Print("  >> %d: %s\n", i, name_chars);
   }
 }
 
 
 TEST_CASE(Debug_Breakpoint) {
   const char* kScriptChars =
       "void moo(s) { }        \n"
       "class A {              \n"
       "  static void foo() {  \n"
       "    moo('good news');  \n"
@@ skipping 34 matching lines @@
   Dart_Handle func_name;
   res = Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL);
   EXPECT_NOT_ERROR(res);
   EXPECT(Dart_IsString(func_name));
   const char* name_chars;
   Dart_StringToCString(func_name, &name_chars);
   if (breakpoint_hit_counter < expected_bpts_length) {
     EXPECT_STREQ(expected_bpts[breakpoint_hit_counter], name_chars);
   }
   if (verbose) {
-    printf("  >> bpt nr %d: %s\n", breakpoint_hit_counter, name_chars);
+    OS::Print("  >> bpt nr %d: %s\n", breakpoint_hit_counter, name_chars);
   }
   breakpoint_hit = true;
   breakpoint_hit_counter++;
   Dart_SetStepOut();
 }
 
 
 TEST_CASE(Debug_StepOut) {
   const char* kScriptChars =
       "void f1() { return 1; }  \n"
@@ skipping 65 matching lines @@
   Dart_Handle func_name;
   res = Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL);
   EXPECT_NOT_ERROR(res);
   EXPECT(Dart_IsString(func_name));
   const char* name_chars;
   Dart_StringToCString(func_name, &name_chars);
   if (breakpoint_hit_counter < expected_bpts_length) {
     EXPECT_STREQ(expected_bpts[breakpoint_hit_counter], name_chars);
   }
   if (verbose) {
-    printf("  >> bpt nr %d: %s\n", breakpoint_hit_counter, name_chars);
+    OS::Print("  >> bpt nr %d: %s\n", breakpoint_hit_counter, name_chars);
   }
   breakpoint_hit = true;
   breakpoint_hit_counter++;
   Dart_SetStepInto();
 }
 
 
 TEST_CASE(Debug_StepInto) {
   const char* kScriptChars =
       "void f1() { return 1; }  \n"
@@ skipping 34 matching lines @@
   Dart_Handle retval = Invoke(lib, "main");
   EXPECT(!Dart_IsError(retval));
   EXPECT(Dart_IsInteger(retval));
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
   EXPECT_EQ(7, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
+void TestIgnoreBPHandler(Dart_Breakpoint bpt, Dart_StackTrace trace) {
+  if (verbose) {
+    OS::Print(">>> Breakpoint nr. %d in %s <<<\n",
+              breakpoint_hit_counter, BreakpointInfo(trace));
+    PrintStackTrace(trace);

[siva, 2012/03/10 00:11:40]

This ensures that the ignore breakpoint feature is tested when accessing
instance fields, what about also testing it when accessing static fields.

[hausner, 2012/03/10 00:41:56]

Added a static field to the sample and to the stack dump.

+  }
+  breakpoint_hit = true;
+  breakpoint_hit_counter++;
+  Dart_SetStepInto();

[siva, 2012/03/10 00:11:40]

Why is it necessary to single step after this?

[hausner, 2012/03/10 00:41:56]

It's just the easiest way to make sure we get into every function.

[siva, 2012/03/12 22:19:14]

Not sure I understand what you mean by get into every function.

On 2012/03/10 00:41:56, hausner wrote:

[hausner, 2012/03/12 22:36:44]

The relevant case that we test here happens when we step into the getter
function get:i of class B. The easiest way to get a breakpoint inside the getter
is to stop at main, and then step into every function call.

On 2012/03/12 22:19:14, asiva wrote:

+}
+
+
+TEST_CASE(Debug_IgnoreBP) {
+  const char* kScriptChars =
+      "class B {                \n"
+      "  var i = 100;           \n"
+      "  var d = 3.14;          \n"
+      "  var s = 'Dr Seuss';    \n"
+      "}                        \n"
+      "                         \n"
+      "void main() {            \n"
+      "  var x = new B();       \n"
+      "  return x.i + 1;        \n"
+      "}                        \n";
+
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
+  EXPECT(!Dart_IsError(lib));
+
+  Dart_SetBreakpointHandler(&TestIgnoreBPHandler);
+
+  Dart_Handle c_name = Dart_NewString("");
+  Dart_Handle f_name = Dart_NewString("main");
+  Dart_Breakpoint bpt;
+  Dart_Handle res = Dart_SetBreakpointAtEntry(lib, c_name, f_name, &bpt);
+  EXPECT_NOT_ERROR(res);
+
+  breakpoint_hit = false;
+  breakpoint_hit_counter = 0;

[siva, 2012/03/10 00:11:40]

What is the significance of breakpoint_hit_counter in this test as you are not
checking the value with any EXPECT clause.

Maybe there should be a EXPECT_EQ(1, breakpoint_hit_counter);

[hausner, 2012/03/10 00:41:56]

It's just boilerplate that I copied from other test cases. I could eliminate it,
but then, there's no harm in leaving it.

On 2012/03/10 00:11:40, asiva wrote:

[siva, 2012/03/12 22:19:14]

If you are retaining it then why not add the check
EXPECT_EQ(1, breakpoint_hit_counter);

On 2012/03/10 00:41:56, hausner wrote:

[hausner, 2012/03/12 22:36:44]

This test hits many breakpoints (including the internal ones that are the result
of stepping):

Running test: Debug_IgnoreBP
    function main
      local var x = null
    function B.B.
      local var this = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function main
      local var x = null
    function Object.Object.
      local var this = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function B.B.
      local var this = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function main
      local var x = null
    function B.B.
      local var this = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function main
      local var x = null
    function main
      local var x = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function B.get:i
      local var this = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function main
      local var x = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function main
      local var x = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function IntegerImplementation.+
      local var this = 100
      local var other = 1
    function main
      local var x = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function IntegerImplementation.addFromInteger
      local var this = 1
      local var other = 100
    function IntegerImplementation.+
      local var this = 100
      local var other = 1
    function main
      local var x = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function IntegerImplementation.+
      local var this = 100
      local var other = 1
    function main
      local var x = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
    function main
      local var x = object of type 'Library:'dart:test-lib' Class: B'
        field i = 100
        field d = 3.14
        field s = "Dr Seuss"
        static field z = 0
Done: Debug_IgnoreBP


On 2012/03/12 22:19:14, asiva wrote:

+  Dart_Handle retval = Invoke(lib, "main");
+  EXPECT(!Dart_IsError(retval));
+  EXPECT(Dart_IsInteger(retval));
+  int64_t int_value = 0;
+  Dart_IntegerToInt64(retval, &int_value);
+  EXPECT_EQ(101, int_value);
+  EXPECT(breakpoint_hit == true);
+}
+
+
 void TestSingleStepHandler(Dart_Breakpoint bpt, Dart_StackTrace trace) {
   const char* expected_bpts[] = {
       "moo", "foo", "moo", "foo", "moo", "foo", "main"};
   const intptr_t expected_bpts_length = ARRAY_SIZE(expected_bpts);
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_NOT_ERROR(res);
   EXPECT(breakpoint_hit_counter < expected_bpts_length);
   Dart_ActivationFrame frame;
   res = Dart_GetActivationFrame(trace, 0, &frame);
   EXPECT_NOT_ERROR(res);
   Dart_Handle func_name;
   res = Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL);
   EXPECT_NOT_ERROR(res);
   EXPECT(Dart_IsString(func_name));
   const char* name_chars;
   Dart_StringToCString(func_name, &name_chars);
   if (verbose) {
-    printf("  >> bpt nr %d: %s\n", breakpoint_hit_counter, name_chars);
+    OS::Print("  >> bpt nr %d: %s\n", breakpoint_hit_counter, name_chars);
   }
   if (breakpoint_hit_counter < expected_bpts_length) {
     EXPECT_STREQ(expected_bpts[breakpoint_hit_counter], name_chars);
   }
   breakpoint_hit = true;
   breakpoint_hit_counter++;
   Dart_SetStepOver();
 }
 
 
@@ skipping 43 matching lines @@
     Dart_ActivationFrame frame;
     res = Dart_GetActivationFrame(trace, i, &frame);
     EXPECT_NOT_ERROR(res);
     Dart_Handle func_name;
     res = Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL);
     EXPECT_NOT_ERROR(res);
     EXPECT(Dart_IsString(func_name));
     const char* name_chars;
     Dart_StringToCString(func_name, &name_chars);
     EXPECT_STREQ(expected_trace[i], name_chars);
-    if (verbose) printf("  >> %d: %s\n", i, name_chars);
+    if (verbose) OS::Print("  >> %d: %s\n", i, name_chars);
   }
 }
 
 
 TEST_CASE(Debug_ClosureBreakpoint) {
   const char* kScriptChars =
       "callback(s) {          \n"
       "  return 111;          \n"
       "}                      \n"
       "                       \n"
@@ skipping 38 matching lines @@
     Dart_ActivationFrame frame;
     res = Dart_GetActivationFrame(trace, i, &frame);
     EXPECT_NOT_ERROR(res);
     Dart_Handle func_name;
     res = Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL);
     EXPECT_NOT_ERROR(res);
     EXPECT(Dart_IsString(func_name));
     const char* name_chars;
     Dart_StringToCString(func_name, &name_chars);
     EXPECT_STREQ(expected_trace[i], name_chars);
-    if (verbose) printf("  >> %d: %s\n", i, name_chars);
+    if (verbose) OS::Print("  >> %d: %s\n", i, name_chars);
   }
   // Remove the breakpoint after we've hit it twice
   if (breakpoint_hit_counter == 2) {
-    if (verbose) printf("uninstalling breakpoint\n");
+    if (verbose) OS::Print("uninstalling breakpoint\n");
     Dart_Handle res = Dart_DeleteBreakpoint(bpt);
     EXPECT_NOT_ERROR(res);
   }
 }
 
 
 TEST_CASE(Debug_DeleteBreakpoint) {
   const char* kScriptChars =
       "moo(s) { }             \n"
       "                       \n"
@@ skipping 55 matching lines @@
   EXPECT_NOT_ERROR(object_b);
 
   Dart_Handle fields = Dart_GetInstanceFields(object_b);
   EXPECT_NOT_ERROR(fields);
   EXPECT(Dart_IsList(fields));
   intptr_t list_length = 0;
   Dart_Handle retval = Dart_ListLength(fields, &list_length);
   EXPECT_NOT_ERROR(retval);
   int num_fields = list_length / 2;
   EXPECT_EQ(kNumObjectFields, num_fields);
-  printf("Object has %d fields:\n", num_fields);
+  OS::Print("Object has %d fields:\n", num_fields);
   for (int i = 0; i + 1 < list_length; i += 2) {
     Dart_Handle name_handle = Dart_ListGetAt(fields, i);
     EXPECT_NOT_ERROR(name_handle);
     EXPECT(Dart_IsString(name_handle));
     char const* name;
     Dart_StringToCString(name_handle, &name);
     Dart_Handle value_handle = Dart_ListGetAt(fields, i + 1);
     EXPECT_NOT_ERROR(value_handle);
     value_handle = Dart_ToString(value_handle);
     EXPECT_NOT_ERROR(value_handle);
     EXPECT(Dart_IsString(value_handle));
     char const* value;
     Dart_StringToCString(value_handle, &value);
-    printf("  %s: %s\n", name, value);
+    OS::Print("  %s: %s\n", name, value);
   }
 
   // Check that an integer value returns an empty list of fields.
   Dart_Handle triple_six = Invoke(lib, "get_int");
   EXPECT_NOT_ERROR(triple_six);
   EXPECT(Dart_IsInteger(triple_six));
   int64_t int_value = 0;
   Dart_IntegerToInt64(triple_six, &int_value);
   EXPECT_EQ(666, int_value);
   fields = Dart_GetInstanceFields(triple_six);
@@ skipping 105 matching lines @@
   Dart_Handle libs = Dart_GetLibraryURLs();
   EXPECT(Dart_IsList(libs));
   intptr_t num_libs;
   Dart_ListLength(libs, &num_libs);
   EXPECT(num_libs > 0);
   for (int i = 0; i < num_libs; i++) {
     Dart_Handle lib_url = Dart_ListGetAt(libs, i);
     EXPECT(Dart_IsString(lib_url));
     char const* chars;
     Dart_StringToCString(lib_url, &chars);
-    printf("Lib %d: %s\n", i, chars);
+    OS::Print("Lib %d: %s\n", i, chars);
 
     Dart_Handle scripts = Dart_GetScriptURLs(lib_url);
     EXPECT(Dart_IsList(scripts));
     intptr_t num_scripts;
     Dart_ListLength(scripts, &num_scripts);
     EXPECT(num_scripts >= 0);
     for (int i = 0; i < num_scripts; i++) {
       Dart_Handle script_url = Dart_ListGetAt(scripts, i);
       char const* chars;
       Dart_StringToCString(script_url, &chars);
-      printf("  script %d: '%s'\n", i + 1, chars);
+      OS::Print("  script %d: '%s'\n", i + 1, chars);
     }
   }
 
   Dart_Handle lib_url = Dart_NewString(TestCase::url());
   Dart_Handle source = Dart_GetScriptSource(lib_url, lib_url);
   EXPECT(Dart_IsString(source));
   char const* source_chars;
   Dart_StringToCString(source, &source_chars);
-  printf("\n=== source: ===\n%s", source_chars);
+  OS::Print("\n=== source: ===\n%s", source_chars);
   EXPECT_STREQ(kScriptChars, source_chars);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart