1/*
2 * Copyright 2014 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 "SkPaint.h"
9#include "SkPoint.h"
10#include "SkTextBlob.h"
11
12#include "Test.h"
13
14
15class TextBlobTester {
16public:
17    // This unit test feeds an SkTextBlobBuilder various runs then checks to see if
18    // the result contains the provided data and merges runs when appropriate.
19    static void TestBuilder(skiatest::Reporter* reporter) {
20        SkTextBlobBuilder builder;
21
22        // empty run set
23        RunBuilderTest(reporter, builder, NULL, 0, NULL, 0);
24
25        RunDef set1[] = {
26            { 128, SkTextBlob::kDefault_Positioning, 100, 100 },
27        };
28        RunBuilderTest(reporter, builder, set1, SK_ARRAY_COUNT(set1), set1, SK_ARRAY_COUNT(set1));
29
30        RunDef set2[] = {
31            { 128, SkTextBlob::kHorizontal_Positioning, 100, 100 },
32        };
33        RunBuilderTest(reporter, builder, set2, SK_ARRAY_COUNT(set2), set2, SK_ARRAY_COUNT(set2));
34
35        RunDef set3[] = {
36            { 128, SkTextBlob::kFull_Positioning, 100, 100 },
37        };
38        RunBuilderTest(reporter, builder, set3, SK_ARRAY_COUNT(set3), set3, SK_ARRAY_COUNT(set3));
39
40        RunDef set4[] = {
41            { 128, SkTextBlob::kDefault_Positioning, 100, 150 },
42            { 128, SkTextBlob::kDefault_Positioning, 100, 150 },
43            { 128, SkTextBlob::kDefault_Positioning, 100, 150 },
44        };
45        RunBuilderTest(reporter, builder, set4, SK_ARRAY_COUNT(set4), set4, SK_ARRAY_COUNT(set4));
46
47        RunDef set5[] = {
48            { 128, SkTextBlob::kHorizontal_Positioning, 100, 150 },
49            { 128, SkTextBlob::kHorizontal_Positioning, 200, 150 },
50            { 128, SkTextBlob::kHorizontal_Positioning, 300, 250 },
51        };
52        RunDef mergedSet5[] = {
53            { 256, SkTextBlob::kHorizontal_Positioning, 0, 150 },
54            { 128, SkTextBlob::kHorizontal_Positioning, 0, 250 },
55        };
56        RunBuilderTest(reporter, builder, set5, SK_ARRAY_COUNT(set5), mergedSet5,
57                       SK_ARRAY_COUNT(mergedSet5));
58
59        RunDef set6[] = {
60            { 128, SkTextBlob::kFull_Positioning, 100, 100 },
61            { 128, SkTextBlob::kFull_Positioning, 200, 200 },
62            { 128, SkTextBlob::kFull_Positioning, 300, 300 },
63        };
64        RunDef mergedSet6[] = {
65            { 384, SkTextBlob::kFull_Positioning, 0, 0 },
66        };
67        RunBuilderTest(reporter, builder, set6, SK_ARRAY_COUNT(set6), mergedSet6,
68                       SK_ARRAY_COUNT(mergedSet6));
69
70        RunDef set7[] = {
71            { 128, SkTextBlob::kDefault_Positioning, 100, 150 },
72            { 128, SkTextBlob::kDefault_Positioning, 100, 150 },
73            { 128, SkTextBlob::kHorizontal_Positioning, 100, 150 },
74            { 128, SkTextBlob::kHorizontal_Positioning, 200, 150 },
75            { 128, SkTextBlob::kFull_Positioning, 400, 350 },
76            { 128, SkTextBlob::kFull_Positioning, 400, 350 },
77            { 128, SkTextBlob::kDefault_Positioning, 100, 450 },
78            { 128, SkTextBlob::kDefault_Positioning, 100, 450 },
79            { 128, SkTextBlob::kHorizontal_Positioning, 100, 550 },
80            { 128, SkTextBlob::kHorizontal_Positioning, 200, 650 },
81            { 128, SkTextBlob::kFull_Positioning, 400, 750 },
82            { 128, SkTextBlob::kFull_Positioning, 400, 850 },
83        };
84        RunDef mergedSet7[] = {
85            { 128, SkTextBlob::kDefault_Positioning, 100, 150 },
86            { 128, SkTextBlob::kDefault_Positioning, 100, 150 },
87            { 256, SkTextBlob::kHorizontal_Positioning, 0, 150 },
88            { 256, SkTextBlob::kFull_Positioning, 0, 0 },
89            { 128, SkTextBlob::kDefault_Positioning, 100, 450 },
90            { 128, SkTextBlob::kDefault_Positioning, 100, 450 },
91            { 128, SkTextBlob::kHorizontal_Positioning, 0, 550 },
92            { 128, SkTextBlob::kHorizontal_Positioning, 0, 650 },
93            { 256, SkTextBlob::kFull_Positioning, 0, 0 },
94        };
95        RunBuilderTest(reporter, builder, set7, SK_ARRAY_COUNT(set7), mergedSet7,
96                       SK_ARRAY_COUNT(mergedSet7));
97    }
98
99    // This unit test verifies blob bounds computation.
100    static void TestBounds(skiatest::Reporter* reporter) {
101        SkTextBlobBuilder builder;
102        SkPaint font;
103        font.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
104
105        // Explicit bounds.
106        {
107            SkAutoTUnref<const SkTextBlob> blob(builder.build());
108            REPORTER_ASSERT(reporter, blob->bounds().isEmpty());
109        }
110
111        {
112            SkRect r1 = SkRect::MakeXYWH(10, 10, 20, 20);
113            builder.allocRun(font, 16, 0, 0, &r1);
114            SkAutoTUnref<const SkTextBlob> blob(builder.build());
115            REPORTER_ASSERT(reporter, blob->bounds() == r1);
116        }
117
118        {
119            SkRect r1 = SkRect::MakeXYWH(10, 10, 20, 20);
120            builder.allocRunPosH(font, 16, 0, &r1);
121            SkAutoTUnref<const SkTextBlob> blob(builder.build());
122            REPORTER_ASSERT(reporter, blob->bounds() == r1);
123        }
124
125        {
126            SkRect r1 = SkRect::MakeXYWH(10, 10, 20, 20);
127            builder.allocRunPos(font, 16, &r1);
128            SkAutoTUnref<const SkTextBlob> blob(builder.build());
129            REPORTER_ASSERT(reporter, blob->bounds() == r1);
130        }
131
132        {
133            SkRect r1 = SkRect::MakeXYWH(10, 10, 20, 20);
134            SkRect r2 = SkRect::MakeXYWH(15, 20, 50, 50);
135            SkRect r3 = SkRect::MakeXYWH(0, 5, 10, 5);
136
137            builder.allocRun(font, 16, 0, 0, &r1);
138            builder.allocRunPosH(font, 16, 0, &r2);
139            builder.allocRunPos(font, 16, &r3);
140
141            SkAutoTUnref<const SkTextBlob> blob(builder.build());
142            REPORTER_ASSERT(reporter, blob->bounds() == SkRect::MakeXYWH(0, 5, 65, 65));
143        }
144
145        {
146            // Verify empty blob bounds after building some non-empty blobs.
147            SkAutoTUnref<const SkTextBlob> blob(builder.build());
148            REPORTER_ASSERT(reporter, blob->bounds().isEmpty());
149        }
150
151        // Implicit bounds
152        // FIXME: not supported yet.
153    }
154
155private:
156    struct RunDef {
157        unsigned                     count;
158        SkTextBlob::GlyphPositioning pos;
159        SkScalar                     x, y;
160    };
161
162    static void RunBuilderTest(skiatest::Reporter* reporter, SkTextBlobBuilder& builder,
163                               const RunDef in[], unsigned inCount,
164                               const RunDef out[], unsigned outCount) {
165        SkPaint font;
166        font.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
167
168        unsigned glyphCount = 0;
169        unsigned posCount = 0;
170
171        for (unsigned i = 0; i < inCount; ++i) {
172            AddRun(font, in[i].count, in[i].pos, SkPoint::Make(in[i].x, in[i].y), builder);
173            glyphCount += in[i].count;
174            posCount += in[i].count * in[i].pos;
175        }
176
177        SkAutoTUnref<const SkTextBlob> blob(builder.build());
178
179        SkTextBlob::RunIterator it(blob);
180        for (unsigned i = 0; i < outCount; ++i) {
181            REPORTER_ASSERT(reporter, !it.done());
182            REPORTER_ASSERT(reporter, out[i].pos == it.positioning());
183            REPORTER_ASSERT(reporter, out[i].count == it.glyphCount());
184            if (SkTextBlob::kDefault_Positioning == out[i].pos) {
185                REPORTER_ASSERT(reporter, out[i].x == it.offset().x());
186                REPORTER_ASSERT(reporter, out[i].y == it.offset().y());
187            } else if (SkTextBlob::kHorizontal_Positioning == out[i].pos) {
188                REPORTER_ASSERT(reporter, out[i].y == it.offset().y());
189            }
190
191            for (unsigned k = 0; k < it.glyphCount(); ++k) {
192                REPORTER_ASSERT(reporter, k % 128 == it.glyphs()[k]);
193                if (SkTextBlob::kHorizontal_Positioning == it.positioning()) {
194                    REPORTER_ASSERT(reporter, SkIntToScalar(k % 128) == it.pos()[k]);
195                } else if (SkTextBlob::kFull_Positioning == it.positioning()) {
196                    REPORTER_ASSERT(reporter, SkIntToScalar(k % 128) == it.pos()[k * 2]);
197                    REPORTER_ASSERT(reporter, -SkIntToScalar(k % 128) == it.pos()[k * 2 + 1]);
198                }
199            }
200
201            it.next();
202        }
203
204        REPORTER_ASSERT(reporter, it.done());
205    }
206
207    static void AddRun(const SkPaint& font, int count, SkTextBlob::GlyphPositioning pos,
208                       const SkPoint& offset, SkTextBlobBuilder& builder,
209                       const SkRect* bounds = NULL) {
210        switch (pos) {
211        case SkTextBlob::kDefault_Positioning: {
212            const SkTextBlobBuilder::RunBuffer& rb = builder.allocRun(font, count, offset.x(),
213                                                                      offset.y(), bounds);
214            for (int i = 0; i < count; ++i) {
215                rb.glyphs[i] = i;
216            }
217        } break;
218        case SkTextBlob::kHorizontal_Positioning: {
219            const SkTextBlobBuilder::RunBuffer& rb = builder.allocRunPosH(font, count, offset.y(),
220                                                                          bounds);
221            for (int i = 0; i < count; ++i) {
222                rb.glyphs[i] = i;
223                rb.pos[i] = SkIntToScalar(i);
224            }
225        } break;
226        case SkTextBlob::kFull_Positioning: {
227            const SkTextBlobBuilder::RunBuffer& rb = builder.allocRunPos(font, count, bounds);
228            for (int i = 0; i < count; ++i) {
229                rb.glyphs[i] = i;
230                rb.pos[i * 2] = SkIntToScalar(i);
231                rb.pos[i * 2 + 1] = -SkIntToScalar(i);
232            }
233        } break;
234        default:
235            SkFAIL("unhandled positioning value");
236        }
237    }
238};
239
240DEF_TEST(TextBlob_builder, reporter) {
241    TextBlobTester::TestBuilder(reporter);
242    TextBlobTester::TestBounds(reporter);
243}
244