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

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