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

/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2014, 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();
extern IntlTest *createLRUCacheTest();
extern IntlTest *createSimplePatternFormatterTest();

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