1
2/********************************************************************
3 * COPYRIGHT:
4 * Copyright (c) 1997-2007, International Business Machines Corporation and
5 * others. All Rights Reserved.
6 ********************************************************************
7**********************************************************************
8*   Date        Name        Description
9*   10/20/99    alan        Creation.
10*   03/22/2000  Madhu       Added additional tests
11**********************************************************************
12*/
13
14#ifndef _TESTUNISET
15#define _TESTUNISET
16
17#include "unicode/unistr.h"
18#include "unicode/uniset.h"
19#include "unicode/ucnv_err.h"
20#include "intltest.h"
21
22class UnicodeSetWithStrings;
23
24/**
25 * UnicodeSet test
26 */
27class UnicodeSetTest: public IntlTest {
28public:
29    UnicodeSetTest();
30    ~UnicodeSetTest();
31
32private:
33    void runIndexedTest(int32_t index, UBool exec, const char* &name, char* par=NULL);
34
35    void Testj2268();
36
37    /**
38     * Test that toPattern() round trips with syntax characters and
39     * whitespace.
40     */
41    void TestToPattern();
42
43    void TestPatterns(void);
44    void TestCategories(void);
45    void TestAddRemove(void);
46    void TestCloneEqualHash(void);
47
48    /**
49     * Make sure minimal representation is maintained.
50     */
51    void TestMinimalRep(void);
52
53    void TestAPI(void);
54
55    void TestIteration(void);
56
57    void TestStrings(void);
58
59    void TestScriptSet(void);
60
61    /**
62     * Test the [:Latin:] syntax.
63     */
64    void TestPropertySet(void);
65
66    void TestClone(void);
67
68    void TestIndexOf(void);
69
70    void TestExhaustive(void);
71
72    void TestCloseOver(void);
73
74    void TestEscapePattern(void);
75
76    void TestInvalidCodePoint(void);
77
78    void TestSymbolTable(void);
79
80    void TestSurrogate();
81
82    void TestPosixClasses();
83
84    void TestFreezable();
85
86    void TestSpan();
87
88    void TestStringSpan();
89
90private:
91
92    UBool toPatternAux(UChar32 start, UChar32 end);
93
94    UBool checkPat(const UnicodeString& source,
95                   const UnicodeSet& testSet);
96
97    UBool checkPat(const UnicodeString& source, const UnicodeSet& testSet, const UnicodeString& pat);
98
99    void _testComplement(int32_t a, UnicodeSet&, UnicodeSet&);
100
101    void _testAdd(int32_t a, int32_t b, UnicodeSet&, UnicodeSet&, UnicodeSet&);
102
103    void _testRetain(int32_t a, int32_t b, UnicodeSet&, UnicodeSet&, UnicodeSet&);
104
105    void _testRemove(int32_t a, int32_t b, UnicodeSet&, UnicodeSet&, UnicodeSet&);
106
107    void _testXor(int32_t a, int32_t b, UnicodeSet&, UnicodeSet&, UnicodeSet&);
108
109    /**
110     * Check that ranges are monotonically increasing and non-
111     * overlapping.
112     */
113    void checkCanonicalRep(const UnicodeSet& set, const UnicodeString& msg);
114
115    /**
116     * Convert a bitmask to a UnicodeSet.
117     */
118    static UnicodeSet& bitsToSet(int32_t a, UnicodeSet&);
119
120    /**
121     * Convert a UnicodeSet to a bitmask.  Only the characters
122     * U+0000 to U+0020 are represented in the bitmask.
123     */
124    static int32_t setToBits(const UnicodeSet& x);
125
126    /**
127     * Return the representation of an inversion list based UnicodeSet
128     * as a pairs list.  Ranges are listed in ascending Unicode order.
129     * For example, the set [a-zA-M3] is represented as "33AMaz".
130     */
131    static UnicodeString getPairs(const UnicodeSet& set);
132
133    /**
134     * Basic consistency check for a few items.
135     * That the iterator works, and that we can create a pattern and
136     * get the same thing back
137     */
138    void checkRoundTrip(const UnicodeSet& s);
139
140    void copyWithIterator(UnicodeSet& t, const UnicodeSet& s, UBool withRange);
141
142    UBool checkEqual(const UnicodeSet& s, const UnicodeSet& t, const char* message);
143
144    void expectContainment(const UnicodeString& pat,
145                           const UnicodeString& charsIn,
146                           const UnicodeString& charsOut);
147    void expectContainment(const UnicodeSet& set,
148                           const UnicodeString& charsIn,
149                           const UnicodeString& charsOut);
150    void expectContainment(const UnicodeSet& set,
151                           const UnicodeString& setName,
152                           const UnicodeString& charsIn,
153                           const UnicodeString& charsOut);
154    void expectPattern(UnicodeSet& set,
155                       const UnicodeString& pattern,
156                       const UnicodeString& expectedPairs);
157    void expectPairs(const UnicodeSet& set,
158                     const UnicodeString& expectedPairs);
159    void expectToPattern(const UnicodeSet& set,
160                         const UnicodeString& expPat,
161                         const char** expStrings);
162    void expectRange(const UnicodeString& label,
163                     const UnicodeSet& set,
164                     UChar32 start, UChar32 end);
165    void doAssert(UBool, const char*);
166
167    void testSpan(const UnicodeSetWithStrings *sets[4], const void *s, int32_t length, UBool isUTF16,
168                  uint32_t whichSpans,
169                  int32_t expectLimits[], int32_t &expectCount,
170                  const char *testName, int32_t index);
171    void testSpan(const UnicodeSetWithStrings *sets[4], const void *s, int32_t length, UBool isUTF16,
172                  uint32_t whichSpans,
173                  const char *testName, int32_t index);
174    void testSpanBothUTFs(const UnicodeSetWithStrings *sets[4],
175                          const UChar *s16, int32_t length16,
176                          uint32_t whichSpans,
177                          const char *testName, int32_t index);
178    void testSpanContents(const UnicodeSetWithStrings *sets[4], uint32_t whichSpans, const char *testName);
179    void testSpanUTF16String(const UnicodeSetWithStrings *sets[4], uint32_t whichSpans, const char *testName);
180    void testSpanUTF8String(const UnicodeSetWithStrings *sets[4], uint32_t whichSpans, const char *testName);
181
182    UConverter *openUTF8Converter();
183
184    UConverter *utf8Cnv;
185
186public:
187    static UnicodeString escape(const UnicodeString& s);
188};
189
190#endif
191