1 /* 2 ********************************************************************** 3 * Copyright (C) 1999-2007, 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 TestSourceTargetSet(void); 338 339 void TestRuleWhitespace(void); 340 341 void TestAllCodepoints(void); 342 343 void TestBoilerplate(void); 344 345 void TestAlternateSyntax(void); 346 347 void TestRuleStripping(void); 348 349 /** 350 * Tests the multiple-pass syntax 351 */ 352 void TestBeginEnd(void); 353 354 /** 355 * Tests that toRules() works right with the multiple-pass syntax 356 */ 357 void TestBeginEndToRules(void); 358 359 /** 360 * Tests the registerAlias() function 361 */ 362 void TestRegisterAlias(void); 363 364 //====================================================================== 365 // Support methods 366 //====================================================================== 367 protected: 368 void expectT(const UnicodeString& id, 369 const UnicodeString& source, 370 const UnicodeString& expectedResult); 371 372 void expect(const UnicodeString& rules, 373 const UnicodeString& source, 374 const UnicodeString& expectedResult, 375 UTransPosition *pos=0); 376 377 void expect(const UnicodeString& id, 378 const UnicodeString& rules, 379 const UnicodeString& source, 380 const UnicodeString& expectedResult, 381 UTransPosition *pos=0); 382 383 void expect(const Transliterator& t, 384 const UnicodeString& source, 385 const UnicodeString& expectedResult, 386 const Transliterator& reverseTransliterator); 387 388 void expect(const Transliterator& t, 389 const UnicodeString& source, 390 const UnicodeString& expectedResult, 391 UTransPosition *pos=0); 392 393 void expectAux(const UnicodeString& tag, 394 const UnicodeString& source, 395 const UnicodeString& result, 396 const UnicodeString& expectedResult); 397 398 virtual void expectAux(const UnicodeString& tag, 399 const UnicodeString& summary, UBool pass, 400 const UnicodeString& expectedResult); 401 402 static UnicodeString& formatInput(UnicodeString &appendTo, 403 const UnicodeString& input, 404 const UTransPosition& pos); 405 406 void checkRules(const UnicodeString& label, Transliterator& t2, 407 const UnicodeString& testRulesForward); 408 void CheckIncrementalAux(const Transliterator* t, 409 const UnicodeString& input); 410 411 void reportParseError(const UnicodeString& message, const UParseError& parseError, const UErrorCode& status); 412 413 414 const UnicodeString DESERET_DEE; 415 const UnicodeString DESERET_dee; 416 417 }; 418 419 #endif /* #if !UCONFIG_NO_TRANSLITERATION */ 420 421 #endif 422