[apple/icu.git] / icuSources / test / intltest / trnserr.cpp

/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 2001-2004, 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 "rbt.h"
#include "unicode/unifilt.h"
#include "cpdtrans.h"
#include "nultrans.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, 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)){
        errln("FAIL: construction of Latin-Greek");
        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\"");
    } else {
        delete t1;
    }
    status = U_ZERO_ERROR;
    Transliterator* t2 = new RuleBasedTransliterator(newID, newIDRules, UTRANS_FORWARD, 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;
    }
    RuleBasedTransliterator *t = new RuleBasedTransliterator(id, rules, UTRANS_REVERSE, set, 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;
//}

#endif /* #if !UCONFIG_NO_TRANSLITERATION */
Commit	Line	Data
b75a7d8f A	1	/********************************************************************
b75a7d8f A	2	* COPYRIGHT:
374ca955	3	* Copyright (c) 2001-2004, International Business Machines Corporation and
b75a7d8f A	4	* others. All Rights Reserved.
	5	********************************************************************/
	6	/************************************************************************
	7	* This test program is intended for testing error conditions of the
	8	* transliterator APIs to make sure the exceptions are raised where
	9	* necessary.
	10	*
	11	* Date Name Description
	12	* 11/14/2001 hshih Creation.
	13	*
	14	************************************************************************/
	15
	16	#include "unicode/utypes.h"
	17
	18	#if !UCONFIG_NO_TRANSLITERATION
	19
	20	#include "ittrans.h"
	21	#include "trnserr.h"
	22	#include "unicode/utypes.h"
	23	#include "unicode/translit.h"
	24	#include "unicode/uniset.h"
	25	#include "rbt.h"
b75a7d8f A	26	#include "unicode/unifilt.h"
	27	#include "cpdtrans.h"
	28	#include "nultrans.h"
	29	#include <string.h>
	30	#include <stdio.h>
	31	#include <stdlib.h>
	32	#include "unicode/rep.h"
	33	#include "unicode/locid.h"
	34
	35	//---------------------------------------------
	36	// runIndexedTest
	37	//---------------------------------------------
	38
	39	void
	40	TransliteratorErrorTest::runIndexedTest(int32_t index, UBool exec,
	41	const char* &name, char* /par/) {
	42	switch (index) {
	43	TESTCASE(0,TestTransliteratorErrors);
	44	TESTCASE(1, TestUnicodeSetErrors);
374ca955 A	45	TESTCASE(2, TestRBTErrors);
	46	//TESTCASE(3, TestUniToHexErrors);
	47	//TESTCASE(4, TestHexToUniErrors);
b75a7d8f A	48	// TODO: Add a subclass to test clone().
	49	default: name = ""; break;
	50	}
	51	}
	52
	53
	54	void TransliteratorErrorTest::TestTransliteratorErrors() {
	55	UnicodeString trans="Latin-Greek";
	56	UnicodeString bogusID="LATINGREEK-GREEKLATIN";
	57	UnicodeString newID="Bogus-Latin";
	58	UnicodeString newIDRules="zzz > Z; f <> ph";
	59	UnicodeString bogusRules="a } [b-g m-p ";
	60	UParseError parseError;
	61	UErrorCode status = U_ZERO_ERROR;
	62	UnicodeString testString="A quick fox jumped over the lazy dog.";
	63	UnicodeString insertString="cats and dogs";
	64	int32_t stoppedAt = 0, len;
	65	UTransPosition pos;
	66
	67	Transliterator* t= Transliterator::createInstance(trans, UTRANS_FORWARD, parseError, status);
	68	if(t==0 \|\| U_FAILURE(status)){
	69	errln("FAIL: construction of Latin-Greek");
	70	return;
	71	}
	72	pos.contextLimit = 0;
	73	pos.contextStart = 0;
	74	pos.limit = 0;
	75	pos.start = 0;
	76	len = testString.length();
	77	stoppedAt = t->transliterate(testString, 0, 100);
	78	if (stoppedAt != -1) {
	79	errln("FAIL: Out of bounds check failed (1).");
	80	} else if (testString.length() != len) {
	81	testString="A quick fox jumped over the lazy dog.";
	82	errln("FAIL: Transliterate fails and the target string was modified.");
	83	}
	84	stoppedAt = t->transliterate(testString, 100, testString.length()-1);
	85	if (stoppedAt != -1)
	86	errln("FAIL: Out of bounds check failed (2).");
	87	else if (testString.length() != len) {
	88	testString="A quick fox jumped over the lazy dog.";
	89	errln("FAIL: Transliterate fails and the target string was modified.");
	90	}
	91	pos.start = 100;
	92	pos.limit = testString.length();
	93	t->transliterate(testString, pos, status);
	94	if (U_SUCCESS(status)) {
	95	errln("FAIL: Start offset is out of bounds, error not reported.\n");
	96	}
	97	status = U_ZERO_ERROR;
	98	pos.limit = 100;
	99	pos.start = 0;
	100	t->transliterate(testString, pos, status);
	101	if (U_SUCCESS(status)) {
	102	errln("FAIL: Limit offset is out of bounds, error not reported.\n");
	103	}
	104	status = U_ZERO_ERROR;
	105	len = pos.contextLimit = testString.length();
	106	pos.contextStart = 0;
	107	pos.limit = len - 1;
	108	pos.start = 5;
	109	t->transliterate(testString, pos, insertString, status);
	110	if (len == pos.limit) {
	111	errln("FAIL: Test insertion with string: the transliteration position limit didn't change as expected.");
112	if (U_SUCCESS(status)) {
113	errln("FAIL: Error code wasn't set either.");
114	}
115	}
116	status = U_ZERO_ERROR;
117	pos.contextStart = 0;
118	pos.contextLimit = testString.length();
119	pos.limit = testString.length() -1;
120	pos.start = 5;
121	t->transliterate(testString, pos, (UChar32)0x0061, status);
122	if (len == pos.limit) {
123	errln("FAIL: Test insertion with character: the transliteration position limit didn't change as expected.");
124	if (U_SUCCESS(status)) {
125	errln("FAIL: Error code wasn't set either.");
126	}
127	}
128	status = U_ZERO_ERROR;
129	len = pos.limit = testString.length();
130	pos.contextStart = 0;
131	pos.contextLimit = testString.length() - 1;
132	pos.start = 5;
133	t->transliterate(testString, pos, insertString, status);
134	if (U_SUCCESS(status)) {
135	errln("FAIL: Out of bounds check failed (3).");
136	if (testString.length() != len)
137	errln("FAIL: The input string was modified though the offsets were out of bounds.");
138	}
139	Transliterator* t1= Transliterator::createInstance(bogusID, UTRANS_FORWARD, parseError, status);
140	if(t1!=0 \|\| U_SUCCESS(status)){
141	delete t1;
142	errln("FAIL: construction of bogus ID \"LATINGREEK-GREEKLATIN\"");
143	} else {
144	delete t1;
145	}
146	status = U_ZERO_ERROR;
147	Transliterator* t2 = new RuleBasedTransliterator(newID, newIDRules, UTRANS_FORWARD, status);
148	if (U_SUCCESS(status)) {
149	Transliterator* t3 = t2->createInverse(status);
150	if (U_SUCCESS(status)) {
151	delete t3;
152	errln("FAIL: The newID transliterator was not registered so createInverse should fail.");
153	} else {
154	delete t3;
155	}
156	}
157	status = U_ZERO_ERROR;
158	Transliterator* t4 = Transliterator::createFromRules(newID, bogusRules, UTRANS_FORWARD, parseError, status);
159	if (t4 != NULL \|\| U_SUCCESS(status)) {
160	errln("FAIL: The rules is malformed but error was not reported.");
161	if (parseError.offset != -1) {
162	errln("FAIL: The parse error offset isn't set correctly when fails.");
163	} else if (parseError.postContext[0] == 0 \|\| parseError.preContext[0] == 0) {
164	errln("FAIL: The parse error pre/post context isn't reset properly.");
165	}
166	delete t4;
167	}
168	delete t;
169	delete t2;
170	}
171
172	void TransliteratorErrorTest::TestUnicodeSetErrors() {
173	UnicodeString badPattern="[[:L:]-[0x0300-0x0400]";
174	UnicodeSet set;
175	UErrorCode status = U_ZERO_ERROR;
176	UnicodeString result;
177
178	if (!set.isEmpty()) {
179	errln("FAIL: The default ctor of UnicodeSet created a non-empty object.");
180	}
181	set.applyPattern(badPattern, status);
182	if (U_SUCCESS(status)) {
183	errln("FAIL: Applied a bad pattern to the UnicodeSet object okay.");
184	}
185	status = U_ZERO_ERROR;
186	UnicodeSet *set1 = new UnicodeSet(badPattern, status);
187	if (U_SUCCESS(status)) {
188	errln("FAIL: Created a UnicodeSet based on bad patterns.");
189	}
190	delete set1;
191	}
192
374ca955 A	193	//void TransliteratorErrorTest::TestUniToHexErrors() {
	194	// UErrorCode status = U_ZERO_ERROR;
	195	// Transliterator *t = new UnicodeToHexTransliterator("", TRUE, NULL, status);
	196	// if (U_SUCCESS(status)) {
	197	// errln("FAIL: Created a UnicodeToHexTransliterator with an empty pattern.");
	198	// }
	199	// delete t;
	200	//
	201	// status = U_ZERO_ERROR;
	202	// t = new UnicodeToHexTransliterator("\\x", TRUE, NULL, status);
	203	// if (U_SUCCESS(status)) {
	204	// errln("FAIL: Created a UnicodeToHexTransliterator with a bad pattern.");
	205	// }
	206	// delete t;
	207	//
	208	// status = U_ZERO_ERROR;
	209	// t = new UnicodeToHexTransliterator();
	210	// ((UnicodeToHexTransliterator*)t)->applyPattern("\\x", status);
	211	// if (U_SUCCESS(status)) {
	212	// errln("FAIL: UnicodeToHexTransliterator::applyPattern succeeded with a bad pattern.");
	213	// }
	214	// delete t;
	215	//}
b75a7d8f A	216
	217	void TransliteratorErrorTest::TestRBTErrors() {
	218
	219	UnicodeString rules="ab>y";
	220	UnicodeString id="MyRandom-YReverse";
	221	UnicodeString goodPattern="[[:L:]&[\\u0000-\\uFFFF]]"; /* all BMP letters */
	222	UErrorCode status = U_ZERO_ERROR;
	223	UParseError parseErr;
	224	UnicodeSet *set = new UnicodeSet(goodPattern, status);
	225	if (U_FAILURE(status)) {
	226	errln("FAIL: Was not able to create a good UnicodeSet based on valid patterns.");
	227	return;
	228	}
	229	RuleBasedTransliterator *t = new RuleBasedTransliterator(id, rules, UTRANS_REVERSE, set, parseErr, status);
	230	if (U_FAILURE(status)) {
	231	errln("FAIL: Was not able to create a good RBT to test registration.");
	232	delete set;
	233	return;
	234	}
	235	Transliterator::registerInstance(t);
	236	Transliterator::unregister(id);
	237	status = U_ZERO_ERROR;
	238	Transliterator* t1= Transliterator::createInstance(id, UTRANS_REVERSE, parseErr, status);
	239	if(U_SUCCESS(status)){
	240	delete t1;
	241	errln("FAIL: construction of unregistered ID failed.");
	242	}
	243	}
	244
374ca955 A	245	//void TransliteratorErrorTest::TestHexToUniErrors() {
	246	// UErrorCode status = U_ZERO_ERROR;
	247	// Transliterator *t = new HexToUnicodeTransliterator("", NULL, status);
	248	// if (U_FAILURE(status)) {
	249	// errln("FAIL: Could not create a HexToUnicodeTransliterator with an empty pattern.");
	250	// }
	251	// delete t;
	252	// status = U_ZERO_ERROR;
	253	// t = new HexToUnicodeTransliterator("\\x", NULL, status);
	254	// if (U_SUCCESS(status)) {
	255	// errln("FAIL: Created a HexToUnicodeTransliterator with a bad pattern.");
	256	// }
	257	// delete t;
	258	// status = U_ZERO_ERROR;
	259	// t = new HexToUnicodeTransliterator();
	260	// ((HexToUnicodeTransliterator*)t)->applyPattern("\\x", status);
	261	// if (U_SUCCESS(status)) {
	262	// errln("FAIL: HexToUnicodeTransliterator::applyPattern succeeded with a bad pattern.");
	263	// }
	264	// delete t;
	265	//}
b75a7d8f A	266
b75a7d8f A	267	#endif /* #if !UCONFIG_NO_TRANSLITERATION */