source/test/intltest/transtst.h

   1 // Copyright (C) 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