StepOver, StepInto, StepOut

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 42 matching lines @@
     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);
   }
 }
 
 
 TEST_CASE(Debug_Breakpoint) {
   const char* kScriptChars =
-      "void moo(s) { }\n"
-      "class A {\n"
-      "  static void foo() {\n"
-      "    moo('good news');\n"
-      "  }\n"
-      "}\n"
-      "void main() {\n"
-      "  A.foo();\n"
-      "}\n";
+      "void moo(s) { }        \n"
+      "class A {              \n"
+      "  static void foo() {  \n"
+      "    moo('good news');  \n"
+      "  }                    \n"
+      "}                      \n"
+      "void main() {          \n"
+      "  A.foo();             \n"
+      "}                      \n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT(!Dart_IsError(lib));
 
   Dart_SetBreakpointHandler(&TestBreakpointHandler);
 
   Dart_Handle c_name = Dart_NewString("A");
   Dart_Handle f_name = Dart_NewString("foo");
   Dart_Breakpoint bpt;
   Dart_Handle res = Dart_SetBreakpointAtEntry(lib, c_name, f_name, &bpt);
   EXPECT_NOT_ERROR(res);
 
   breakpoint_hit = false;
   Dart_Handle retval = Invoke(lib, "main");
   EXPECT(!Dart_IsError(retval));
   EXPECT(breakpoint_hit == true);
 }
 
 
+void TestStepOutHandler(Dart_Breakpoint bpt, Dart_StackTrace trace) {
+  const char* expected_bpts[] = {"f1", "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 (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);
+  }
+  breakpoint_hit = true;
+  breakpoint_hit_counter++;
+  Dart_SetStepOut();
+}
+
+
+TEST_CASE(Debug_StepOut) {
+  const char* kScriptChars =
+      "void f1() { return 1; }  \n"
+      "void f2() { return 2; }  \n"
+      "                         \n"
+      "void foo() {             \n"
+      "  f1();                  \n"
+      "  return f2();           \n"
+      "}                        \n"
+      "                         \n"
+      "void main() {            \n"
+      "  return foo();          \n"
+      "}                        \n";
+
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
+  EXPECT(!Dart_IsError(lib));
+
+  Dart_SetBreakpointHandler(&TestStepOutHandler);
+
+  // Set a breakpoint in function f1, then repeatedly step out until
+  // we get to main. We should see one breakpoint each in f1,
+  // foo, main, but not in f2.
+  Dart_Handle c_name = Dart_NewString("");
+  Dart_Handle f_name = Dart_NewString("f1");
+  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;
+  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(2, int_value);
+  EXPECT(breakpoint_hit == true);
+}
+
+
+void TestStepIntoHandler(Dart_Breakpoint bpt, Dart_StackTrace trace) {
+  const char* expected_bpts[] = {
+      "main",
+        "foo",
+          "f1",
+        "foo",
+          "X.X.",
+            "Object.Object.",
+          "X.X.",
+        "foo",
+          "X.kvmk",
+            "f2",
+          "X.kvmk",
+            "IntegerImplementation.+",
+              "IntegerImplementation.addFromInteger",
+            "IntegerImplementation.+",
+          "X.kvmk",
+        "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 (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);
+  }
+  breakpoint_hit = true;
+  breakpoint_hit_counter++;
+  Dart_SetStepInto();
+}
+
+
+TEST_CASE(Debug_StepInto) {
+  const char* kScriptChars =
+      "void f1() { return 1; }  \n"
+      "void f2() { return 2; }  \n"
+      "                         \n"
+      "class X {                \n"
+      "  kvmk(a, [b, c]) {      \n"
+      "    return c + f2();     \n"
+      "  }                      \n"
+      "}                        \n"
+      "                         \n"
+      "void foo() {             \n"
+      "  f1();                  \n"
+      "  var o = new X();       \n"
+      "  return o.kvmk(3, c:5); \n"
+      "}                        \n"
+      "                         \n"
+      "void main() {            \n"
+      "  return foo();          \n"
+      "}                        \n";
+
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
+  EXPECT(!Dart_IsError(lib));
+
+  Dart_SetBreakpointHandler(&TestStepIntoHandler);
+
+  // Set a breakpoint in function f1, then repeatedly step out until
+  // we get to main. We should see one breakpoint each in f1,
+  // foo, main, but not in f2.
+  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;
+  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 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 (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);
+  }
+  breakpoint_hit = true;
+  breakpoint_hit_counter++;
+  Dart_SetStepOver();
+}
+
+
+TEST_CASE(Debug_SingleStep) {
+  const char* kScriptChars =
+      "void moo(s) { return 1; } \n"
+      "                          \n"
+      "void foo() {              \n"
+      "  moo('step one');        \n"
+      "  moo('step two');        \n"
+      "  moo('step three');      \n"
+      "}                         \n"
+      "                          \n"
+      "void main() {             \n"
+      "  foo();                  \n"
+      "}                         \n";
+
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
+  EXPECT(!Dart_IsError(lib));
+
+  Dart_SetBreakpointHandler(&TestSingleStepHandler);
+
+  Dart_Handle c_name = Dart_NewString("");
+  Dart_Handle f_name = Dart_NewString("moo");
+  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;
+  Dart_Handle retval = Invoke(lib, "main");
+  EXPECT(!Dart_IsError(retval));
+  EXPECT(breakpoint_hit == true);
+}
+
+
+
 static void DeleteBreakpointHandler(Dart_Breakpoint bpt,
                                     Dart_StackTrace trace) {
   const char* expected_trace[] = {"foo", "main"};
   const intptr_t expected_trace_length = 2;
   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++) {
@@ skipping 13 matching lines @@
   if (breakpoint_hit_counter == 2) {
     if (verbose) printf("uninstalling breakpoint\n");
     Dart_Handle res = Dart_DeleteBreakpoint(bpt);
     EXPECT_NOT_ERROR(res);
   }
 }
 
 
 TEST_CASE(Debug_DeleteBreakpoint) {
   const char* kScriptChars =
-      "moo(s) { }\n"
-      "\n"
-      "foo() {\n"
-      "    moo('good news');\n"
-      "}\n"
-      "\n"
-      "void main() {\n"
-      "  foo();\n"
-      "  foo();\n"
-      "  foo();\n"
-      "}\n";
+      "moo(s) { }             \n"
+      "                       \n"
+      "foo() {                \n"
+      "    moo('good news');  \n"
+      "}                      \n"
+      "                       \n"
+      "void main() {          \n"
+      "  foo();               \n"
+      "  foo();               \n"
+      "  foo();               \n"
+      "}                      \n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT(!Dart_IsError(lib));
 
   Dart_Handle script_url = Dart_NewString(TestCase::url());
   Dart_Handle line_no = Dart_NewInteger(4);  // In function 'foo'.
 
   Dart_SetBreakpointHandler(&DeleteBreakpointHandler);
 
   Dart_Breakpoint bpt;
   Dart_Handle res = Dart_SetBreakpointAtLine(script_url, line_no, &bpt);
   EXPECT_NOT_ERROR(res);
 
   // Function main() calls foo() 3 times. On the second iteration, the
   // breakpoint is removed by the handler, so we expect the breakpoint
   // to fire twice only.
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke(lib, "main");
   EXPECT(!Dart_IsError(retval));
   EXPECT(breakpoint_hit_counter == 2);
 }
 
 
 TEST_CASE(Debug_InspectObject) {
   const char* kScriptChars =
-    " class A { \n"
-    "   var a_field = 'a'; \n"
-    "   static var bla = 'yada yada yada';\n"
-    "   static var error = unresolvedName(); \n"
-    "   var d = 42.1; \n"
-    " } \n"
-    " class B extends A { \n"
+    " class A {                                 \n"
+    "   var a_field = 'a';                      \n"
+    "   static var bla = 'yada yada yada';      \n"
+    "   static var error = unresolvedName();    \n"
+    "   var d = 42.1;                           \n"
+    " }                                         \n"
+    " class B extends A {                       \n"
     "   var oneDay = const Duration(hours: 24); \n"
-    "   static var bla = 'blah blah'; \n"
-    " } \n"
-    " get_b() { return new B(); } \n"
-    " get_int() { return 666; } \n";
+    "   static var bla = 'blah blah';           \n"
+    " }                                         \n"
+    " get_b() { return new B(); }               \n"
+    " get_int() { return 666; }                 \n";
 
   // Number of instance fields in an object of class B.
   const intptr_t kNumObjectFields = 3;
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_NOT_ERROR(lib);
 
   Dart_Handle object_b = Invoke(lib, "get_b");
 
   EXPECT_NOT_ERROR(object_b);
@@ skipping 92 matching lines @@
   EXPECT(Dart_IsString(name_handle));
   Dart_StringToCString(name_handle, &name);
   EXPECT_STREQ("error", name);
   value_handle = Dart_ListGetAt(fields, 3);
   EXPECT(Dart_IsError(value_handle));
 }
 
 
 TEST_CASE(Debug_LookupSourceLine) {
   const char* kScriptChars =
-  /*1*/  "class A {\n"
-  /*2*/  "  static void foo() {\n"
-  /*3*/  "    moo('good news');\n"
-  /*4*/  "  }\n"
-  /*5*/  "}\n"
-  /*6*/  "\n"
-  /*7*/  "void main() {\n"
-  /*8*/  "  A.foo();\n"
-  /*9*/  "}\n"
-  /*10*/ "\n";
+  /*1*/  "class A {                 \n"
+  /*2*/  "  static void foo() {     \n"
+  /*3*/  "    moo('good news');     \n"
+  /*4*/  "  }                       \n"
+  /*5*/  "}                         \n"
+  /*6*/  "                          \n"
+  /*7*/  "void main() {             \n"
+  /*8*/  "  A.foo();                \n"
+  /*9*/  "}                         \n"
+  /*10*/ "                          \n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT(!Dart_IsError(lib));
 
   const Library& test_lib = Library::CheckedHandle(Api::UnwrapHandle(lib));
   const String& script_url = String::Handle(String::New(TestCase::url()));
   Function& func = Function::Handle();
 
   // TODO(hausner): Looking up functions from source and line number
   // needs to be refined. We currently dont find "main" on line 7.
@@ skipping 44 matching lines @@
   EXPECT(Dart_IsString(source));
   char const* source_chars;
   Dart_StringToCString(source, &source_chars);
   printf("\n=== source: ===\n%s", source_chars);
   EXPECT_STREQ(kScriptChars, source_chars);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart