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

/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2012, 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"

extern IntlTest *createBytesTrieTest();
static IntlTest *createLocalPointerTest();
extern IntlTest *createUCharsTrieTest();
static IntlTest *createEnumSetTest();

#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;
        case 17:
            name = "BytesTrieTest";
            if (exec) {
                logln("TestSuite BytesTrieTest---"); logln();
                LocalPointer<IntlTest> test(createBytesTrieTest());
                callTest(*test, par);
            }
            break;
        case 18:
            name = "UCharsTrieTest";
            if (exec) {
                logln("TestSuite UCharsTrieTest---"); logln();
                LocalPointer<IntlTest> test(createUCharsTrieTest());
                callTest(*test, par);
            }
            break;
        case 19:
            name = "EnumSetTest";
            if (exec) {
                logln("TestSuite EnumSetTest---"); logln();
                LocalPointer<IntlTest> test(createEnumSetTest());
                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.logDataIfFailureAndReset("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_getNFCInstance(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 */

}

/** EnumSet test **/
#include "unicode/enumset.h"

class EnumSetTest : public IntlTest {
public:
  EnumSetTest() {}
  virtual void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL);
  void TestEnumSet();
};

static IntlTest *createEnumSetTest() {
    return new EnumSetTest();
}

void EnumSetTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
  TESTCASE_AUTO_BEGIN;
  TESTCASE_AUTO(TestEnumSet);
  TESTCASE_AUTO_END;
}
enum myEnum {
    MAX_NONBOOLEAN=-1,
    THING1,
    THING2,
    THING3,
    LIMIT_BOOLEAN
};

void EnumSetTest::TestEnumSet() {
    EnumSet<myEnum,
            MAX_NONBOOLEAN+1,
            LIMIT_BOOLEAN>
                            flags;

    logln("Enum is from [%d..%d]\n", MAX_NONBOOLEAN+1,
          LIMIT_BOOLEAN);

    TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);

    logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n",          flags.get(THING1),          flags.get(THING2),          flags.get(THING3));
    logln("Value now: %d\n", flags.getAll());
    flags.clear();
    logln("clear -Value now: %d\n", flags.getAll());
    logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n",          flags.get(THING1),          flags.get(THING2),          flags.get(THING3));
    TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
    flags.add(THING1);
    logln("set THING1 -Value now: %d\n", flags.getAll());
    TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
    TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
    logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n",          flags.get(THING1),          flags.get(THING2),          flags.get(THING3));
    flags.add(THING3);
    logln("set THING3 -Value now: %d\n", flags.getAll());
    TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
    TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
    logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n",          flags.get(THING1),          flags.get(THING2),          flags.get(THING3));
    flags.remove(THING2);
    TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
    TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
    logln("remove THING2 -Value now: %d\n", flags.getAll());
    logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n",          flags.get(THING1),          flags.get(THING2),          flags.get(THING3));
    flags.remove(THING1);
    TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
    logln("remove THING1 -Value now: %d\n", flags.getAll());
    logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n",          flags.get(THING1),          flags.get(THING2),          flags.get(THING3));

    flags.clear();
    logln("clear -Value now: %d\n", flags.getAll());
    logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n",          flags.get(THING1),          flags.get(THING2),          flags.get(THING3));
    TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
    TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
}
Commit	Line	Data
b75a7d8f A	1	/********************************************************************
b75a7d8f A	2	* COPYRIGHT:
51004dcb	3	* Copyright (c) 1997-2012, 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
4388f060	32	extern IntlTest *createBytesTrieTest();
729e4ab9	33	static IntlTest *createLocalPointerTest();
4388f060	34	extern IntlTest *createUCharsTrieTest();
51004dcb	35	static IntlTest *createEnumSetTest();
46f4442e A	36
	37	#define CASE(id, test) case id: \
	38	name = #test; \
	39	if (exec) { \
	40	logln(#test "---"); logln(); \
	41	test t; \
	42	callTest(t, par); \
	43	} \
	44	break
b75a7d8f A	45
	46	void IntlTestUtilities::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
	47	{
	48	if (exec) logln("TestSuite Utilities: ");
	49	switch (index) {
729e4ab9 A	50	CASE(0, MultithreadTest);
	51	CASE(1, StringTest);
	52	CASE(2, UnicodeStringTest);
	53	CASE(3, LocaleTest);
	54	CASE(4, CharIterTest);
	55	CASE(5, UObjectTest);
	56	CASE(6, UnicodeTest);
	57	CASE(7, ResourceBundleTest);
	58	CASE(8, NewResourceBundleTest);
	59	CASE(9, PUtilTest);
	60	CASE(10, UVector32Test);
	61	CASE(11, UVectorTest);
	62	CASE(12, UTextTest);
	63	CASE(13, LocaleAliasTest);
	64	CASE(14, UnicodeSetTest);
	65	CASE(15, ErrorCodeTest);
	66	case 16:
	67	name = "LocalPointerTest";
	68	if (exec) {
	69	logln("TestSuite LocalPointerTest---"); logln();
	70	LocalPointer<IntlTest> test(createLocalPointerTest());
	71	callTest(*test, par);
	72	}
	73	break;
4388f060 A	74	case 17:
	75	name = "BytesTrieTest";
	76	if (exec) {
	77	logln("TestSuite BytesTrieTest---"); logln();
	78	LocalPointer<IntlTest> test(createBytesTrieTest());
	79	callTest(*test, par);
	80	}
	81	break;
	82	case 18:
	83	name = "UCharsTrieTest";
	84	if (exec) {
	85	logln("TestSuite UCharsTrieTest---"); logln();
	86	LocalPointer<IntlTest> test(createUCharsTrieTest());
	87	callTest(*test, par);
	88	}
	89	break;
51004dcb A	90	case 19:
	91	name = "EnumSetTest";
	92	if (exec) {
	93	logln("TestSuite EnumSetTest---"); logln();
	94	LocalPointer<IntlTest> test(createEnumSetTest());
	95	callTest(*test, par);
	96	}
	97	break;
b75a7d8f A	98	default: name = ""; break; //needed to end loop
	99	}
	100	}
	101
729e4ab9 A	102	void ErrorCodeTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /par/) {
	103	if (exec) logln("TestSuite Utilities: ");
	104	switch (index) {
	105	case 0: name = "TestErrorCode"; if (exec) TestErrorCode(); break;
	106	case 1: name = "TestSubclass"; if (exec) TestSubclass(); break;
	107	default: name = ""; break; //needed to end loop
	108	}
	109	}
	110
	111	static void RefPlusOne(UErrorCode &code) { code=(UErrorCode)(code+1); }
	112	static void PtrPlusTwo(UErrorCode code) { code=(UErrorCode)(*code+2); }
	113
	114	void ErrorCodeTest::TestErrorCode() {
	115	ErrorCode errorCode;
	116	if(errorCode.get()!=U_ZERO_ERROR \|\| !errorCode.isSuccess() \|\| errorCode.isFailure()) {
	117	errln("ErrorCode did not initialize properly");
	118	return;
	119	}
	120	errorCode.assertSuccess();
	121	if(errorCode.errorName()!=u_errorName(U_ZERO_ERROR)) {
	122	errln("ErrorCode did not format error message string properly");
	123	}
	124	RefPlusOne(errorCode);
	125	if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
	126	errln("ErrorCode did not yield a writable reference");
	127	}
	128	PtrPlusTwo(errorCode);
	129	if(errorCode.get()!=U_INVALID_FORMAT_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
	130	errln("ErrorCode did not yield a writable pointer");
	131	}
	132	errorCode.set(U_PARSE_ERROR);
	133	if(errorCode.get()!=U_PARSE_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
	134	errln("ErrorCode.set() failed");
	135	}
	136	if( errorCode.reset()!=U_PARSE_ERROR \|\| errorCode.get()!=U_ZERO_ERROR \|\|
	137	!errorCode.isSuccess() \|\| errorCode.isFailure()
	138	) {
	139	errln("ErrorCode did not reset properly");
	140	}
	141	}
	142
	143	class MyErrorCode: public ErrorCode {
	144	public:
	145	MyErrorCode(int32_t &countChecks, int32_t &countDests)
	146	: checks(countChecks), dests(countDests) {}
	147	~MyErrorCode() {
	148	if(isFailure()) {
	149	++dests;
	150	}
	151	}
	152	private:
	153	virtual void handleFailure() const {
	154	++checks;
	155	}
	156	int32_t &checks;
	157	int32_t &dests;
	158	};
	159
	160	void ErrorCodeTest::TestSubclass() {
	161	int32_t countChecks=0;
	162	int32_t countDests=0;
	163	{
	164	MyErrorCode errorCode(countChecks, countDests);
	165	if( errorCode.get()!=U_ZERO_ERROR \|\| !errorCode.isSuccess() \|\| errorCode.isFailure() \|\|
166	countChecks!=0 \|\| countDests!=0
167	) {
168	errln("ErrorCode did not initialize properly");
169	return;
170	}
171	errorCode.assertSuccess();
172	if(countChecks!=0) {
173	errln("ErrorCode.assertSuccess() called handleFailure() despite success");
174	}
175	RefPlusOne(errorCode);
176	if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
177	errln("ErrorCode did not yield a writable reference");
178	}
179	errorCode.assertSuccess();
180	if(countChecks!=1) {
181	errln("ErrorCode.assertSuccess() did not handleFailure()");
182	}
183	PtrPlusTwo(errorCode);
184	if(errorCode.get()!=U_INVALID_FORMAT_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
185	errln("ErrorCode did not yield a writable pointer");
186	}
187	errorCode.assertSuccess();
188	if(countChecks!=2) {
189	errln("ErrorCode.assertSuccess() did not handleFailure()");
190	}
191	errorCode.set(U_PARSE_ERROR);
192	if(errorCode.get()!=U_PARSE_ERROR \|\| errorCode.isSuccess() \|\| !errorCode.isFailure()) {
193	errln("ErrorCode.set() failed");
194	}
195	if( errorCode.reset()!=U_PARSE_ERROR \|\| errorCode.get()!=U_ZERO_ERROR \|\|
196	!errorCode.isSuccess() \|\| errorCode.isFailure()
197	) {
198	errln("ErrorCode did not reset properly");
199	}
200	errorCode.assertSuccess();
201	if(countChecks!=2) {
202	errln("ErrorCode.assertSuccess() called handleFailure() despite success");
203	}
204	}
205	if(countDests!=0) {
206	errln("MyErrorCode destructor detected failure despite success");
207	}
208	countChecks=countDests=0;
209	{
210	MyErrorCode errorCode(countChecks, countDests);
211	errorCode.set(U_PARSE_ERROR);
212	}
213	if(countDests!=1) {
214	errln("MyErrorCode destructor failed to detect failure");
215	}
216	}
217
218	class LocalPointerTest : public IntlTest {
219	public:
220	LocalPointerTest() {}
221
222	void runIndexedTest(int32_t index, UBool exec, const char &name, char par=NULL);
223
224	void TestLocalPointer();
225	void TestLocalArray();
226	void TestLocalXyzPointer();
227	void TestLocalXyzPointerNull();
228	};
229
230	static IntlTest *createLocalPointerTest() {
231	return new LocalPointerTest();
232	}
233
234	void LocalPointerTest::runIndexedTest(int32_t index, UBool exec, const char &name, char /par/) {
235	if(exec) {
236	logln("TestSuite LocalPointerTest: ");
237	}
238	switch (index) {
239	TESTCASE(0, TestLocalPointer);
240	TESTCASE(1, TestLocalArray);
241	TESTCASE(2, TestLocalXyzPointer);
242	TESTCASE(3, TestLocalXyzPointerNull);
243	default:
244	name="";
245	break; // needed to end the loop
246	}
247	}
248
249	// Exercise every LocalPointer and LocalPointerBase method.
250	void LocalPointerTest::TestLocalPointer() {
251	// constructor
252	LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
253	// isNULL(), isValid(), operator==(), operator!=()
254	if(s.isNull() \|\| !s.isValid() \|\| s==NULL \|\| !(s!=NULL)) {
255	errln("LocalPointer constructor or NULL test failure");
256	return;
257	}
258	// getAlias(), operator->, operator*
259	if(s.getAlias()->length()!=2 \|\| s->length()!=2 \|\| (*s).length()!=2) {
260	errln("LocalPointer access failure");
261	}
262	// adoptInstead(), orphan()
263	s.adoptInstead(new UnicodeString((UChar)0xfffc));
264	if(s->length()!=1) {
265	errln("LocalPointer adoptInstead(U+FFFC) failure");
266	}
267	UnicodeString *orphan=s.orphan();
268	if(orphan==NULL \|\| orphan->length()!=1 \|\| s.isValid() \|\| s!=NULL) {
269	errln("LocalPointer orphan() failure");
270	}
271	delete orphan;
272	// destructor
273	s.adoptInstead(new UnicodeString());
274	if(s->length()!=0) {
275	errln("LocalPointer adoptInstead(empty) failure");
276	}
277	}
278
279	// Exercise every LocalArray method (but not LocalPointerBase).
280	void LocalPointerTest::TestLocalArray() {
281	// constructor
282	LocalArray<UnicodeString> a(new UnicodeString[2]);
283	// operator[]()
284	a[0].append((UChar)0x61);
285	a[1].append((UChar32)0x60006);
286	if(a[0].length()!=1 \|\| a[1].length()!=2) {
287	errln("LocalArray access failure");
288	}
289	// adoptInstead()
290	a.adoptInstead(new UnicodeString[4]);
291	a[3].append((UChar)0x62).append((UChar)0x63).reverse();
292	if(a[3].length()!=2 \|\| a[3][1]!=0x62) {
293	errln("LocalArray adoptInstead() failure");
294	}
295	// destructor
296	}
297
298	#include "unicode/ucnvsel.h"
299	#include "unicode/ucal.h"
300	#include "unicode/udatpg.h"
301	#include "unicode/uidna.h"
302	#include "unicode/uldnames.h"
303	#include "unicode/umsg.h"
304	#include "unicode/unorm2.h"
305	#include "unicode/uregex.h"
306	#include "unicode/utrans.h"
307
308	// Use LocalXyzPointer types that are not covered elsewhere in the intltest suite.
309	void LocalPointerTest::TestLocalXyzPointer() {
310	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointer");
311
312	static const char *const encoding="ISO-8859-1";
313	LocalUConverterSelectorPointer sel(
314	ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
315	if(errorCode.logIfFailureAndReset("ucnvsel_open()")) {
316	return;
317	}
318	if(sel.isNull()) {
319	errln("LocalUConverterSelectorPointer failure");
320	return;
321	}
322
323	#if !UCONFIG_NO_FORMATTING
324	LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
325	if(errorCode.logDataIfFailureAndReset("ucal_open()")) {
326	return;
327	}
328	if(cal.isNull()) {
329	errln("LocalUCalendarPointer failure");
330	return;
331	}
332
333	LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
4388f060	334	if(errorCode.logDataIfFailureAndReset("udatpg_open()")) {
729e4ab9 A	335	return;
	336	}
	337	if(patgen.isNull()) {
	338	errln("LocalUDateTimePatternGeneratorPointer failure");
	339	return;
	340	}
	341
	342	LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode));
	343	if(errorCode.logIfFailureAndReset("uldn_open()")) {
	344	return;
	345	}
	346	if(ldn.isNull()) {
	347	errln("LocalULocaleDisplayNamesPointer failure");
	348	return;
	349	}
	350
	351	UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
	352	LocalUMessageFormatPointer msg(
	353	umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
	354	if(errorCode.logIfFailureAndReset("umsg_open()")) {
	355	return;
	356	}
	357	if(msg.isNull()) {
	358	errln("LocalUMessageFormatPointer failure");
	359	return;
	360	}
	361	#endif /* UCONFIG_NO_FORMATTING */
	362
	363	#if !UCONFIG_NO_NORMALIZATION
4388f060	364	const UNormalizer2 *nfc=unorm2_getNFCInstance(errorCode);
729e4ab9 A	365	UnicodeSet emptySet;
	366	LocalUNormalizer2Pointer fn2(unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode));
	367	if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) {
	368	return;
	369	}
	370	if(fn2.isNull()) {
	371	errln("LocalUNormalizer2Pointer failure");
	372	return;
	373	}
	374	#endif /* !UCONFIG_NO_NORMALIZATION */
	375
	376	#if !UCONFIG_NO_IDNA
	377	LocalUIDNAPointer idna(uidna_openUTS46(0, errorCode));
	378	if(errorCode.logIfFailureAndReset("uidna_openUTS46()")) {
	379	return;
	380	}
	381	if(idna.isNull()) {
	382	errln("LocalUIDNAPointer failure");
	383	return;
	384	}
	385	#endif /* !UCONFIG_NO_IDNA */
	386
	387	#if !UCONFIG_NO_REGULAR_EXPRESSIONS
	388	UnicodeString pattern=UNICODE_STRING_SIMPLE("abc\|xy+z");
	389	LocalURegularExpressionPointer regex(
	390	uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
	391	if(errorCode.logIfFailureAndReset("uregex_open()")) {
	392	return;
	393	}
	394	if(regex.isNull()) {
	395	errln("LocalURegularExpressionPointer failure");
	396	return;
	397	}
	398	#endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
	399
	400	#if !UCONFIG_NO_TRANSLITERATION
	401	UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
	402	LocalUTransliteratorPointer trans(
	403	utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
	404	if(errorCode.logIfFailureAndReset("utrans_open()")) {
	405	return;
	406	}
	407	if(trans.isNull()) {
	408	errln("LocalUTransliteratorPointer failure");
	409	return;
	410	}
	411	#endif /* !UCONFIG_NO_TRANSLITERATION */
	412
	413	// destructors
	414	}
	415
	416	// Try LocalXyzPointer types with NULL pointers.
	417	void LocalPointerTest::TestLocalXyzPointerNull() {
	418	{
	419	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUConverterSelectorPointer");
	420	static const char *const encoding="ISO-8859-1";
	421	LocalUConverterSelectorPointer null;
	422	LocalUConverterSelectorPointer sel(
	423	ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
	424	sel.adoptInstead(NULL);
	425	}
	426	#if !UCONFIG_NO_FORMATTING
	427	{
	428	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUCalendarPointer");
429	LocalUCalendarPointer null;
430	LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
431	if(!errorCode.logDataIfFailureAndReset("ucal_open()")) {
432	cal.adoptInstead(NULL);
433	}
434	}
435	{
436	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUDateTimePatternGeneratorPointer");
437	LocalUDateTimePatternGeneratorPointer null;
438	LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
439	patgen.adoptInstead(NULL);
440	}
441	{
442	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUMessageFormatPointer");
443	UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
444	LocalUMessageFormatPointer null;
445	LocalUMessageFormatPointer msg(
446	umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
447	msg.adoptInstead(NULL);
448	}
449	#endif /* !UCONFIG_NO_FORMATTING */
450
451	#if !UCONFIG_NO_REGULAR_EXPRESSIONS
452	{
453	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalURegularExpressionPointer");
454	UnicodeString pattern=UNICODE_STRING_SIMPLE("abc\|xy+z");
455	LocalURegularExpressionPointer null;
456	LocalURegularExpressionPointer regex(
457	uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
458	if(!errorCode.logDataIfFailureAndReset("urege_open()")) {
459	regex.adoptInstead(NULL);
460	}
461	}
462	#endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
463
464	#if !UCONFIG_NO_TRANSLITERATION
465	{
466	IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUTransliteratorPointer");
467	UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
468	LocalUTransliteratorPointer null;
469	LocalUTransliteratorPointer trans(
470	utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
471	if(!errorCode.logDataIfFailureAndReset("utrans_openU()")) {
472	trans.adoptInstead(NULL);
473	}
474	}
475	#endif /* !UCONFIG_NO_TRANSLITERATION */
476
477	}
51004dcb A	478
	479	/ EnumSet test /
	480	#include "unicode/enumset.h"
	481
	482	class EnumSetTest : public IntlTest {
	483	public:
	484	EnumSetTest() {}
	485	virtual void runIndexedTest(int32_t index, UBool exec, const char &name, char par=NULL);
	486	void TestEnumSet();
	487	};
	488
	489	static IntlTest *createEnumSetTest() {
	490	return new EnumSetTest();
	491	}
	492
	493	void EnumSetTest::runIndexedTest(int32_t index, UBool exec, const char &name, char /par/) {
	494	TESTCASE_AUTO_BEGIN;
	495	TESTCASE_AUTO(TestEnumSet);
	496	TESTCASE_AUTO_END;
	497	}
	498	enum myEnum {
	499	MAX_NONBOOLEAN=-1,
	500	THING1,
	501	THING2,
	502	THING3,
	503	LIMIT_BOOLEAN
	504	};
	505
	506	void EnumSetTest::TestEnumSet() {
	507	EnumSet<myEnum,
	508	MAX_NONBOOLEAN+1,
	509	LIMIT_BOOLEAN>
	510	flags;
	511
	512	logln("Enum is from [%d..%d]\n", MAX_NONBOOLEAN+1,
	513	LIMIT_BOOLEAN);
	514
	515	TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
	516	TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
	517	TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
	518
	519	logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
	520	logln("Value now: %d\n", flags.getAll());
	521	flags.clear();
	522	logln("clear -Value now: %d\n", flags.getAll());
	523	logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
	524	TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
	525	TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
	526	TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
	527	flags.add(THING1);
	528	logln("set THING1 -Value now: %d\n", flags.getAll());
	529	TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
	530	TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
	531	TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
	532	logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
	533	flags.add(THING3);
	534	logln("set THING3 -Value now: %d\n", flags.getAll());
	535	TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
	536	TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
	537	TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
	538	logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
	539	flags.remove(THING2);
	540	TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
	541	TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
542	TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
543	logln("remove THING2 -Value now: %d\n", flags.getAll());
544	logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
545	flags.remove(THING1);
546	TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
547	TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
548	TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
549	logln("remove THING1 -Value now: %d\n", flags.getAll());
550	logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
551
552	flags.clear();
553	logln("clear -Value now: %d\n", flags.getAll());
554	logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
555	TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
556	TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
557	TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
558	}