SkUnicodeTest.cpp File Reference

#include "include/core/SkSpan.h"
#include "include/core/SkStream.h"
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
#include "src/base/SkBitmaskEnum.h"
#include "tests/Test.h"
#include "modules/skunicode/include/SkUnicode.h"
#include <vector>

Go to the source code of this file.

Macros
#define	DEF_TEST_ICU(name, reporter)
#define	DEF_TEST_ICU4X(name, reporter)
#define	DEF_TEST_LIBGRAPHEME(name, reporter)
#define	DEF_TEST_NOIMPL(name, reporter)
#define	DEF_TEST_UNICODES(name, reporter)
#define	DEF_TEST_ICU_UNICODES(name, reporter)

Functions
bool	hasWordFlag (SkUnicode::CodeUnitFlags flags)
	DEF_TEST_ICU_UNICODES (SkUnicode_GetBidiRegionsLTR, reporter)
	DEF_TEST_ICU_UNICODES (SkUnicode_GetBidiRegionsRTL, reporter)
	DEF_TEST_ICU_UNICODES (SkUnicode_GetBidiRegionsMix1, reporter)
	DEF_TEST_ICU_UNICODES (SkUnicode_GetBidiRegionsMix2, reporter)
	DEF_TEST_ICU_UNICODES (SkUnicode_ToUpper, reporter)
	DEF_TEST_ICU_UNICODES (SkUnicode_ComputeCodeUnitFlags, reporter)
	DEF_TEST_UNICODES (SkUnicode_ReorderVisual, reporter)
static void	SkUnicode_Emoji (SkUnicode *icu, skiatest::Reporter *reporter)
static void	SkUnicode_Ideographic (SkUnicode *icu, skiatest::Reporter *reporter)

Macro Definition Documentation

DEF_TEST_ICU

#define DEF_TEST_ICU	(		name,
			reporter
	)

Definition at line 36 of file SkUnicodeTest.cpp.

DEF_TEST_ICU4X

#define DEF_TEST_ICU4X	(		name,
			reporter
	)

Definition at line 43 of file SkUnicodeTest.cpp.

DEF_TEST_ICU_UNICODES

#define DEF_TEST_ICU_UNICODES	(		name,
			reporter
	)

Value:

    static void name(skiatest::Reporter* reporter, sk_sp<SkUnicode> unicode); \
    DEF_TEST_ICU(name, reporter) \
    DEF_TEST_ICU4X(name, reporter) \
    DEF_TEST_NOIMPL(name, reporter) \
    void name(skiatest::Reporter* reporter, sk_sp<SkUnicode> unicode)

Definition at line 63 of file SkUnicodeTest.cpp.

DEF_TEST_LIBGRAPHEME

#define DEF_TEST_LIBGRAPHEME	(		name,
			reporter
	)

Definition at line 50 of file SkUnicodeTest.cpp.

DEF_TEST_NOIMPL

#define DEF_TEST_NOIMPL	(		name,
			reporter
	)

Definition at line 53 of file SkUnicodeTest.cpp.

DEF_TEST_UNICODES

#define DEF_TEST_UNICODES	(		name,
			reporter
	)

Value:

    static void name(skiatest::Reporter* reporter, sk_sp<SkUnicode> unicode); \
    DEF_TEST_ICU(name, reporter) \
    DEF_TEST_ICU4X(name, reporter) \
    DEF_TEST_LIBGRAPHEME(name, reporter) \
    DEF_TEST_NOIMPL(name, reporter) \
    void name(skiatest::Reporter* reporter, sk_sp<SkUnicode> unicode)

Definition at line 55 of file SkUnicodeTest.cpp.

Function Documentation

DEF_TEST_ICU_UNICODES() [1/6]

DEF_TEST_ICU_UNICODES	(	SkUnicode_ComputeCodeUnitFlags	,
		reporter
	)

Definition at line 251 of file SkUnicodeTest.cpp.

                                                                {
    if (!unicode) {
        return;
    }
    //SkString text("World domination is such an ugly phrase - I prefer to call it world optimisation");
    SkString text("1\n22 333 4444 55555 666666 7777777");
    // 4 8 13 19 24
    TArray<SkUnicode::CodeUnitFlags> results;
    auto result = unicode->computeCodeUnitFlags(text.data(),
                                                text.size(),
                                                /*replaceTabs=*/true,
                                                &results);
    REPORTER_ASSERT(reporter, result);
    REPORTER_ASSERT(reporter, results.size() == SkToS16(text.size() + 1));
    for (auto i = 0; i < results.size(); ++i) {
        auto flags = results[i];
        auto expected = SkUnicode::CodeUnitFlags::kGraphemeStart;
        if (i == 1) {
            expected |= SkUnicode::CodeUnitFlags::kControl;
        }
        if (i == 2) {
            expected |= SkUnicode::CodeUnitFlags::kHardLineBreakBefore;
        }
        if (i == 1 || i == 4 || i == 8 || i == 13 || i == 19 || i == 26) {
            expected |= SkUnicode::CodeUnitFlags::kPartOfWhiteSpaceBreak;
            expected |= SkUnicode::CodeUnitFlags::kPartOfIntraWordBreak;
        }
        if (i == 0 || i == 2 || i == 5 || i == 9 || i == 14 || i == 20
                                                 || i == 27 || i == 34) {
            expected |= SkUnicode::CodeUnitFlags::kSoftLineBreakBefore;
        }
        REPORTER_ASSERT(reporter, flags == expected);
    }
}

DEF_TEST_ICU_UNICODES() [2/6]

DEF_TEST_ICU_UNICODES	(	SkUnicode_GetBidiRegionsLTR	,
		reporter
	)

Definition at line 143 of file SkUnicodeTest.cpp.

                                                             {
    if (!unicode) {
        return;
    }
    SkString text("1 22 333 4444 55555 666666 7777777");
    std::vector<SkUnicode::BidiRegion> results;
    auto result = unicode->getBidiRegions(text.data(),
                                          text.size(),
                                          SkUnicode::TextDirection::kLTR,
                                          &results);
    REPORTER_ASSERT(reporter, result);
    REPORTER_ASSERT(reporter, results.size() == 1);
    REPORTER_ASSERT(reporter, results[0].start == 0 &&
                              results[0].end == text.size() &&
                              results[0].level == 0);
}

DEF_TEST_ICU_UNICODES() [3/6]

DEF_TEST_ICU_UNICODES	(	SkUnicode_GetBidiRegionsMix1	,
		reporter
	)

Definition at line 177 of file SkUnicodeTest.cpp.

                                                              {
    if (!unicode) {
        return;
    }
    // Spaces become Arabic (RTL) but numbers remain English (LTR)
    SkString text("1 22 333 4444 55555 666666 7777777");
    std::vector<SkUnicode::BidiRegion> expected = {
        {0, 1, 2},
        {1, 2, 1},
        {2, 4, 2},
        {4, 5, 1},
        {5, 8, 2},
        {8, 9, 1},
        {9, 13, 2},
        {13, 14, 1},
        {14, 19, 2},
        {19, 20, 1},
        {20, 26, 2},
        {26, 27, 1},
        {27, 34, 2},
    };
    std::vector<SkUnicode::BidiRegion> results;
    auto result = unicode->getBidiRegions(text.data(),
                                          text.size(),
                                          SkUnicode::TextDirection::kRTL,
                                          &results);
    REPORTER_ASSERT(reporter, result);
    REPORTER_ASSERT(reporter, results.size() == expected.size());
    for (auto i = 0ul; i < results.size(); ++i) {
      REPORTER_ASSERT(reporter, results[i].start == expected[i].start &&
                                results[i].end == expected[i].end &&
                                results[i].level == expected[i].level);
    }
}

DEF_TEST_ICU_UNICODES() [4/6]

DEF_TEST_ICU_UNICODES	(	SkUnicode_GetBidiRegionsMix2	,
		reporter
	)

Definition at line 212 of file SkUnicodeTest.cpp.

                                                              {
    if (!unicode) {
      return;
    }
    // Few Russian/English words (ЛТР) in the mix
    SkString text("World ЛТР Domination هي عبارة قبيحة ، أفضل أن أسميها World ЛТР Optimization.");
    std::vector<SkUnicode::BidiRegion> expected = {
        { 0, 24, 0},
        { 24, 80, 1},
        { 80, 107, 0},
    };
    std::vector<SkUnicode::BidiRegion> results;
    auto result = unicode->getBidiRegions(text.data(),
                                          text.size(),
                                          SkUnicode::TextDirection::kLTR,
                                          &results);
    REPORTER_ASSERT(reporter, result);
    REPORTER_ASSERT(reporter, results.size() == expected.size());
    for (auto i = 0ul; i < results.size(); ++i) {
        REPORTER_ASSERT(reporter, results[i].start == expected[i].start &&
                                  results[i].end == expected[i].end &&
                                  results[i].level == expected[i].level);
    }
}

DEF_TEST_ICU_UNICODES() [5/6]

DEF_TEST_ICU_UNICODES	(	SkUnicode_GetBidiRegionsRTL	,
		reporter
	)

Definition at line 160 of file SkUnicodeTest.cpp.

                                                             {
    if (!unicode) {
        return;
    }
    SkString text("الهيمنة على العالم عبارة قبيحة ، أفضل أن أسميها تحسين العالم.");
    std::vector<SkUnicode::BidiRegion> results;
    auto result = unicode->getBidiRegions(text.data(),
                                          text.size(),
                                          SkUnicode::TextDirection::kRTL,
                                          &results);
    REPORTER_ASSERT(reporter, result);
    REPORTER_ASSERT(reporter, results.size() == 1);
    REPORTER_ASSERT(reporter, results[0].start == 0 &&
                              results[0].end == text.size() &&
                              results[0].level == 1);
}

DEF_TEST_ICU_UNICODES() [6/6]

DEF_TEST_ICU_UNICODES	(	SkUnicode_ToUpper	,
		reporter
	)

Definition at line 239 of file SkUnicodeTest.cpp.

                                                   {
    if (!unicode) {
        return;
    }
    SkString lower("abcdefghijklmnopqrstuvwxyz");
    SkString upper("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
    auto icu_result1 = unicode->toUpper(lower);
    REPORTER_ASSERT(reporter, icu_result1.equals(upper));
    auto icu_result2 = unicode->toUpper(upper);
    REPORTER_ASSERT(reporter, icu_result2.equals(upper));
}

DEF_TEST_UNICODES()

DEF_TEST_UNICODES	(	SkUnicode_ReorderVisual	,
		reporter
	)

Definition at line 286 of file SkUnicodeTest.cpp.

                                                     {
    if (!unicode) {
        return;
    }
    auto reorder = [&](std::vector<SkUnicode::BidiLevel> levels,
                       std::vector<int32_t> expected) {
            std::vector<int32_t> logicalOrder(levels.size());
            unicode->reorderVisual(levels.data(), levels.size(), logicalOrder.data());
            for (auto i = 0ul; i < levels.size(); ++i) {
                REPORTER_ASSERT(reporter, expected[i] == logicalOrder[i]);
            }
        };
    reorder({}, {});
    reorder({0}, {0});
    reorder({1}, {0});
    reorder({0, 1, 0, 1}, {0, 1, 2, 3});
}

hasWordFlag()

bool hasWordFlag

(

SkUnicode::CodeUnitFlags

flags

)

Definition at line 138 of file SkUnicodeTest.cpp.

                                               {
    return (flags & SkUnicode::kWordBreak) == SkUnicode::kWordBreak;
}

SkUnicode_Emoji()

static void SkUnicode_Emoji ( SkUnicode *  icu, skiatest::Reporter *  reporter  )

static

Definition at line 304 of file SkUnicodeTest.cpp.

                                                                                         {
    std::u32string emojis(U"😄😁😆😅😂🤣");
    std::u32string not_emojis(U"満毎行昼本可");
    for (auto e : emojis) {
        REPORTER_ASSERT(reporter, icu->isEmoji(e));
    }
    for (auto n: not_emojis) {
        REPORTER_ASSERT(reporter, !icu->isEmoji(n));
    }
}

SkUnicode_Ideographic()

static void SkUnicode_Ideographic ( SkUnicode *  icu, skiatest::Reporter *  reporter  )

static

Definition at line 337 of file SkUnicodeTest.cpp.

                                                                                               {
    std::u32string ideographic(U"満毎行昼本可");
    std::u32string not_ideographic(U"😄😁😆😅😂🤣");
    for (auto i : ideographic) {
        REPORTER_ASSERT(reporter, icu->isIdeographic(i));
    }
    for (auto n: not_ideographic) {
        REPORTER_ASSERT(reporter, !icu->isIdeographic(n));
    }
}