1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 ************************************************************************
5 * Copyright (c) 1997-2003, International Business Machines
6 * Corporation and others.  All Rights Reserved.
7 ************************************************************************
8 */
9 
10 #ifndef _NORMCONF
11 #define _NORMCONF
12 
13 #include "unicode/utypes.h"
14 
15 #if !UCONFIG_NO_NORMALIZATION
16 
17 #include "unicode/normalizer2.h"
18 #include "unicode/normlzr.h"
19 #include "intltest.h"
20 
21 typedef struct _FileStream FileStream;
22 
23 class NormalizerConformanceTest : public IntlTest {
24     Normalizer normalizer;
25     const Normalizer2 *nfc, *nfd, *nfkc, *nfkd;
26 
27  public:
28     NormalizerConformanceTest();
29     virtual ~NormalizerConformanceTest();
30 
31     void runIndexedTest(int32_t index, UBool exec, const char* &name, char* par=NULL);
32 
33     /**
34      * Test the conformance of Normalizer to
35      * http://www.unicode.org/Public/UNIDATA/NormalizationTest.txt
36      */
37     void TestConformance();
38     void TestConformance32();
39     void TestConformance(FileStream *input, int32_t options);
40 
41     // Specific tests for debugging.  These are generally failures taken from
42     // the conformance file, but culled out to make debugging easier.
43     void TestCase6(void);
44 
45  private:
46     FileStream *openNormalizationTestFile(const char *filename);
47 
48     /**
49      * Verify the conformance of the given line of the Unicode
50      * normalization (UTR 15) test suite file.  For each line,
51      * there are five columns, corresponding to field[0]..field[4].
52      *
53      * The following invariants must be true for all conformant implementations
54      *  c2 == NFC(c1) == NFC(c2) == NFC(c3)
55      *  c3 == NFD(c1) == NFD(c2) == NFD(c3)
56      *  c4 == NFKC(c1) == NFKC(c2) == NFKC(c3) == NFKC(c4) == NFKC(c5)
57      *  c5 == NFKD(c1) == NFKD(c2) == NFKD(c3) == NFKD(c4) == NFKD(c5)
58      *
59      * @param field the 5 columns
60      * @param line the source line from the test suite file
61      * @return true if the test passes
62      */
63     UBool checkConformance(const UnicodeString* field,
64                            const char *line,
65                            int32_t options,
66                            UErrorCode &status);
67 
68     UBool checkNorm(UNormalizationMode mode, int32_t options,
69                     const Normalizer2 *norm2,
70                     const UnicodeString &s, const UnicodeString &exp,
71                     int32_t field);
72 
73     void iterativeNorm(const UnicodeString& str,
74                        UNormalizationMode mode, int32_t options,
75                        UnicodeString& result,
76                        int8_t dir);
77 
78     /**
79      * @param op name of normalization form, e.g., "KC"
80      * @param op2 name of test case variant, e.g., "(-1)"
81      * @param s string being normalized
82      * @param got value received
83      * @param exp expected value
84      * @param msg description of this test
85      * @param return true if got == exp
86      */
87     UBool assertEqual(const char *op, const char *op2,
88                       const UnicodeString& s,
89                       const UnicodeString& got,
90                       const UnicodeString& exp,
91                       const char *msg);
92 
93     /**
94      * Split a string into pieces based on the given delimiter
95      * character.  Then, parse the resultant fields from hex into
96      * characters.  That is, "0040 0400;0C00;0899" -> new String[] {
97      * "\u0040\u0400", "\u0C00", "\u0899" }.  The output is assumed to
98      * be of the proper length already, and exactly output.length
99      * fields are parsed.  If there are too few an exception is
100      * thrown.  If there are too many the extras are ignored.
101      *
102      * @param buf scratch buffer
103      * @return FALSE upon failure
104      */
105     UBool hexsplit(const char *s, char delimiter,
106                    UnicodeString output[], int32_t outputLength);
107 
108     void _testOneLine(const char *line);
109     void compare(const UnicodeString& s1,const UnicodeString& s2);
110 };
111 
112 #endif /* #if !UCONFIG_NO_NORMALIZATION */
113 
114 #endif
115