• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 **********************************************************************
5 *   Copyright (C) 1999-2011, International Business Machines
6 *   Corporation and others.  All Rights Reserved.
7 **********************************************************************
8 *   Date        Name        Description
9 *   11/10/99    aliu        Creation.
10 **********************************************************************
11 */
12 #ifndef TRANSTST_H
13 #define TRANSTST_H
14 
15 #include "unicode/utypes.h"
16 
17 #if !UCONFIG_NO_TRANSLITERATION
18 
19 #include "unicode/translit.h"
20 #include "intltest.h"
21 
22 /**
23  * @test
24  * @summary General test of Transliterator
25  */
26 class TransliteratorTest : public IntlTest {
27 
28 public:
29     TransliteratorTest();
30     virtual ~TransliteratorTest();
31 
32 private:
33     void runIndexedTest(int32_t index, UBool exec, const char* &name,
34                         char* par=NULL);
35 
36     void TestInstantiation(void);
37 
38     void TestSimpleRules(void);
39 
40     void TestInlineSet(void);
41 
42     void TestAnchors(void);
43 
44     void TestPatternQuoting(void);
45 
46     /**
47      * Create some inverses and confirm that they work.  We have to be
48      * careful how we do this, since the inverses will not be true
49      * inverses -- we can't throw any random string at the composition
50      * of the transliterators and expect the identity function.  F x
51      * F' != I.  However, if we are careful about the input, we will
52      * get the expected results.
53      */
54     void TestRuleBasedInverse(void);
55 
56     /**
57      * Basic test of keyboard.
58      */
59     void TestKeyboard(void);
60 
61     /**
62      * Basic test of keyboard with cursor.
63      */
64     void TestKeyboard2(void);
65 
66     /**
67      * Test keyboard transliteration with back-replacement.
68      */
69     void TestKeyboard3(void);
70 
71     void keyboardAux(const Transliterator& t,
72                      const char* DATA[], int32_t DATA_length);
73 
74     void TestArabic(void);
75 
76     /**
77      * Compose the Kana transliterator forward and reverse and try
78      * some strings that should come out unchanged.
79      */
80     void TestCompoundKana(void);
81 
82     /**
83      * Compose the hex transliterators forward and reverse.
84      */
85     void TestCompoundHex(void);
86 
87     /**
88      * Do some basic tests of filtering.
89      */
90     void TestFiltering(void);
91 
92     /**
93      * Regression test for bugs found in Greek transliteration.
94      */
95     void TestJ277(void);
96 
97     /**
98      * Prefix, suffix support in hex transliterators.
99      */
100     void TestJ243(void);
101 
102     /**
103      * Parsers need better syntax error messages.
104      */
105     void TestJ329(void);
106 
107     /**
108      * Test segments and segment references.
109      */
110     void TestSegments(void);
111 
112     /**
113      * Test cursor positioning outside of the key
114      */
115     void TestCursorOffset(void);
116 
117     /**
118      * Test zero length and > 1 char length variable values.  Test
119      * use of variable refs in UnicodeSets.
120      */
121     void TestArbitraryVariableValues(void);
122 
123     /**
124      * Confirm that the contextStart, contextLimit, start, and limit
125      * behave correctly. J474.
126      */
127     void TestPositionHandling(void);
128 
129     /**
130      * Test the Hiragana-Katakana transliterator.
131      */
132     void TestHiraganaKatakana(void);
133 
134     /**
135      * Test cloning / copy constructor of RBT.
136      */
137     void TestCopyJ476(void);
138 
139     /**
140      * Test inter-Indic transliterators.  These are composed.
141      * ICU4C Jitterbug 483.
142      */
143     void TestInterIndic(void);
144 
145     /**
146      * Test filter syntax in IDs. (J918)
147      */
148     void TestFilterIDs(void);
149 
150     /**
151      * Test the case mapping transliterators.
152      */
153     void TestCaseMap(void);
154 
155     /**
156      * Test the name mapping transliterators.
157      */
158     void TestNameMap(void);
159 
160     /**
161      * Test liberalized ID syntax.  1006c
162      */
163     void TestLiberalizedID(void);
164     /**
165      * Test Jitterbug 912
166      */
167     void TestCreateInstance(void);
168 
169     void TestNormalizationTransliterator(void);
170 
171     void TestCompoundRBT(void);
172 
173     void TestCompoundFilter(void);
174 
175     void TestRemove(void);
176 
177     void TestToRules(void);
178 
179     void TestContext(void);
180 
181     void TestSupplemental(void);
182 
183     void TestQuantifier(void);
184 
185     /**
186      * Test Source-Target/Variant.
187      */
188     void TestSTV(void);
189 
190     void TestCompoundInverse(void);
191 
192     void TestNFDChainRBT(void);
193 
194     /**
195      * Inverse of "Null" should be "Null". (J21)
196      */
197     void TestNullInverse(void);
198 
199     /**
200      * Check ID of inverse of alias. (J22)
201      */
202     void TestAliasInverseID(void);
203 
204     /**
205      * Test IDs of inverses of compound transliterators. (J20)
206      */
207     void TestCompoundInverseID(void);
208 
209     /**
210      * Test undefined variable.
211      */
212     void TestUndefinedVariable(void);
213 
214     /**
215      * Test empty context.
216      */
217     void TestEmptyContext(void);
218 
219     /**
220      * Test compound filter ID syntax
221      */
222     void TestCompoundFilterID(void);
223 
224     /**
225      * Test new property set syntax
226      */
227     void TestPropertySet(void);
228 
229     /**
230      * Test various failure points of the new 2.0 engine.
231      */
232     void TestNewEngine(void);
233 
234     /**
235      * Test quantified segment behavior.  We want:
236      * ([abc])+ > x $1 x; applied to "cba" produces "xax"
237      */
238     void TestQuantifiedSegment(void);
239 
240     /* Devanagari-Latin rules Test */
241     void TestDevanagariLatinRT(void);
242 
243     /* Telugu-Latin rules Test */
244     void TestTeluguLatinRT(void);
245 
246     /* Gujarati-Latin rules Test */
247     void TestGujaratiLatinRT(void);
248 
249     /* Sanskrit-Latin rules Test */
250     void TestSanskritLatinRT(void);
251 
252     /* Test Compound Indic-Latin transliterators*/
253     void TestCompoundLatinRT(void);
254 
255     /* Test bindi and tippi for Gurmukhi */
256     void TestGurmukhiDevanagari(void);
257     /**
258      * Test instantiation from a locale.
259      */
260     void TestLocaleInstantiation(void);
261 
262     /**
263      * Test title case handling of accent (should ignore accents)
264      */
265     void TestTitleAccents(void);
266 
267     /**
268      * Basic test of a locale resource based rule.
269      */
270     void TestLocaleResource(void);
271 
272     /**
273      * Make sure parse errors reference the right line.
274      */
275     void TestParseError(void);
276 
277     /**
278      * Make sure sets on output are disallowed.
279      */
280     void TestOutputSet(void);
281 
282     /**
283      * Test the use variable range pragma, making sure that use of
284      * variable range characters is detected and flagged as an error.
285      */
286     void TestVariableRange(void);
287 
288     /**
289      * Test invalid post context error handling
290      */
291     void TestInvalidPostContext(void);
292 
293     /**
294      * Test ID form variants
295      */
296     void TestIDForms(void);
297 
298     /**
299      * Mark's toRules test.
300      */
301     void TestToRulesMark(void);
302 
303     /**
304      * Test Escape and Unescape transliterators.
305      */
306     void TestEscape(void);
307 
308     void TestAnchorMasking(void);
309 
310     /**
311      * Make sure display names of variants look reasonable.
312      */
313     void TestDisplayName(void);
314 
315     /**
316      * Check to see if case mapping works correctly.
317      */
318     void TestSpecialCases(void);
319     /**
320      * Check to see that incremental gets at least part way through a reasonable string.
321      */
322     void TestIncrementalProgress(void);
323 
324     /**
325      * Check that casing handles surrogates.
326      */
327     void TestSurrogateCasing (void);
328 
329     void TestFunction(void);
330 
331     void TestInvalidBackRef(void);
332 
333     void TestMulticharStringSet(void);
334 
335     void TestUserFunction(void);
336 
337     void TestAnyX(void);
338 
339     void TestAny(void);
340 
341     void TestSourceTargetSet(void);
342 
343     void TestPatternWhiteSpace(void);
344 
345     void TestAllCodepoints(void);
346 
347     void TestBoilerplate(void);
348 
349     void TestAlternateSyntax(void);
350 
351     void TestRuleStripping(void);
352 
353     void TestHalfwidthFullwidth(void);
354 
355     void TestThai(void);
356 
357     /**
358      * Tests the multiple-pass syntax
359      */
360     void TestBeginEnd(void);
361 
362     /**
363      * Tests that toRules() works right with the multiple-pass syntax
364      */
365     void TestBeginEndToRules(void);
366 
367     /**
368      * Tests the registerAlias() function
369      */
370     void TestRegisterAlias(void);
371 
372     //======================================================================
373     // Support methods
374     //======================================================================
375  protected:
376     void expectT(const UnicodeString& id,
377                  const UnicodeString& source,
378                  const UnicodeString& expectedResult);
379 
380     void expect(const UnicodeString& rules,
381                 const UnicodeString& source,
382                 const UnicodeString& expectedResult,
383                 UTransPosition *pos=0);
384 
385     void expect(const UnicodeString& id,
386                 const UnicodeString& rules,
387                 const UnicodeString& source,
388                 const UnicodeString& expectedResult,
389                 UTransPosition *pos=0);
390 
391     void expect(const Transliterator& t,
392                 const UnicodeString& source,
393                 const UnicodeString& expectedResult,
394                 const Transliterator& reverseTransliterator);
395 
396     void expect(const Transliterator& t,
397                 const UnicodeString& source,
398                 const UnicodeString& expectedResult,
399                 UTransPosition *pos=0);
400 
401     void expectAux(const UnicodeString& tag,
402                    const UnicodeString& source,
403                    const UnicodeString& result,
404                    const UnicodeString& expectedResult);
405 
406     virtual void expectAux(const UnicodeString& tag,
407                    const UnicodeString& summary, UBool pass,
408                    const UnicodeString& expectedResult);
409 
410     static UnicodeString& formatInput(UnicodeString &appendTo,
411                                       const UnicodeString& input,
412                                       const UTransPosition& pos);
413 
414     void checkRules(const UnicodeString& label, Transliterator& t2,
415                     const UnicodeString& testRulesForward);
416     void CheckIncrementalAux(const Transliterator* t,
417                              const UnicodeString& input);
418 
419     void reportParseError(const UnicodeString& message, const UParseError& parseError, const UErrorCode& status);
420 
421 
422     const UnicodeString DESERET_DEE;
423     const UnicodeString DESERET_dee;
424 
425 };
426 
427 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
428 
429 #endif
430