~ubuntu-branches/ubuntu/maverick/icu/maverick-updates

« back to all changes in this revision

Viewing changes to source/test/intltest/transtst.h

  • Committer: Package Import Robot
  • Author(s): Jay Berkenbilt
  • Date: 2009-09-04 11:56:06 UTC
  • mfrom: (10.1.6 sid)
  • Revision ID: package-import@ubuntu.com-20090904115606-sqxxuizelam5tozb
Tags: 4.2.1-3
Change install-doc target to not fail if there are subdirectories of
doc/html.  This is necessary to handle the doc/html/search directory
created by doxygen 3.6.1.  (Closes: #544799)

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
**********************************************************************
 
3
*   Copyright (C) 1999-2009, 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
 */
 
24
class TransliteratorTest : public IntlTest {
 
25
 
 
26
public:
 
27
    TransliteratorTest();
 
28
    virtual ~TransliteratorTest();
 
29
 
 
30
private:
 
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 TestRuleWhitespace(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