*/
#include "unicode/std_string.h"
+#include "unicode/brkiter.h"
#include "unicode/casemap.h"
#include "unicode/edits.h"
#include "unicode/uchar.h"
#include "unicode/ubrk.h"
#include "unicode/unistr.h"
#include "unicode/ucasemap.h"
+#include "unicode/ustring.h"
#include "ucase.h"
#include "ustrtest.h"
#include "unicode/tstdtmod.h"
#include "cmemory.h"
-
-struct EditChange {
- UBool change;
- int32_t oldLength, newLength;
-};
+#include "testutil.h"
class StringCaseTest: public IntlTest {
public:
int32_t whichCase,
void *iter, const char *localeID, uint32_t options);
void TestCasing();
+ void TestTitleOptions();
void TestFullCaseFoldingIterator();
void TestGreekUpper();
void TestLongUpper();
void TestMalformedUTF8();
void TestBufferOverflow();
void TestEdits();
+ void TestCopyMoveEdits();
+ void TestEditsFindFwdBwd();
+ void TestMergeEdits();
void TestCaseMapWithEdits();
void TestCaseMapUTF8WithEdits();
+ void TestCaseMapToString();
+ void TestCaseMapUTF8ToString();
void TestLongUnicodeString();
void TestBug13127();
+ void TestInPlaceTitle();
+ void TestCaseMapEditsIteratorDocs();
+ void TestCaseMapGreekExtended();
private:
void assertGreekUpper(const char16_t *s, const char16_t *expected);
- void checkEditsIter(
- const UnicodeString &name, Edits::Iterator ei1, Edits::Iterator ei2, // two equal iterators
- const EditChange expected[], int32_t expLength, UBool withUnchanged,
- UErrorCode &errorCode);
Locale GREEK_LOCALE_;
};
TESTCASE_AUTO(TestCaseConversion);
#if !UCONFIG_NO_BREAK_ITERATION && !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
TESTCASE_AUTO(TestCasing);
- TESTCASE_AUTO(TestBug13127);
+ TESTCASE_AUTO(TestTitleOptions);
#endif
TESTCASE_AUTO(TestFullCaseFoldingIterator);
TESTCASE_AUTO(TestGreekUpper);
TESTCASE_AUTO(TestMalformedUTF8);
TESTCASE_AUTO(TestBufferOverflow);
TESTCASE_AUTO(TestEdits);
+ TESTCASE_AUTO(TestCopyMoveEdits);
+ TESTCASE_AUTO(TestEditsFindFwdBwd);
+ TESTCASE_AUTO(TestMergeEdits);
TESTCASE_AUTO(TestCaseMapWithEdits);
TESTCASE_AUTO(TestCaseMapUTF8WithEdits);
+ TESTCASE_AUTO(TestCaseMapToString);
+ TESTCASE_AUTO(TestCaseMapUTF8ToString);
TESTCASE_AUTO(TestLongUnicodeString);
+#if !UCONFIG_NO_BREAK_ITERATION
+ TESTCASE_AUTO(TestBug13127);
+ TESTCASE_AUTO(TestInPlaceTitle);
+#endif
+ TESTCASE_AUTO(TestCaseMapEditsIteratorDocs);
+ TESTCASE_AUTO(TestCaseMapGreekExtended);
TESTCASE_AUTO_END;
}
#endif
}
+void
+StringCaseTest::TestTitleOptions() {
+ // New options in ICU 60.
+ TestCasingImpl(u"ʻcAt! ʻeTc.", u"ʻCat! ʻetc.", TEST_TITLE,
+ nullptr, "", U_TITLECASE_WHOLE_STRING);
+ TestCasingImpl(u"a ʻCaT. A ʻdOg! ʻeTc.", u"A ʻCaT. A ʻdOg! ʻETc.", TEST_TITLE,
+ nullptr, "", U_TITLECASE_SENTENCES|U_TITLECASE_NO_LOWERCASE);
+ TestCasingImpl(u"49eRs", u"49ers", TEST_TITLE,
+ nullptr, "", U_TITLECASE_WHOLE_STRING);
+ TestCasingImpl(u"«丰(aBc)»", u"«丰(abc)»", TEST_TITLE,
+ nullptr, "", U_TITLECASE_WHOLE_STRING);
+ TestCasingImpl(u"49eRs", u"49Ers", TEST_TITLE,
+ nullptr, "", U_TITLECASE_WHOLE_STRING|U_TITLECASE_ADJUST_TO_CASED);
+ TestCasingImpl(u"«丰(aBc)»", u"«丰(Abc)»", TEST_TITLE,
+ nullptr, "", U_TITLECASE_WHOLE_STRING|U_TITLECASE_ADJUST_TO_CASED);
+ TestCasingImpl(u" john. Smith", u" John. Smith", TEST_TITLE,
+ nullptr, "", U_TITLECASE_WHOLE_STRING|U_TITLECASE_NO_LOWERCASE);
+ TestCasingImpl(u" john. Smith", u" john. smith", TEST_TITLE,
+ nullptr, "", U_TITLECASE_WHOLE_STRING|U_TITLECASE_NO_BREAK_ADJUSTMENT);
+ TestCasingImpl(u"«ijs»", u"«IJs»", TEST_TITLE,
+ nullptr, "nl-BE", U_TITLECASE_WHOLE_STRING);
+ TestCasingImpl(u"«ijs»", u"«İjs»", TEST_TITLE,
+ nullptr, "tr-DE", U_TITLECASE_WHOLE_STRING);
+
+#if !UCONFIG_NO_BREAK_ITERATION
+ // Test conflicting settings.
+ // If & when we add more options, then the ORed combinations may become
+ // indistinguishable from valid values.
+ IcuTestErrorCode errorCode(*this, "TestTitleOptions");
+ CaseMap::toTitle("", U_TITLECASE_NO_BREAK_ADJUSTMENT|U_TITLECASE_ADJUST_TO_CASED, nullptr,
+ u"", 0, nullptr, 0, nullptr, errorCode);
+ if (errorCode.get() != U_ILLEGAL_ARGUMENT_ERROR) {
+ errln("CaseMap::toTitle(multiple adjustment options) -> %s not illegal argument",
+ errorCode.errorName());
+ }
+ errorCode.reset();
+ CaseMap::toTitle("", U_TITLECASE_WHOLE_STRING|U_TITLECASE_SENTENCES, nullptr,
+ u"", 0, nullptr, 0, nullptr, errorCode);
+ if (errorCode.get() != U_ILLEGAL_ARGUMENT_ERROR) {
+ errln("CaseMap::toTitle(multiple iterator options) -> %s not illegal argument",
+ errorCode.errorName());
+ }
+ errorCode.reset();
+ LocalPointer<BreakIterator> iter(
+ BreakIterator::createCharacterInstance(Locale::getRoot(), errorCode));
+ CaseMap::toTitle("", U_TITLECASE_WHOLE_STRING, iter.getAlias(),
+ u"", 0, nullptr, 0, nullptr, errorCode);
+ if (errorCode.get() != U_ILLEGAL_ARGUMENT_ERROR) {
+ errln("CaseMap::toTitle(iterator option + iterator) -> %s not illegal argument",
+ errorCode.errorName());
+ }
+ errorCode.reset();
+#endif
+}
+
void
StringCaseTest::TestFullCaseFoldingIterator() {
UnicodeString ffi=UNICODE_STRING_SIMPLE("ffi");
msg = UnicodeString("ucasemap_utf8ToUpper/Greek(\"") + s16 + "\")";
char dest8[1000];
length = ucasemap_utf8ToUpper(csm.getAlias(), dest8, UPRV_LENGTHOF(dest8),
- s8.data(), s8.length(), &errorCode);
+ s8.data(), static_cast<int32_t>(s8.length()), &errorCode);
assertSuccess("ucasemap_utf8ToUpper", errorCode);
StringPiece result8(dest8, length);
UnicodeString result16From8 = UnicodeString::fromUTF8(result8);
memset(dest8b, 0x5A, UPRV_LENGTHOF(dest8b));
UErrorCode errorCode = U_ZERO_ERROR;
length = ucasemap_utf8ToUpper(csm.getAlias(), dest8b, cap,
- s8.data(), s8.length(), &errorCode);
+ s8.data(), static_cast<int32_t>(s8.length()), &errorCode);
assertEquals(msg + cap, expected8Length, length);
UErrorCode expectedErrorCode;
if (cap < expected8Length) {
assertGreekUpper(u"Το ένα ή το άλλο.", u"ΤΟ ΕΝΑ Ή ΤΟ ΑΛΛΟ.");
// http://multilingualtypesetting.co.uk/blog/greek-typesetting-tips/
assertGreekUpper(u"ρωμέικα", u"ΡΩΜΕΪΚΑ");
+ assertGreekUpper(u"ή.", u"Ή.");
}
void
std::string data_utf8;
data.toUTF8String(data_utf8);
#if !UCONFIG_NO_BREAK_ITERATION
- result = ucasemap_utf8ToTitle(csm.getAlias(), NULL, 0, data_utf8.c_str(), data_utf8.length(), errorCode);
+ result = ucasemap_utf8ToTitle(csm.getAlias(), NULL, 0, data_utf8.c_str(), static_cast<int32_t>(data_utf8.length()), errorCode);
if (errorCode.get() != U_BUFFER_OVERFLOW_ERROR || result != (int32_t)data_utf8.length()) {
errln("%s:%d ucasemap_toTitle(\"hello world\") failed: "
"expected (U_BUFFER_OVERFLOW_ERROR, %d), got (%s, %d)",
errorCode.reset();
}
-void StringCaseTest::checkEditsIter(
- const UnicodeString &name,
- Edits::Iterator ei1, Edits::Iterator ei2, // two equal iterators
- const EditChange expected[], int32_t expLength, UBool withUnchanged,
- UErrorCode &errorCode) {
- assertFalse(name, ei2.findSourceIndex(-1, errorCode));
-
- int32_t expSrcIndex = 0;
- int32_t expDestIndex = 0;
- int32_t expReplIndex = 0;
- for (int32_t expIndex = 0; expIndex < expLength; ++expIndex) {
- const EditChange &expect = expected[expIndex];
- UnicodeString msg = UnicodeString(name).append(u' ') + expIndex;
- if (withUnchanged || expect.change) {
- assertTrue(msg, ei1.next(errorCode));
- assertEquals(msg, expect.change, ei1.hasChange());
- assertEquals(msg, expect.oldLength, ei1.oldLength());
- assertEquals(msg, expect.newLength, ei1.newLength());
- assertEquals(msg, expSrcIndex, ei1.sourceIndex());
- assertEquals(msg, expDestIndex, ei1.destinationIndex());
- assertEquals(msg, expReplIndex, ei1.replacementIndex());
- }
-
- if (expect.oldLength > 0) {
- assertTrue(msg, ei2.findSourceIndex(expSrcIndex, errorCode));
- assertEquals(msg, expect.change, ei2.hasChange());
- assertEquals(msg, expect.oldLength, ei2.oldLength());
- assertEquals(msg, expect.newLength, ei2.newLength());
- assertEquals(msg, expSrcIndex, ei2.sourceIndex());
- assertEquals(msg, expDestIndex, ei2.destinationIndex());
- assertEquals(msg, expReplIndex, ei2.replacementIndex());
- if (!withUnchanged) {
- // For some iterators, move past the current range
- // so that findSourceIndex() has to look before the current index.
- ei2.next(errorCode);
- ei2.next(errorCode);
- }
- }
-
- expSrcIndex += expect.oldLength;
- expDestIndex += expect.newLength;
- if (expect.change) {
- expReplIndex += expect.newLength;
- }
- }
- // TODO: remove casts from u"" when merging into trunk
- UnicodeString msg = UnicodeString(name).append(u" end");
- assertFalse(msg, ei1.next(errorCode));
- assertFalse(msg, ei1.hasChange());
- assertEquals(msg, 0, ei1.oldLength());
- assertEquals(msg, 0, ei1.newLength());
- assertEquals(msg, expSrcIndex, ei1.sourceIndex());
- assertEquals(msg, expDestIndex, ei1.destinationIndex());
- assertEquals(msg, expReplIndex, ei1.replacementIndex());
-
- assertFalse(name, ei2.findSourceIndex(expSrcIndex, errorCode));
-}
-
void StringCaseTest::TestEdits() {
IcuTestErrorCode errorCode(*this, "TestEdits");
Edits edits;
- assertFalse("new Edits", edits.hasChanges());
+ assertFalse("new Edits hasChanges", edits.hasChanges());
+ assertEquals("new Edits numberOfChanges", 0, edits.numberOfChanges());
assertEquals("new Edits", 0, edits.lengthDelta());
edits.addUnchanged(1); // multiple unchanged ranges are combined
edits.addUnchanged(10000); // too long, and they are split
edits.addReplace(0, 0);
edits.addUnchanged(2);
- assertFalse("unchanged 10003", edits.hasChanges());
+ assertFalse("unchanged 10003 hasChanges", edits.hasChanges());
+ assertEquals("unchanged 10003 numberOfChanges", 0, edits.numberOfChanges());
assertEquals("unchanged 10003", 0, edits.lengthDelta());
- edits.addReplace(1, 1); // multiple short equal-length edits are compressed
+ edits.addReplace(2, 1); // multiple short equal-lengths edits are compressed
edits.addUnchanged(0);
- edits.addReplace(1, 1);
- edits.addReplace(1, 1);
+ edits.addReplace(2, 1);
+ edits.addReplace(2, 1);
edits.addReplace(0, 10);
edits.addReplace(100, 0);
edits.addReplace(3000, 4000); // variable-length encoding
edits.addReplace(100000, 100000);
- assertTrue("some edits", edits.hasChanges());
- assertEquals("some edits", 10 - 100 + 1000, edits.lengthDelta());
+ assertTrue("some edits hasChanges", edits.hasChanges());
+ assertEquals("some edits numberOfChanges", 7, edits.numberOfChanges());
+ assertEquals("some edits", -3 + 10 - 100 + 1000, edits.lengthDelta());
UErrorCode outErrorCode = U_ZERO_ERROR;
assertFalse("edits done: copyErrorTo", edits.copyErrorTo(outErrorCode));
static const EditChange coarseExpectedChanges[] = {
{ FALSE, 10003, 10003 },
- { TRUE, 103103, 104013 }
+ { TRUE, 103106, 104013 }
};
- checkEditsIter(u"coarse",
+ TestUtility::checkEditsIter(*this, u"coarse",
edits.getCoarseIterator(), edits.getCoarseIterator(),
coarseExpectedChanges, UPRV_LENGTHOF(coarseExpectedChanges), TRUE, errorCode);
- checkEditsIter(u"coarse changes",
+ TestUtility::checkEditsIter(*this, u"coarse changes",
edits.getCoarseChangesIterator(), edits.getCoarseChangesIterator(),
coarseExpectedChanges, UPRV_LENGTHOF(coarseExpectedChanges), FALSE, errorCode);
static const EditChange fineExpectedChanges[] = {
{ FALSE, 10003, 10003 },
- { TRUE, 1, 1 },
- { TRUE, 1, 1 },
- { TRUE, 1, 1 },
+ { TRUE, 2, 1 },
+ { TRUE, 2, 1 },
+ { TRUE, 2, 1 },
{ TRUE, 0, 10 },
{ TRUE, 100, 0 },
{ TRUE, 3000, 4000 },
{ TRUE, 100000, 100000 }
};
- checkEditsIter(u"fine",
+ TestUtility::checkEditsIter(*this, u"fine",
edits.getFineIterator(), edits.getFineIterator(),
fineExpectedChanges, UPRV_LENGTHOF(fineExpectedChanges), TRUE, errorCode);
- checkEditsIter(u"fine changes",
+ TestUtility::checkEditsIter(*this, u"fine changes",
edits.getFineChangesIterator(), edits.getFineChangesIterator(),
fineExpectedChanges, UPRV_LENGTHOF(fineExpectedChanges), FALSE, errorCode);
edits.reset();
- assertFalse("reset", edits.hasChanges());
+ assertFalse("reset hasChanges", edits.hasChanges());
+ assertEquals("reset numberOfChanges", 0, edits.numberOfChanges());
assertEquals("reset", 0, edits.lengthDelta());
Edits::Iterator ei = edits.getCoarseChangesIterator();
assertFalse("reset then iterator", ei.next(errorCode));
}
+void StringCaseTest::TestCopyMoveEdits() {
+ IcuTestErrorCode errorCode(*this, "TestCopyMoveEdits");
+ // Exceed the stack array capacity.
+ Edits a;
+ for (int32_t i = 0; i < 250; ++i) {
+ a.addReplace(i % 10, (i % 10) + 1);
+ }
+ assertEquals("a: many edits, length delta", 250, a.lengthDelta());
+
+ // copy
+ Edits b(a);
+ assertEquals("b: copy of many edits, length delta", 250, b.lengthDelta());
+ assertEquals("a remains: many edits, length delta", 250, a.lengthDelta());
+ TestUtility::checkEqualEdits(*this, u"b copy of a", a, b, errorCode);
+
+ // assign
+ Edits c;
+ c.addUnchanged(99);
+ c.addReplace(88, 77);
+ c = b;
+ assertEquals("c: assigned many edits, length delta", 250, c.lengthDelta());
+ assertEquals("b remains: many edits, length delta", 250, b.lengthDelta());
+ TestUtility::checkEqualEdits(*this, u"c = b", b, c, errorCode);
+
+ // std::move trouble on these platforms.
+ // See https://ssl.icu-project.org/trac/ticket/13393
+#if !(U_PLATFORM == U_PF_AIX || U_PLATFORM == U_PF_OS390)
+ // move constructor empties object with heap array
+ Edits d(std::move(a));
+ assertEquals("d: move-constructed many edits, length delta", 250, d.lengthDelta());
+ assertFalse("a moved away: no more hasChanges", a.hasChanges());
+ TestUtility::checkEqualEdits(*this, u"d() <- a", d, b, errorCode);
+ Edits empty;
+ TestUtility::checkEqualEdits(*this, u"a moved away", empty, a, errorCode);
+
+ // move assignment empties object with heap array
+ Edits e;
+ e.addReplace(0, 1000);
+ e = std::move(b);
+ assertEquals("e: move-assigned many edits, length delta", 250, e.lengthDelta());
+ assertFalse("b moved away: no more hasChanges", b.hasChanges());
+ TestUtility::checkEqualEdits(*this, u"e <- b", e, c, errorCode);
+ TestUtility::checkEqualEdits(*this, u"b moved away", empty, b, errorCode);
+
+ // Edits::Iterator default constructor.
+ Edits::Iterator iter;
+ assertFalse("Edits::Iterator().next()", iter.next(errorCode));
+ assertSuccess("Edits::Iterator().next()", errorCode);
+ iter = e.getFineChangesIterator();
+ assertTrue("iter.next()", iter.next(errorCode));
+ assertSuccess("iter.next()", errorCode);
+ assertTrue("iter.hasChange()", iter.hasChange());
+ assertEquals("iter.newLength()", 1, iter.newLength());
+#endif
+}
+
+void StringCaseTest::TestEditsFindFwdBwd() {
+ IcuTestErrorCode errorCode(*this, "TestEditsFindFwdBwd");
+ // Some users need index mappings to be efficient when they are out of order.
+ // The most interesting failure case for this test is it taking a very long time.
+ Edits e;
+ constexpr int32_t N = 200000;
+ for (int32_t i = 0; i < N; ++i) {
+ e.addUnchanged(1);
+ e.addReplace(3, 1);
+ }
+ Edits::Iterator iter = e.getFineIterator();
+ for (int32_t i = 0; i <= N; i += 2) {
+ assertEquals("ascending", i * 2, iter.sourceIndexFromDestinationIndex(i, errorCode));
+ assertEquals("ascending", i * 2 + 1, iter.sourceIndexFromDestinationIndex(i + 1, errorCode));
+ }
+ for (int32_t i = N; i >= 0; i -= 2) {
+ assertEquals("descending", i * 2 + 1, iter.sourceIndexFromDestinationIndex(i + 1, errorCode));
+ assertEquals("descending", i * 2, iter.sourceIndexFromDestinationIndex(i, errorCode));
+ }
+}
+
+void StringCaseTest::TestMergeEdits() {
+ // For debugging, set -v to see matching edits up to a failure.
+ IcuTestErrorCode errorCode(*this, "TestMergeEdits");
+ Edits ab, bc, ac, expected_ac;
+
+ // Simple: Two parallel non-changes.
+ ab.addUnchanged(2);
+ bc.addUnchanged(2);
+ expected_ac.addUnchanged(2);
+
+ // Simple: Two aligned changes.
+ ab.addReplace(3, 2);
+ bc.addReplace(2, 1);
+ expected_ac.addReplace(3, 1);
+
+ // Unequal non-changes.
+ ab.addUnchanged(5);
+ bc.addUnchanged(3);
+ expected_ac.addUnchanged(3);
+ // ab ahead by 2
+
+ // Overlapping changes accumulate until they share a boundary.
+ ab.addReplace(4, 3);
+ bc.addReplace(3, 2);
+ ab.addReplace(4, 3);
+ bc.addReplace(3, 2);
+ ab.addReplace(4, 3);
+ bc.addReplace(3, 2);
+ bc.addUnchanged(4);
+ expected_ac.addReplace(14, 8);
+ // bc ahead by 2
+
+ // Balance out intermediate-string lengths.
+ ab.addUnchanged(2);
+ expected_ac.addUnchanged(2);
+
+ // Insert something and delete it: Should disappear.
+ ab.addReplace(0, 5);
+ ab.addReplace(0, 2);
+ bc.addReplace(7, 0);
+
+ // Parallel change to make a new boundary.
+ ab.addReplace(1, 2);
+ bc.addReplace(2, 3);
+ expected_ac.addReplace(1, 3);
+
+ // Multiple ab deletions should remain separate at the boundary.
+ ab.addReplace(1, 0);
+ ab.addReplace(2, 0);
+ ab.addReplace(3, 0);
+ expected_ac.addReplace(1, 0);
+ expected_ac.addReplace(2, 0);
+ expected_ac.addReplace(3, 0);
+
+ // Unequal non-changes can be split for another boundary.
+ ab.addUnchanged(2);
+ bc.addUnchanged(1);
+ expected_ac.addUnchanged(1);
+ // ab ahead by 1
+
+ // Multiple bc insertions should create a boundary and remain separate.
+ bc.addReplace(0, 4);
+ bc.addReplace(0, 5);
+ bc.addReplace(0, 6);
+ expected_ac.addReplace(0, 4);
+ expected_ac.addReplace(0, 5);
+ expected_ac.addReplace(0, 6);
+ // ab ahead by 1
+
+ // Multiple ab deletions in the middle of a bc change are merged.
+ bc.addReplace(2, 2);
+ // bc ahead by 1
+ ab.addReplace(1, 0);
+ ab.addReplace(2, 0);
+ ab.addReplace(3, 0);
+ ab.addReplace(4, 1);
+ expected_ac.addReplace(11, 2);
+
+ // Multiple bc insertions in the middle of an ab change are merged.
+ ab.addReplace(5, 6);
+ bc.addReplace(3, 3);
+ // ab ahead by 3
+ bc.addReplace(0, 4);
+ bc.addReplace(0, 5);
+ bc.addReplace(0, 6);
+ bc.addReplace(3, 7);
+ expected_ac.addReplace(5, 25);
+
+ // Delete around a deletion.
+ ab.addReplace(4, 4);
+ ab.addReplace(3, 0);
+ ab.addUnchanged(2);
+ bc.addReplace(2, 2);
+ bc.addReplace(4, 0);
+ expected_ac.addReplace(9, 2);
+
+ // Insert into an insertion.
+ ab.addReplace(0, 2);
+ bc.addReplace(1, 1);
+ bc.addReplace(0, 8);
+ bc.addUnchanged(4);
+ expected_ac.addReplace(0, 10);
+ // bc ahead by 3
+
+ // Balance out intermediate-string lengths.
+ ab.addUnchanged(3);
+ expected_ac.addUnchanged(3);
+
+ // Deletions meet insertions.
+ // Output order is arbitrary in principle, but we expect insertions first
+ // and want to keep it that way.
+ ab.addReplace(2, 0);
+ ab.addReplace(4, 0);
+ ab.addReplace(6, 0);
+ bc.addReplace(0, 1);
+ bc.addReplace(0, 3);
+ bc.addReplace(0, 5);
+ expected_ac.addReplace(0, 1);
+ expected_ac.addReplace(0, 3);
+ expected_ac.addReplace(0, 5);
+ expected_ac.addReplace(2, 0);
+ expected_ac.addReplace(4, 0);
+ expected_ac.addReplace(6, 0);
+
+ // End with a non-change, so that further edits are never reordered.
+ ab.addUnchanged(1);
+ bc.addUnchanged(1);
+ expected_ac.addUnchanged(1);
+
+ ac.mergeAndAppend(ab, bc, errorCode);
+ assertSuccess("ab+bc", errorCode);
+ if (!TestUtility::checkEqualEdits(*this, u"ab+bc", expected_ac, ac, errorCode)) {
+ return;
+ }
+
+ // Append more Edits.
+ Edits ab2, bc2;
+ ab2.addUnchanged(5);
+ bc2.addReplace(1, 2);
+ bc2.addUnchanged(4);
+ expected_ac.addReplace(1, 2);
+ expected_ac.addUnchanged(4);
+ ac.mergeAndAppend(ab2, bc2, errorCode);
+ assertSuccess("ab2+bc2", errorCode);
+ if (!TestUtility::checkEqualEdits(*this, u"ab2+bc2", expected_ac, ac, errorCode)) {
+ return;
+ }
+
+ // Append empty edits.
+ Edits empty;
+ ac.mergeAndAppend(empty, empty, errorCode);
+ assertSuccess("empty+empty", errorCode);
+ if (!TestUtility::checkEqualEdits(*this, u"empty+empty", expected_ac, ac, errorCode)) {
+ return;
+ }
+
+ // Error: Append more edits with mismatched intermediate-string lengths.
+ Edits mismatch;
+ mismatch.addReplace(1, 1);
+ ac.mergeAndAppend(ab2, mismatch, errorCode);
+ assertEquals("ab2+mismatch", U_ILLEGAL_ARGUMENT_ERROR, errorCode.get());
+ errorCode.reset();
+ ac.mergeAndAppend(mismatch, bc2, errorCode);
+ assertEquals("mismatch+bc2", U_ILLEGAL_ARGUMENT_ERROR, errorCode.get());
+ errorCode.reset();
+}
+
void StringCaseTest::TestCaseMapWithEdits() {
- IcuTestErrorCode errorCode(*this, "TestEdits");
+ IcuTestErrorCode errorCode(*this, "TestCaseMapWithEdits");
UChar dest[20];
Edits edits;
- int32_t length = CaseMap::toLower("tr", UCASEMAP_OMIT_UNCHANGED_TEXT,
+ int32_t length = CaseMap::toLower("tr", U_OMIT_UNCHANGED_TEXT,
u"IstanBul", 8, dest, UPRV_LENGTHOF(dest), &edits, errorCode);
assertEquals(u"toLower(IstanBul)", UnicodeString(u"ıb"), UnicodeString(TRUE, dest, length));
static const EditChange lowerExpectedChanges[] = {
{ TRUE, 1, 1 },
{ FALSE, 2, 2 }
};
- checkEditsIter(u"toLower(IstanBul)",
+ TestUtility::checkEditsIter(*this, u"toLower(IstanBul)",
edits.getFineIterator(), edits.getFineIterator(),
lowerExpectedChanges, UPRV_LENGTHOF(lowerExpectedChanges),
TRUE, errorCode);
edits.reset();
- length = CaseMap::toUpper("el", UCASEMAP_OMIT_UNCHANGED_TEXT,
+ length = CaseMap::toUpper("el", U_OMIT_UNCHANGED_TEXT,
u"Πατάτα", 6, dest, UPRV_LENGTHOF(dest), &edits, errorCode);
assertEquals(u"toUpper(Πατάτα)", UnicodeString(u"ΑΤΑΤΑ"), UnicodeString(TRUE, dest, length));
static const EditChange upperExpectedChanges[] = {
{ TRUE, 1, 1 },
{ TRUE, 1, 1 }
};
- checkEditsIter(u"toUpper(Πατάτα)",
+ TestUtility::checkEditsIter(*this, u"toUpper(Πατάτα)",
edits.getFineIterator(), edits.getFineIterator(),
upperExpectedChanges, UPRV_LENGTHOF(upperExpectedChanges),
TRUE, errorCode);
#if !UCONFIG_NO_BREAK_ITERATION
length = CaseMap::toTitle("nl",
- UCASEMAP_OMIT_UNCHANGED_TEXT |
+ U_OMIT_UNCHANGED_TEXT |
U_TITLECASE_NO_BREAK_ADJUSTMENT |
U_TITLECASE_NO_LOWERCASE,
- NULL, u"IjssEL IglOo", 12,
+ nullptr, u"IjssEL IglOo", 12,
dest, UPRV_LENGTHOF(dest), &edits, errorCode);
assertEquals(u"toTitle(IjssEL IglOo)", UnicodeString(u"J"), UnicodeString(TRUE, dest, length));
static const EditChange titleExpectedChanges[] = {
{ TRUE, 1, 1 },
{ FALSE, 10, 10 }
};
- checkEditsIter(u"toTitle(IjssEL IglOo)",
+ TestUtility::checkEditsIter(*this, u"toTitle(IjssEL IglOo)",
edits.getFineIterator(), edits.getFineIterator(),
titleExpectedChanges, UPRV_LENGTHOF(titleExpectedChanges),
TRUE, errorCode);
#endif
- edits.reset();
- length = CaseMap::fold(UCASEMAP_OMIT_UNCHANGED_TEXT | U_FOLD_CASE_EXCLUDE_SPECIAL_I,
+ // No explicit nor automatic edits.reset(). Edits should be appended.
+ length = CaseMap::fold(U_OMIT_UNCHANGED_TEXT | U_EDITS_NO_RESET | U_FOLD_CASE_EXCLUDE_SPECIAL_I,
u"IßtanBul", 8, dest, UPRV_LENGTHOF(dest), &edits, errorCode);
assertEquals(u"foldCase(IßtanBul)", UnicodeString(u"ıssb"), UnicodeString(TRUE, dest, length));
static const EditChange foldExpectedChanges[] = {
+#if !UCONFIG_NO_BREAK_ITERATION
+ // From titlecasing.
+ { FALSE, 1, 1 },
+ { TRUE, 1, 1 },
+ { FALSE, 10, 10 },
+#endif
+ // From case folding.
{ TRUE, 1, 1 },
{ TRUE, 1, 2 },
{ FALSE, 3, 3 },
{ TRUE, 1, 1 },
{ FALSE, 2, 2 }
};
- checkEditsIter(u"foldCase(IßtanBul)",
+ TestUtility::checkEditsIter(*this, u"foldCase(no Edits reset, IßtanBul)",
edits.getFineIterator(), edits.getFineIterator(),
foldExpectedChanges, UPRV_LENGTHOF(foldExpectedChanges),
TRUE, errorCode);
}
void StringCaseTest::TestCaseMapUTF8WithEdits() {
- IcuTestErrorCode errorCode(*this, "TestEdits");
+ IcuTestErrorCode errorCode(*this, "TestCaseMapUTF8WithEdits");
char dest[50];
Edits edits;
- int32_t length = CaseMap::utf8ToLower("tr", UCASEMAP_OMIT_UNCHANGED_TEXT,
- u8"IstanBul", 8, dest, UPRV_LENGTHOF(dest), &edits, errorCode);
+ int32_t length = CaseMap::utf8ToLower("tr", U_OMIT_UNCHANGED_TEXT,
+ reinterpret_cast<const char*>(u8"IstanBul"), 8, dest, UPRV_LENGTHOF(dest), &edits, errorCode);
assertEquals(u"toLower(IstanBul)", UnicodeString(u"ıb"),
UnicodeString::fromUTF8(StringPiece(dest, length)));
static const EditChange lowerExpectedChanges[] = {
{ TRUE, 1, 1 },
{ FALSE, 2, 2 }
};
- checkEditsIter(u"toLower(IstanBul)",
+ TestUtility::checkEditsIter(*this, u"toLower(IstanBul)",
edits.getFineIterator(), edits.getFineIterator(),
lowerExpectedChanges, UPRV_LENGTHOF(lowerExpectedChanges),
TRUE, errorCode);
edits.reset();
- length = CaseMap::utf8ToUpper("el", UCASEMAP_OMIT_UNCHANGED_TEXT,
- u8"Πατάτα", 6 * 2, dest, UPRV_LENGTHOF(dest), &edits, errorCode);
+ length = CaseMap::utf8ToUpper("el", U_OMIT_UNCHANGED_TEXT,
+ reinterpret_cast<const char*>(u8"Πατάτα"), 6 * 2, dest, UPRV_LENGTHOF(dest), &edits, errorCode);
assertEquals(u"toUpper(Πατάτα)", UnicodeString(u"ΑΤΑΤΑ"),
UnicodeString::fromUTF8(StringPiece(dest, length)));
static const EditChange upperExpectedChanges[] = {
{ TRUE, 2, 2 },
{ TRUE, 2, 2 }
};
- checkEditsIter(u"toUpper(Πατάτα)",
+ TestUtility::checkEditsIter(*this, u"toUpper(Πατάτα)",
edits.getFineIterator(), edits.getFineIterator(),
upperExpectedChanges, UPRV_LENGTHOF(upperExpectedChanges),
TRUE, errorCode);
edits.reset();
#if !UCONFIG_NO_BREAK_ITERATION
length = CaseMap::utf8ToTitle("nl",
- UCASEMAP_OMIT_UNCHANGED_TEXT |
+ U_OMIT_UNCHANGED_TEXT |
U_TITLECASE_NO_BREAK_ADJUSTMENT |
U_TITLECASE_NO_LOWERCASE,
- NULL, u8"IjssEL IglOo", 12,
+ nullptr, reinterpret_cast<const char*>(u8"IjssEL IglOo"), 12,
dest, UPRV_LENGTHOF(dest), &edits, errorCode);
assertEquals(u"toTitle(IjssEL IglOo)", UnicodeString(u"J"),
UnicodeString::fromUTF8(StringPiece(dest, length)));
{ TRUE, 1, 1 },
{ FALSE, 10, 10 }
};
- checkEditsIter(u"toTitle(IjssEL IglOo)",
+ TestUtility::checkEditsIter(*this, u"toTitle(IjssEL IglOo)",
edits.getFineIterator(), edits.getFineIterator(),
titleExpectedChanges, UPRV_LENGTHOF(titleExpectedChanges),
TRUE, errorCode);
#endif
- edits.reset();
- length = CaseMap::utf8Fold(UCASEMAP_OMIT_UNCHANGED_TEXT | U_FOLD_CASE_EXCLUDE_SPECIAL_I,
- u8"IßtanBul", 1 + 2 + 6, dest, UPRV_LENGTHOF(dest), &edits, errorCode);
+ // No explicit nor automatic edits.reset(). Edits should be appended.
+ length = CaseMap::utf8Fold(U_OMIT_UNCHANGED_TEXT | U_EDITS_NO_RESET |
+ U_FOLD_CASE_EXCLUDE_SPECIAL_I,
+ reinterpret_cast<const char*>(u8"IßtanBul"), 1 + 2 + 6, dest, UPRV_LENGTHOF(dest), &edits, errorCode);
assertEquals(u"foldCase(IßtanBul)", UnicodeString(u"ıssb"),
UnicodeString::fromUTF8(StringPiece(dest, length)));
static const EditChange foldExpectedChanges[] = {
+#if !UCONFIG_NO_BREAK_ITERATION
+ // From titlecasing.
+ { FALSE, 1, 1 },
+ { TRUE, 1, 1 },
+ { FALSE, 10, 10 },
+#endif
+ // From case folding.
{ TRUE, 1, 2 },
{ TRUE, 2, 2 },
{ FALSE, 3, 3 },
{ TRUE, 1, 1 },
{ FALSE, 2, 2 }
};
- checkEditsIter(u"foldCase(IßtanBul)",
+ TestUtility::checkEditsIter(*this, u"foldCase(IßtanBul)",
edits.getFineIterator(), edits.getFineIterator(),
foldExpectedChanges, UPRV_LENGTHOF(foldExpectedChanges),
TRUE, errorCode);
}
+void StringCaseTest::TestCaseMapToString() {
+ // This test function name is parallel with one in UCharacterCaseTest.java.
+ // It is a bit of a misnomer until we have CaseMap API that writes to
+ // a UnicodeString, at which point we should change this code here.
+ IcuTestErrorCode errorCode(*this, "TestCaseMapToString");
+ UChar dest[20];
+
+ // Omit unchanged text.
+ int32_t length = CaseMap::toLower("tr", U_OMIT_UNCHANGED_TEXT,
+ u"IstanBul", 8, dest, UPRV_LENGTHOF(dest), nullptr, errorCode);
+ assertEquals(u"toLower(IstanBul)",
+ UnicodeString(u"ıb"), UnicodeString(TRUE, dest, length));
+ length = CaseMap::toUpper("el", U_OMIT_UNCHANGED_TEXT,
+ u"Πατάτα", 6, dest, UPRV_LENGTHOF(dest), nullptr, errorCode);
+ assertEquals(u"toUpper(Πατάτα)",
+ UnicodeString(u"ΑΤΑΤΑ"), UnicodeString(TRUE, dest, length));
+#if !UCONFIG_NO_BREAK_ITERATION
+ length = CaseMap::toTitle("nl",
+ U_OMIT_UNCHANGED_TEXT |
+ U_TITLECASE_NO_BREAK_ADJUSTMENT |
+ U_TITLECASE_NO_LOWERCASE,
+ nullptr, u"IjssEL IglOo", 12,
+ dest, UPRV_LENGTHOF(dest), nullptr, errorCode);
+ assertEquals(u"toTitle(IjssEL IglOo)",
+ UnicodeString(u"J"), UnicodeString(TRUE, dest, length));
+#endif
+ length = CaseMap::fold(U_OMIT_UNCHANGED_TEXT | U_FOLD_CASE_EXCLUDE_SPECIAL_I,
+ u"IßtanBul", 8, dest, UPRV_LENGTHOF(dest), nullptr, errorCode);
+ assertEquals(u"foldCase(IßtanBul)",
+ UnicodeString(u"ıssb"), UnicodeString(TRUE, dest, length));
+
+ // Return the whole result string.
+ length = CaseMap::toLower("tr", 0,
+ u"IstanBul", 8, dest, UPRV_LENGTHOF(dest), nullptr, errorCode);
+ assertEquals(u"toLower(IstanBul)",
+ UnicodeString(u"ıstanbul"), UnicodeString(TRUE, dest, length));
+ length = CaseMap::toUpper("el", 0,
+ u"Πατάτα", 6, dest, UPRV_LENGTHOF(dest), nullptr, errorCode);
+ assertEquals(u"toUpper(Πατάτα)",
+ UnicodeString(u"ΠΑΤΑΤΑ"), UnicodeString(TRUE, dest, length));
+#if !UCONFIG_NO_BREAK_ITERATION
+ length = CaseMap::toTitle("nl",
+ U_TITLECASE_NO_BREAK_ADJUSTMENT |
+ U_TITLECASE_NO_LOWERCASE,
+ nullptr, u"IjssEL IglOo", 12,
+ dest, UPRV_LENGTHOF(dest), nullptr, errorCode);
+ assertEquals(u"toTitle(IjssEL IglOo)",
+ UnicodeString(u"IJssEL IglOo"), UnicodeString(TRUE, dest, length));
+#endif
+ length = CaseMap::fold(U_FOLD_CASE_EXCLUDE_SPECIAL_I,
+ u"IßtanBul", 8, dest, UPRV_LENGTHOF(dest), nullptr, errorCode);
+ assertEquals(u"foldCase(IßtanBul)",
+ UnicodeString(u"ısstanbul"), UnicodeString(TRUE, dest, length));
+}
+
+void StringCaseTest::TestCaseMapUTF8ToString() {
+ IcuTestErrorCode errorCode(*this, "TestCaseMapUTF8ToString");
+ std::string dest;
+ StringByteSink<std::string> sink(&dest);
+
+ // Omit unchanged text.
+ CaseMap::utf8ToLower("tr", U_OMIT_UNCHANGED_TEXT, reinterpret_cast<const char*>(u8"IstanBul"), sink, nullptr, errorCode);
+ assertEquals(u"toLower(IstanBul)", UnicodeString(u"ıb"), UnicodeString::fromUTF8(dest));
+ dest.clear();
+ CaseMap::utf8ToUpper("el", U_OMIT_UNCHANGED_TEXT, reinterpret_cast<const char*>(u8"Πατάτα"), sink, nullptr, errorCode);
+ assertEquals(u"toUpper(Πατάτα)", UnicodeString(u"ΑΤΑΤΑ"),
+ UnicodeString::fromUTF8(dest));
+#if !UCONFIG_NO_BREAK_ITERATION
+ dest.clear();
+ CaseMap::utf8ToTitle(
+ "nl", U_OMIT_UNCHANGED_TEXT | U_TITLECASE_NO_BREAK_ADJUSTMENT | U_TITLECASE_NO_LOWERCASE,
+ nullptr, reinterpret_cast<const char*>(u8"IjssEL IglOo"), sink, nullptr, errorCode);
+ assertEquals(u"toTitle(IjssEL IglOo)", UnicodeString(u"J"),
+ UnicodeString::fromUTF8(dest));
+#endif
+ dest.clear();
+ CaseMap::utf8Fold(U_OMIT_UNCHANGED_TEXT | U_FOLD_CASE_EXCLUDE_SPECIAL_I,
+ reinterpret_cast<const char*>(u8"IßtanBul"), sink, nullptr, errorCode);
+ assertEquals(u"foldCase(IßtanBul)", UnicodeString(u"ıssb"),
+ UnicodeString::fromUTF8(dest));
+
+ // Return the whole result string.
+ dest.clear();
+ CaseMap::utf8ToLower("tr", 0, reinterpret_cast<const char*>(u8"IstanBul"), sink, nullptr, errorCode);
+ assertEquals(u"toLower(IstanBul)", UnicodeString(u"ıstanbul"),
+ UnicodeString::fromUTF8(dest));
+ dest.clear();
+ CaseMap::utf8ToUpper("el", 0, reinterpret_cast<const char*>(u8"Πατάτα"), sink, nullptr, errorCode);
+ assertEquals(u"toUpper(Πατάτα)", UnicodeString(u"ΠΑΤΑΤΑ"),
+ UnicodeString::fromUTF8(dest));
+#if !UCONFIG_NO_BREAK_ITERATION
+ dest.clear();
+ CaseMap::utf8ToTitle("nl", U_TITLECASE_NO_BREAK_ADJUSTMENT | U_TITLECASE_NO_LOWERCASE,
+ nullptr, reinterpret_cast<const char*>(u8"IjssEL IglOo"), sink, nullptr, errorCode);
+ assertEquals(u"toTitle(IjssEL IglOo)", UnicodeString(u"IJssEL IglOo"),
+ UnicodeString::fromUTF8(dest));
+#endif
+ dest.clear();
+ CaseMap::utf8Fold(U_FOLD_CASE_EXCLUDE_SPECIAL_I, reinterpret_cast<const char*>(u8"IßtanBul"), sink, nullptr, errorCode);
+ assertEquals(u"foldCase(IßtanBul)", UnicodeString(u"ısstanbul"),
+ UnicodeString::fromUTF8(dest));
+}
+
void StringCaseTest::TestLongUnicodeString() {
// Code coverage for UnicodeString case mapping code handling
// long strings or many changes in a string.
assertEquals("string length 306", expected, s);
}
+#if !UCONFIG_NO_BREAK_ITERATION
void StringCaseTest::TestBug13127() {
// Test case crashed when the bug was present.
const char16_t *s16 = u"日本語";
UnicodeString s(TRUE, s16, -1);
s.toTitle(0, Locale::getEnglish());
}
+
+void StringCaseTest::TestInPlaceTitle() {
+ // Similar to TestBug13127. u_strToTitle() can modify the buffer in-place.
+ IcuTestErrorCode errorCode(*this, "TestInPlaceTitle");
+ char16_t s[32] = u"ß ß ß日本語 abcdef";
+ const char16_t *expected = u"Ss Ss Ss日本語 Abcdef";
+ int32_t length = u_strToTitle(s, UPRV_LENGTHOF(s), s, -1, nullptr, "", errorCode);
+ assertEquals("u_strToTitle(in-place) length", u_strlen(expected), length);
+ assertEquals("u_strToTitle(in-place)", expected, s);
+}
+#endif
+
+void StringCaseTest::TestCaseMapEditsIteratorDocs() {
+ IcuTestErrorCode status(*this, "TestCaseMapEditsIteratorDocs");
+ const char16_t* input = u"abcßDeF";
+ int32_t inputLength = u_strlen(input);
+ // output: "abcssdef"
+
+ char16_t output[10];
+ Edits edits;
+ CaseMap::fold(0, input, -1, output, 10, &edits, status);
+
+ static const char16_t* fineIteratorExpected[] = {
+ u"{ src[0..3] ≡ dest[0..3] (no-change) }",
+ u"{ src[3..4] ⇝ dest[3..5], repl[0..2] }",
+ u"{ src[4..5] ⇝ dest[5..6], repl[2..3] }",
+ u"{ src[5..6] ≡ dest[6..7] (no-change) }",
+ u"{ src[6..7] ⇝ dest[7..8], repl[3..4] }",
+ };
+ static const char16_t* fineChangesIteratorExpected[] = {
+ u"{ src[3..4] ⇝ dest[3..5], repl[0..2] }",
+ u"{ src[4..5] ⇝ dest[5..6], repl[2..3] }",
+ u"{ src[6..7] ⇝ dest[7..8], repl[3..4] }",
+ };
+ static const char16_t* coarseIteratorExpected[] = {
+ u"{ src[0..3] ≡ dest[0..3] (no-change) }",
+ u"{ src[3..5] ⇝ dest[3..6], repl[0..3] }",
+ u"{ src[5..6] ≡ dest[6..7] (no-change) }",
+ u"{ src[6..7] ⇝ dest[7..8], repl[3..4] }",
+ };
+ static const char16_t* coarseChangesIteratorExpected[] = {
+ u"{ src[3..5] ⇝ dest[3..6], repl[0..3] }",
+ u"{ src[6..7] ⇝ dest[7..8], repl[3..4] }",
+ };
+
+ // Expected destination indices when source index is queried
+ static int32_t expectedDestFineEditIndices[] = {0, 0, 0, 3, 5, 6, 7};
+ static int32_t expectedDestCoarseEditIndices[] = {0, 0, 0, 3, 3, 6, 7};
+ static int32_t expectedDestFineStringIndices[] = {0, 1, 2, 3, 5, 6, 7};
+ static int32_t expectedDestCoarseStringIndices[] = {0, 1, 2, 3, 6, 6, 7};
+
+ // Expected source indices when destination index is queried
+ static int32_t expectedSrcFineEditIndices[] = { 0, 0, 0, 3, 3, 4, 5, 6 };
+ static int32_t expectedSrcCoarseEditIndices[] = { 0, 0, 0, 3, 3, 3, 5, 6 };
+ static int32_t expectedSrcFineStringIndices[] = { 0, 1, 2, 3, 4, 4, 5, 6 };
+ static int32_t expectedSrcCoarseStringIndices[] = { 0, 1, 2, 3, 5, 5, 5, 6 };
+
+ // Demonstrate the iterator next() method:
+ Edits::Iterator fineIterator = edits.getFineIterator();
+ int i = 0;
+ UnicodeString toString;
+ while (fineIterator.next(status)) {
+ UnicodeString expected = fineIteratorExpected[i++];
+ assertEquals(UnicodeString(u"Iteration #") + i,
+ expected,
+ fineIterator.toString(toString.remove()));
+ }
+ Edits::Iterator fineChangesIterator = edits.getFineChangesIterator();
+ i = 0;
+ while (fineChangesIterator.next(status)) {
+ UnicodeString expected = fineChangesIteratorExpected[i++];
+ assertEquals(UnicodeString(u"Iteration #") + i,
+ expected,
+ fineChangesIterator.toString(toString.remove()));
+ }
+ Edits::Iterator coarseIterator = edits.getCoarseIterator();
+ i = 0;
+ while (coarseIterator.next(status)) {
+ UnicodeString expected = coarseIteratorExpected[i++];
+ assertEquals(UnicodeString(u"Iteration #") + i,
+ expected,
+ coarseIterator.toString(toString.remove()));
+ }
+ Edits::Iterator coarseChangesIterator = edits.getCoarseChangesIterator();
+ i = 0;
+ while (coarseChangesIterator.next(status)) {
+ UnicodeString expected = coarseChangesIteratorExpected[i++];
+ assertEquals(UnicodeString(u"Iteration #") + i,
+ expected,
+ coarseChangesIterator.toString(toString.remove()));
+ }
+
+ // Demonstrate the iterator indexing methods:
+ // fineIterator should have the same behavior as fineChangesIterator, and
+ // coarseIterator should have the same behavior as coarseChangesIterator.
+ for (int32_t srcIndex=0; srcIndex<inputLength; srcIndex++) {
+ fineIterator.findSourceIndex(srcIndex, status);
+ fineChangesIterator.findSourceIndex(srcIndex, status);
+ coarseIterator.findSourceIndex(srcIndex, status);
+ coarseChangesIterator.findSourceIndex(srcIndex, status);
+
+ assertEquals(UnicodeString("Source index: ") + srcIndex,
+ expectedDestFineEditIndices[srcIndex],
+ fineIterator.destinationIndex());
+ assertEquals(UnicodeString("Source index: ") + srcIndex,
+ expectedDestFineEditIndices[srcIndex],
+ fineChangesIterator.destinationIndex());
+ assertEquals(UnicodeString("Source index: ") + srcIndex,
+ expectedDestCoarseEditIndices[srcIndex],
+ coarseIterator.destinationIndex());
+ assertEquals(UnicodeString("Source index: ") + srcIndex,
+ expectedDestCoarseEditIndices[srcIndex],
+ coarseChangesIterator.destinationIndex());
+
+ assertEquals(UnicodeString("Source index: ") + srcIndex,
+ expectedDestFineStringIndices[srcIndex],
+ fineIterator.destinationIndexFromSourceIndex(srcIndex, status));
+ assertEquals(UnicodeString("Source index: ") + srcIndex,
+ expectedDestFineStringIndices[srcIndex],
+ fineChangesIterator.destinationIndexFromSourceIndex(srcIndex, status));
+ assertEquals(UnicodeString("Source index: ") + srcIndex,
+ expectedDestCoarseStringIndices[srcIndex],
+ coarseIterator.destinationIndexFromSourceIndex(srcIndex, status));
+ assertEquals(UnicodeString("Source index: ") + srcIndex,
+ expectedDestCoarseStringIndices[srcIndex],
+ coarseChangesIterator.destinationIndexFromSourceIndex(srcIndex, status));
+ }
+ for (int32_t destIndex=0; destIndex<inputLength; destIndex++) {
+ fineIterator.findDestinationIndex(destIndex, status);
+ fineChangesIterator.findDestinationIndex(destIndex, status);
+ coarseIterator.findDestinationIndex(destIndex, status);
+ coarseChangesIterator.findDestinationIndex(destIndex, status);
+
+ assertEquals(UnicodeString("Destination index: ") + destIndex,
+ expectedSrcFineEditIndices[destIndex],
+ fineIterator.sourceIndex());
+ assertEquals(UnicodeString("Destination index: ") + destIndex,
+ expectedSrcFineEditIndices[destIndex],
+ fineChangesIterator.sourceIndex());
+ assertEquals(UnicodeString("Destination index: ") + destIndex,
+ expectedSrcCoarseEditIndices[destIndex],
+ coarseIterator.sourceIndex());
+ assertEquals(UnicodeString("Destination index: ") + destIndex,
+ expectedSrcCoarseEditIndices[destIndex],
+ coarseChangesIterator.sourceIndex());
+
+ assertEquals(UnicodeString("Destination index: ") + destIndex,
+ expectedSrcFineStringIndices[destIndex],
+ fineIterator.sourceIndexFromDestinationIndex(destIndex, status));
+ assertEquals(UnicodeString("Destination index: ") + destIndex,
+ expectedSrcFineStringIndices[destIndex],
+ fineChangesIterator.sourceIndexFromDestinationIndex(destIndex, status));
+ assertEquals(UnicodeString("Destination index: ") + destIndex,
+ expectedSrcCoarseStringIndices[destIndex],
+ coarseIterator.sourceIndexFromDestinationIndex(destIndex, status));
+ assertEquals(UnicodeString("Destination index: ") + destIndex,
+ expectedSrcCoarseStringIndices[destIndex],
+ coarseChangesIterator.sourceIndexFromDestinationIndex(destIndex, status));
+ }
+}
+
+void StringCaseTest::TestCaseMapGreekExtended() {
+ // Ticket 13851
+ UnicodeString s(u"\u1F80\u1F88\u1FFC");
+ UnicodeString result(s);
+ result.toLower(Locale::getRoot());
+ assertEquals(u"lower", u"\u1F80\u1F80\u1FF3", result);
+#if !UCONFIG_NO_BREAK_ITERATION
+ result = s;
+ result.toTitle(nullptr, Locale::getRoot());
+ assertEquals(u"title", u"\u1F88\u1F80\u1FF3", result);
+#endif
+}
+
+//#endif
projects / apple / icu.git / blobdiff