Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright 2016 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include "SkFlattenable.h"
      9 #include "SkReadBuffer.h"
     10 #include "SkWriteBuffer.h"
     11 #include "Test.h"
     12 
     13 class IntFlattenable : public SkFlattenable {
     14 public:
     15     IntFlattenable(uint32_t a, uint32_t b, uint32_t c, uint32_t d)
     16         : fA(a)
     17         , fB(b)
     18         , fC(c)
     19         , fD(d)
     20     {}
     21 
     22     void flatten(SkWriteBuffer& buffer) const override {
     23         buffer.writeUInt(fA);
     24         buffer.writeUInt(fB);
     25         buffer.writeUInt(fC);
     26         buffer.writeUInt(fD);
     27     }
     28 
     29     Factory getFactory() const override { return nullptr; }
     30 
     31     uint32_t a() const { return fA; }
     32     uint32_t b() const { return fB; }
     33     uint32_t c() const { return fC; }
     34     uint32_t d() const { return fD; }
     35 
     36     const char* getTypeName() const override { return "IntFlattenable"; }
     37 
     38 private:
     39     uint32_t fA;
     40     uint32_t fB;
     41     uint32_t fC;
     42     uint32_t fD;
     43 };
     44 
     45 static sk_sp<SkFlattenable> custom_create_proc(SkReadBuffer& buffer) {
     46     uint32_t a = buffer.readUInt();
     47     uint32_t b = buffer.readUInt();
     48     uint32_t c = buffer.readUInt();
     49     uint32_t d = buffer.readUInt();
     50     return sk_sp<SkFlattenable>(new IntFlattenable(a + 1, b + 1, c + 1, d + 1));
     51 }
     52 
     53 DEF_TEST(UnflattenWithCustomFactory, r) {
     54     // Create and flatten the test flattenable
     55     SkBinaryWriteBuffer writeBuffer;
     56     sk_sp<SkFlattenable> flattenable1(new IntFlattenable(1, 2, 3, 4));
     57     writeBuffer.writeFlattenable(flattenable1.get());
     58     sk_sp<SkFlattenable> flattenable2(new IntFlattenable(2, 3, 4, 5));
     59     writeBuffer.writeFlattenable(flattenable2.get());
     60     sk_sp<SkFlattenable> flattenable3(new IntFlattenable(3, 4, 5, 6));
     61     writeBuffer.writeFlattenable(flattenable3.get());
     62 
     63     // Copy the contents of the write buffer into a read buffer
     64     sk_sp<SkData> data = SkData::MakeUninitialized(writeBuffer.bytesWritten());
     65     writeBuffer.writeToMemory(data->writable_data());
     66     SkReadBuffer readBuffer(data->data(), data->size());
     67 
     68     // Register a custom factory with the read buffer
     69     readBuffer.setCustomFactory(SkString("IntFlattenable"), &custom_create_proc);
     70 
     71     // Unflatten and verify the flattenables
     72     sk_sp<IntFlattenable> out1((IntFlattenable*) readBuffer.readFlattenable(
     73             SkFlattenable::kSkUnused_Type));
     74     REPORTER_ASSERT(r, out1);
     75     REPORTER_ASSERT(r, 2 == out1->a());
     76     REPORTER_ASSERT(r, 3 == out1->b());
     77     REPORTER_ASSERT(r, 4 == out1->c());
     78     REPORTER_ASSERT(r, 5 == out1->d());
     79 
     80     sk_sp<IntFlattenable> out2((IntFlattenable*) readBuffer.readFlattenable(
     81             SkFlattenable::kSkUnused_Type));
     82     REPORTER_ASSERT(r, out2);
     83     REPORTER_ASSERT(r, 3 == out2->a());
     84     REPORTER_ASSERT(r, 4 == out2->b());
     85     REPORTER_ASSERT(r, 5 == out2->c());
     86     REPORTER_ASSERT(r, 6 == out2->d());
     87 
     88     sk_sp<IntFlattenable> out3((IntFlattenable*) readBuffer.readFlattenable(
     89             SkFlattenable::kSkUnused_Type));
     90     REPORTER_ASSERT(r, out3);
     91     REPORTER_ASSERT(r, 4 == out3->a());
     92     REPORTER_ASSERT(r, 5 == out3->b());
     93     REPORTER_ASSERT(r, 6 == out3->c());
     94     REPORTER_ASSERT(r, 7 == out3->d());
     95 }
     96