SkValue: SkXfermode

tests/ValueTest.cpp

Index: tests/ValueTest.cpp
diff --git a/tests/ValueTest.cpp b/tests/ValueTest.cpp
index 220ef2f9aeceb43d318a2c2f3c250a837c9c25d4..52a76a9ff0487412b712fb5b1bc35ce53bea3c3c 100644
--- a/tests/ValueTest.cpp
+++ b/tests/ValueTest.cpp
@@ -5,5 +5,111 @@
  * found in the LICENSE file.
  */
 
-#include "Test.h"
+#include "SkArithmeticMode.h"
+#include "SkLerpXfermode.h"
+#include "SkPixelXorXfermode.h"
+#include "SkStream.h"
 #include "SkValue.h"
+#include "SkXfermode.h"
+#include "Test.h"
+
+static void dump(const SkValue&, SkWStream*);
+
+template <class T>
+void test_value(skiatest::Reporter* r, T* object, SkValue::Type type) {
+    SkValue val = object->asValue();
+    object->unref();
+    REPORTER_ASSERT(r, type == val.type());
+    if (r->verbose()) {
+        SkDebugWStream debugWStream;
+        dump(val, &debugWStream);
+        SkDebugf("\n");
+    }
+}
+
+DEF_TEST(Value_Xfermode, r) {

[mtklein, 2016/01/15 00:25:22]

Let's test SkValue with new types scoped to this file.

As written, these tests are coupled to the implementation details of SkXfermode,
but have little to do with SkXfermodes themselves.  It's annoying to other
people working on SkXfermodes to have to update tests like this, particularly
when we can just make up our own types to test with (using the top half of
Test's range).

[hal.canary, 2016/01/15 13:38:56]

okay.

+    SkAutoTUnref<SkXfermode> xfermode(
+            SkXfermode::Create(SkXfermode::kDstOver_Mode));
+    SkValue val = xfermode->asValue();
+    REPORTER_ASSERT(r, SkValue::ProcCoeffXfermode == val.type());
+    SkValue valCopy = val;
+    REPORTER_ASSERT(r, SkValue::ProcCoeffXfermode == valCopy.type());
+
+    const SkValue* mode = val.get(0 /* ProcCoeffXfermode_Mode */);
+    REPORTER_ASSERT(r, mode);
+    if (mode) {
+        REPORTER_ASSERT(r, (uint32_t)SkXfermode::kDstOver_Mode == mode->u32());
+    }
+
+    test_value(r, xfermode.detach(), SkValue::ProcCoeffXfermode);
+    test_value(r, SkArithmeticMode::Create(0.125f, 0.25f, 0.375f, 0.5f, true),
+               SkValue::ArithmeticXfermode);
+    test_value(r, SkLerpXfermode::Create(1.0f/3.0f), SkValue::LerpXfermode);
+    test_value(r, SkPixelXorXfermode::Create(0xFF00FF00),
+               SkValue::PixelXorXfermode);
+}
+
+static bool skwstream_printf(SkWStream* wstream, const char format[], ...) {
+    char buffer[128];
+    va_list args;
+    va_start(args, format);
+    #ifdef SK_BUILD_FOR_WIN
+        int written =
+            _vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args);
+    #else
+        int written = vsnprintf(buffer, sizeof(buffer), format, args);
+    #endif
+    va_end(args);
+    if (written >= 0 && written < SkToInt(sizeof(buffer))) {
+        return wstream->write(buffer, SkToSizeT(written));
+    }
+    SkDEBUGFAIL("");
+    return false;
+}
+
+#include <inttypes.h>
+
+#ifndef PRId32
+#define PRId32 "d"

[mtklein, 2016/01/15 00:25:22]

Why are you making this complicated?  Just write %d and %u like normal.

[hal.canary, 2016/01/15 13:38:56]

that assumes that ints are 32 bits.

[mtklein, 2016/01/15 14:16:08]

ints are 32 bits.

+#define PRIu32 "u"
+#endif
+
+#define OBJECTS(M)                              \
+    M(ArithmeticXfermode)                       \
+    M(LerpXfermode)                             \
+    M(OverdrawXfermode)                         \
+    M(PixelXorXfermode)                         \
+    M(ProcCoeffXfermode)
+
+static void dump_object(const char* name, const SkValue& val, SkWStream* o) {
+    skwstream_printf(o, "[ \"%s\", {\n", name);
+    // todo: sort keys
+    val.foreach([=](SkValue::Key k, const SkValue& v){
+            skwstream_printf(o, "  \"key_%" PRIu32 "\" : ", k);
+            dump(v, o);
+            o->writeText(",\n");
+        });
+    o->writeText("} ]\n");
+}
+static void dump(const SkValue& val, SkWStream* o) {

[mtklein, 2016/01/15 00:25:22]

Just use SkDebugf?

[hal.canary, 2016/01/15 13:38:56]

Ease of reuse.  I may eventually reuse this code as a DM sink.

[mtklein, 2016/01/15 14:16:08]

I don't care unless you actually do it.  Don't write complicated code until it
needs to exist.

+    switch (val.type()) {
+        case SkValue::Null:
+            o->writeText("[ \"Null\", null ]");
+            return;
+        case SkValue::S32:
+            skwstream_printf(o, "[ \"S32\", %" PRId32 " ]", val.s32());
+            return;
+        case SkValue::U32:
+            skwstream_printf(o, "[ \"U32\", %" PRIu32 " ]", val.u32());
+            return;
+        case SkValue::F32:
+            skwstream_printf(o, "[ \"F32\", %.9g ]", val.f32());
+            return;
+        #define FN(OBJECT) \
+            case SkValue::OBJECT: dump_object(#OBJECT, val, o); return;
+        OBJECTS(FN)
+        #undef FN
+        default:
+            SkASSERT(false);
+    }
+}