icuSources/test/intltest/transtst.h

   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  */
  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 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