Fix static field inspection in debugger

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 {
 
 // Only ia32 and x64 can run execution tests.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 
 static bool breakpoint_hit = false;
 static int  breakpoint_hit_counter = 0;
+static Dart_Handle script_lib = NULL;
 
 static const bool verbose = true;
 
 #define EXPECT_NOT_ERROR(handle)                                              \
   if (Dart_IsError(handle)) {                                                 \
     OS::Print("Error: %s\n", Dart_GetError(handle));                          \
   }                                                                           \
   EXPECT(!Dart_IsError(handle));
 
 
-static Dart_Handle Invoke(Dart_Handle lib, const char* func_name) {
-  return  Dart_InvokeStatic(lib,
+static void LoadScript(const char* source) {
+  script_lib = TestCase::LoadTestScript(source, NULL);
+  EXPECT(!Dart_IsError(script_lib));
+}
+
+
+static void SetBreakpointAtEntry(const char* cname, const char* fname) {
+  ASSERT(script_lib != NULL);
+  ASSERT(!Dart_IsError(script_lib));
+  ASSERT(Dart_IsLibrary(script_lib));
+  Dart_Breakpoint bpt;
+  Dart_Handle res = Dart_SetBreakpointAtEntry(script_lib,
+                        Dart_NewString(cname),
+                        Dart_NewString(fname),
+                        &bpt);
+  EXPECT_NOT_ERROR(res);
+}
+
+
+static Dart_Handle Invoke(const char* func_name) {
+  ASSERT(script_lib != NULL);
+  ASSERT(!Dart_IsError(script_lib));
+  ASSERT(Dart_IsLibrary(script_lib));
+  return  Dart_InvokeStatic(script_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;
@@ skipping 172 matching lines @@
       "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));
-
+  LoadScript(kScriptChars);
   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);
+  SetBreakpointAtEntry("A", "foo");
 
   breakpoint_hit = false;
-  Dart_Handle retval = Invoke(lib, "main");
+  Dart_Handle retval = Invoke("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);
@@ skipping 27 matching lines @@
       "                         \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));
-
+  LoadScript(kScriptChars);
   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);
+  SetBreakpointAtEntry("", "f1");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
-  Dart_Handle retval = Invoke(lib, "main");
+  Dart_Handle retval = Invoke("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) {
@@ skipping 56 matching lines @@
       "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));
-
+  LoadScript(kScriptChars);
   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);
+  SetBreakpointAtEntry("", "main");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
-  Dart_Handle retval = Invoke(lib, "main");
+  Dart_Handle retval = Invoke("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);
 }
 
 
 static void StepIntoHandler(Dart_Breakpoint bpt, Dart_StackTrace trace) {
@@ skipping 15 matching lines @@
       "  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));
-
+  LoadScript(kScriptChars);
   Dart_SetBreakpointHandler(&StepIntoHandler);
 
-  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);
+  SetBreakpointAtEntry("", "main");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
-  Dart_Handle retval = Invoke(lib, "main");
+  Dart_Handle retval = Invoke("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);
 }
 
 
 TEST_CASE(Debug_DeoptimizeFunction) {
   const char* kScriptChars =
       "foo(x) => 2 * x;         \n"
       "                         \n"
       "warmup() {               \n"
       "  for (int i = 0; i < 5000; i++) {   \n"
       "    foo(i);              \n"
       "  }                      \n"
       "}                        \n"
       "                         \n"
       "void main() {            \n"
       "  return foo(99);        \n"
       "}                        \n";
 
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
-  EXPECT(!Dart_IsError(lib));
-
+  LoadScript(kScriptChars);
   Dart_SetBreakpointHandler(&StepIntoHandler);
 
 
   // Cause function foo to be optimized before we set a BP.
-  Dart_Handle res = Invoke(lib, "warmup");
+  Dart_Handle res = Invoke("warmup");
   EXPECT_NOT_ERROR(res);
 
   // Now set breakpoint in main and then step into optimized function foo.
-  Dart_Handle c_name = Dart_NewString("");
-  Dart_Handle f_name = Dart_NewString("main");
-  Dart_Breakpoint bpt;
-  res = Dart_SetBreakpointAtEntry(lib, c_name, f_name, &bpt);
-  EXPECT_NOT_ERROR(res);
+  SetBreakpointAtEntry("", "main");
+
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
-  Dart_Handle retval = Invoke(lib, "main");
+  Dart_Handle retval = Invoke("main");
   EXPECT(!Dart_IsError(retval));
   EXPECT(Dart_IsInteger(retval));
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
   EXPECT_EQ(2 * 99, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
 void TestSingleStepHandler(Dart_Breakpoint bpt, Dart_StackTrace trace) {
@@ skipping 32 matching lines @@
       "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));
-
+  LoadScript(kScriptChars);
   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);
+  SetBreakpointAtEntry("", "moo");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
-  Dart_Handle retval = Invoke(lib, "main");
+  Dart_Handle retval = Invoke("main");
   EXPECT_NOT_ERROR(retval);
   EXPECT(breakpoint_hit == true);
 }
 
 
 static void ClosureBreakpointHandler(Dart_Breakpoint bpt,
                                      Dart_StackTrace trace) {
   const char* expected_trace[] = {"callback", "main"};
   const intptr_t expected_trace_length = 2;
   breakpoint_hit_counter++;
@@ skipping 23 matching lines @@
       "  return 111;          \n"
       "}                      \n"
       "                       \n"
       "main() {               \n"
       "  var h = callback;    \n"
       "  h('bla');            \n"
       "  callback('jada');    \n"
       "  return 442;          \n"
       "}                      \n";
 
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
-  EXPECT(!Dart_IsError(lib));
-
+  LoadScript(kScriptChars);
   Dart_SetBreakpointHandler(&ClosureBreakpointHandler);
 
-  Dart_Handle c_name = Dart_NewString("");
-  Dart_Handle f_name = Dart_NewString("callback");
-  Dart_Breakpoint bpt;
-  Dart_Handle res = Dart_SetBreakpointAtEntry(lib, c_name, f_name, &bpt);
-  EXPECT_NOT_ERROR(res);
+  SetBreakpointAtEntry("", "callback");
 
   breakpoint_hit_counter = 0;
-  Dart_Handle retval = Invoke(lib, "main");
+  Dart_Handle retval = Invoke("main");
   EXPECT_NOT_ERROR(retval);
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
   EXPECT_EQ(442, int_value);
   EXPECT_EQ(2, breakpoint_hit_counter);
 }
 
 
 static void ExprClosureBreakpointHandler(Dart_Breakpoint bpt,
                                          Dart_StackTrace trace) {
   static const char* expected_trace[] = {"add", "main", ""};
   breakpoint_hit_counter++;
   PrintStackTrace(trace);
   VerifyStackTrace(trace, expected_trace, 2);
 }
 
 
 TEST_CASE(Debug_ExprClosureBreakpoint) {
   const char* kScriptChars =
       "var c;                 \n"
       "                       \n"
       "main() {               \n"
       "  c = add(a, b) {      \n"
       "    return a + b;      \n"
       "  };                   \n"
       "  return c(10, 20);    \n"
       "}                      \n";
 
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
-  EXPECT(!Dart_IsError(lib));
-
+  LoadScript(kScriptChars);
   Dart_SetBreakpointHandler(&ExprClosureBreakpointHandler);
 
   Dart_Handle script_url = Dart_NewString(TestCase::url());
   Dart_Handle line_no = Dart_NewInteger(5);  // In closure 'add'.
   Dart_Breakpoint bpt;
   Dart_Handle res = Dart_SetBreakpointAtLine(script_url, line_no, &bpt);
   EXPECT_NOT_ERROR(res);
 
   breakpoint_hit_counter = 0;
-  Dart_Handle retval = Invoke(lib, "main");
+  Dart_Handle retval = Invoke("main");
   EXPECT_NOT_ERROR(retval);
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
   EXPECT_EQ(30, int_value);
   EXPECT_EQ(1, breakpoint_hit_counter);
 }
 
 
 static void DeleteBreakpointHandler(Dart_Breakpoint bpt,
                                     Dart_StackTrace trace) {
@@ skipping 33 matching lines @@
       "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));
+  LoadScript(kScriptChars);
 
   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");
+  Dart_Handle retval = Invoke("main");
   EXPECT(!Dart_IsError(retval));
   EXPECT_EQ(2, breakpoint_hit_counter);
 }
 
 
+static void InspectStaticFieldHandler(Dart_Breakpoint bpt,
+                                      Dart_StackTrace trace) {
+  ASSERT(script_lib != NULL);
+  ASSERT(!Dart_IsError(script_lib));
+  ASSERT(Dart_IsLibrary(script_lib));
+  Dart_Handle class_A = Dart_GetClass(script_lib, Dart_NewString("A"));
+  EXPECT(!Dart_IsError(class_A));
+
+  const int expected_num_fields = 2;
+  struct {
+    const char* field_name;
+    const char* field_value;
+  } expected[] = {
+    // Expected values at first breakpoint.
+    { "bla", "yada yada yada"},
+    { "u", "null" },
+    // Expected values at second breakpoint.
+    { "bla", "silence is golden" },
+    { "u", "442" }
+  };
+  ASSERT(breakpoint_hit_counter < 2);
+  int expected_idx = breakpoint_hit_counter * expected_num_fields;
+  breakpoint_hit_counter++;
+
+  Dart_Handle fields = Dart_GetStaticFields(class_A);
+  ASSERT(!Dart_IsError(fields));
+  ASSERT(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;
+  OS::Print("Class A has %d fields:\n", num_fields);
+  ASSERT(expected_num_fields == 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);
+    EXPECT_STREQ(expected[expected_idx].field_name, 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);
+    EXPECT_STREQ(expected[expected_idx].field_value, value);
+    OS::Print("  %s: %s\n", name, value);
+    expected_idx++;
+  }
+}
+
+
+TEST_CASE(Debug_InspectStaticField) {
+  const char* kScriptChars =
+    " class A {                                 \n"
+    "   static var bla = 'yada yada yada';      \n"
+    "   static var u;                           \n"
+    " }                                         \n"
+    "                                           \n"
+    " debugBreak() { }                          \n"
+    " main() {                                  \n"
+    "   var a = new A();                        \n"
+    "   debugBreak();                           \n"
+    "   A.u = 442;                              \n"
+    "   A.bla = 'silence is golden';            \n"
+    "   debugBreak();                           \n"
+    " }                                         \n";
+
+  LoadScript(kScriptChars);
+  Dart_SetBreakpointHandler(&InspectStaticFieldHandler);
+  SetBreakpointAtEntry("", "debugBreak");
+
+  breakpoint_hit_counter = 0;
+  Dart_Handle retval = Invoke("main");
+  EXPECT(!Dart_IsError(retval));
+}
+
+
 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"
     "   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";
 
   // 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);
+  LoadScript(kScriptChars);
 
-  Dart_Handle object_b = Invoke(lib, "get_b");
+  Dart_Handle object_b = Invoke("get_b");
 
   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);
   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);
     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");
+  Dart_Handle triple_six = Invoke("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);
   EXPECT_NOT_ERROR(fields);
   EXPECT(Dart_IsList(fields));
   retval = Dart_ListLength(fields, &list_length);
   EXPECT_EQ(0, list_length);
@@ skipping 65 matching lines @@
   /*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));
+  LoadScript(kScriptChars);
 
-  const Library& test_lib = Library::CheckedHandle(Api::UnwrapHandle(lib));
+  const Library& test_lib =
+      Library::CheckedHandle(Api::UnwrapHandle(script_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.
   for (int line = 8; line <= 9; line++) {
     func = test_lib.LookupFunctionInSource(script_url, line);
     EXPECT(!func.IsNull());
     EXPECT_STREQ("main", String::Handle(func.name()).ToCString());
   }
@@ skipping 39 matching lines @@
   EXPECT(Dart_IsString(source));
   char const* source_chars;
   Dart_StringToCString(source, &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