Improve failure logging for NPN_ConvertPoint test

webkit/glue/plugins/test/plugin_windowless_test.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #define STRSAFE_NO_DEPRECATE
+#include "base/string_util.h"
 #include "webkit/glue/plugins/test/plugin_windowless_test.h"
 #include "webkit/glue/plugins/test/plugin_client.h"
 
 #if defined(OS_MACOSX)
 #include <ApplicationServices/ApplicationServices.h>
 #include <Carbon/Carbon.h>
 #endif
 
 namespace NPAPIClient {
 
@@ skipping 124 matching lines @@
 
 void WindowlessPluginTest::MultipleInstanceSyncCalls(NPNetscapeFuncs* browser) {
   if (this == g_other_instance)
     return;
 
   DCHECK(g_other_instance);
   ExecuteScript(browser, g_other_instance->id(), "TestCallback();", NULL);
   SignalTestCompleted();
 }
 
+#if defined(OS_MACOSX)
+std::string StringForPoint(int x, int y) {
+  std::string point_string("(");
+  point_string.append(IntToString(x));
+  point_string.append(", ");
+  point_string.append(IntToString(y));
+  point_string.append(")");
+  return point_string;
+}
+#endif
+
 void WindowlessPluginTest::ConvertPoint(NPNetscapeFuncs* browser) {
 #if defined(OS_MACOSX)
   // First, just sanity-test that round trips work.
   NPCoordinateSpace spaces[] = { NPCoordinateSpacePlugin,
                                  NPCoordinateSpaceWindow,
                                  NPCoordinateSpaceFlippedWindow,
                                  NPCoordinateSpaceScreen,
                                  NPCoordinateSpaceFlippedScreen };
   for (unsigned int i = 0; i < arraysize(spaces); ++i) {
     for (unsigned int j = 0; j < arraysize(spaces); ++j) {
       double x, y, round_trip_x, round_trip_y;
       if (!(browser->convertpoint(id(), 0, 0, spaces[i], &x, &y, spaces[j])) ||
           !(browser->convertpoint(id(), x, y, spaces[j], &round_trip_x,
                                   &round_trip_y, spaces[i]))) {
         SetError("Conversion failed");
         SignalTestCompleted();
         return;
       }
       if (i != j && x == 0 && y == 0) {
         SetError("Converting a coordinate should change it");
         SignalTestCompleted();
         return;
       }
       if (round_trip_x != 0 || round_trip_y != 0) {
-        SetError("Round-trip conversion should give return the original point");
+        SetError("Round-trip conversion should return the original point");
         SignalTestCompleted();
         return;
       }
     }
   }
 
   // Now, more extensive testing on a single point.
   double screen_x, screen_y;
   browser->convertpoint(id(), 0, 0, NPCoordinateSpacePlugin,
                         &screen_x, &screen_y, NPCoordinateSpaceScreen);
   double flipped_screen_x, flipped_screen_y;
   browser->convertpoint(id(), 0, 0, NPCoordinateSpacePlugin,
                         &flipped_screen_x, &flipped_screen_y,
                         NPCoordinateSpaceFlippedScreen);
   double window_x, window_y;
   browser->convertpoint(id(), 0, 0, NPCoordinateSpacePlugin,
                         &window_x, &window_y, NPCoordinateSpaceWindow);
   double flipped_window_x, flipped_window_y;
   browser->convertpoint(id(), 0, 0, NPCoordinateSpacePlugin,
                         &flipped_window_x, &flipped_window_y,
                         NPCoordinateSpaceFlippedWindow);
 
   CGRect main_display_bounds = CGDisplayBounds(CGMainDisplayID());
 
   // Check that all the coordinates are right. The plugin is in a 600x600 window
   // at (100, 100), with a content area origin of (100, 100).
   // Y-coordinates are not checked exactly so that the test is robust against
   // toolbar changes, info bar visibility, etc.
+  std::string error_string;
   if (screen_x != flipped_screen_x)
-    SetError("Flipping screen coordinates shouldn't change x");
+    error_string = "Flipping screen coordinates shouldn't change x";
   else if (flipped_screen_y != main_display_bounds.size.height - screen_y)
-    SetError("Flipped screen coordinates should be flipped vertically!");
+    error_string = "Flipped screen coordinates should be flipped vertically";
   else if (screen_x != 200)
-    SetError("Screen x location is wrong");
+    error_string = "Screen x location is wrong";
   else if (flipped_screen_y < 200 || flipped_screen_y > 400)
-    SetError("Screen y location is wrong");
-  if (window_x != flipped_window_x)
-    SetError("Flipping window coordinates shouldn't change x");
+    error_string = "Screen y location is wrong";
+  else if (window_x != flipped_window_x)
+    error_string = "Flipping window coordinates shouldn't change x";
   else if (flipped_window_y != 600 - window_y)
-    SetError("Flipped window coordinates should be flipped vertically!");
+    error_string = "Flipped window coordinates should be flipped vertically";
   else if (window_x != 100)
-    SetError("Window x location is wrong");
+    error_string = "Window x location is wrong";
   else if (flipped_screen_y < 100 || flipped_screen_y > 300)
-    SetError("Window y location is wrong");
+    error_string = "Window y location is wrong";
+
+  if (!error_string.empty()) {
+    error_string.append(" - ");
+    error_string.append(StringForPoint(screen_x, screen_y));
+    error_string.append(" - ");
+    error_string.append(StringForPoint(flipped_screen_x, flipped_screen_y));
+    error_string.append(" - ");
+    error_string.append(StringForPoint(window_x, window_y));
+    error_string.append(" - ");
+    error_string.append(StringForPoint(flipped_window_x, flipped_window_y));
+    SetError(error_string);
+  }
 #else
   SetError("Unimplemented");
 #endif
   SignalTestCompleted();
 }
 
 } // namespace NPAPIClient