| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <gtest/gtest.h> |
| #include <minikin/GraphemeBreak.h> |
| #include "UnicodeUtils.h" |
| |
| namespace minikin { |
| |
| bool IsBreak(const char* src) { |
| const size_t BUF_SIZE = 256; |
| uint16_t buf[BUF_SIZE]; |
| size_t offset; |
| size_t size; |
| ParseUnicode(buf, BUF_SIZE, src, &size, &offset); |
| return GraphemeBreak::isGraphemeBreak(nullptr, buf, 0, size, offset); |
| } |
| |
| bool IsBreakWithAdvances(const float* advances, const char* src) { |
| const size_t BUF_SIZE = 256; |
| uint16_t buf[BUF_SIZE]; |
| size_t offset; |
| size_t size; |
| ParseUnicode(buf, BUF_SIZE, src, &size, &offset); |
| return GraphemeBreak::isGraphemeBreak(advances, buf, 0, size, offset); |
| } |
| |
| TEST(GraphemeBreak, utf16) { |
| EXPECT_FALSE(IsBreak("U+D83C | U+DC31")); // emoji, U+1F431 |
| |
| // tests for invalid UTF-16 |
| EXPECT_TRUE(IsBreak("U+D800 | U+D800")); // two leading surrogates |
| EXPECT_TRUE(IsBreak("U+DC00 | U+DC00")); // two trailing surrogates |
| EXPECT_TRUE(IsBreak("'a' | U+D800")); // lonely leading surrogate |
| EXPECT_TRUE(IsBreak("U+DC00 | 'a'")); // lonely trailing surrogate |
| EXPECT_TRUE( |
| IsBreak("U+D800 | 'a'")); // leading surrogate followed by non-surrogate |
| EXPECT_TRUE( |
| IsBreak("'a' | U+DC00")); // non-surrogate followed by trailing surrogate |
| } |
| |
| TEST(GraphemeBreak, rules) { |
| // Rule GB1, sot ÷; Rule GB2, ÷ eot |
| EXPECT_TRUE(IsBreak("| 'a'")); |
| EXPECT_TRUE(IsBreak("'a' |")); |
| |
| // Rule GB3, CR x LF |
| EXPECT_FALSE(IsBreak("U+000D | U+000A")); // CR x LF |
| |
| // Rule GB4, (Control | CR | LF) ÷ |
| EXPECT_TRUE(IsBreak("'a' | U+2028")); // Line separator |
| EXPECT_TRUE(IsBreak("'a' | U+000D")); // LF |
| EXPECT_TRUE(IsBreak("'a' | U+000A")); // CR |
| |
| // Rule GB5, ÷ (Control | CR | LF) |
| EXPECT_TRUE(IsBreak("U+2028 | 'a'")); // Line separator |
| EXPECT_TRUE(IsBreak("U+000D | 'a'")); // LF |
| EXPECT_TRUE(IsBreak("U+000A | 'a'")); // CR |
| |
| // Rule GB6, L x ( L | V | LV | LVT ) |
| EXPECT_FALSE(IsBreak("U+1100 | U+1100")); // L x L |
| EXPECT_FALSE(IsBreak("U+1100 | U+1161")); // L x V |
| EXPECT_FALSE(IsBreak("U+1100 | U+AC00")); // L x LV |
| EXPECT_FALSE(IsBreak("U+1100 | U+AC01")); // L x LVT |
| |
| // Rule GB7, ( LV | V ) x ( V | T ) |
| EXPECT_FALSE(IsBreak("U+AC00 | U+1161")); // LV x V |
| EXPECT_FALSE(IsBreak("U+1161 | U+1161")); // V x V |
| EXPECT_FALSE(IsBreak("U+AC00 | U+11A8")); // LV x T |
| EXPECT_FALSE(IsBreak("U+1161 | U+11A8")); // V x T |
| |
| // Rule GB8, ( LVT | T ) x T |
| EXPECT_FALSE(IsBreak("U+AC01 | U+11A8")); // LVT x T |
| EXPECT_FALSE(IsBreak("U+11A8 | U+11A8")); // T x T |
| |
| // Other hangul pairs not counted above _are_ breaks (GB10) |
| EXPECT_TRUE(IsBreak("U+AC00 | U+1100")); // LV x L |
| EXPECT_TRUE(IsBreak("U+AC01 | U+1100")); // LVT x L |
| EXPECT_TRUE(IsBreak("U+11A8 | U+1100")); // T x L |
| EXPECT_TRUE(IsBreak("U+11A8 | U+AC00")); // T x LV |
| EXPECT_TRUE(IsBreak("U+11A8 | U+AC01")); // T x LVT |
| |
| // Rule GB12 and Rule GB13, Regional_Indicator x Regional_Indicator |
| EXPECT_FALSE(IsBreak("U+1F1FA | U+1F1F8")); |
| EXPECT_TRUE(IsBreak( |
| "U+1F1FA U+1F1F8 | U+1F1FA U+1F1F8")); // Regional indicator pair (flag) |
| EXPECT_FALSE(IsBreak( |
| "U+1F1FA | U+1F1F8 U+1F1FA U+1F1F8")); // Regional indicator pair (flag) |
| EXPECT_FALSE(IsBreak( |
| "U+1F1FA U+1F1F8 U+1F1FA | U+1F1F8")); // Regional indicator pair (flag) |
| |
| EXPECT_TRUE( |
| IsBreak("U+1F1FA U+1F1F8 | U+1F1FA")); // Regional indicator pair (flag) |
| EXPECT_FALSE( |
| IsBreak("U+1F1FA | U+1F1F8 U+1F1FA")); // Regional indicator pair (flag) |
| // Same case as the two above, knowing that the first two characters ligate, |
| // which is what would typically happen. |
| const float firstPairLigated[] = {1.0, 0.0, 0.0, 0.0, |
| 1.0, 0.0}; // Two entries per codepoint |
| EXPECT_TRUE( |
| IsBreakWithAdvances(firstPairLigated, "U+1F1FA U+1F1F8 | U+1F1FA")); |
| EXPECT_FALSE( |
| IsBreakWithAdvances(firstPairLigated, "U+1F1FA | U+1F1F8 U+1F1FA")); |
| // Repeat the tests, But now the font doesn't have a ligature for the first |
| // two characters, while it does have a ligature for the last two. This could |
| // happen for fonts that do not support some (potentially encoded later than |
| // they were developed) flags. |
| const float secondPairLigated[] = {1.0, 0.0, 1.0, 0.0, 0.0, 0.0}; |
| EXPECT_FALSE( |
| IsBreakWithAdvances(secondPairLigated, "U+1F1FA U+1F1F8 | U+1F1FA")); |
| EXPECT_TRUE( |
| IsBreakWithAdvances(secondPairLigated, "U+1F1FA | U+1F1F8 U+1F1FA")); |
| |
| EXPECT_TRUE(IsBreak( |
| "'a' U+1F1FA U+1F1F8 | U+1F1FA")); // Regional indicator pair (flag) |
| EXPECT_FALSE(IsBreak( |
| "'a' U+1F1FA | U+1F1F8 U+1F1FA")); // Regional indicator pair (flag) |
| |
| EXPECT_TRUE(IsBreak("'a' U+1F1FA U+1F1F8 | U+1F1FA U+1F1F8")); // Regional |
| // indicator |
| // pair (flag) |
| EXPECT_FALSE(IsBreak("'a' U+1F1FA | U+1F1F8 U+1F1FA U+1F1F8")); // Regional |
| // indicator |
| // pair |
| // (flag) |
| EXPECT_FALSE(IsBreak("'a' U+1F1FA U+1F1F8 U+1F1FA | U+1F1F8")); // Regional |
| // indicator |
| // pair |
| // (flag) |
| |
| // Rule GB9, x (Extend | ZWJ) |
| EXPECT_FALSE(IsBreak("'a' | U+0301")); // combining accent |
| // TODO(jsimmons): re-enable this test when ICU has been updated in all |
| // Flutter platforms. |
| // EXPECT_FALSE(IsBreak("'a' | U+200D")); // ZWJ |
| // Rule GB9a, x SpacingMark |
| EXPECT_FALSE(IsBreak("U+0915 | U+093E")); // KA, AA (spacing mark) |
| // Rule GB9b, Prepend x |
| // see tailoring test for prepend, as current ICU doesn't have any characters |
| // in the class |
| |
| // Rule GB999, Any ÷ Any |
| EXPECT_TRUE(IsBreak("'a' | 'b'")); |
| EXPECT_TRUE(IsBreak("'f' | 'i'")); // probable ligature |
| EXPECT_TRUE(IsBreak("U+0644 | U+0627")); // probable ligature, lam + alef |
| EXPECT_TRUE(IsBreak("U+4E00 | U+4E00")); // CJK ideographs |
| EXPECT_TRUE( |
| IsBreak("'a' | U+1F1FA U+1F1F8")); // Regional indicator pair (flag) |
| EXPECT_TRUE( |
| IsBreak("U+1F1FA U+1F1F8 | 'a'")); // Regional indicator pair (flag) |
| |
| // Extended rule for emoji tag sequence. |
| EXPECT_TRUE(IsBreak("'a' | U+1F3F4 'a'")); |
| EXPECT_TRUE(IsBreak("'a' U+1F3F4 | 'a'")); |
| |
| // Immediate tag_term after tag_base. |
| EXPECT_TRUE(IsBreak("'a' | U+1F3F4 U+E007F 'a'")); |
| EXPECT_FALSE(IsBreak("U+1F3F4 | U+E007F")); |
| EXPECT_TRUE(IsBreak("'a' U+1F3F4 U+E007F | 'a'")); |
| |
| // Flag sequence |
| // U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F is emoji tag |
| // sequence for the flag of Scotland. U+1F3F4 is WAVING BLACK FLAG. This can |
| // be a tag_base character. U+E0067 is TAG LATIN SMALL LETTER G. This can be a |
| // part of tag_spec. U+E0062 is TAG LATIN SMALL LETTER B. This can be a part |
| // of tag_spec. U+E0073 is TAG LATIN SMALL LETTER S. This can be a part of |
| // tag_spec. U+E0063 is TAG LATIN SMALL LETTER C. This can be a part of |
| // tag_spec. U+E0074 is TAG LATIN SMALL LETTER T. This can be a part of |
| // tag_spec. U+E007F is CANCEL TAG. This is a tag_term character. |
| EXPECT_TRUE( |
| IsBreak("'a' | U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F")); |
| EXPECT_FALSE( |
| IsBreak("U+1F3F4 | U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F")); |
| EXPECT_FALSE( |
| IsBreak("U+1F3F4 U+E0067 | U+E0062 U+E0073 U+E0063 U+E0074 U+E007F")); |
| EXPECT_FALSE( |
| IsBreak("U+1F3F4 U+E0067 U+E0062 | U+E0073 U+E0063 U+E0074 U+E007F")); |
| EXPECT_FALSE( |
| IsBreak("U+1F3F4 U+E0067 U+E0062 U+E0073 | U+E0063 U+E0074 U+E007F")); |
| EXPECT_FALSE( |
| IsBreak("U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 | U+E0074 U+E007F")); |
| EXPECT_FALSE( |
| IsBreak("U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 | U+E007F")); |
| EXPECT_TRUE( |
| IsBreak("U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F | 'a'")); |
| } |
| |
| TEST(GraphemeBreak, DISABLED_tailoring) { |
| // control characters that we interpret as "extend" |
| EXPECT_FALSE(IsBreak("'a' | U+00AD")); // soft hyphen |
| EXPECT_FALSE(IsBreak("'a' | U+200B")); // zwsp |
| EXPECT_FALSE(IsBreak("'a' | U+200E")); // lrm |
| EXPECT_FALSE(IsBreak("'a' | U+202A")); // lre |
| EXPECT_FALSE(IsBreak("'a' | U+E0041")); // tag character |
| |
| // UTC-approved characters for the Prepend class |
| EXPECT_FALSE( |
| IsBreak("U+06DD | U+0661")); // arabic subtending mark + digit one |
| |
| EXPECT_TRUE(IsBreak("U+0E01 | U+0E33")); // Thai sara am |
| |
| // virama is not a grapheme break, but "pure killer" is |
| EXPECT_FALSE(IsBreak("U+0915 | U+094D U+0915")); // Devanagari ka+virama+ka |
| EXPECT_FALSE(IsBreak("U+0915 U+094D | U+0915")); // Devanagari ka+virama+ka |
| EXPECT_FALSE( |
| IsBreak("U+0E01 | U+0E3A U+0E01")); // thai phinthu = pure killer |
| EXPECT_TRUE(IsBreak("U+0E01 U+0E3A | U+0E01")); // thai phinthu = pure killer |
| |
| // Repetition of above tests, but with a given advances array that implies |
| // everything became just one cluster. |
| const float conjoined[] = {1.0, 0.0, 0.0}; |
| EXPECT_FALSE(IsBreakWithAdvances( |
| conjoined, |
| "U+0915 | U+094D U+0915")); // Devanagari ka+virama+ka |
| EXPECT_FALSE(IsBreakWithAdvances( |
| conjoined, |
| "U+0915 U+094D | U+0915")); // Devanagari ka+virama+ka |
| EXPECT_FALSE(IsBreakWithAdvances( |
| conjoined, |
| "U+0E01 | U+0E3A U+0E01")); // thai phinthu = pure killer |
| EXPECT_TRUE(IsBreakWithAdvances( |
| conjoined, |
| "U+0E01 U+0E3A | U+0E01")); // thai phinthu = pure killer |
| |
| // Repetition of above tests, but with a given advances array that the virama |
| // did not form a cluster with the following consonant. The difference is that |
| // there is now a grapheme break after the virama in ka+virama+ka. |
| const float separate[] = {1.0, 0.0, 1.0}; |
| EXPECT_FALSE(IsBreakWithAdvances( |
| separate, |
| "U+0915 | U+094D U+0915")); // Devanagari ka+virama+ka |
| EXPECT_TRUE(IsBreakWithAdvances( |
| separate, |
| "U+0915 U+094D | U+0915")); // Devanagari ka+virama+ka |
| EXPECT_FALSE(IsBreakWithAdvances( |
| separate, |
| "U+0E01 | U+0E3A U+0E01")); // thai phinthu = pure killer |
| EXPECT_TRUE(IsBreakWithAdvances( |
| separate, |
| "U+0E01 U+0E3A | U+0E01")); // thai phinthu = pure killer |
| |
| // suppress grapheme breaks in zwj emoji sequences |
| EXPECT_FALSE( |
| IsBreak("U+1F469 U+200D | U+2764 U+FE0F U+200D U+1F48B U+200D U+1F468")); |
| EXPECT_FALSE( |
| IsBreak("U+1F469 U+200D U+2764 U+FE0F U+200D | U+1F48B U+200D U+1F468")); |
| EXPECT_FALSE( |
| IsBreak("U+1F469 U+200D U+2764 U+FE0F U+200D U+1F48B U+200D | U+1F468")); |
| EXPECT_FALSE(IsBreak("U+1F468 U+200D | U+1F469 U+200D U+1F466")); |
| EXPECT_FALSE(IsBreak("U+1F468 U+200D U+1F469 U+200D | U+1F466")); |
| EXPECT_FALSE( |
| IsBreak("U+1F469 U+200D | U+1F469 U+200D U+1F467 U+200D U+1F466")); |
| EXPECT_FALSE( |
| IsBreak("U+1F469 U+200D U+1F469 U+200D | U+1F467 U+200D U+1F466")); |
| EXPECT_FALSE( |
| IsBreak("U+1F469 U+200D U+1F469 U+200D U+1F467 U+200D | U+1F466")); |
| EXPECT_FALSE(IsBreak("U+1F441 U+200D | U+1F5E8")); |
| |
| // Do not break before and after zwj with all kind of emoji characters. |
| EXPECT_FALSE(IsBreak("U+1F431 | U+200D U+1F464")); |
| EXPECT_FALSE(IsBreak("U+1F431 U+200D | U+1F464")); |
| |
| // ARABIC LETTER BEH + ZWJ + heart, not a zwj emoji sequence, so we preserve |
| // the break |
| EXPECT_TRUE(IsBreak("U+0628 U+200D | U+2764")); |
| } |
| |
| TEST(GraphemeBreak, DISABLED_emojiModifiers) { |
| EXPECT_FALSE( |
| IsBreak("U+261D | U+1F3FB")); // white up pointing index + modifier |
| EXPECT_FALSE(IsBreak("U+270C | U+1F3FB")); // victory hand + modifier |
| EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FB")); // boy + modifier |
| EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FC")); // boy + modifier |
| EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FD")); // boy + modifier |
| EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FE")); // boy + modifier |
| EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FF")); // boy + modifier |
| EXPECT_FALSE(IsBreak("U+1F918 | U+1F3FF")); // sign of the horns + modifier |
| EXPECT_FALSE(IsBreak("U+1F933 | U+1F3FF")); // selfie (Unicode 9) + modifier |
| // Repetition of the tests above, with the knowledge that they are ligated. |
| const float ligated1_2[] = {1.0, 0.0, 0.0}; |
| const float ligated2_2[] = {1.0, 0.0, 0.0, 0.0}; |
| EXPECT_FALSE(IsBreakWithAdvances(ligated1_2, "U+261D | U+1F3FB")); |
| EXPECT_FALSE(IsBreakWithAdvances(ligated1_2, "U+270C | U+1F3FB")); |
| EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FB")); |
| EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FC")); |
| EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FD")); |
| EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FE")); |
| EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FF")); |
| EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F918 | U+1F3FF")); |
| EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F933 | U+1F3FF")); |
| // Repetition of the tests above, with the knowledge that they are not |
| // ligated. |
| const float unligated1_2[] = {1.0, 1.0, 0.0}; |
| const float unligated2_2[] = {1.0, 0.0, 1.0, 0.0}; |
| EXPECT_TRUE(IsBreakWithAdvances(unligated1_2, "U+261D | U+1F3FB")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated1_2, "U+270C | U+1F3FB")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FB")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FC")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FD")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FE")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FF")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F918 | U+1F3FF")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F933 | U+1F3FF")); |
| |
| // adding extend characters between emoji base and modifier doesn't affect |
| // grapheme cluster |
| EXPECT_FALSE(IsBreak( |
| "U+270C U+FE0E | U+1F3FB")); // victory hand + text style + modifier |
| EXPECT_FALSE( |
| IsBreak("U+270C U+FE0F | U+1F3FB")); // heart + emoji style + modifier |
| // Repetition of the two tests above, with the knowledge that they are |
| // ligated. |
| const float ligated1_1_2[] = {1.0, 0.0, 0.0, 0.0}; |
| EXPECT_FALSE(IsBreakWithAdvances(ligated1_1_2, "U+270C U+FE0E | U+1F3FB")); |
| EXPECT_FALSE(IsBreakWithAdvances(ligated1_1_2, "U+270C U+FE0F | U+1F3FB")); |
| // Repetition of the first two tests, with the knowledge that they are not |
| // ligated. |
| const float unligated1_1_2[] = {1.0, 0.0, 1.0, 0.0}; |
| EXPECT_TRUE(IsBreakWithAdvances(unligated1_1_2, "U+270C U+FE0E | U+1F3FB")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated1_1_2, "U+270C U+FE0F | U+1F3FB")); |
| |
| // heart is not an emoji base |
| EXPECT_TRUE(IsBreak("U+2764 | U+1F3FB")); // heart + modifier |
| EXPECT_TRUE( |
| IsBreak("U+2764 U+FE0E | U+1F3FB")); // heart + emoji style + modifier |
| EXPECT_TRUE( |
| IsBreak("U+2764 U+FE0F | U+1F3FB")); // heart + emoji style + modifier |
| EXPECT_TRUE(IsBreak("U+1F3FB | U+1F3FB")); // modifier + modifier |
| |
| // rat is not an emoji modifer |
| EXPECT_TRUE(IsBreak("U+1F466 | U+1F400")); // boy + rat |
| } |
| |
| TEST(GraphemeBreak, DISABLED_genderBalancedEmoji) { |
| // U+1F469 is WOMAN, U+200D is ZWJ, U+1F4BC is BRIEFCASE. |
| EXPECT_FALSE(IsBreak("U+1F469 | U+200D U+1F4BC")); |
| EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+1F4BC")); |
| // The above two cases, when the ligature is not supported in the font. We now |
| // expect a break between them. |
| const float unligated2_1_2[] = {1.0, 0.0, 0.0, 1.0, 0.0}; |
| EXPECT_FALSE(IsBreakWithAdvances(unligated2_1_2, "U+1F469 | U+200D U+1F4BC")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated2_1_2, "U+1F469 U+200D | U+1F4BC")); |
| |
| // U+2695 has now emoji property, so should be part of ZWJ sequence. |
| EXPECT_FALSE(IsBreak("U+1F469 | U+200D U+2695")); |
| EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+2695")); |
| // The above two cases, when the ligature is not supported in the font. We now |
| // expect a break between them. |
| const float unligated2_1_1[] = {1.0, 0.0, 0.0, 1.0}; |
| EXPECT_FALSE(IsBreakWithAdvances(unligated2_1_1, "U+1F469 | U+200D U+2695")); |
| EXPECT_TRUE(IsBreakWithAdvances(unligated2_1_1, "U+1F469 U+200D | U+2695")); |
| } |
| |
| TEST(GraphemeBreak, offsets) { |
| uint16_t string[] = {0x0041, 0x06DD, 0x0045, 0x0301, 0x0049, 0x0301}; |
| EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(nullptr, string, 2, 3, 2)); |
| EXPECT_FALSE(GraphemeBreak::isGraphemeBreak(nullptr, string, 2, 3, 3)); |
| EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(nullptr, string, 2, 3, 4)); |
| EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(nullptr, string, 2, 3, 5)); |
| } |
| |
| } // namespace minikin |
