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