+// Exercise almost 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");
+ }
+
+ // LocalArray(p, errorCode) sets U_MEMORY_ALLOCATION_ERROR if p==NULL.
+ UErrorCode errorCode = U_ZERO_ERROR;
+ LocalArray<UnicodeString> 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<UnicodeString> 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<UnicodeString> a1(p1);
+ LocalArray<UnicodeString> 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<UnicodeString> a3;
+ a3.moveFrom(a1);
+ if(a3.getAlias() != p1 || a1.isValid()) {
+ errln("LocalArray.moveFrom() did not move");
+ }
+#if U_HAVE_RVALUE_REFERENCES
+ infoln("TestLocalArrayMoveSwap() with rvalue references");
+ a1 = static_cast<LocalArray<UnicodeString> &&>(a3);
+ if(a1.getAlias() != p1 || a3.isValid()) {
+ errln("LocalArray move assignment operator did not move");
+ }
+ LocalArray<UnicodeString> a4(static_cast<LocalArray<UnicodeString> &&>(a2));
+ if(a4.getAlias() != p2 || a2.isValid()) {
+ errln("LocalArray move constructor did not move");
+ }
+#else
+ infoln("TestLocalArrayMoveSwap() without rvalue references");
+#endif
+
+ // 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.
+ a1.moveFrom(a1);
+ a3.moveFrom(a3);
+}
+
+#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
+}
+
+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.logIfFailureAndReset("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.logIfFailureAndReset("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.moveFrom(f1);
+ if(f3.getAlias() != p1 || f1.isValid()) {
+ errln("LocalUNormalizer2Pointer.moveFrom() did not move");
+ }
+#if U_HAVE_RVALUE_REFERENCES
+ infoln("TestLocalXyzPointerMoveSwap() with rvalue references");
+ f1 = static_cast<LocalUNormalizer2Pointer &&>(f3);
+ if(f1.getAlias() != p1 || f3.isValid()) {
+ errln("LocalUNormalizer2Pointer move assignment operator did not move");
+ }
+ LocalUNormalizer2Pointer f4(static_cast<LocalUNormalizer2Pointer &&>(f2));
+ if(f4.getAlias() != p2 || f2.isValid()) {
+ errln("LocalUNormalizer2Pointer move constructor did not move");
+ }
+#else
+ infoln("TestLocalXyzPointerMoveSwap() without rvalue references");
+#endif
+ // 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.
+ f1.moveFrom(f1);
+ f3.moveFrom(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.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);
+}
projects / apple / icu.git / blobdiff