| /******************************************************************** |
| * Copyright (c) 2001-2009, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************* |
| * This test program is intended for testing error conditions of the |
| * transliterator APIs to make sure the exceptions are raised where |
| * necessary. |
| * |
| * Date Name Description |
| * 11/14/2001 hshih Creation. |
| * |
| ********************************************************************/ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_TRANSLITERATION |
| |
| #include "ittrans.h" |
| #include "trnserr.h" |
| #include "unicode/utypes.h" |
| #include "unicode/translit.h" |
| #include "unicode/uniset.h" |
| #include "unicode/unifilt.h" |
| #include "cpdtrans.h" |
| #include <string.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include "unicode/rep.h" |
| #include "unicode/locid.h" |
| |
| //--------------------------------------------- |
| // runIndexedTest |
| //--------------------------------------------- |
| |
| void |
| TransliteratorErrorTest::runIndexedTest(int32_t index, UBool exec, |
| const char* &name, char* /*par*/) { |
| switch (index) { |
| TESTCASE(0,TestTransliteratorErrors); |
| TESTCASE(1, TestUnicodeSetErrors); |
| TESTCASE(2, TestRBTErrors); |
| TESTCASE(3, TestCoverage); |
| //TESTCASE(3, TestUniToHexErrors); |
| //TESTCASE(4, TestHexToUniErrors); |
| // TODO: Add a subclass to test clone(). |
| default: name = ""; break; |
| } |
| } |
| |
| |
| void TransliteratorErrorTest::TestTransliteratorErrors() { |
| UnicodeString trans="Latin-Greek"; |
| UnicodeString bogusID="LATINGREEK-GREEKLATIN"; |
| UnicodeString newID="Bogus-Latin"; |
| UnicodeString newIDRules="zzz > Z; f <> ph"; |
| UnicodeString bogusRules="a } [b-g m-p "; |
| UParseError parseError; |
| UErrorCode status = U_ZERO_ERROR; |
| UnicodeString testString="A quick fox jumped over the lazy dog."; |
| UnicodeString insertString="cats and dogs"; |
| int32_t stoppedAt = 0, len; |
| UTransPosition pos; |
| |
| Transliterator* t= Transliterator::createInstance(trans, UTRANS_FORWARD, parseError, status); |
| if(t==0 || U_FAILURE(status)){ |
| dataerrln("FAIL: construction of Latin-Greek - %s", u_errorName(status)); |
| return; |
| } |
| pos.contextLimit = 0; |
| pos.contextStart = 0; |
| pos.limit = 0; |
| pos.start = 0; |
| len = testString.length(); |
| stoppedAt = t->transliterate(testString, 0, 100); |
| if (stoppedAt != -1) { |
| errln("FAIL: Out of bounds check failed (1)."); |
| } else if (testString.length() != len) { |
| testString="A quick fox jumped over the lazy dog."; |
| errln("FAIL: Transliterate fails and the target string was modified."); |
| } |
| stoppedAt = t->transliterate(testString, 100, testString.length()-1); |
| if (stoppedAt != -1) |
| errln("FAIL: Out of bounds check failed (2)."); |
| else if (testString.length() != len) { |
| testString="A quick fox jumped over the lazy dog."; |
| errln("FAIL: Transliterate fails and the target string was modified."); |
| } |
| pos.start = 100; |
| pos.limit = testString.length(); |
| t->transliterate(testString, pos, status); |
| if (U_SUCCESS(status)) { |
| errln("FAIL: Start offset is out of bounds, error not reported.\n"); |
| } |
| status = U_ZERO_ERROR; |
| pos.limit = 100; |
| pos.start = 0; |
| t->transliterate(testString, pos, status); |
| if (U_SUCCESS(status)) { |
| errln("FAIL: Limit offset is out of bounds, error not reported.\n"); |
| } |
| status = U_ZERO_ERROR; |
| len = pos.contextLimit = testString.length(); |
| pos.contextStart = 0; |
| pos.limit = len - 1; |
| pos.start = 5; |
| t->transliterate(testString, pos, insertString, status); |
| if (len == pos.limit) { |
| errln("FAIL: Test insertion with string: the transliteration position limit didn't change as expected."); |
| if (U_SUCCESS(status)) { |
| errln("FAIL: Error code wasn't set either."); |
| } |
| } |
| status = U_ZERO_ERROR; |
| pos.contextStart = 0; |
| pos.contextLimit = testString.length(); |
| pos.limit = testString.length() -1; |
| pos.start = 5; |
| t->transliterate(testString, pos, (UChar32)0x0061, status); |
| if (len == pos.limit) { |
| errln("FAIL: Test insertion with character: the transliteration position limit didn't change as expected."); |
| if (U_SUCCESS(status)) { |
| errln("FAIL: Error code wasn't set either."); |
| } |
| } |
| status = U_ZERO_ERROR; |
| len = pos.limit = testString.length(); |
| pos.contextStart = 0; |
| pos.contextLimit = testString.length() - 1; |
| pos.start = 5; |
| t->transliterate(testString, pos, insertString, status); |
| if (U_SUCCESS(status)) { |
| errln("FAIL: Out of bounds check failed (3)."); |
| if (testString.length() != len) |
| errln("FAIL: The input string was modified though the offsets were out of bounds."); |
| } |
| Transliterator* t1= Transliterator::createInstance(bogusID, UTRANS_FORWARD, parseError, status); |
| if(t1!=0 || U_SUCCESS(status)){ |
| delete t1; |
| errln("FAIL: construction of bogus ID \"LATINGREEK-GREEKLATIN\""); |
| } |
| status = U_ZERO_ERROR; |
| Transliterator* t2 = Transliterator::createFromRules(newID, newIDRules, UTRANS_FORWARD, parseError, status); |
| if (U_SUCCESS(status)) { |
| Transliterator* t3 = t2->createInverse(status); |
| if (U_SUCCESS(status)) { |
| delete t3; |
| errln("FAIL: The newID transliterator was not registered so createInverse should fail."); |
| } else { |
| delete t3; |
| } |
| } |
| status = U_ZERO_ERROR; |
| Transliterator* t4 = Transliterator::createFromRules(newID, bogusRules, UTRANS_FORWARD, parseError, status); |
| if (t4 != NULL || U_SUCCESS(status)) { |
| errln("FAIL: The rules is malformed but error was not reported."); |
| if (parseError.offset != -1) { |
| errln("FAIL: The parse error offset isn't set correctly when fails."); |
| } else if (parseError.postContext[0] == 0 || parseError.preContext[0] == 0) { |
| errln("FAIL: The parse error pre/post context isn't reset properly."); |
| } |
| delete t4; |
| } |
| delete t; |
| delete t2; |
| } |
| |
| void TransliteratorErrorTest::TestUnicodeSetErrors() { |
| UnicodeString badPattern="[[:L:]-[0x0300-0x0400]"; |
| UnicodeSet set; |
| UErrorCode status = U_ZERO_ERROR; |
| UnicodeString result; |
| |
| if (!set.isEmpty()) { |
| errln("FAIL: The default ctor of UnicodeSet created a non-empty object."); |
| } |
| set.applyPattern(badPattern, status); |
| if (U_SUCCESS(status)) { |
| errln("FAIL: Applied a bad pattern to the UnicodeSet object okay."); |
| } |
| status = U_ZERO_ERROR; |
| UnicodeSet *set1 = new UnicodeSet(badPattern, status); |
| if (U_SUCCESS(status)) { |
| errln("FAIL: Created a UnicodeSet based on bad patterns."); |
| } |
| delete set1; |
| } |
| |
| //void TransliteratorErrorTest::TestUniToHexErrors() { |
| // UErrorCode status = U_ZERO_ERROR; |
| // Transliterator *t = new UnicodeToHexTransliterator("", TRUE, NULL, status); |
| // if (U_SUCCESS(status)) { |
| // errln("FAIL: Created a UnicodeToHexTransliterator with an empty pattern."); |
| // } |
| // delete t; |
| // |
| // status = U_ZERO_ERROR; |
| // t = new UnicodeToHexTransliterator("\\x", TRUE, NULL, status); |
| // if (U_SUCCESS(status)) { |
| // errln("FAIL: Created a UnicodeToHexTransliterator with a bad pattern."); |
| // } |
| // delete t; |
| // |
| // status = U_ZERO_ERROR; |
| // t = new UnicodeToHexTransliterator(); |
| // ((UnicodeToHexTransliterator*)t)->applyPattern("\\x", status); |
| // if (U_SUCCESS(status)) { |
| // errln("FAIL: UnicodeToHexTransliterator::applyPattern succeeded with a bad pattern."); |
| // } |
| // delete t; |
| //} |
| |
| void TransliteratorErrorTest::TestRBTErrors() { |
| |
| UnicodeString rules="ab>y"; |
| UnicodeString id="MyRandom-YReverse"; |
| //UnicodeString goodPattern="[[:L:]&[\\u0000-\\uFFFF]]"; /* all BMP letters */ |
| UErrorCode status = U_ZERO_ERROR; |
| UParseError parseErr; |
| /*UnicodeSet *set = new UnicodeSet(goodPattern, status); |
| if (U_FAILURE(status)) { |
| errln("FAIL: Was not able to create a good UnicodeSet based on valid patterns."); |
| return; |
| }*/ |
| Transliterator *t = Transliterator::createFromRules(id, rules, UTRANS_REVERSE, parseErr, status); |
| if (U_FAILURE(status)) { |
| errln("FAIL: Was not able to create a good RBT to test registration."); |
| //delete set; |
| return; |
| } |
| Transliterator::registerInstance(t); |
| Transliterator::unregister(id); |
| status = U_ZERO_ERROR; |
| Transliterator* t1= Transliterator::createInstance(id, UTRANS_REVERSE, parseErr, status); |
| if(U_SUCCESS(status)){ |
| delete t1; |
| errln("FAIL: construction of unregistered ID failed."); |
| } |
| } |
| |
| //void TransliteratorErrorTest::TestHexToUniErrors() { |
| // UErrorCode status = U_ZERO_ERROR; |
| // Transliterator *t = new HexToUnicodeTransliterator("", NULL, status); |
| // if (U_FAILURE(status)) { |
| // errln("FAIL: Could not create a HexToUnicodeTransliterator with an empty pattern."); |
| // } |
| // delete t; |
| // status = U_ZERO_ERROR; |
| // t = new HexToUnicodeTransliterator("\\x", NULL, status); |
| // if (U_SUCCESS(status)) { |
| // errln("FAIL: Created a HexToUnicodeTransliterator with a bad pattern."); |
| // } |
| // delete t; |
| // status = U_ZERO_ERROR; |
| // t = new HexToUnicodeTransliterator(); |
| // ((HexToUnicodeTransliterator*)t)->applyPattern("\\x", status); |
| // if (U_SUCCESS(status)) { |
| // errln("FAIL: HexToUnicodeTransliterator::applyPattern succeeded with a bad pattern."); |
| // } |
| // delete t; |
| //} |
| |
| class StubTransliterator: public Transliterator{ |
| public: |
| StubTransliterator(): Transliterator(UNICODE_STRING_SIMPLE("Any-Null"), 0) {} |
| virtual void handleTransliterate(Replaceable& ,UTransPosition& offsets,UBool) const { |
| offsets.start = offsets.limit; |
| } |
| |
| virtual UClassID getDynamicClassID() const{ |
| static char classID = 0; |
| return (UClassID)&classID; |
| } |
| }; |
| |
| void TransliteratorErrorTest::TestCoverage() { |
| StubTransliterator stub; |
| |
| if (stub.clone() != NULL){ |
| errln("FAIL: default Transliterator::clone() should return NULL"); |
| } |
| } |
| |
| #endif /* #if !UCONFIG_NO_TRANSLITERATION */ |
