Change EXPECT(!Dart_IsError(...)) to EXPECT_VALID(...) in VM tests.

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)                                              \

[Ivan Posva, 2012/08/03 18:59:47]

Please just remove the use of EXPECT_NOT_ERROR and replace it with EXPECT_VALID.

[Kevin Millikin (Google), 2012/08/06 07:49:47]

Done.

   if (Dart_IsError(handle)) {                                                 \
     OS::Print("Error: %s\n", Dart_GetError(handle));                          \
   }                                                                           \
-  EXPECT(!Dart_IsError(handle));
+  EXPECT_VALID(handle);
 
 
 static void LoadScript(const char* source) {
   script_lib = TestCase::LoadTestScript(source, NULL);
-  EXPECT(!Dart_IsError(script_lib));
+  EXPECT_VALID(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),
@@ skipping 236 matching lines @@
       "void main() {          \n"
       "  A.foo();             \n"
       "}                      \n";
 
   LoadScript(kScriptChars);
   Dart_SetBreakpointHandler(&TestBreakpointHandler);
   SetBreakpointAtEntry("A", "foo");
 
   breakpoint_hit = false;
   Dart_Handle retval = Invoke("main");
-  EXPECT(!Dart_IsError(retval));
+  EXPECT_VALID(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);
@@ skipping 37 matching lines @@
   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.
   SetBreakpointAtEntry("", "f1");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
-  EXPECT(!Dart_IsError(retval));
+  EXPECT_VALID(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[] = {
@@ skipping 60 matching lines @@
   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.
   SetBreakpointAtEntry("", "main");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
-  EXPECT(!Dart_IsError(retval));
+  EXPECT_VALID(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) {
   if (verbose) {
@@ skipping 22 matching lines @@
       "}                        \n";
 
   LoadScript(kScriptChars);
   Dart_SetBreakpointHandler(&StepIntoHandler);
 
   SetBreakpointAtEntry("", "main");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
-  EXPECT(!Dart_IsError(retval));
+  EXPECT_VALID(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 =
@@ skipping 17 matching lines @@
   Dart_Handle res = Invoke("warmup");
   EXPECT_NOT_ERROR(res);
 
   // Now set breakpoint in main and then step into optimized function foo.
   SetBreakpointAtEntry("", "main");
 
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
-  EXPECT(!Dart_IsError(retval));
+  EXPECT_VALID(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) {
   const char* expected_bpts[] = {
@@ skipping 208 matching lines @@
   EXPECT(Dart_IsInteger(res));
   int64_t bp_id = 0;
   Dart_IntegerToInt64(res, &bp_id);
 
   // 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.
   bp_id_to_be_deleted = bp_id;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
-  EXPECT(!Dart_IsError(retval));
+  EXPECT_VALID(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));
+  EXPECT_VALID(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.
@@ skipping 51 matching lines @@
     "   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));
+  EXPECT_VALID(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"
@@ skipping 212 matching lines @@
   list_as_string = Dart_ToString(lib_list);
   list_cstr = "";
   EXPECT_VALID(Dart_StringToCString(list_as_string, &list_cstr));
   EXPECT_SUBSTRING(TestCase::url(), list_cstr);
 }
 
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart