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

/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2010, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/


/**
 * IntlTestUtilities is the medium level test class for everything in the directory "utility".
 */

#include "unicode/utypes.h"
#include "unicode/errorcode.h"
#include "unicode/localpointer.h"
#include "itutil.h"
#include "strtest.h"
#include "loctest.h"
#include "citrtest.h"
#include "ustrtest.h"
#include "ucdtest.h"
#include "restest.h"
#include "restsnew.h"
#include "tsmthred.h"
#include "tsputil.h"
#include "uobjtest.h"
#include "utxttest.h"
#include "v32test.h"
#include "uvectest.h" 
#include "aliastst.h"
#include "usettest.h"

static IntlTest *createLocalPointerTest();

#define CASE(id, test) case id:                               \
                          name = #test;                       \
                          if (exec) {                         \
                              logln(#test "---"); logln();    \
                              test t;                         \
                              callTest(t, par);               \
                          }                                   \
                          break

void IntlTestUtilities::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
{
    if (exec) logln("TestSuite Utilities: ");
    switch (index) {
        CASE(0, MultithreadTest);
        CASE(1, StringTest);
        CASE(2, UnicodeStringTest);
        CASE(3, LocaleTest);
        CASE(4, CharIterTest);
        CASE(5, UObjectTest);
        CASE(6, UnicodeTest);
        CASE(7, ResourceBundleTest);
        CASE(8, NewResourceBundleTest);
        CASE(9, PUtilTest);
        CASE(10, UVector32Test);
        CASE(11, UVectorTest);
        CASE(12, UTextTest);
        CASE(13, LocaleAliasTest);
        CASE(14, UnicodeSetTest);
        CASE(15, ErrorCodeTest);
        case 16:
            name = "LocalPointerTest";
            if (exec) {
                logln("TestSuite LocalPointerTest---"); logln();
                LocalPointer<IntlTest> test(createLocalPointerTest());
                callTest(*test, par);
            }
            break;
        default: name = ""; break; //needed to end loop
    }
}

void ErrorCodeTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
    if (exec) logln("TestSuite Utilities: ");
    switch (index) {
        case 0: name = "TestErrorCode"; if (exec) TestErrorCode(); break;
        case 1: name = "TestSubclass"; if (exec) TestSubclass(); break;
        default: name = ""; break; //needed to end loop
    }
}

static void RefPlusOne(UErrorCode &code) { code=(UErrorCode)(code+1); }
static void PtrPlusTwo(UErrorCode *code) { *code=(UErrorCode)(*code+2); }

void ErrorCodeTest::TestErrorCode() {
    ErrorCode errorCode;
    if(errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure()) {
        errln("ErrorCode did not initialize properly");
        return;
    }
    errorCode.assertSuccess();
    if(errorCode.errorName()!=u_errorName(U_ZERO_ERROR)) {
        errln("ErrorCode did not format error message string properly");
    }
    RefPlusOne(errorCode);
    if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
        errln("ErrorCode did not yield a writable reference");
    }
    PtrPlusTwo(errorCode);
    if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
        errln("ErrorCode did not yield a writable pointer");
    }
    errorCode.set(U_PARSE_ERROR);
    if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
        errln("ErrorCode.set() failed");
    }
    if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR ||
        !errorCode.isSuccess() || errorCode.isFailure()
    ) {
        errln("ErrorCode did not reset properly");
    }
}

class MyErrorCode: public ErrorCode {
public:
    MyErrorCode(int32_t &countChecks, int32_t &countDests)
        : checks(countChecks), dests(countDests) {}
    ~MyErrorCode() {
        if(isFailure()) {
            ++dests;
        }
    }
private:
    virtual void handleFailure() const {
        ++checks;
    }
    int32_t &checks;
    int32_t &dests;
};

void ErrorCodeTest::TestSubclass() {
    int32_t countChecks=0;
    int32_t countDests=0;
    {
        MyErrorCode errorCode(countChecks, countDests);
        if( errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure() ||
            countChecks!=0 || countDests!=0
        ) {
            errln("ErrorCode did not initialize properly");
            return;
        }
        errorCode.assertSuccess();
        if(countChecks!=0) {
            errln("ErrorCode.assertSuccess() called handleFailure() despite success");
        }
        RefPlusOne(errorCode);
        if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
            errln("ErrorCode did not yield a writable reference");
        }
        errorCode.assertSuccess();
        if(countChecks!=1) {
            errln("ErrorCode.assertSuccess() did not handleFailure()");
        }
        PtrPlusTwo(errorCode);
        if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
            errln("ErrorCode did not yield a writable pointer");
        }
        errorCode.assertSuccess();
        if(countChecks!=2) {
            errln("ErrorCode.assertSuccess() did not handleFailure()");
        }
        errorCode.set(U_PARSE_ERROR);
        if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
            errln("ErrorCode.set() failed");
        }
        if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR ||
            !errorCode.isSuccess() || errorCode.isFailure()
        ) {
            errln("ErrorCode did not reset properly");
        }
        errorCode.assertSuccess();
        if(countChecks!=2) {
            errln("ErrorCode.assertSuccess() called handleFailure() despite success");
        }
    }
    if(countDests!=0) {
        errln("MyErrorCode destructor detected failure despite success");
    }
    countChecks=countDests=0;
    {
        MyErrorCode errorCode(countChecks, countDests);
        errorCode.set(U_PARSE_ERROR);
    }
    if(countDests!=1) {
        errln("MyErrorCode destructor failed to detect failure");
    }
}

class LocalPointerTest : public IntlTest {
public:
    LocalPointerTest() {}

    void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL);

    void TestLocalPointer();
    void TestLocalArray();
    void TestLocalXyzPointer();
    void TestLocalXyzPointerNull();
};

static IntlTest *createLocalPointerTest() {
    return new LocalPointerTest();
}

void LocalPointerTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
    if(exec) {
        logln("TestSuite LocalPointerTest: ");
    }
    switch (index) {
        TESTCASE(0, TestLocalPointer);
        TESTCASE(1, TestLocalArray);
        TESTCASE(2, TestLocalXyzPointer);
        TESTCASE(3, TestLocalXyzPointerNull);
        default:
            name="";
            break; // needed to end the loop
    }
}

// Exercise every LocalPointer and LocalPointerBase method.
void LocalPointerTest::TestLocalPointer() {
    // constructor
    LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
    // isNULL(), isValid(), operator==(), operator!=()
    if(s.isNull() || !s.isValid() || s==NULL || !(s!=NULL)) {
        errln("LocalPointer constructor or NULL test failure");
        return;
    }
    // getAlias(), operator->, operator*
    if(s.getAlias()->length()!=2 || s->length()!=2 || (*s).length()!=2) {
        errln("LocalPointer access failure");
    }
    // adoptInstead(), orphan()
    s.adoptInstead(new UnicodeString((UChar)0xfffc));
    if(s->length()!=1) {
        errln("LocalPointer adoptInstead(U+FFFC) failure");
    }
    UnicodeString *orphan=s.orphan();
    if(orphan==NULL || orphan->length()!=1 || s.isValid() || s!=NULL) {
        errln("LocalPointer orphan() failure");
    }
    delete orphan;
    // destructor
    s.adoptInstead(new UnicodeString());
    if(s->length()!=0) {
        errln("LocalPointer adoptInstead(empty) failure");
    }
}

// Exercise every LocalArray method (but not LocalPointerBase).
void LocalPointerTest::TestLocalArray() {
    // constructor
    LocalArray<UnicodeString> a(new UnicodeString[2]);
    // operator[]()
    a[0].append((UChar)0x61);
    a[1].append((UChar32)0x60006);
    if(a[0].length()!=1 || a[1].length()!=2) {
        errln("LocalArray access failure");
    }
    // adoptInstead()
    a.adoptInstead(new UnicodeString[4]);
    a[3].append((UChar)0x62).append((UChar)0x63).reverse();
    if(a[3].length()!=2 || a[3][1]!=0x62) {
        errln("LocalArray adoptInstead() failure");
    }
    // destructor
}

#include "unicode/ucnvsel.h"
#include "unicode/ucal.h"
#include "unicode/udatpg.h"
#include "unicode/uidna.h"
#include "unicode/uldnames.h"
#include "unicode/umsg.h"
#include "unicode/unorm2.h"
#include "unicode/uregex.h"
#include "unicode/utrans.h"

// Use LocalXyzPointer types that are not covered elsewhere in the intltest suite.
void LocalPointerTest::TestLocalXyzPointer() {
    IcuTestErrorCode errorCode(*this, "TestLocalXyzPointer");

    static const char *const encoding="ISO-8859-1";
    LocalUConverterSelectorPointer sel(
        ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
    if(errorCode.logIfFailureAndReset("ucnvsel_open()")) {
        return;
    }
    if(sel.isNull()) {
        errln("LocalUConverterSelectorPointer failure");
        return;
    }

#if !UCONFIG_NO_FORMATTING
    LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
    if(errorCode.logDataIfFailureAndReset("ucal_open()")) {
        return;
    }
    if(cal.isNull()) {
        errln("LocalUCalendarPointer failure");
        return;
    }

    LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
    if(errorCode.logIfFailureAndReset("udatpg_open()")) {
        return;
    }
    if(patgen.isNull()) {
        errln("LocalUDateTimePatternGeneratorPointer failure");
        return;
    }

    LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode));
    if(errorCode.logIfFailureAndReset("uldn_open()")) {
        return;
    }
    if(ldn.isNull()) {
        errln("LocalULocaleDisplayNamesPointer failure");
        return;
    }

    UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
    LocalUMessageFormatPointer msg(
        umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
    if(errorCode.logIfFailureAndReset("umsg_open()")) {
        return;
    }
    if(msg.isNull()) {
        errln("LocalUMessageFormatPointer failure");
        return;
    }
#endif  /* UCONFIG_NO_FORMATTING  */

#if !UCONFIG_NO_NORMALIZATION
    const UNormalizer2 *nfc=unorm2_getInstance(NULL, "nfc", UNORM2_COMPOSE, errorCode);
    UnicodeSet emptySet;
    LocalUNormalizer2Pointer fn2(unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode));
    if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) {
        return;
    }
    if(fn2.isNull()) {
        errln("LocalUNormalizer2Pointer failure");
        return;
    }
#endif /* !UCONFIG_NO_NORMALIZATION */

#if !UCONFIG_NO_IDNA
    LocalUIDNAPointer idna(uidna_openUTS46(0, errorCode));
    if(errorCode.logIfFailureAndReset("uidna_openUTS46()")) {
        return;
    }
    if(idna.isNull()) {
        errln("LocalUIDNAPointer failure");
        return;
    }
#endif  /* !UCONFIG_NO_IDNA */

#if !UCONFIG_NO_REGULAR_EXPRESSIONS
    UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
    LocalURegularExpressionPointer regex(
        uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
    if(errorCode.logIfFailureAndReset("uregex_open()")) {
        return;
    }
    if(regex.isNull()) {
        errln("LocalURegularExpressionPointer failure");
        return;
    }
#endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */

#if !UCONFIG_NO_TRANSLITERATION
    UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
    LocalUTransliteratorPointer trans(
        utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
    if(errorCode.logIfFailureAndReset("utrans_open()")) {
        return;
    }
    if(trans.isNull()) {
        errln("LocalUTransliteratorPointer failure");
        return;
    }
#endif /* !UCONFIG_NO_TRANSLITERATION */

    // destructors
}

// Try LocalXyzPointer types with NULL pointers.
void LocalPointerTest::TestLocalXyzPointerNull() {
    {
        IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUConverterSelectorPointer");
        static const char *const encoding="ISO-8859-1";
        LocalUConverterSelectorPointer null;
        LocalUConverterSelectorPointer sel(
            ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
        sel.adoptInstead(NULL);
    }
#if !UCONFIG_NO_FORMATTING
    {
        IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUCalendarPointer");
        LocalUCalendarPointer null;
        LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
        if(!errorCode.logDataIfFailureAndReset("ucal_open()")) {
            cal.adoptInstead(NULL);
        }
    }
    {
        IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUDateTimePatternGeneratorPointer");
        LocalUDateTimePatternGeneratorPointer null;
        LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
        patgen.adoptInstead(NULL);
    }
    {
        IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUMessageFormatPointer");
        UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
        LocalUMessageFormatPointer null;
        LocalUMessageFormatPointer msg(
            umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
        msg.adoptInstead(NULL);
    }
#endif /* !UCONFIG_NO_FORMATTING */

#if !UCONFIG_NO_REGULAR_EXPRESSIONS
    {
        IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalURegularExpressionPointer");
        UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
        LocalURegularExpressionPointer null;
        LocalURegularExpressionPointer regex(
            uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
        if(!errorCode.logDataIfFailureAndReset("urege_open()")) {
            regex.adoptInstead(NULL);
        }
    }
#endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */

#if !UCONFIG_NO_TRANSLITERATION
    {
        IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUTransliteratorPointer");
        UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
        LocalUTransliteratorPointer null;
        LocalUTransliteratorPointer trans(
            utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
        if(!errorCode.logDataIfFailureAndReset("utrans_openU()")) {
            trans.adoptInstead(NULL);
        }
    }
#endif /* !UCONFIG_NO_TRANSLITERATION */

}
Commit	Line	Data
b75a7d8f A	1	/********************************************************************
b75a7d8f A	2	* COPYRIGHT:
729e4ab9	3	* Copyright (c) 1997-2010, International Business Machines Corporation and
b75a7d8f A	4	* others. All Rights Reserved.
	5	********************************************************************/
	6
	7
	8	/**
	9	* IntlTestUtilities is the medium level test class for everything in the directory "utility".
	10	*/
	11
	12	#include "unicode/utypes.h"
729e4ab9 A	13	#include "unicode/errorcode.h"
729e4ab9 A	14	#include "unicode/localpointer.h"
b75a7d8f A	15	#include "itutil.h"
	16	#include "strtest.h"
	17	#include "loctest.h"
	18	#include "citrtest.h"
	19	#include "ustrtest.h"
	20	#include "ucdtest.h"
	21	#include "restest.h"
	22	#include "restsnew.h"
b75a7d8f A	23	#include "tsmthred.h"
	24	#include "tsputil.h"
	25	#include "uobjtest.h"
73c04bcf	26	#include "utxttest.h"
374ca955	27	#include "v32test.h"
73c04bcf A	28	#include "uvectest.h"
73c04bcf A	29	#include "aliastst.h"
46f4442e A	30	#include "usettest.h"
46f4442e A	31
729e4ab9	32	static IntlTest *createLocalPointerTest();
46f4442e A	33
	34	#define CASE(id, test) case id: \
	35	name = #test; \
	36	if (exec) { \
	37	logln(#test "---"); logln(); \
	38	test t; \
	39	callTest(t, par); \
	40	} \
	41	break
b75a7d8f A	42
	43	void IntlTestUtilities::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
	44	{
	45	if (exec) logln("TestSuite Utilities: ");
	46	switch (index) {
729e4ab9 A	47	CASE(0, MultithreadTest);
	48	CASE(1, StringTest);
	49	CASE(2, UnicodeStringTest);
	50	CASE(3, LocaleTest);
	51	CASE(4, CharIterTest);
	52	CASE(5, UObjectTest);
	53	CASE(6, UnicodeTest);
	54	CASE(7, ResourceBundleTest);
	55	CASE(8, NewResourceBundleTest);
	56	CASE(9, PUtilTest);
	57	CASE(10, UVector32Test);
	58	CASE(11, UVectorTest);
	59	CASE(12, UTextTest);
	60	CASE(13, LocaleAliasTest);
	61	CASE(14, UnicodeSetTest);
	62	CASE(15, ErrorCodeTest);
	63	case 16:
	64	name = "LocalPointerTest";
	65	if (exec) {
	66	logln("TestSuite LocalPointerTest---"); logln();
	67	LocalPointer<IntlTest> test(createLocalPointerTest());
	68	callTest(*test, par);
	69	}
	70	break;
b75a7d8f A	71	default: name = ""; break; //needed to end loop
	72	}
	73	}
	74
729e4ab9 A	75	void ErrorCodeTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /par/) {
	76	if (exec) logln("TestSuite Utilities: ");
	77	switch (index) {
	78	case 0: name = "TestErrorCode"; if (exec) TestErrorCode(); break;
	79	case 1: name = "TestSubclass"; if (exec) TestSubclass(); break;
	80	default: name = ""; break; //needed to end loop
	81	}
	82	}
	83
	84	static void RefPlusOne(UErrorCode &code) { code=(UErrorCode)(code+1); }
	85	static void PtrPlusTwo(UErrorCode code) { code=(UErrorCode)(*code+2); }
	86
	87	void ErrorCodeTest::TestErrorCode() {
	88	ErrorCode errorCode;
	89	if(errorCode.get()!=U_ZERO_ERROR \|\| !errorCode.isSuccess() \|\| errorCode.isFailure()) {
	90	errln("ErrorCode did not initialize properly");
	91	return;
	92	}
	93	errorCode.assertSuccess();
	94	if(errorCode.errorName()!=u_errorName(U_ZERO_ERROR)) {
	95	errln("ErrorCode did not format error message string properly");
	96	}
	97	RefPlusOne(errorCode);
	98	if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
	99	errln("ErrorCode did not yield a writable reference");
	100	}
	101	PtrPlusTwo(errorCode);
	102	if(errorCode.get()!=U_INVALID_FORMAT_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
	103	errln("ErrorCode did not yield a writable pointer");
	104	}
	105	errorCode.set(U_PARSE_ERROR);
	106	if(errorCode.get()!=U_PARSE_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
	107	errln("ErrorCode.set() failed");
	108	}
	109	if( errorCode.reset()!=U_PARSE_ERROR \|\| errorCode.get()!=U_ZERO_ERROR \|\|
	110	!errorCode.isSuccess() \|\| errorCode.isFailure()
	111	) {
	112	errln("ErrorCode did not reset properly");
	113	}
	114	}
	115
	116	class MyErrorCode: public ErrorCode {
	117	public:
	118	MyErrorCode(int32_t &countChecks, int32_t &countDests)
	119	: checks(countChecks), dests(countDests) {}
	120	~MyErrorCode() {
	121	if(isFailure()) {
	122	++dests;
	123	}
	124	}
	125	private:
	126	virtual void handleFailure() const {
	127	++checks;
	128	}
	129	int32_t &checks;
	130	int32_t &dests;
	131	};
	132
	133	void ErrorCodeTest::TestSubclass() {
	134	int32_t countChecks=0;
	135	int32_t countDests=0;
	136	{
	137	MyErrorCode errorCode(countChecks, countDests);
	138	if( errorCode.get()!=U_ZERO_ERROR \|\| !errorCode.isSuccess() \|\| errorCode.isFailure() \|\|
139	countChecks!=0 \|\| countDests!=0
140	) {
141	errln("ErrorCode did not initialize properly");
142	return;
143	}
144	errorCode.assertSuccess();
145	if(countChecks!=0) {
146	errln("ErrorCode.assertSuccess() called handleFailure() despite success");
147	}
148	RefPlusOne(errorCode);
149	if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
150	errln("ErrorCode did not yield a writable reference");
151	}
152	errorCode.assertSuccess();
153	if(countChecks!=1) {
154	errln("ErrorCode.assertSuccess() did not handleFailure()");
155	}
156	PtrPlusTwo(errorCode);
157	if(errorCode.get()!=U_INVALID_FORMAT_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
158	errln("ErrorCode did not yield a writable pointer");
159	}
160	errorCode.assertSuccess();
161	if(countChecks!=2) {
162	errln("ErrorCode.assertSuccess() did not handleFailure()");
163	}
164	errorCode.set(U_PARSE_ERROR);
165	if(errorCode.get()!=U_PARSE_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
166	errln("ErrorCode.set() failed");
167	}
168	if( errorCode.reset()!=U_PARSE_ERROR \|\| errorCode.get()!=U_ZERO_ERROR \|\|
169	!errorCode.isSuccess() \|\| errorCode.isFailure()
170	) {
171	errln("ErrorCode did not reset properly");
172	}
173	errorCode.assertSuccess();
174	if(countChecks!=2) {
175	errln("ErrorCode.assertSuccess() called handleFailure() despite success");
176	}
177	}
178	if(countDests!=0) {
179	errln("MyErrorCode destructor detected failure despite success");
180	}
181	countChecks=countDests=0;
182	{
183	MyErrorCode errorCode(countChecks, countDests);
184	errorCode.set(U_PARSE_ERROR);
185	}
186	if(countDests!=1) {
187	errln("MyErrorCode destructor failed to detect failure");
188	}
189	}
190
191	class LocalPointerTest : public IntlTest {
192	public:
193	LocalPointerTest() {}
194
195	void runIndexedTest(int32_t index, UBool exec, const char &name, char par=NULL);
196
197	void TestLocalPointer();
198	void TestLocalArray();
199	void TestLocalXyzPointer();
200	void TestLocalXyzPointerNull();
201	};
202
203	static IntlTest *createLocalPointerTest() {
204	return new LocalPointerTest();
205	}
206
207	void LocalPointerTest::runIndexedTest(int32_t index, UBool exec, const char &name, char /par/) {
208	if(exec) {
209	logln("TestSuite LocalPointerTest: ");
210	}
211	switch (index) {
212	TESTCASE(0, TestLocalPointer);
213	TESTCASE(1, TestLocalArray);
214	TESTCASE(2, TestLocalXyzPointer);
215	TESTCASE(3, TestLocalXyzPointerNull);
216	default:
217	name="";
218	break; // needed to end the loop
219	}
220	}
221
222	// Exercise every LocalPointer and LocalPointerBase method.
223	void LocalPointerTest::TestLocalPointer() {
224	// constructor
225	LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
226	// isNULL(), isValid(), operator==(), operator!=()
227	if(s.isNull() \|\| !s.isValid() \|\| s==NULL \|\| !(s!=NULL)) {
228	errln("LocalPointer constructor or NULL test failure");
229	return;
230	}
231	// getAlias(), operator->, operator*
232	if(s.getAlias()->length()!=2 \|\| s->length()!=2 \|\| (*s).length()!=2) {
233	errln("LocalPointer access failure");
234	}
235	// adoptInstead(), orphan()
236	s.adoptInstead(new UnicodeString((UChar)0xfffc));
237	if(s->length()!=1) {
238	errln("LocalPointer adoptInstead(U+FFFC) failure");
239	}
240	UnicodeString *orphan=s.orphan();
241	if(orphan==NULL \|\| orphan->length()!=1 \|\| s.isValid() \|\| s!=NULL) {
242	errln("LocalPointer orphan() failure");
243	}
244	delete orphan;
245	// destructor
246	s.adoptInstead(new UnicodeString());
247	if(s->length()!=0) {
248	errln("LocalPointer adoptInstead(empty) failure");
249	}
250	}
251
252	// Exercise every LocalArray method (but not LocalPointerBase).
253	void LocalPointerTest::TestLocalArray() {
254	// constructor
255	LocalArray<UnicodeString> a(new UnicodeString[2]);
256	// operator[]()
257	a[0].append((UChar)0x61);
258	a[1].append((UChar32)0x60006);
259	if(a[0].length()!=1 \|\| a[1].length()!=2) {
260	errln("LocalArray access failure");
261	}
262	// adoptInstead()
263	a.adoptInstead(new UnicodeString[4]);
264	a[3].append((UChar)0x62).append((UChar)0x63).reverse();
265	if(a[3].length()!=2 \|\| a[3][1]!=0x62) {
266	errln("LocalArray adoptInstead() failure");
267	}
268	// destructor
269	}
270
271	#include "unicode/ucnvsel.h"
272	#include "unicode/ucal.h"
273	#include "unicode/udatpg.h"
274	#include "unicode/uidna.h"
275	#include "unicode/uldnames.h"
276	#include "unicode/umsg.h"
277	#include "unicode/unorm2.h"
278	#include "unicode/uregex.h"
279	#include "unicode/utrans.h"
280
281	// Use LocalXyzPointer types that are not covered elsewhere in the intltest suite.
282	void LocalPointerTest::TestLocalXyzPointer() {
283	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointer");
284
285	static const char *const encoding="ISO-8859-1";
286	LocalUConverterSelectorPointer sel(
287	ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
288	if(errorCode.logIfFailureAndReset("ucnvsel_open()")) {
289	return;
290	}
291	if(sel.isNull()) {
292	errln("LocalUConverterSelectorPointer failure");
293	return;
294	}
295
296	#if !UCONFIG_NO_FORMATTING
297	LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
298	if(errorCode.logDataIfFailureAndReset("ucal_open()")) {
299	return;
300	}
301	if(cal.isNull()) {
302	errln("LocalUCalendarPointer failure");
303	return;
304	}
305
306	LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
307	if(errorCode.logIfFailureAndReset("udatpg_open()")) {
308	return;
309	}
310	if(patgen.isNull()) {
311	errln("LocalUDateTimePatternGeneratorPointer failure");
312	return;
313	}
314
315	LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode));
316	if(errorCode.logIfFailureAndReset("uldn_open()")) {
317	return;
318	}
319	if(ldn.isNull()) {
320	errln("LocalULocaleDisplayNamesPointer failure");
321	return;
322	}
323
324	UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
325	LocalUMessageFormatPointer msg(
326	umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
327	if(errorCode.logIfFailureAndReset("umsg_open()")) {
328	return;
329	}
330	if(msg.isNull()) {
331	errln("LocalUMessageFormatPointer failure");
332	return;
333	}
334	#endif /* UCONFIG_NO_FORMATTING */
335
336	#if !UCONFIG_NO_NORMALIZATION
337	const UNormalizer2 *nfc=unorm2_getInstance(NULL, "nfc", UNORM2_COMPOSE, errorCode);
338	UnicodeSet emptySet;
339	LocalUNormalizer2Pointer fn2(unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode));
340	if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) {
341	return;
342	}
343	if(fn2.isNull()) {
344	errln("LocalUNormalizer2Pointer failure");
345	return;
346	}
347	#endif /* !UCONFIG_NO_NORMALIZATION */
348
349	#if !UCONFIG_NO_IDNA
350	LocalUIDNAPointer idna(uidna_openUTS46(0, errorCode));
351	if(errorCode.logIfFailureAndReset("uidna_openUTS46()")) {
352	return;
353	}
354	if(idna.isNull()) {
355	errln("LocalUIDNAPointer failure");
356	return;
357	}
358	#endif /* !UCONFIG_NO_IDNA */
359
360	#if !UCONFIG_NO_REGULAR_EXPRESSIONS
361	UnicodeString pattern=UNICODE_STRING_SIMPLE("abc\|xy+z");
362	LocalURegularExpressionPointer regex(
363	uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
364	if(errorCode.logIfFailureAndReset("uregex_open()")) {
365	return;
366	}
367	if(regex.isNull()) {
368	errln("LocalURegularExpressionPointer failure");
369	return;
370	}
371	#endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
372
373	#if !UCONFIG_NO_TRANSLITERATION
374	UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
375	LocalUTransliteratorPointer trans(
376	utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
377	if(errorCode.logIfFailureAndReset("utrans_open()")) {
378	return;
379	}
380	if(trans.isNull()) {
381	errln("LocalUTransliteratorPointer failure");
382	return;
383	}
384	#endif /* !UCONFIG_NO_TRANSLITERATION */
385
386	// destructors
387	}
388
389	// Try LocalXyzPointer types with NULL pointers.
390	void LocalPointerTest::TestLocalXyzPointerNull() {
391	{
392	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUConverterSelectorPointer");
393	static const char *const encoding="ISO-8859-1";
394	LocalUConverterSelectorPointer null;
395	LocalUConverterSelectorPointer sel(
396	ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
397	sel.adoptInstead(NULL);
398	}
399	#if !UCONFIG_NO_FORMATTING
400	{
401	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUCalendarPointer");
402	LocalUCalendarPointer null;
403	LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
404	if(!errorCode.logDataIfFailureAndReset("ucal_open()")) {
405	cal.adoptInstead(NULL);
406	}
407	}
408	{
409	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUDateTimePatternGeneratorPointer");
410	LocalUDateTimePatternGeneratorPointer null;
411	LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
412	patgen.adoptInstead(NULL);
413	}
414	{
415	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUMessageFormatPointer");
416	UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
417	LocalUMessageFormatPointer null;
418	LocalUMessageFormatPointer msg(
419	umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
420	msg.adoptInstead(NULL);
421	}
422	#endif /* !UCONFIG_NO_FORMATTING */
423
424	#if !UCONFIG_NO_REGULAR_EXPRESSIONS
425	{
426	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalURegularExpressionPointer");
427	UnicodeString pattern=UNICODE_STRING_SIMPLE("abc\|xy+z");
428	LocalURegularExpressionPointer null;
429	LocalURegularExpressionPointer regex(
430	uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
431	if(!errorCode.logDataIfFailureAndReset("urege_open()")) {
432	regex.adoptInstead(NULL);
433	}
434	}
435	#endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
436
437	#if !UCONFIG_NO_TRANSLITERATION
438	{
439	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUTransliteratorPointer");
440	UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
441	LocalUTransliteratorPointer null;
442	LocalUTransliteratorPointer trans(
443	utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
444	if(!errorCode.logDataIfFailureAndReset("utrans_openU()")) {
445	trans.adoptInstead(NULL);
446	}
447	}
448	#endif /* !UCONFIG_NO_TRANSLITERATION */
449
450	}