SkValue: SkXfermode

tests/ValueTest.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
+#include "SkArithmeticMode.h"
+#include "SkLerpXfermode.h"
+#include "SkPixelXorXfermode.h"
+#include "SkStream.h"
+#include "SkValue.h"
+#include "SkXfermode.h"
 #include "Test.h"
-#include "SkValue.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);
+    }
+}