| /** |
| ******************************************************************************* |
| * Copyright (C) 2001-2010, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| */ |
| package com.ibm.icu.dev.test.translit; |
| import com.ibm.icu.dev.test.TestFmwk; |
| import com.ibm.icu.text.ReplaceableString; |
| import com.ibm.icu.text.Transliterator; |
| import com.ibm.icu.text.UnicodeSet; |
| |
| /** |
| * @test |
| * @summary Error condition test of Transliterator |
| */ |
| public class ErrorTest extends TestFmwk { |
| |
| public static void main(String[] args) throws Exception { |
| new ErrorTest().run(args); |
| } |
| |
| public void TestTransliteratorErrors() { |
| String trans = "Latin-Greek"; |
| String bogusID = "LATINGREEK-GREEKLATIN"; |
| String newID = "Bogus-Latin"; |
| String newIDRules = "zzz > Z; f <> ph"; |
| String bogusRules = "a } [b-g m-p "; |
| ReplaceableString testString = |
| new ReplaceableString("A quick fox jumped over the lazy dog."); |
| String insertString = "cats and dogs"; |
| int stoppedAt = 0, len; |
| Transliterator.Position pos = new Transliterator.Position(); |
| |
| Transliterator t = |
| Transliterator.getInstance(trans, Transliterator.FORWARD); |
| if (t == null) { |
| errln("FAIL: construction of Latin-Greek"); |
| return; |
| } |
| 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 = |
| new ReplaceableString("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 = |
| new ReplaceableString("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(); |
| try { |
| t.transliterate(testString, pos); |
| errln("FAIL: Start offset is out of bounds, error not reported."); |
| } catch (IllegalArgumentException e) { |
| logln("Start offset is out of bounds and detected."); |
| } |
| pos.limit = 100; |
| pos.start = 0; |
| |
| try { |
| t.transliterate(testString, pos); |
| errln("FAIL: Limit offset is out of bounds, error not reported.\n"); |
| } catch (IllegalArgumentException e) { |
| logln("Start offset is out of bounds and detected."); |
| } |
| len = pos.contextLimit = testString.length(); |
| pos.contextStart = 0; |
| pos.limit = len - 1; |
| pos.start = 5; |
| try { |
| t.transliterate(testString, pos, insertString); |
| if (len == pos.limit) { |
| errln("FAIL: Test insertion with string: the transliteration position limit didn't change as expected."); |
| } |
| } catch (IllegalArgumentException e) { |
| errln("Insertion test with string failed for some reason."); |
| } |
| pos.contextStart = 0; |
| pos.contextLimit = testString.length(); |
| pos.limit = testString.length() - 1; |
| pos.start = 5; |
| try { |
| t.transliterate(testString, pos, 0x0061); |
| if (len == pos.limit) { |
| errln("FAIL: Test insertion with character: the transliteration position limit didn't change as expected."); |
| } |
| } catch (IllegalArgumentException e) { |
| errln("FAIL: Insertion test with UTF-16 code point failed for some reason."); |
| } |
| len = pos.limit = testString.length(); |
| pos.contextStart = 0; |
| pos.contextLimit = testString.length() - 1; |
| pos.start = 5; |
| try { |
| t.transliterate(testString, pos, insertString); |
| 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."); |
| } |
| } catch (IllegalArgumentException e) { |
| logln("Insertion test with out of bounds indexes."); |
| } |
| Transliterator t1 = null; |
| try { |
| t1 = Transliterator.getInstance(bogusID, Transliterator.FORWARD); |
| if (t1 != null) { |
| errln("FAIL: construction of bogus ID \"LATINGREEK-GREEKLATIN\""); |
| } |
| } catch (IllegalArgumentException e) { |
| } |
| |
| //try { // unneeded - Exception cannot be thrown |
| Transliterator t2 = |
| Transliterator.createFromRules( |
| newID, |
| newIDRules, |
| Transliterator.FORWARD); |
| try { |
| Transliterator t3 = t2.getInverse(); |
| errln("FAIL: The newID transliterator was not registered so createInverse should fail."); |
| if (t3 != null) { |
| errln("FAIL: The newID transliterator was not registered so createInverse should fail."); |
| } |
| } catch (Exception e) { |
| } |
| //} catch (Exception e) { } |
| try { |
| Transliterator t4 = |
| Transliterator.createFromRules( |
| newID, |
| bogusRules, |
| Transliterator.FORWARD); |
| if (t4 != null) { |
| errln("FAIL: The rules is malformed but error was not reported."); |
| } |
| } catch (Exception e) { |
| } |
| } |
| |
| public void TestUnicodeSetErrors() { |
| String badPattern = "[[:L:]-[0x0300-0x0400]"; |
| UnicodeSet set = new UnicodeSet(); |
| //String result; |
| |
| if (!set.isEmpty()) { |
| errln("FAIL: The default ctor of UnicodeSet created a non-empty object."); |
| } |
| try { |
| set.applyPattern(badPattern); |
| errln("FAIL: Applied a bad pattern to the UnicodeSet object okay."); |
| } catch (IllegalArgumentException e) { |
| logln("Test applying with the bad pattern."); |
| } |
| try { |
| new UnicodeSet(badPattern); |
| errln("FAIL: Created a UnicodeSet based on bad patterns."); |
| } catch (IllegalArgumentException e) { |
| logln("Test constructing with the bad pattern."); |
| } |
| } |
| |
| // public void TestUniToHexErrors() { |
| // Transliterator t = null; |
| // try { |
| // t = new UnicodeToHexTransliterator("", true, null); |
| // if (t != null) { |
| // errln("FAIL: Created a UnicodeToHexTransliterator with an empty pattern."); |
| // } |
| // } catch (IllegalArgumentException e) { |
| // } |
| // try { |
| // t = new UnicodeToHexTransliterator("\\x", true, null); |
| // if (t != null) { |
| // errln("FAIL: Created a UnicodeToHexTransliterator with a bad pattern."); |
| // } |
| // } catch (IllegalArgumentException e) { |
| // } |
| // t = new UnicodeToHexTransliterator(); |
| // try { |
| // ((UnicodeToHexTransliterator) t).applyPattern("\\x"); |
| // errln("FAIL: UnicodeToHexTransliterator::applyPattern succeeded with a bad pattern."); |
| // } catch (Exception e) { |
| // } |
| // } |
| |
| public void TestRBTErrors() { |
| |
| String rules = "ab>y"; |
| String id = "MyRandom-YReverse"; |
| String goodPattern = "[[:L:]&[\\u0000-\\uFFFF]]"; /* all BMP letters */ |
| UnicodeSet set = null; |
| try { |
| set = new UnicodeSet(goodPattern); |
| try { |
| Transliterator t = |
| Transliterator.createFromRules(id, rules, Transliterator.REVERSE); |
| t.setFilter(set); |
| Transliterator.registerClass(id, t.getClass(), null); |
| Transliterator.unregister(id); |
| try { |
| Transliterator.getInstance(id, Transliterator.REVERSE); |
| errln("FAIL: construction of unregistered ID should have failed."); |
| } catch (IllegalArgumentException e) { |
| } |
| } catch (IllegalArgumentException e) { |
| errln("FAIL: Was not able to create a good RBT to test registration."); |
| } |
| } catch (IllegalArgumentException e) { |
| errln("FAIL: Was not able to create a good UnicodeSet based on valid patterns."); |
| return; |
| } |
| } |
| |
| // public void TestHexToUniErrors() { |
| // Transliterator t = null; |
| // //try { // unneeded - exception cannot be thrown |
| // t = new HexToUnicodeTransliterator("", null); |
| // //} catch (Exception e) { |
| // // errln("FAIL: Could not create a HexToUnicodeTransliterator with an empty pattern."); |
| // //} |
| // try { |
| // t = new HexToUnicodeTransliterator("\\x", null); |
| // errln("FAIL: Created a HexToUnicodeTransliterator with a bad pattern."); |
| // } catch (IllegalArgumentException e) { |
| // } |
| // |
| // t = new HexToUnicodeTransliterator(); |
| // try { |
| // ((HexToUnicodeTransliterator) t).applyPattern("\\x"); |
| // errln("FAIL: HexToUnicodeTransliterator::applyPattern succeeded with a bad pattern."); |
| // } catch (IllegalArgumentException e) { |
| // } |
| // } |
| } |
