/**
 *******************************************************************************
 * Copyright (C) 2001-2003, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 */
package com.ibm.icu.dev.test.translit;
import com.ibm.icu.dev.test.*;
import com.ibm.icu.text.*;

/**
 * @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 {
			UnicodeSet set1 = new UnicodeSet(badPattern);
			errln("FAIL: Created a UnicodeSet based on bad patterns.");
			if (set1 != null) {
				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 t1 =
						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) {
//		}
//	}
}