silence the error test to be a better citizen

tests/ErrorTest.cpp

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Test.h"
 #include "SkError.h"
 #include "SkPath.h"
 #include "SkRect.h"
 
+typedef struct {

[tfarina, 2013/09/11 19:39:25]

typedef should not be necessary here as we compile with C++ rather than C.

[tfarina, 2013/09/11 19:39:25]

I think this can be simply:

struct ErrorContext {
};

unless I'm missing something.

+    skiatest::Reporter *fReporter;
+    unsigned int *fIntPointer;
+} ErrorContext;

[tfarina, 2013/09/11 19:39:25]

this is creating a variable as far as I can see. Do you need this?

[mtklein, 2013/09/11 20:51:19]

Oh how I love C++ syntax!

typedef struct { ... } Foo;

makes a type Foo which is a struct, as if you'd written

struct Foo { ... };

on the other hand, visually similar

struct { ... } Foo;

makes a variable Foo whose type is an anonymous struct.

But, yeah, C++ generally would write

struct ErrorContext {
    skiatest::Reporter *fReporter;
    unsigned int *fIntPointer;
};

+
 #define CHECK(errcode)                                                        \
   REPORTER_ASSERT( reporter, (err = SkGetLastError()) == errcode);            \
   if (err != kNoError_SkError)                                                \
   {                                                                           \
-     SkDebugf("Last error string: %s\n", SkGetLastErrorString());             \
      SkClearLastError();                                                      \
   }
 
 static void cb(SkError err, void *context) {
-    int *context_ptr = static_cast<int *>(context);
-    SkDebugf("CB (0x%x): %s\n", *context_ptr, SkGetLastErrorString());
+    ErrorContext *context_ptr = static_cast<ErrorContext *>(context);
+    REPORTER_ASSERT( context_ptr->fReporter, (*(context_ptr->fIntPointer) == 0xdeadbeef) );
 }
 
 static void ErrorTest(skiatest::Reporter* reporter) {
     SkError err;
+    
+    unsigned int test_value = 0xdeadbeef;
+    ErrorContext context;
+    context.fReporter = reporter;
+    context.fIntPointer = &test_value;
+    
+    SkSetErrorCallback(cb, &context);
 
     CHECK(kNoError_SkError);
 
     SkRect r = SkRect::MakeWH(50, 100);
     CHECK(kNoError_SkError);
 
     SkPath path;
     path.addRect(r);
     CHECK(kNoError_SkError);
 
     path.addRoundRect(r, 10, 10);
     CHECK(kNoError_SkError);
 
     // should trigger the default error callback, which just prints to the screen.
     path.addRoundRect(r, -10, -10);
     CHECK(kInvalidArgument_SkError);
     CHECK(kNoError_SkError);
 
-    int test_value = 0xdeadbeef;
-    SkSetErrorCallback(cb, &test_value);
-
     // should trigger *our* callback.
     path.addRoundRect(r, -10, -10);
     CHECK(kInvalidArgument_SkError);
     CHECK(kNoError_SkError);
-
-    // Should trigger the default one again.
-    SkSetErrorCallback(NULL, NULL);
-    path.addRoundRect(r, -10, -10);
-    CHECK(kInvalidArgument_SkError);
-    CHECK(kNoError_SkError);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Error", ErrorTestClass, ErrorTest)