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