+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2012, International Business Machines Corporation and
+ * Copyright (c) 1997-2016, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
+#include <utility>
/**
* 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 "usettest.h"
extern IntlTest *createBytesTrieTest();
+extern IntlTest *createLocaleMatcherTest();
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
+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: ");
- 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
- }
+ 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*/) {
switch (index) {
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
}
}
}
}
+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() {
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
- }
+ 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 every LocalPointer and LocalPointerBase method.
+// Exercise almost every LocalPointer and LocalPointerBase method.
void LocalPointerTest::TestLocalPointer() {
// constructor
LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
errln("LocalPointer orphan() failure");
}
delete orphan;
- // destructor
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<CharString> 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<CharString> null(NULL, errorCode);
+ if(errorCode != U_MEMORY_ALLOCATION_ERROR) {
+ errln("LocalPointer(NULL, errorCode) did not set U_MEMORY_ALLOCATION_ERROR");
+ return;
+ }
+
+ // destructor
}
-// Exercise every LocalArray method (but not LocalPointerBase).
+// Try to avoid clang -Wself-move warnings from s1 = std::move(s1);
+template<typename T>
+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<UnicodeString> s1(p1);
+ LocalPointer<UnicodeString> 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<UnicodeString> 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<LocalPointer<UnicodeString> &&>(s3);
+ if(s1.getAlias() != p1 || s3.isValid()) {
+ errln("LocalPointer move assignment operator did not move");
+ }
+ LocalPointer<UnicodeString> s4(static_cast<LocalPointer<UnicodeString> &&>(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<UnicodeString> s = LocalPointer<UnicodeString>(ptr);
+ // Explicit move constructor
+ LocalPointer<UnicodeString> 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<UnicodeString> a(new UnicodeString[2]);
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 = std::move(a1);
+ if(a3.getAlias() != p1 || a1.isValid()) {
+ errln("LocalArray = std::move() did not move");
+ }
+ 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");
+ }
+
+ // 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<UnicodeString[]> a = LocalArray<UnicodeString>(ptr);
+ // Explicit move constructor
+ LocalArray<UnicodeString> 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/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() {
static const char *const encoding="ISO-8859-1";
LocalUConverterSelectorPointer sel(
ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
- if(errorCode.logIfFailureAndReset("ucnvsel_open()")) {
+ if(errorCode.errIfFailureAndReset("ucnvsel_open()")) {
return;
}
if(sel.isNull()) {
#if !UCONFIG_NO_FORMATTING
LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
- if(errorCode.logDataIfFailureAndReset("ucal_open()")) {
+ if(errorCode.errDataIfFailureAndReset("ucal_open()")) {
return;
}
if(cal.isNull()) {
}
LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
- if(errorCode.logDataIfFailureAndReset("udatpg_open()")) {
+ if(errorCode.errDataIfFailureAndReset("udatpg_open()")) {
return;
}
if(patgen.isNull()) {
}
LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode));
- if(errorCode.logIfFailureAndReset("uldn_open()")) {
+ if(errorCode.errIfFailureAndReset("uldn_open()")) {
return;
}
if(ldn.isNull()) {
UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
LocalUMessageFormatPointer msg(
umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
- if(errorCode.logIfFailureAndReset("umsg_open()")) {
+ if(errorCode.errIfFailureAndReset("umsg_open()")) {
return;
}
if(msg.isNull()) {
const UNormalizer2 *nfc=unorm2_getNFCInstance(errorCode);
UnicodeSet emptySet;
LocalUNormalizer2Pointer fn2(unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode));
- if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) {
+ if(errorCode.errIfFailureAndReset("unorm2_openFiltered()")) {
return;
}
if(fn2.isNull()) {
#if !UCONFIG_NO_IDNA
LocalUIDNAPointer idna(uidna_openUTS46(0, errorCode));
- if(errorCode.logIfFailureAndReset("uidna_openUTS46()")) {
+ if(errorCode.errIfFailureAndReset("uidna_openUTS46()")) {
return;
}
if(idna.isNull()) {
UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
LocalURegularExpressionPointer regex(
uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
- if(errorCode.logIfFailureAndReset("uregex_open()")) {
+ if(errorCode.errIfFailureAndReset("uregex_open()")) {
return;
}
if(regex.isNull()) {
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()")) {
+ if(errorCode.errIfFailureAndReset("utrans_open()")) {
return;
}
if(trans.isNull()) {
// 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<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");
+ }
+ // 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/LocalUCalendarPointer");
LocalUCalendarPointer null;
LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
- if(!errorCode.logDataIfFailureAndReset("ucal_open()")) {
+ if(!errorCode.errDataIfFailureAndReset("ucal_open()")) {
cal.adoptInstead(NULL);
}
}
LocalURegularExpressionPointer null;
LocalURegularExpressionPointer regex(
uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
- if(!errorCode.logDataIfFailureAndReset("urege_open()")) {
+ if(!errorCode.errDataIfFailureAndReset("urege_open()")) {
regex.adoptInstead(NULL);
}
}
LocalUTransliteratorPointer null;
LocalUTransliteratorPointer trans(
utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
- if(!errorCode.logDataIfFailureAndReset("utrans_openU()")) {
+ if(!errorCode.errDataIfFailureAndReset("utrans_openU()")) {
trans.adoptInstead(NULL);
}
}
}
+void LocalPointerTest::TestLocalXyzStdUniquePtr() {
+ IcuTestErrorCode status(*this, "TestLocalXyzStdUniquePtr");
+#if !UCONFIG_NO_FORMATTING
+ auto* ptr = ucfpos_open(status);
+ // Implicit conversion operator
+ std::unique_ptr<UConstrainedFieldPosition, void(*)(UConstrainedFieldPosition*)> 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"
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);
+ 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));
- TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
- TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
- TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
+ 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());
- TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
- TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
- TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
+ 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());
- TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
- TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
- TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
+ 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);
- TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
- TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
- TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
+ 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);
- TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
- TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
- TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
+ 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));
- TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
- TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
- TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
+ assertFalse(WHERE, flags.get(THING1));
+ assertFalse(WHERE, flags.get(THING2));
+ assertFalse(WHERE, flags.get(THING3));
}
projects / apple / icu.git / blobdiff