1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/********************************************************************
4 * Copyright (c) 1997-2016, International Business Machines Corporation and
5 * others. All Rights Reserved.
6 ********************************************************************/
7
8#include "unicode/ustring.h"
9#include "unicode/uchar.h"
10#include "unicode/uniset.h"
11#include "unicode/putil.h"
12#include "unicode/uscript.h"
13#include "cstring.h"
14#include "hash.h"
15#include "patternprops.h"
16#include "normalizer2impl.h"
17#include "uparse.h"
18#include "ucdtest.h"
19
20static const char *ignorePropNames[]={
21    "FC_NFKC",
22    "NFD_QC",
23    "NFC_QC",
24    "NFKD_QC",
25    "NFKC_QC",
26    "Expands_On_NFD",
27    "Expands_On_NFC",
28    "Expands_On_NFKD",
29    "Expands_On_NFKC",
30    "NFKC_CF"
31};
32
33UnicodeTest::UnicodeTest()
34{
35    UErrorCode errorCode=U_ZERO_ERROR;
36    unknownPropertyNames=new U_NAMESPACE_QUALIFIER Hashtable(errorCode);
37    if(U_FAILURE(errorCode)) {
38        delete unknownPropertyNames;
39        unknownPropertyNames=NULL;
40    }
41    // Ignore some property names altogether.
42    for(int32_t i=0; i<UPRV_LENGTHOF(ignorePropNames); ++i) {
43        unknownPropertyNames->puti(UnicodeString(ignorePropNames[i], -1, US_INV), 1, errorCode);
44    }
45}
46
47UnicodeTest::~UnicodeTest()
48{
49    delete unknownPropertyNames;
50}
51
52void UnicodeTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
53{
54    if(exec) {
55        logln("TestSuite UnicodeTest: ");
56    }
57    TESTCASE_AUTO_BEGIN;
58    TESTCASE_AUTO(TestAdditionalProperties);
59    TESTCASE_AUTO(TestBinaryValues);
60    TESTCASE_AUTO(TestConsistency);
61    TESTCASE_AUTO(TestPatternProperties);
62    TESTCASE_AUTO(TestScriptMetadata);
63    TESTCASE_AUTO(TestBidiPairedBracketType);
64    TESTCASE_AUTO(TestEmojiProperties);
65    TESTCASE_AUTO(TestDefaultScriptExtensions);
66    TESTCASE_AUTO_END;
67}
68
69//====================================================
70// private data used by the tests
71//====================================================
72
73// test DerivedCoreProperties.txt -------------------------------------------
74
75// copied from genprops.c
76static int32_t
77getTokenIndex(const char *const tokens[], int32_t countTokens, const char *s) {
78    const char *t, *z;
79    int32_t i, j;
80
81    s=u_skipWhitespace(s);
82    for(i=0; i<countTokens; ++i) {
83        t=tokens[i];
84        if(t!=NULL) {
85            for(j=0;; ++j) {
86                if(t[j]!=0) {
87                    if(s[j]!=t[j]) {
88                        break;
89                    }
90                } else {
91                    z=u_skipWhitespace(s+j);
92                    if(*z==';' || *z==0) {
93                        return i;
94                    } else {
95                        break;
96                    }
97                }
98            }
99        }
100    }
101    return -1;
102}
103
104static const char *const
105derivedPropsNames[]={
106    "Math",
107    "Alphabetic",
108    "Lowercase",
109    "Uppercase",
110    "ID_Start",
111    "ID_Continue",
112    "XID_Start",
113    "XID_Continue",
114    "Default_Ignorable_Code_Point",
115    "Full_Composition_Exclusion",
116    "Grapheme_Extend",
117    "Grapheme_Link", /* Unicode 5 moves this property here from PropList.txt */
118    "Grapheme_Base",
119    "Cased",
120    "Case_Ignorable",
121    "Changes_When_Lowercased",
122    "Changes_When_Uppercased",
123    "Changes_When_Titlecased",
124    "Changes_When_Casefolded",
125    "Changes_When_Casemapped",
126    "Changes_When_NFKC_Casefolded"
127};
128
129static const UProperty
130derivedPropsIndex[]={
131    UCHAR_MATH,
132    UCHAR_ALPHABETIC,
133    UCHAR_LOWERCASE,
134    UCHAR_UPPERCASE,
135    UCHAR_ID_START,
136    UCHAR_ID_CONTINUE,
137    UCHAR_XID_START,
138    UCHAR_XID_CONTINUE,
139    UCHAR_DEFAULT_IGNORABLE_CODE_POINT,
140    UCHAR_FULL_COMPOSITION_EXCLUSION,
141    UCHAR_GRAPHEME_EXTEND,
142    UCHAR_GRAPHEME_LINK,
143    UCHAR_GRAPHEME_BASE,
144    UCHAR_CASED,
145    UCHAR_CASE_IGNORABLE,
146    UCHAR_CHANGES_WHEN_LOWERCASED,
147    UCHAR_CHANGES_WHEN_UPPERCASED,
148    UCHAR_CHANGES_WHEN_TITLECASED,
149    UCHAR_CHANGES_WHEN_CASEFOLDED,
150    UCHAR_CHANGES_WHEN_CASEMAPPED,
151    UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED
152};
153
154static int32_t numErrors[UPRV_LENGTHOF(derivedPropsIndex)]={ 0 };
155
156enum { MAX_ERRORS=50 };
157
158U_CFUNC void U_CALLCONV
159derivedPropsLineFn(void *context,
160                   char *fields[][2], int32_t /* fieldCount */,
161                   UErrorCode *pErrorCode)
162{
163    UnicodeTest *me=(UnicodeTest *)context;
164    uint32_t start, end;
165    int32_t i;
166
167    u_parseCodePointRange(fields[0][0], &start, &end, pErrorCode);
168    if(U_FAILURE(*pErrorCode)) {
169        me->errln("UnicodeTest: syntax error in DerivedCoreProperties.txt or DerivedNormalizationProps.txt field 0 at %s\n", fields[0][0]);
170        return;
171    }
172
173    /* parse derived binary property name, ignore unknown names */
174    i=getTokenIndex(derivedPropsNames, UPRV_LENGTHOF(derivedPropsNames), fields[1][0]);
175    if(i<0) {
176        UnicodeString propName(fields[1][0], (int32_t)(fields[1][1]-fields[1][0]));
177        propName.trim();
178        if(me->unknownPropertyNames->find(propName)==NULL) {
179            UErrorCode errorCode=U_ZERO_ERROR;
180            me->unknownPropertyNames->puti(propName, 1, errorCode);
181            me->errln("UnicodeTest warning: unknown property name '%s' in DerivedCoreProperties.txt or DerivedNormalizationProps.txt\n", fields[1][0]);
182        }
183        return;
184    }
185
186    me->derivedProps[i].add(start, end);
187}
188
189void UnicodeTest::TestAdditionalProperties() {
190#if !UCONFIG_NO_NORMALIZATION
191    // test DerivedCoreProperties.txt and DerivedNormalizationProps.txt
192    if(UPRV_LENGTHOF(derivedProps)<UPRV_LENGTHOF(derivedPropsNames)) {
193        errln("error: UnicodeTest::derivedProps[] too short, need at least %d UnicodeSets\n",
194              UPRV_LENGTHOF(derivedPropsNames));
195        return;
196    }
197    if(UPRV_LENGTHOF(derivedPropsIndex)!=UPRV_LENGTHOF(derivedPropsNames)) {
198        errln("error in ucdtest.cpp: UPRV_LENGTHOF(derivedPropsIndex)!=UPRV_LENGTHOF(derivedPropsNames)\n");
199        return;
200    }
201
202    char path[500];
203    if(getUnidataPath(path) == NULL) {
204        errln("unable to find path to source/data/unidata/");
205        return;
206    }
207    char *basename=strchr(path, 0);
208    strcpy(basename, "DerivedCoreProperties.txt");
209
210    char *fields[2][2];
211    UErrorCode errorCode=U_ZERO_ERROR;
212    u_parseDelimitedFile(path, ';', fields, 2, derivedPropsLineFn, this, &errorCode);
213    if(U_FAILURE(errorCode)) {
214        errln("error parsing DerivedCoreProperties.txt: %s\n", u_errorName(errorCode));
215        return;
216    }
217
218    strcpy(basename, "DerivedNormalizationProps.txt");
219    u_parseDelimitedFile(path, ';', fields, 2, derivedPropsLineFn, this, &errorCode);
220    if(U_FAILURE(errorCode)) {
221        errln("error parsing DerivedNormalizationProps.txt: %s\n", u_errorName(errorCode));
222        return;
223    }
224
225    // now we have all derived core properties in the UnicodeSets
226    // run them all through the API
227    int32_t rangeCount, range;
228    uint32_t i;
229    UChar32 start, end;
230
231    // test all TRUE properties
232    for(i=0; i<UPRV_LENGTHOF(derivedPropsNames); ++i) {
233        rangeCount=derivedProps[i].getRangeCount();
234        for(range=0; range<rangeCount && numErrors[i]<MAX_ERRORS; ++range) {
235            start=derivedProps[i].getRangeStart(range);
236            end=derivedProps[i].getRangeEnd(range);
237            for(; start<=end; ++start) {
238                if(!u_hasBinaryProperty(start, derivedPropsIndex[i])) {
239                    dataerrln("UnicodeTest error: u_hasBinaryProperty(U+%04lx, %s)==FALSE is wrong", start, derivedPropsNames[i]);
240                    if(++numErrors[i]>=MAX_ERRORS) {
241                      dataerrln("Too many errors, moving to the next test");
242                      break;
243                    }
244                }
245            }
246        }
247    }
248
249    // invert all properties
250    for(i=0; i<UPRV_LENGTHOF(derivedPropsNames); ++i) {
251        derivedProps[i].complement();
252    }
253
254    // test all FALSE properties
255    for(i=0; i<UPRV_LENGTHOF(derivedPropsNames); ++i) {
256        rangeCount=derivedProps[i].getRangeCount();
257        for(range=0; range<rangeCount && numErrors[i]<MAX_ERRORS; ++range) {
258            start=derivedProps[i].getRangeStart(range);
259            end=derivedProps[i].getRangeEnd(range);
260            for(; start<=end; ++start) {
261                if(u_hasBinaryProperty(start, derivedPropsIndex[i])) {
262                    errln("UnicodeTest error: u_hasBinaryProperty(U+%04lx, %s)==TRUE is wrong\n", start, derivedPropsNames[i]);
263                    if(++numErrors[i]>=MAX_ERRORS) {
264                      errln("Too many errors, moving to the next test");
265                      break;
266                    }
267                }
268            }
269        }
270    }
271#endif /* !UCONFIG_NO_NORMALIZATION */
272}
273
274void UnicodeTest::TestBinaryValues() {
275    /*
276     * Unicode 5.1 explicitly defines binary property value aliases.
277     * Verify that they are all recognized.
278     */
279    UErrorCode errorCode=U_ZERO_ERROR;
280    UnicodeSet alpha(UNICODE_STRING_SIMPLE("[:Alphabetic:]"), errorCode);
281    if(U_FAILURE(errorCode)) {
282        dataerrln("UnicodeSet([:Alphabetic:]) failed - %s", u_errorName(errorCode));
283        return;
284    }
285
286    static const char *const falseValues[]={ "N", "No", "F", "False" };
287    static const char *const trueValues[]={ "Y", "Yes", "T", "True" };
288    int32_t i;
289    for(i=0; i<UPRV_LENGTHOF(falseValues); ++i) {
290        UnicodeString pattern=UNICODE_STRING_SIMPLE("[:Alphabetic=:]");
291        pattern.insert(pattern.length()-2, UnicodeString(falseValues[i], -1, US_INV));
292        errorCode=U_ZERO_ERROR;
293        UnicodeSet set(pattern, errorCode);
294        if(U_FAILURE(errorCode)) {
295            errln("UnicodeSet([:Alphabetic=%s:]) failed - %s\n", falseValues[i], u_errorName(errorCode));
296            continue;
297        }
298        set.complement();
299        if(set!=alpha) {
300            errln("UnicodeSet([:Alphabetic=%s:]).complement()!=UnicodeSet([:Alphabetic:])\n", falseValues[i]);
301        }
302    }
303    for(i=0; i<UPRV_LENGTHOF(trueValues); ++i) {
304        UnicodeString pattern=UNICODE_STRING_SIMPLE("[:Alphabetic=:]");
305        pattern.insert(pattern.length()-2, UnicodeString(trueValues[i], -1, US_INV));
306        errorCode=U_ZERO_ERROR;
307        UnicodeSet set(pattern, errorCode);
308        if(U_FAILURE(errorCode)) {
309            errln("UnicodeSet([:Alphabetic=%s:]) failed - %s\n", trueValues[i], u_errorName(errorCode));
310            continue;
311        }
312        if(set!=alpha) {
313            errln("UnicodeSet([:Alphabetic=%s:])!=UnicodeSet([:Alphabetic:])\n", trueValues[i]);
314        }
315    }
316}
317
318void UnicodeTest::TestConsistency() {
319#if !UCONFIG_NO_NORMALIZATION
320    /*
321     * Test for an example that getCanonStartSet() delivers
322     * all characters that compose from the input one,
323     * even in multiple steps.
324     * For example, the set for "I" (0049) should contain both
325     * I-diaeresis (00CF) and I-diaeresis-acute (1E2E).
326     * In general, the set for the middle such character should be a subset
327     * of the set for the first.
328     */
329    IcuTestErrorCode errorCode(*this, "TestConsistency");
330    const Normalizer2 *nfd=Normalizer2::getNFDInstance(errorCode);
331    const Normalizer2Impl *nfcImpl=Normalizer2Factory::getNFCImpl(errorCode);
332    if(!nfcImpl->ensureCanonIterData(errorCode) || errorCode.isFailure()) {
333        dataerrln("Normalizer2::getInstance(NFD) or Normalizer2Factory::getNFCImpl() failed - %s\n",
334                  errorCode.errorName());
335        errorCode.reset();
336        return;
337    }
338
339    UnicodeSet set1, set2;
340    if (nfcImpl->getCanonStartSet(0x49, set1)) {
341        /* enumerate all characters that are plausible to be latin letters */
342        for(UChar start=0xa0; start<0x2000; ++start) {
343            UnicodeString decomp=nfd->normalize(UnicodeString(start), errorCode);
344            if(decomp.length()>1 && decomp[0]==0x49) {
345                set2.add(start);
346            }
347        }
348
349        if (set1!=set2) {
350            errln("[canon start set of 0049] != [all c with canon decomp with 0049]");
351        }
352        // This was available in cucdtst.c but the test had to move to intltest
353        // because the new internal normalization functions are in C++.
354        //compareUSets(set1, set2,
355        //             "[canon start set of 0049]", "[all c with canon decomp with 0049]",
356        //             TRUE);
357    } else {
358        errln("NFC.getCanonStartSet() returned FALSE");
359    }
360#endif
361}
362
363/**
364 * Test various implementations of Pattern_Syntax & Pattern_White_Space.
365 */
366void UnicodeTest::TestPatternProperties() {
367    IcuTestErrorCode errorCode(*this, "TestPatternProperties()");
368    UnicodeSet syn_pp;
369    UnicodeSet syn_prop(UNICODE_STRING_SIMPLE("[:Pattern_Syntax:]"), errorCode);
370    UnicodeSet syn_list(
371        "[!-/\\:-@\\[-\\^`\\{-~"
372        "\\u00A1-\\u00A7\\u00A9\\u00AB\\u00AC\\u00AE\\u00B0\\u00B1\\u00B6\\u00BB\\u00BF\\u00D7\\u00F7"
373        "\\u2010-\\u2027\\u2030-\\u203E\\u2041-\\u2053\\u2055-\\u205E\\u2190-\\u245F\\u2500-\\u2775"
374        "\\u2794-\\u2BFF\\u2E00-\\u2E7F\\u3001-\\u3003\\u3008-\\u3020\\u3030\\uFD3E\\uFD3F\\uFE45\\uFE46]", errorCode);
375    UnicodeSet ws_pp;
376    UnicodeSet ws_prop(UNICODE_STRING_SIMPLE("[:Pattern_White_Space:]"), errorCode);
377    UnicodeSet ws_list(UNICODE_STRING_SIMPLE("[\\u0009-\\u000D\\ \\u0085\\u200E\\u200F\\u2028\\u2029]"), errorCode);
378    UnicodeSet syn_ws_pp;
379    UnicodeSet syn_ws_prop(syn_prop);
380    syn_ws_prop.addAll(ws_prop);
381    for(UChar32 c=0; c<=0xffff; ++c) {
382        if(PatternProps::isSyntax(c)) {
383            syn_pp.add(c);
384        }
385        if(PatternProps::isWhiteSpace(c)) {
386            ws_pp.add(c);
387        }
388        if(PatternProps::isSyntaxOrWhiteSpace(c)) {
389            syn_ws_pp.add(c);
390        }
391    }
392    compareUSets(syn_pp, syn_prop,
393                 "PatternProps.isSyntax()", "[:Pattern_Syntax:]", TRUE);
394    compareUSets(syn_pp, syn_list,
395                 "PatternProps.isSyntax()", "[Pattern_Syntax ranges]", TRUE);
396    compareUSets(ws_pp, ws_prop,
397                 "PatternProps.isWhiteSpace()", "[:Pattern_White_Space:]", TRUE);
398    compareUSets(ws_pp, ws_list,
399                 "PatternProps.isWhiteSpace()", "[Pattern_White_Space ranges]", TRUE);
400    compareUSets(syn_ws_pp, syn_ws_prop,
401                 "PatternProps.isSyntaxOrWhiteSpace()",
402                 "[[:Pattern_Syntax:][:Pattern_White_Space:]]", TRUE);
403}
404
405// So far only minimal port of Java & cucdtst.c compareUSets().
406UBool
407UnicodeTest::compareUSets(const UnicodeSet &a, const UnicodeSet &b,
408                          const char *a_name, const char *b_name,
409                          UBool diffIsError) {
410    UBool same= a==b;
411    if(!same && diffIsError) {
412        errln("Sets are different: %s vs. %s\n", a_name, b_name);
413    }
414    return same;
415}
416
417namespace {
418
419/**
420 * Maps a special script code to the most common script of its encoded characters.
421 */
422UScriptCode getCharScript(UScriptCode script) {
423    switch(script) {
424    case USCRIPT_HAN_WITH_BOPOMOFO:
425    case USCRIPT_SIMPLIFIED_HAN:
426    case USCRIPT_TRADITIONAL_HAN:
427        return USCRIPT_HAN;
428    case USCRIPT_JAPANESE:
429        return USCRIPT_HIRAGANA;
430    case USCRIPT_JAMO:
431    case USCRIPT_KOREAN:
432        return USCRIPT_HANGUL;
433    case USCRIPT_SYMBOLS_EMOJI:
434        return USCRIPT_SYMBOLS;
435    default:
436        return script;
437    }
438}
439
440}  // namespace
441
442void UnicodeTest::TestScriptMetadata() {
443    IcuTestErrorCode errorCode(*this, "TestScriptMetadata()");
444    UnicodeSet rtl("[[:bc=R:][:bc=AL:]-[:Cn:]-[:sc=Common:]]", errorCode);
445    // So far, sample characters are uppercase.
446    // Georgian is special.
447    UnicodeSet cased("[[:Lu:]-[:sc=Common:]-[:sc=Geor:]]", errorCode);
448    for(int32_t sci = 0; sci < USCRIPT_CODE_LIMIT; ++sci) {
449        UScriptCode sc = (UScriptCode)sci;
450        // Run the test with -v to see which script has failures:
451        // .../intltest$ make && ./intltest utility/UnicodeTest/TestScriptMetadata -v | grep -C 6 FAIL
452        logln(uscript_getShortName(sc));
453        UScriptUsage usage = uscript_getUsage(sc);
454        UnicodeString sample = uscript_getSampleUnicodeString(sc);
455        UnicodeSet scriptSet;
456        scriptSet.applyIntPropertyValue(UCHAR_SCRIPT, sc, errorCode);
457        if(usage == USCRIPT_USAGE_NOT_ENCODED) {
458            assertTrue("not encoded, no sample", sample.isEmpty());
459            assertFalse("not encoded, not RTL", uscript_isRightToLeft(sc));
460            assertFalse("not encoded, not LB letters", uscript_breaksBetweenLetters(sc));
461            assertFalse("not encoded, not cased", uscript_isCased(sc));
462            assertTrue("not encoded, no characters", scriptSet.isEmpty());
463        } else {
464            assertFalse("encoded, has a sample character", sample.isEmpty());
465            UChar32 firstChar = sample.char32At(0);
466            UScriptCode charScript = getCharScript(sc);
467            assertEquals("script(sample(script))",
468                         (int32_t)charScript, (int32_t)uscript_getScript(firstChar, errorCode));
469            assertEquals("RTL vs. set", (UBool)rtl.contains(firstChar), (UBool)uscript_isRightToLeft(sc));
470            assertEquals("cased vs. set", (UBool)cased.contains(firstChar), (UBool)uscript_isCased(sc));
471            assertEquals("encoded, has characters", (UBool)(sc == charScript), (UBool)(!scriptSet.isEmpty()));
472            if(uscript_isRightToLeft(sc)) {
473                rtl.removeAll(scriptSet);
474            }
475            if(uscript_isCased(sc)) {
476                cased.removeAll(scriptSet);
477            }
478        }
479    }
480    UnicodeString pattern;
481    assertEquals("no remaining RTL characters",
482                 UnicodeString("[]"), rtl.toPattern(pattern));
483    assertEquals("no remaining cased characters",
484                 UnicodeString("[]"), cased.toPattern(pattern));
485
486    assertTrue("Hani breaks between letters", uscript_breaksBetweenLetters(USCRIPT_HAN));
487    assertTrue("Thai breaks between letters", uscript_breaksBetweenLetters(USCRIPT_THAI));
488    assertFalse("Latn does not break between letters", uscript_breaksBetweenLetters(USCRIPT_LATIN));
489}
490
491void UnicodeTest::TestBidiPairedBracketType() {
492    // BidiBrackets-6.3.0.txt says:
493    //
494    // The set of code points listed in this file was originally derived
495    // using the character properties General_Category (gc), Bidi_Class (bc),
496    // Bidi_Mirrored (Bidi_M), and Bidi_Mirroring_Glyph (bmg), as follows:
497    // two characters, A and B, form a pair if A has gc=Ps and B has gc=Pe,
498    // both have bc=ON and Bidi_M=Y, and bmg of A is B. Bidi_Paired_Bracket
499    // maps A to B and vice versa, and their Bidi_Paired_Bracket_Type
500    // property values are Open and Close, respectively.
501    IcuTestErrorCode errorCode(*this, "TestBidiPairedBracketType()");
502    UnicodeSet bpt("[:^bpt=n:]", errorCode);
503    assertTrue("bpt!=None is not empty", !bpt.isEmpty());
504    // The following should always be true.
505    UnicodeSet mirrored("[:Bidi_M:]", errorCode);
506    UnicodeSet other_neutral("[:bc=ON:]", errorCode);
507    assertTrue("bpt!=None is a subset of Bidi_M", mirrored.containsAll(bpt));
508    assertTrue("bpt!=None is a subset of bc=ON", other_neutral.containsAll(bpt));
509    // The following are true at least initially in Unicode 6.3.
510    UnicodeSet bpt_open("[:bpt=o:]", errorCode);
511    UnicodeSet bpt_close("[:bpt=c:]", errorCode);
512    UnicodeSet ps("[:Ps:]", errorCode);
513    UnicodeSet pe("[:Pe:]", errorCode);
514    assertTrue("bpt=Open is a subset of Ps", ps.containsAll(bpt_open));
515    assertTrue("bpt=Close is a subset of Pe", pe.containsAll(bpt_close));
516}
517
518void UnicodeTest::TestEmojiProperties() {
519    assertFalse("space is not Emoji", u_hasBinaryProperty(0x20, UCHAR_EMOJI));
520    assertTrue("shooting star is Emoji", u_hasBinaryProperty(0x1F320, UCHAR_EMOJI));
521    IcuTestErrorCode errorCode(*this, "TestEmojiProperties()");
522    UnicodeSet emoji("[:Emoji:]", errorCode);
523    assertTrue("lots of Emoji", emoji.size() > 700);
524
525    assertTrue("shooting star is Emoji_Presentation",
526               u_hasBinaryProperty(0x1F320, UCHAR_EMOJI_PRESENTATION));
527    assertTrue("Fitzpatrick 6 is Emoji_Modifier",
528               u_hasBinaryProperty(0x1F3FF, UCHAR_EMOJI_MODIFIER));
529    assertTrue("happy person is Emoji_Modifier_Base",
530               u_hasBinaryProperty(0x1F64B, UCHAR_EMOJI_MODIFIER_BASE));
531    assertTrue("asterisk is Emoji_Component",
532               u_hasBinaryProperty(0x2A, UCHAR_EMOJI_COMPONENT));
533}
534
535void UnicodeTest::TestDefaultScriptExtensions() {
536    // Block 3000..303F CJK Symbols and Punctuation defaults to scx=Bopo Hang Hani Hira Kana Yiii
537    // but some of its characters revert to scx=<script> which is usually Common.
538    IcuTestErrorCode errorCode(*this, "TestDefaultScriptExtensions()");
539    UScriptCode scx[20];
540    scx[0] = USCRIPT_INVALID_CODE;
541    assertEquals("U+3000 num scx", 1,  // IDEOGRAPHIC SPACE
542                 uscript_getScriptExtensions(0x3000, scx, UPRV_LENGTHOF(scx), errorCode));
543    assertEquals("U+3000 num scx[0]", USCRIPT_COMMON, scx[0]);
544    scx[0] = USCRIPT_INVALID_CODE;
545    assertEquals("U+3012 num scx", 1,  // POSTAL MARK
546                 uscript_getScriptExtensions(0x3012, scx, UPRV_LENGTHOF(scx), errorCode));
547    assertEquals("U+3012 num scx[0]", USCRIPT_COMMON, scx[0]);
548}
549