Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright 2015 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 "SkTypes.h"
      9 
     10 #ifdef SK_XML
     11 
     12 #include "SkCanvas.h"
     13 #include "SkData.h"
     14 #include "SkDOM.h"
     15 #include "SkParse.h"
     16 #include "SkStream.h"
     17 #include "SkSVGCanvas.h"
     18 #include "SkXMLWriter.h"
     19 #include "Test.h"
     20 
     21 #include <string.h>
     22 
     23 namespace {
     24 
     25 void check_text_node(skiatest::Reporter* reporter,
     26                      const SkDOM& dom,
     27                      const SkDOM::Node* root,
     28                      const SkPoint& offset,
     29                      unsigned scalarsPerPos,
     30                      const char* expected) {
     31     if (root == nullptr) {
     32         ERRORF(reporter, "root element not found.");
     33         return;
     34     }
     35 
     36     const SkDOM::Node* textElem = dom.getFirstChild(root, "text");
     37     if (textElem == nullptr) {
     38         ERRORF(reporter, "<text> element not found.");
     39         return;
     40     }
     41     REPORTER_ASSERT(reporter, dom.getType(textElem) == SkDOM::kElement_Type);
     42 
     43     const SkDOM::Node* textNode= dom.getFirstChild(textElem);
     44     REPORTER_ASSERT(reporter, textNode != nullptr);
     45     if (textNode != nullptr) {
     46         REPORTER_ASSERT(reporter, dom.getType(textNode) == SkDOM::kText_Type);
     47         REPORTER_ASSERT(reporter, strcmp(expected, dom.getName(textNode)) == 0);
     48     }
     49 
     50     int textLen = SkToInt(strlen(expected));
     51 
     52     const char* x = dom.findAttr(textElem, "x");
     53     REPORTER_ASSERT(reporter, x != nullptr);
     54     if (x != nullptr) {
     55         int xposCount = (scalarsPerPos < 1) ? 1 : textLen;
     56         REPORTER_ASSERT(reporter, SkParse::Count(x) == xposCount);
     57 
     58         SkAutoTMalloc<SkScalar> xpos(xposCount);
     59         SkParse::FindScalars(x, xpos.get(), xposCount);
     60         if (scalarsPerPos < 1) {
     61             REPORTER_ASSERT(reporter, xpos[0] == offset.x());
     62         } else {
     63             for (int i = 0; i < xposCount; ++i) {
     64                 REPORTER_ASSERT(reporter, xpos[i] == SkIntToScalar(expected[i]));
     65             }
     66         }
     67     }
     68 
     69     const char* y = dom.findAttr(textElem, "y");
     70     REPORTER_ASSERT(reporter, y != nullptr);
     71     if (y != nullptr) {
     72         int yposCount = (scalarsPerPos < 2) ? 1 : textLen;
     73         REPORTER_ASSERT(reporter, SkParse::Count(y) == yposCount);
     74 
     75         SkAutoTMalloc<SkScalar> ypos(yposCount);
     76         SkParse::FindScalars(y, ypos.get(), yposCount);
     77         if (scalarsPerPos < 2) {
     78             REPORTER_ASSERT(reporter, ypos[0] == offset.y());
     79         } else {
     80             for (int i = 0; i < yposCount; ++i) {
     81                 REPORTER_ASSERT(reporter, ypos[i] == -SkIntToScalar(expected[i]));
     82             }
     83         }
     84     }
     85 }
     86 
     87 void test_whitespace_pos(skiatest::Reporter* reporter,
     88                          const char* txt,
     89                          const char* expected) {
     90     size_t len = strlen(txt);
     91 
     92     SkDOM dom;
     93     SkPaint paint;
     94     SkPoint offset = SkPoint::Make(10, 20);
     95 
     96     {
     97         SkXMLParserWriter writer(dom.beginParsing());
     98         std::unique_ptr<SkCanvas> svgCanvas = SkSVGCanvas::Make(SkRect::MakeWH(100, 100), &writer);
     99         svgCanvas->drawText(txt, len, offset.x(), offset.y(), paint);
    100     }
    101     check_text_node(reporter, dom, dom.finishParsing(), offset, 0, expected);
    102 
    103     {
    104         SkAutoTMalloc<SkScalar> xpos(len);
    105         for (int i = 0; i < SkToInt(len); ++i) {
    106             xpos[i] = SkIntToScalar(txt[i]);
    107         }
    108 
    109         SkXMLParserWriter writer(dom.beginParsing());
    110         std::unique_ptr<SkCanvas> svgCanvas = SkSVGCanvas::Make(SkRect::MakeWH(100, 100), &writer);
    111         svgCanvas->drawPosTextH(txt, len, xpos, offset.y(), paint);
    112     }
    113     check_text_node(reporter, dom, dom.finishParsing(), offset, 1, expected);
    114 
    115     {
    116         SkAutoTMalloc<SkPoint> pos(len);
    117         for (int i = 0; i < SkToInt(len); ++i) {
    118             pos[i] = SkPoint::Make(SkIntToScalar(txt[i]), -SkIntToScalar(txt[i]));
    119         }
    120 
    121         SkXMLParserWriter writer(dom.beginParsing());
    122         std::unique_ptr<SkCanvas> svgCanvas = SkSVGCanvas::Make(SkRect::MakeWH(100, 100), &writer);
    123         svgCanvas->drawPosText(txt, len, pos, paint);
    124     }
    125     check_text_node(reporter, dom, dom.finishParsing(), offset, 2, expected);
    126 }
    127 
    128 }
    129 
    130 DEF_TEST(SVGDevice_whitespace_pos, reporter) {
    131     static const struct {
    132         const char* tst_in;
    133         const char* tst_out;
    134     } tests[] = {
    135         { "abcd"      , "abcd" },
    136         { "ab cd"     , "ab cd" },
    137         { "ab \t\t cd", "ab cd" },
    138         { " abcd"     , "abcd" },
    139         { "  abcd"    , "abcd" },
    140         { " \t\t abcd", "abcd" },
    141         { "abcd "     , "abcd " }, // we allow one trailing whitespace char
    142         { "abcd  "    , "abcd " }, // because it makes no difference and
    143         { "abcd\t  "  , "abcd\t" }, // simplifies the implementation
    144         { "\t\t  \t ab \t\t  \t cd \t\t   \t  ", "ab cd " },
    145     };
    146 
    147     for (unsigned i = 0; i < SK_ARRAY_COUNT(tests); ++i) {
    148         test_whitespace_pos(reporter, tests[i].tst_in, tests[i].tst_out);
    149     }
    150 }
    151 
    152 #endif
    153