X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/b75a7d8f3b4adbae880cab104ce2c6a50eee4db2..refs/heads/master:/icuSources/test/intltest/itutil.cpp diff --git a/icuSources/test/intltest/itutil.cpp b/icuSources/test/intltest/itutil.cpp index 84683827..228dbf2f 100644 --- a/icuSources/test/intltest/itutil.cpp +++ b/icuSources/test/intltest/itutil.cpp @@ -1,184 +1,907 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html /******************************************************************** * COPYRIGHT: - * Copyright (c) 1997-2003, International Business Machines Corporation and + * Copyright (c) 1997-2016, International Business Machines Corporation and * others. All Rights Reserved. ********************************************************************/ +#include /** * 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 "charstr.h" #include "itutil.h" #include "strtest.h" #include "loctest.h" +#include "localebuildertest.h" #include "citrtest.h" #include "ustrtest.h" #include "ucdtest.h" #include "restest.h" #include "restsnew.h" -#include "tsmutex.h" #include "tsmthred.h" #include "tsputil.h" #include "uobjtest.h" -//#include "custrtest.h" -//#include "ccitrtst.h" -//#include "cloctest.h" -//#include "ctres.h" -//#include "ctucd.h" +#include "utxttest.h" +#include "v32test.h" +#include "uvectest.h" +#include "aliastst.h" +#include "usettest.h" + +extern IntlTest *createBytesTrieTest(); +extern IntlTest *createLocaleMatcherTest(); +static IntlTest *createLocalPointerTest(); +extern IntlTest *createUCharsTrieTest(); +static IntlTest *createEnumSetTest(); +extern IntlTest *createSimpleFormatterTest(); +extern IntlTest *createUnifiedCacheTest(); +extern IntlTest *createQuantityFormatterTest(); +extern IntlTest *createPluralMapTest(); +#if !UCONFIG_NO_FORMATTING +extern IntlTest *createStaticUnicodeSetsTest(); +#endif void IntlTestUtilities::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par ) { + if (exec) logln("TestSuite Utilities: "); + TESTCASE_AUTO_BEGIN; + TESTCASE_AUTO_CLASS(MultithreadTest); + TESTCASE_AUTO_CLASS(StringTest); + TESTCASE_AUTO_CLASS(UnicodeStringTest); + TESTCASE_AUTO_CLASS(LocaleTest); + TESTCASE_AUTO_CLASS(CharIterTest); + TESTCASE_AUTO_CLASS(UObjectTest); + TESTCASE_AUTO_CLASS(UnicodeTest); + TESTCASE_AUTO_CLASS(ResourceBundleTest); + TESTCASE_AUTO_CLASS(NewResourceBundleTest); + TESTCASE_AUTO_CLASS(PUtilTest); + TESTCASE_AUTO_CLASS(UVector32Test); + TESTCASE_AUTO_CLASS(UVectorTest); + TESTCASE_AUTO_CLASS(UTextTest); + TESTCASE_AUTO_CLASS(LocaleAliasTest); + TESTCASE_AUTO_CLASS(UnicodeSetTest); + TESTCASE_AUTO_CLASS(ErrorCodeTest); + TESTCASE_AUTO_CREATE_CLASS(LocalPointerTest); + TESTCASE_AUTO_CREATE_CLASS(BytesTrieTest); + TESTCASE_AUTO_CREATE_CLASS(UCharsTrieTest); + TESTCASE_AUTO_CREATE_CLASS(EnumSetTest); + TESTCASE_AUTO_CREATE_CLASS(SimpleFormatterTest); + TESTCASE_AUTO_CREATE_CLASS(UnifiedCacheTest); + TESTCASE_AUTO_CREATE_CLASS(QuantityFormatterTest); + TESTCASE_AUTO_CREATE_CLASS(PluralMapTest); +#if !UCONFIG_NO_FORMATTING + TESTCASE_AUTO_CREATE_CLASS(StaticUnicodeSetsTest); +#endif + TESTCASE_AUTO_CLASS(LocaleBuilderTest); + TESTCASE_AUTO_CREATE_CLASS(LocaleMatcherTest); + TESTCASE_AUTO_END; +} + +void ErrorCodeTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) { if (exec) logln("TestSuite Utilities: "); switch (index) { - case 0: - name = "MutexTest"; - if (exec) { - logln("MutexTest---"); logln(""); - MutexTest test; - callTest( test, par ); - } - break; - - case 1: - name = "MultithreadTest"; - if (exec) { - logln("MultithreadTest---"); logln(""); - MultithreadTest test; - callTest( test, par ); - } - break; - - case 2: - name = "StringTest"; - if (exec) { - logln("StringTest---"); logln(""); - StringTest test; - callTest( test, par ); - } - break; - - case 3: - name = "UnicodeStringTest"; - if (exec) { - logln("UnicodeStringTest---"); logln(""); - UnicodeStringTest test; - callTest( test, par ); - } - break; - - case 4: - name = "LocaleTest"; - if (exec) { - logln("LocaleTest---"); logln(""); - LocaleTest test; - callTest( test, par ); - } - break; - - case 5: - name = "CharIterTest"; - if (exec) { - logln("CharIterTest---"); logln(""); - CharIterTest test; - callTest( test, par ); - } - break; - - case 6: - name = "UnicodeTest"; - if (exec) { - logln("UnicodeTest---"); logln(""); - UnicodeTest test; - callTest( test, par ); - } - break; - - case 7: - name = "ResourceBundleTest"; - if (exec) { - logln("ResourceBundleTest---"); logln(""); - ResourceBundleTest test; - callTest( test, par ); - } - break; - case 8: - name = "NewResourceBundleTest"; - if (exec) { - logln("NewResourceBundleTest---"); logln(""); - NewResourceBundleTest test; - callTest( test, par ); - } - break; - - case 9: - name = "PUtilTest"; - if (exec) { - logln("PUtilTest---"); logln(""); - PUtilTest test; - callTest( test, par ); - } - break; - - case 10: - name = "UObjectTest"; - if(exec) { - logln ("UObjectTest---"); logln(""); - UObjectTest test; - callTest( test, par ); - } - break;; - - /* - case 8: - name = "LocaleTest"; - if (exec) { - logln("LocaleTest---"); logln(""); - CLocaleTest test; - callTest( test, par ); - } - break; - - - case 9: - name = "UnicodeStringCAPI"; - if (exec) { - logln("UnicodeString C Round Trip test---"); logln(""); - CUnicodeStringTest test; - callTest(test, par); - } - break; - - case 10: - name = "CharacterIteratorCAPI"; - if (exec) { - logln("CharacterIterator C Round Trip test---"); logln(""); - CCharIterTest test; - callTest(test, par); - } - break; - - - case 11: - name = "UnicodeCAPI"; - if (exec) { - logln("Unicode C-API test---"); logln(); - TestCwrapperUnicode test; - callTest(test, par); - } - break; - - case 12: - name = "ResourceBundleCAPI"; - if (exec) { - logln("ResourceBundle C-API test---"); logln(); - TestCwrapperResourceBundle test; - callTest(test, par); - } - break; - */ + case 0: name = "TestErrorCode"; if (exec) TestErrorCode(); break; + case 1: name = "TestSubclass"; if (exec) TestSubclass(); break; + case 2: name = "TestIcuTestErrorCode"; if (exec) TestIcuTestErrorCode(); 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 IcuTestErrorCodeTestHelper : public IntlTest { + public: + void errln( const UnicodeString &message ) U_OVERRIDE { + test->assertFalse("Already saw an error", seenError); + seenError = TRUE; + test->assertEquals("Message for Error", expectedErrln, message); + if (expectedDataErr) { + test->errln("Got non-data error, but expected data error"); + } + } + + void dataerrln( const UnicodeString &message ) U_OVERRIDE { + test->assertFalse("Already saw an error", seenError); + seenError = TRUE; + test->assertEquals("Message for Error", expectedErrln, message); + if (!expectedDataErr) { + test->errln("Got data error, but expected non-data error"); + } + } + + IntlTest* test; + UBool expectedDataErr; + UnicodeString expectedErrln; + UBool seenError; +}; + +void ErrorCodeTest::TestIcuTestErrorCode() { + IcuTestErrorCodeTestHelper helper; + helper.test = this; + + // Test destructor message + helper.expectedErrln = u"AAA destructor: expected success but got error: U_ILLEGAL_PAD_POSITION"; + helper.expectedDataErr = FALSE; + helper.seenError = FALSE; + { + IcuTestErrorCode testStatus(helper, "AAA"); + testStatus.set(U_ILLEGAL_PAD_POSITION); + } + assertTrue("Should have seen an error", helper.seenError); + + // Test destructor message with scope + helper.expectedErrln = u"BBB destructor: expected success but got error: U_ILLEGAL_PAD_POSITION scope: foo"; + helper.expectedDataErr = FALSE; + helper.seenError = FALSE; + { + IcuTestErrorCode testStatus(helper, "BBB"); + testStatus.setScope("foo"); + testStatus.set(U_ILLEGAL_PAD_POSITION); + } + assertTrue("Should have seen an error", helper.seenError); + + // Check errIfFailure message with scope + helper.expectedErrln = u"CCC expected success but got error: U_ILLEGAL_PAD_POSITION scope: foo"; + helper.expectedDataErr = FALSE; + helper.seenError = FALSE; + { + IcuTestErrorCode testStatus(helper, "CCC"); + testStatus.setScope("foo"); + testStatus.set(U_ILLEGAL_PAD_POSITION); + testStatus.errIfFailureAndReset(); + assertTrue("Should have seen an error", helper.seenError); + helper.seenError = FALSE; + helper.expectedErrln = u"CCC expected success but got error: U_ILLEGAL_CHAR_FOUND scope: foo - 5.4300"; + testStatus.set(U_ILLEGAL_CHAR_FOUND); + testStatus.errIfFailureAndReset("%6.4f", 5.43); + assertTrue("Should have seen an error", helper.seenError); + } + + // Check errDataIfFailure message without scope + helper.expectedErrln = u"DDD data: expected success but got error: U_ILLEGAL_PAD_POSITION"; + helper.expectedDataErr = TRUE; + helper.seenError = FALSE; + { + IcuTestErrorCode testStatus(helper, "DDD"); + testStatus.set(U_ILLEGAL_PAD_POSITION); + testStatus.errDataIfFailureAndReset(); + assertTrue("Should have seen an error", helper.seenError); + helper.seenError = FALSE; + helper.expectedErrln = u"DDD data: expected success but got error: U_ILLEGAL_CHAR_FOUND - 5.4300"; + testStatus.set(U_ILLEGAL_CHAR_FOUND); + testStatus.errDataIfFailureAndReset("%6.4f", 5.43); + assertTrue("Should have seen an error", helper.seenError); + } + + // Check expectFailure + helper.expectedErrln = u"EEE expected: U_ILLEGAL_CHAR_FOUND but got error: U_ILLEGAL_PAD_POSITION"; + helper.expectedDataErr = FALSE; + helper.seenError = FALSE; + { + IcuTestErrorCode testStatus(helper, "EEE"); + testStatus.set(U_ILLEGAL_PAD_POSITION); + testStatus.expectErrorAndReset(U_ILLEGAL_PAD_POSITION); + assertFalse("Should NOT have seen an error", helper.seenError); + testStatus.set(U_ILLEGAL_PAD_POSITION); + testStatus.expectErrorAndReset(U_ILLEGAL_CHAR_FOUND); + assertTrue("Should have seen an error", helper.seenError); + helper.seenError = FALSE; + helper.expectedErrln = u"EEE expected: U_ILLEGAL_CHAR_FOUND but got error: U_ZERO_ERROR scope: scopety scope - 5.4300"; + testStatus.setScope("scopety scope"); + testStatus.set(U_ILLEGAL_PAD_POSITION); + testStatus.expectErrorAndReset(U_ILLEGAL_PAD_POSITION, "%6.4f", 5.43); + assertFalse("Should NOT have seen an error", helper.seenError); + testStatus.expectErrorAndReset(U_ILLEGAL_CHAR_FOUND, "%6.4f", 5.43); + assertTrue("Should have seen an error", helper.seenError); + } +} + + +class LocalPointerTest : public IntlTest { +public: + LocalPointerTest() {} + + void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL); + + void TestLocalPointer(); + void TestLocalPointerMoveSwap(); + void TestLocalPointerStdUniquePtr(); + void TestLocalArray(); + void TestLocalArrayMoveSwap(); + void TestLocalArrayStdUniquePtr(); + void TestLocalXyzPointer(); + void TestLocalXyzPointerMoveSwap(); + void TestLocalXyzPointerNull(); + void TestLocalXyzStdUniquePtr(); +}; + +static IntlTest *createLocalPointerTest() { + return new LocalPointerTest(); +} + +void LocalPointerTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) { + if(exec) { + logln("TestSuite LocalPointerTest: "); + } + TESTCASE_AUTO_BEGIN; + TESTCASE_AUTO(TestLocalPointer); + TESTCASE_AUTO(TestLocalPointerMoveSwap); + TESTCASE_AUTO(TestLocalPointerStdUniquePtr); + TESTCASE_AUTO(TestLocalArray); + TESTCASE_AUTO(TestLocalArrayMoveSwap); + TESTCASE_AUTO(TestLocalArrayStdUniquePtr); + TESTCASE_AUTO(TestLocalXyzPointer); + TESTCASE_AUTO(TestLocalXyzPointerMoveSwap); + TESTCASE_AUTO(TestLocalXyzPointerNull); + TESTCASE_AUTO(TestLocalXyzStdUniquePtr); + TESTCASE_AUTO_END; +} + +// Exercise almost every LocalPointer and LocalPointerBase method. +void LocalPointerTest::TestLocalPointer() { + // constructor + LocalPointer 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; + s.adoptInstead(new UnicodeString()); + if(s->length()!=0) { + errln("LocalPointer adoptInstead(empty) failure"); + } + + // LocalPointer(p, errorCode) sets U_MEMORY_ALLOCATION_ERROR if p==NULL. + UErrorCode errorCode = U_ZERO_ERROR; + LocalPointer csx(new CharString("some chars", errorCode), errorCode); + if(csx.isNull() && U_SUCCESS(errorCode)) { + errln("LocalPointer(p, errorCode) failure"); + return; + } + errorCode = U_ZERO_ERROR; + csx.adoptInsteadAndCheckErrorCode(new CharString("different chars", errorCode), errorCode); + if(csx.isNull() && U_SUCCESS(errorCode)) { + errln("adoptInsteadAndCheckErrorCode(p, errorCode) failure"); + return; + } + // Incoming failure: Keep the current object and delete the input object. + errorCode = U_ILLEGAL_ARGUMENT_ERROR; + csx.adoptInsteadAndCheckErrorCode(new CharString("unused", errorCode), errorCode); + if(csx.isValid() && strcmp(csx->data(), "different chars") != 0) { + errln("adoptInsteadAndCheckErrorCode(p, U_FAILURE) did not retain the old object"); + return; + } + errorCode = U_ZERO_ERROR; + csx.adoptInsteadAndCheckErrorCode(NULL, errorCode); + if(errorCode != U_MEMORY_ALLOCATION_ERROR) { + errln("adoptInsteadAndCheckErrorCode(NULL, errorCode) did not set U_MEMORY_ALLOCATION_ERROR"); + return; + } + if(csx.isValid()) { + errln("adoptInsteadAndCheckErrorCode(NULL, errorCode) kept the object"); + return; + } + errorCode = U_ZERO_ERROR; + LocalPointer null(NULL, errorCode); + if(errorCode != U_MEMORY_ALLOCATION_ERROR) { + errln("LocalPointer(NULL, errorCode) did not set U_MEMORY_ALLOCATION_ERROR"); + return; + } + + // destructor +} + +// Try to avoid clang -Wself-move warnings from s1 = std::move(s1); +template +void moveFrom(T &dest, T &src) { + dest = std::move(src); +} + +void LocalPointerTest::TestLocalPointerMoveSwap() { + UnicodeString *p1 = new UnicodeString((UChar)0x61); + UnicodeString *p2 = new UnicodeString((UChar)0x62); + LocalPointer s1(p1); + LocalPointer s2(p2); + s1.swap(s2); + if(s1.getAlias() != p2 || s2.getAlias() != p1) { + errln("LocalPointer.swap() did not swap"); + } + swap(s1, s2); + if(s1.getAlias() != p1 || s2.getAlias() != p2) { + errln("swap(LocalPointer) did not swap back"); + } + LocalPointer s3; + s3 = std::move(s1); + if(s3.getAlias() != p1 || s1.isValid()) { + errln("LocalPointer = std::move() did not move"); + } + infoln("TestLocalPointerMoveSwap() with rvalue references"); + s1 = static_cast &&>(s3); + if(s1.getAlias() != p1 || s3.isValid()) { + errln("LocalPointer move assignment operator did not move"); + } + LocalPointer s4(static_cast &&>(s2)); + if(s4.getAlias() != p2 || s2.isValid()) { + errln("LocalPointer move constructor did not move"); + } + + // Move self assignment leaves the object valid but in an undefined state. + // Do it to make sure there is no crash, + // but do not check for any particular resulting value. + moveFrom(s1, s1); + moveFrom(s3, s3); +} + +void LocalPointerTest::TestLocalPointerStdUniquePtr() { + auto* ptr = new UnicodeString((UChar32)0x50005); + // Implicit conversion operator + std::unique_ptr s = LocalPointer(ptr); + // Explicit move constructor + LocalPointer s2(std::move(s)); + // Conversion operator should also work with std::move + s = std::move(s2); + // Back again with move assignment + s2 = std::move(s); + assertTrue("Pointer should remain the same", ptr == s2.getAlias()); +} + +// Exercise almost every LocalArray method (but not LocalPointerBase). +void LocalPointerTest::TestLocalArray() { + // constructor + LocalArray 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"); + } + + // LocalArray(p, errorCode) sets U_MEMORY_ALLOCATION_ERROR if p==NULL. + UErrorCode errorCode = U_ZERO_ERROR; + LocalArray ua(new UnicodeString[3], errorCode); + if(ua.isNull() && U_SUCCESS(errorCode)) { + errln("LocalArray(p, errorCode) failure"); + return; + } + errorCode = U_ZERO_ERROR; + UnicodeString *u4 = new UnicodeString[4]; + ua.adoptInsteadAndCheckErrorCode(u4, errorCode); + if(ua.isNull() && U_SUCCESS(errorCode)) { + errln("adoptInsteadAndCheckErrorCode(p, errorCode) failure"); + return; + } + // Incoming failure: Keep the current object and delete the input object. + errorCode = U_ILLEGAL_ARGUMENT_ERROR; + ua.adoptInsteadAndCheckErrorCode(new UnicodeString[5], errorCode); + if(ua.isValid() && ua.getAlias() != u4) { + errln("adoptInsteadAndCheckErrorCode(p, U_FAILURE) did not retain the old array"); + return; + } + errorCode = U_ZERO_ERROR; + ua.adoptInsteadAndCheckErrorCode(NULL, errorCode); + if(errorCode != U_MEMORY_ALLOCATION_ERROR) { + errln("adoptInsteadAndCheckErrorCode(NULL, errorCode) did not set U_MEMORY_ALLOCATION_ERROR"); + return; + } + if(ua.isValid()) { + errln("adoptInsteadAndCheckErrorCode(NULL, errorCode) kept the array"); + return; + } + errorCode = U_ZERO_ERROR; + LocalArray null(NULL, errorCode); + if(errorCode != U_MEMORY_ALLOCATION_ERROR) { + errln("LocalArray(NULL, errorCode) did not set U_MEMORY_ALLOCATION_ERROR"); + return; + } + + // destructor +} + +void LocalPointerTest::TestLocalArrayMoveSwap() { + UnicodeString *p1 = new UnicodeString[2]; + UnicodeString *p2 = new UnicodeString[3]; + LocalArray a1(p1); + LocalArray a2(p2); + a1.swap(a2); + if(a1.getAlias() != p2 || a2.getAlias() != p1) { + errln("LocalArray.swap() did not swap"); + } + swap(a1, a2); + if(a1.getAlias() != p1 || a2.getAlias() != p2) { + errln("swap(LocalArray) did not swap back"); + } + LocalArray a3; + a3 = std::move(a1); + if(a3.getAlias() != p1 || a1.isValid()) { + errln("LocalArray = std::move() did not move"); + } + infoln("TestLocalArrayMoveSwap() with rvalue references"); + a1 = static_cast &&>(a3); + if(a1.getAlias() != p1 || a3.isValid()) { + errln("LocalArray move assignment operator did not move"); + } + LocalArray a4(static_cast &&>(a2)); + if(a4.getAlias() != p2 || a2.isValid()) { + errln("LocalArray move constructor did not move"); + } + + // Move self assignment leaves the object valid but in an undefined state. + // Do it to make sure there is no crash, + // but do not check for any particular resulting value. + moveFrom(a1, a1); + moveFrom(a3, a3); +} + +void LocalPointerTest::TestLocalArrayStdUniquePtr() { + auto* ptr = new UnicodeString[2]; + // Implicit conversion operator + std::unique_ptr a = LocalArray(ptr); + // Explicit move constructor + LocalArray a2(std::move(a)); + // Conversion operator should also work with std::move + a = std::move(a2); + // Back again with move assignment + a2 = std::move(a); + assertTrue("Pointer should remain the same", ptr == a2.getAlias()); +} + +#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" +#include "unicode/uformattedvalue.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.errIfFailureAndReset("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.errDataIfFailureAndReset("ucal_open()")) { + return; + } + if(cal.isNull()) { + errln("LocalUCalendarPointer failure"); + return; + } + + LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode)); + if(errorCode.errDataIfFailureAndReset("udatpg_open()")) { + return; + } + if(patgen.isNull()) { + errln("LocalUDateTimePatternGeneratorPointer failure"); + return; + } + + LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode)); + if(errorCode.errIfFailureAndReset("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.errIfFailureAndReset("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.errIfFailureAndReset("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.errIfFailureAndReset("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.errIfFailureAndReset("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.errIfFailureAndReset("utrans_open()")) { + return; + } + if(trans.isNull()) { + errln("LocalUTransliteratorPointer failure"); + return; + } +#endif /* !UCONFIG_NO_TRANSLITERATION */ + + // destructors +} + +void LocalPointerTest::TestLocalXyzPointerMoveSwap() { +#if !UCONFIG_NO_NORMALIZATION + IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerMoveSwap"); + const UNormalizer2 *nfc=unorm2_getNFCInstance(errorCode); + const UNormalizer2 *nfd=unorm2_getNFDInstance(errorCode); + if(errorCode.errIfFailureAndReset("unorm2_getNF[CD]Instance()")) { + return; + } + UnicodeSet emptySet; + UNormalizer2 *p1 = unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode); + UNormalizer2 *p2 = unorm2_openFiltered(nfd, emptySet.toUSet(), errorCode); + LocalUNormalizer2Pointer f1(p1); + LocalUNormalizer2Pointer f2(p2); + if(errorCode.errIfFailureAndReset("unorm2_openFiltered()")) { + return; + } + if(f1.isNull() || f2.isNull()) { + errln("LocalUNormalizer2Pointer failure"); + return; + } + f1.swap(f2); + if(f1.getAlias() != p2 || f2.getAlias() != p1) { + errln("LocalUNormalizer2Pointer.swap() did not swap"); + } + swap(f1, f2); + if(f1.getAlias() != p1 || f2.getAlias() != p2) { + errln("swap(LocalUNormalizer2Pointer) did not swap back"); + } + LocalUNormalizer2Pointer f3; + f3 = std::move(f1); + if(f3.getAlias() != p1 || f1.isValid()) { + errln("LocalUNormalizer2Pointer = std::move() did not move"); + } + infoln("TestLocalXyzPointerMoveSwap() with rvalue references"); + f1 = static_cast(f3); + if(f1.getAlias() != p1 || f3.isValid()) { + errln("LocalUNormalizer2Pointer move assignment operator did not move"); + } + LocalUNormalizer2Pointer f4(static_cast(f2)); + if(f4.getAlias() != p2 || f2.isValid()) { + errln("LocalUNormalizer2Pointer move constructor did not move"); + } + // Move self assignment leaves the object valid but in an undefined state. + // Do it to make sure there is no crash, + // but do not check for any particular resulting value. + moveFrom(f1, f1); + moveFrom(f3, f3); +#endif /* !UCONFIG_NO_NORMALIZATION */ +} + +// 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.errDataIfFailureAndReset("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.errDataIfFailureAndReset("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.errDataIfFailureAndReset("utrans_openU()")) { + trans.adoptInstead(NULL); + } + } +#endif /* !UCONFIG_NO_TRANSLITERATION */ + +} + +void LocalPointerTest::TestLocalXyzStdUniquePtr() { + IcuTestErrorCode status(*this, "TestLocalXyzStdUniquePtr"); +#if !UCONFIG_NO_FORMATTING + auto* ptr = ucfpos_open(status); + // Implicit conversion operator + std::unique_ptr a = + LocalUConstrainedFieldPositionPointer(ptr); + // Explicit move constructor + LocalUConstrainedFieldPositionPointer a2(std::move(a)); + // Conversion operator should also work with std::move + a = std::move(a2); + // Back again with move assignment + a2 = std::move(a); + assertTrue("Pointer should remain the same", ptr == a2.getAlias()); +#endif // UCONFIG_NO_FORMATTING +} + +/** 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 + flags; + + logln("Enum is from [%d..%d]\n", MAX_NONBOOLEAN+1, + LIMIT_BOOLEAN); + + assertFalse(WHERE, flags.get(THING1)); + assertFalse(WHERE, flags.get(THING2)); + assertFalse(WHERE, flags.get(THING3)); + + 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)); + assertFalse(WHERE, flags.get(THING1)); + assertFalse(WHERE, flags.get(THING2)); + assertFalse(WHERE, flags.get(THING3)); + flags.add(THING1); + logln("set THING1 -Value now: %d\n", flags.getAll()); + assertTrue(WHERE, flags.get(THING1)); + assertFalse(WHERE, flags.get(THING2)); + assertFalse(WHERE, flags.get(THING3)); + 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()); + assertTrue(WHERE, flags.get(THING1)); + assertFalse(WHERE, flags.get(THING2)); + assertTrue(WHERE, flags.get(THING3)); + logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3)); + flags.remove(THING2); + assertTrue(WHERE, flags.get(THING1)); + assertFalse(WHERE, flags.get(THING2)); + assertTrue(WHERE, flags.get(THING3)); + 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); + assertFalse(WHERE, flags.get(THING1)); + assertFalse(WHERE, flags.get(THING2)); + assertTrue(WHERE, flags.get(THING3)); + 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)); + assertFalse(WHERE, flags.get(THING1)); + assertFalse(WHERE, flags.get(THING2)); + assertFalse(WHERE, flags.get(THING3)); +}