// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   Copyright (C) 2002-2016, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   file name:  strcase.cpp
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2002mar12
*   created by: Markus W. Scherer
*
*   Test file for string casing C++ API functions.
*/

#include "unicode/std_string.h"
#include "unicode/brkiter.h"
#include "unicode/casemap.h"
#include "unicode/edits.h"
#include "unicode/uchar.h"
#include "unicode/ures.h"
#include "unicode/uloc.h"
#include "unicode/locid.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"
#include "testutil.h"

class StringCaseTest: public IntlTest {
public:
    StringCaseTest();
    virtual ~StringCaseTest();

    void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);

    void TestCaseConversion();

    void TestCasingImpl(const UnicodeString &input,
                        const UnicodeString &output,
                        int32_t whichCase,
                        void *iter, const char *localeID, uint32_t options);
    void TestCasing();
    void TestTitleOptions();
    void TestFullCaseFoldingIterator();
    void TestGreekUpper();
    void TestArmenian();
    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);

    Locale GREEK_LOCALE_;
};

StringCaseTest::StringCaseTest() : GREEK_LOCALE_("el") {}

StringCaseTest::~StringCaseTest() {}

extern IntlTest *createStringCaseTest() {
    return new StringCaseTest();
}

void
StringCaseTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
    if(exec) {
        logln("TestSuite StringCaseTest: ");
    }
    TESTCASE_AUTO_BEGIN;
    TESTCASE_AUTO(TestCaseConversion);
#if !UCONFIG_NO_BREAK_ITERATION && !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
    TESTCASE_AUTO(TestCasing);
    TESTCASE_AUTO(TestTitleOptions);
#endif
    TESTCASE_AUTO(TestFullCaseFoldingIterator);
    TESTCASE_AUTO(TestGreekUpper);
    TESTCASE_AUTO(TestArmenian);
    TESTCASE_AUTO(TestLongUpper);
    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;
}

void
StringCaseTest::TestCaseConversion()
{
    static const UChar uppercaseGreek[] =
        { 0x399, 0x395, 0x3a3, 0x3a5, 0x3a3, 0x20, 0x03a7, 0x3a1, 0x399, 0x3a3, 0x3a4,
        0x39f, 0x3a3, 0 };
        // "IESUS CHRISTOS"

    static const UChar lowercaseGreek[] = 
        { 0x3b9, 0x3b5, 0x3c3, 0x3c5, 0x3c2, 0x20, 0x03c7, 0x3c1, 0x3b9, 0x3c3, 0x3c4,
        0x3bf, 0x3c2, 0 };
        // "iesus christos"

    static const UChar lowercaseTurkish[] = 
        { 0x69, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x2c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x63, 0x6f, 
        0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x0131, 0x6e, 0x6f, 0x70, 0x6c, 0x65, 0x21, 0 };

    static const UChar uppercaseTurkish[] = 
        { 0x54, 0x4f, 0x50, 0x4b, 0x41, 0x50, 0x49, 0x20, 0x50, 0x41, 0x4c, 0x41, 0x43, 0x45, 0x2c, 0x20,
        0x0130, 0x53, 0x54, 0x41, 0x4e, 0x42, 0x55, 0x4c, 0 };
    
    UnicodeString expectedResult;
    UnicodeString   test3;

    test3 += (UChar32)0x0130;
    test3 += "STANBUL, NOT CONSTANTINOPLE!";

    UnicodeString   test4(test3);
    test4.toLower(Locale(""));
    expectedResult = UnicodeString("i\\u0307stanbul, not constantinople!", "").unescape();
    if (test4 != expectedResult)
        errln("1. toLower failed: expected \"" + expectedResult + "\", got \"" + test4 + "\".");

    test4 = test3;
    test4.toLower(Locale("tr", "TR"));
    expectedResult = lowercaseTurkish;
    if (test4 != expectedResult)
        errln("2. toLower failed: expected \"" + expectedResult + "\", got \"" + test4 + "\".");

    test3 = "topkap";
    test3 += (UChar32)0x0131;
    test3 += " palace, istanbul";
    test4 = test3;

    test4.toUpper(Locale(""));
    expectedResult = "TOPKAPI PALACE, ISTANBUL";
    if (test4 != expectedResult)
        errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test4 + "\".");

    test4 = test3;
    test4.toUpper(Locale("tr", "TR"));
    expectedResult = uppercaseTurkish;
    if (test4 != expectedResult)
        errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test4 + "\".");

    test3 = CharsToUnicodeString("S\\u00FC\\u00DFmayrstra\\u00DFe");

    test3.toUpper(Locale("de", "DE"));
    expectedResult = CharsToUnicodeString("S\\u00DCSSMAYRSTRASSE");
    if (test3 != expectedResult)
        errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test3 + "\".");
    
    test4.replace(0, test4.length(), uppercaseGreek);

    test4.toLower(Locale("el", "GR"));
    expectedResult = lowercaseGreek;
    if (test4 != expectedResult)
        errln("toLower failed: expected \"" + expectedResult + "\", got \"" + test4 + "\".");
    
    test4.replace(0, test4.length(), lowercaseGreek);

    test4.toUpper();
    expectedResult = uppercaseGreek;
    if (test4 != expectedResult)
        errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test4 + "\".");

    // more string case mapping tests with the new implementation
    {
        static const UChar

        beforeLower[]= { 0x61, 0x42, 0x49,  0x3a3, 0xdf, 0x3a3, 0x2f, 0xd93f, 0xdfff },
        lowerRoot[]=   { 0x61, 0x62, 0x69,  0x3c3, 0xdf, 0x3c2, 0x2f, 0xd93f, 0xdfff },
        lowerTurkish[]={ 0x61, 0x62, 0x131, 0x3c3, 0xdf, 0x3c2, 0x2f, 0xd93f, 0xdfff },

        beforeUpper[]= { 0x61, 0x42, 0x69,  0x3c2, 0xdf,       0x3c3, 0x2f, 0xfb03,           0xfb03,           0xfb03,           0xd93f, 0xdfff },
        upperRoot[]=   { 0x41, 0x42, 0x49,  0x3a3, 0x53, 0x53, 0x3a3, 0x2f, 0x46, 0x46, 0x49, 0x46, 0x46, 0x49, 0x46, 0x46, 0x49, 0xd93f, 0xdfff },
        upperTurkish[]={ 0x41, 0x42, 0x130, 0x3a3, 0x53, 0x53, 0x3a3, 0x2f, 0x46, 0x46, 0x49, 0x46, 0x46, 0x49, 0x46, 0x46, 0x49, 0xd93f, 0xdfff },

        beforeMiniUpper[]=  { 0xdf, 0x61 },
        miniUpper[]=        { 0x53, 0x53, 0x41 };

        UnicodeString s;

        /* lowercase with root locale */
        s=UnicodeString(FALSE, beforeLower, UPRV_LENGTHOF(beforeLower));
        s.toLower("");
        if( s.length()!=UPRV_LENGTHOF(lowerRoot) ||
            s!=UnicodeString(FALSE, lowerRoot, s.length())
        ) {
            errln("error in toLower(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerRoot, UPRV_LENGTHOF(lowerRoot)) + "\"");
        }

        /* lowercase with turkish locale */
        s=UnicodeString(FALSE, beforeLower, UPRV_LENGTHOF(beforeLower));
        s.setCharAt(0, beforeLower[0]).toLower(Locale("tr"));
        if( s.length()!=UPRV_LENGTHOF(lowerTurkish) ||
            s!=UnicodeString(FALSE, lowerTurkish, s.length())
        ) {
            errln("error in toLower(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerTurkish, UPRV_LENGTHOF(lowerTurkish)) + "\"");
        }

        /* uppercase with root locale */
        s=UnicodeString(FALSE, beforeUpper, UPRV_LENGTHOF(beforeUpper));
        s.setCharAt(0, beforeUpper[0]).toUpper(Locale(""));
        if( s.length()!=UPRV_LENGTHOF(upperRoot) ||
            s!=UnicodeString(FALSE, upperRoot, s.length())
        ) {
            errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperRoot, UPRV_LENGTHOF(upperRoot)) + "\"");
        }

        /* uppercase with turkish locale */
        s=UnicodeString(FALSE, beforeUpper, UPRV_LENGTHOF(beforeUpper));
        s.toUpper(Locale("tr"));
        if( s.length()!=UPRV_LENGTHOF(upperTurkish) ||
            s!=UnicodeString(FALSE, upperTurkish, s.length())
        ) {
            errln("error in toUpper(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperTurkish, UPRV_LENGTHOF(upperTurkish)) + "\"");
        }

        /* uppercase a short string with root locale */
        s=UnicodeString(FALSE, beforeMiniUpper, UPRV_LENGTHOF(beforeMiniUpper));
        s.setCharAt(0, beforeMiniUpper[0]).toUpper("");
        if( s.length()!=UPRV_LENGTHOF(miniUpper) ||
            s!=UnicodeString(FALSE, miniUpper, s.length())
        ) {
            errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, miniUpper, UPRV_LENGTHOF(miniUpper)) + "\"");
        }
    }

    // test some supplementary characters (>= Unicode 3.1)
    {
        UnicodeString t;

        UnicodeString
            deseretInput=UnicodeString("\\U0001043C\\U00010414", "").unescape(),
            deseretLower=UnicodeString("\\U0001043C\\U0001043C", "").unescape(),
            deseretUpper=UnicodeString("\\U00010414\\U00010414", "").unescape();
        (t=deseretInput).toLower();
        if(t!=deseretLower) {
            errln("error lowercasing Deseret (plane 1) characters");
        }
        (t=deseretInput).toUpper();
        if(t!=deseretUpper) {
            errln("error uppercasing Deseret (plane 1) characters");
        }
    }

    // test some more cases that looked like problems
    {
        UnicodeString t;

        UnicodeString
            ljInput=UnicodeString("ab'cD \\uFB00i\\u0131I\\u0130 \\u01C7\\u01C8\\u01C9 \\U0001043C\\U00010414", "").unescape(),
            ljLower=UnicodeString("ab'cd \\uFB00i\\u0131ii\\u0307 \\u01C9\\u01C9\\u01C9 \\U0001043C\\U0001043C", "").unescape(),
            ljUpper=UnicodeString("AB'CD FFIII\\u0130 \\u01C7\\u01C7\\u01C7 \\U00010414\\U00010414", "").unescape();
        (t=ljInput).toLower("en");
        if(t!=ljLower) {
            errln("error lowercasing LJ characters");
        }
        (t=ljInput).toUpper("en");
        if(t!=ljUpper) {
            errln("error uppercasing LJ characters");
        }
    }

#if !UCONFIG_NO_NORMALIZATION
    // some context-sensitive casing depends on normalization data being present

    // Unicode 3.1.1 SpecialCasing tests
    {
        UnicodeString t;

        // sigmas preceded and/or followed by cased letters
        UnicodeString
            sigmas=UnicodeString("i\\u0307\\u03a3\\u0308j \\u0307\\u03a3\\u0308j i\\u00ad\\u03a3\\u0308 \\u0307\\u03a3\\u0308 ", "").unescape(),
            sigmasLower=UnicodeString("i\\u0307\\u03c3\\u0308j \\u0307\\u03c3\\u0308j i\\u00ad\\u03c2\\u0308 \\u0307\\u03c3\\u0308 ", "").unescape(),
            sigmasUpper=UnicodeString("I\\u0307\\u03a3\\u0308J \\u0307\\u03a3\\u0308J I\\u00ad\\u03a3\\u0308 \\u0307\\u03a3\\u0308 ", "").unescape();

        (t=sigmas).toLower();
        if(t!=sigmasLower) {
            errln("error in sigmas.toLower()=\"" + t + "\" expected \"" + sigmasLower + "\"");
        }

        (t=sigmas).toUpper(Locale(""));
        if(t!=sigmasUpper) {
            errln("error in sigmas.toUpper()=\"" + t + "\" expected \"" + sigmasUpper + "\"");
        }

        // turkish & azerbaijani dotless i & dotted I
        // remove dot above if there was a capital I before and there are no more accents above
        UnicodeString
            dots=UnicodeString("I \\u0130 I\\u0307 I\\u0327\\u0307 I\\u0301\\u0307 I\\u0327\\u0307\\u0301", "").unescape(),
            dotsTurkish=UnicodeString("\\u0131 i i i\\u0327 \\u0131\\u0301\\u0307 i\\u0327\\u0301", "").unescape(),
            dotsDefault=UnicodeString("i i\\u0307 i\\u0307 i\\u0327\\u0307 i\\u0301\\u0307 i\\u0327\\u0307\\u0301", "").unescape();

        (t=dots).toLower("tr");
        if(t!=dotsTurkish) {
            errln("error in dots.toLower(tr)=\"" + t + "\" expected \"" + dotsTurkish + "\"");
        }

        (t=dots).toLower("de");
        if(t!=dotsDefault) {
            errln("error in dots.toLower(de)=\"" + t + "\" expected \"" + dotsDefault + "\"");
        }
    }

    // more Unicode 3.1.1 tests
    {
        UnicodeString t;

        // lithuanian dot above in uppercasing
        UnicodeString
            dots=UnicodeString("a\\u0307 \\u0307 i\\u0307 j\\u0327\\u0307 j\\u0301\\u0307", "").unescape(),
            dotsLithuanian=UnicodeString("A\\u0307 \\u0307 I J\\u0327 J\\u0301\\u0307", "").unescape(),
            dotsDefault=UnicodeString("A\\u0307 \\u0307 I\\u0307 J\\u0327\\u0307 J\\u0301\\u0307", "").unescape();

        (t=dots).toUpper("lt");
        if(t!=dotsLithuanian) {
            errln("error in dots.toUpper(lt)=\"" + t + "\" expected \"" + dotsLithuanian + "\"");
        }

        (t=dots).toUpper("de");
        if(t!=dotsDefault) {
            errln("error in dots.toUpper(de)=\"" + t + "\" expected \"" + dotsDefault + "\"");
        }

        // lithuanian adds dot above to i in lowercasing if there are more above accents
        UnicodeString
            i=UnicodeString("I I\\u0301 J J\\u0301 \\u012e \\u012e\\u0301 \\u00cc\\u00cd\\u0128", "").unescape(),
            iLithuanian=UnicodeString("i i\\u0307\\u0301 j j\\u0307\\u0301 \\u012f \\u012f\\u0307\\u0301 i\\u0307\\u0300i\\u0307\\u0301i\\u0307\\u0303", "").unescape(),
            iDefault=UnicodeString("i i\\u0301 j j\\u0301 \\u012f \\u012f\\u0301 \\u00ec\\u00ed\\u0129", "").unescape();

        (t=i).toLower("lt");
        if(t!=iLithuanian) {
            errln("error in i.toLower(lt)=\"" + t + "\" expected \"" + iLithuanian + "\"");
        }

        (t=i).toLower("de");
        if(t!=iDefault) {
            errln("error in i.toLower(de)=\"" + t + "\" expected \"" + iDefault + "\"");
        }
    }

#endif

    // test case folding
    {
        UnicodeString
            s=UnicodeString("A\\u00df\\u00b5\\ufb03\\U0001040c\\u0130\\u0131", "").unescape(),
            f=UnicodeString("ass\\u03bcffi\\U00010434i\\u0307\\u0131", "").unescape(),
            g=UnicodeString("ass\\u03bcffi\\U00010434i\\u0131", "").unescape(),
            t;

        (t=s).foldCase();
        if(f!=t) {
            errln("error in foldCase(\"" + s + "\", default)=\"" + t + "\" but expected \"" + f + "\"");
        }

        // alternate handling for dotted I/dotless i (U+0130, U+0131)
        (t=s).foldCase(U_FOLD_CASE_EXCLUDE_SPECIAL_I);
        if(g!=t) {
            errln("error in foldCase(\"" + s + "\", U_FOLD_CASE_EXCLUDE_SPECIAL_I)=\"" + t + "\" but expected \"" + g + "\"");
        }
    }
}

// data-driven case mapping tests ------------------------------------------ ***

enum {
    TEST_LOWER,
    TEST_UPPER,
    TEST_TITLE,
    TEST_FOLD,
    TEST_COUNT
};

// names of TestData children in casing.txt
static const char *const dataNames[TEST_COUNT+1]={
    "lowercasing",
    "uppercasing",
    "titlecasing",
    "casefolding",
    ""
};

void
StringCaseTest::TestCasingImpl(const UnicodeString &input,
                               const UnicodeString &output,
                               int32_t whichCase,
                               void *iter, const char *localeID, uint32_t options) {
    // UnicodeString
    UnicodeString result;
    const char *name;
    Locale locale(localeID);

    result=input;
    switch(whichCase) {
    case TEST_LOWER:
        name="toLower";
        result.toLower(locale);
        break;
    case TEST_UPPER:
        name="toUpper";
        result.toUpper(locale);
        break;
#if !UCONFIG_NO_BREAK_ITERATION
    case TEST_TITLE:
        name="toTitle";
        result.toTitle((BreakIterator *)iter, locale, options);
        break;
#endif
    case TEST_FOLD:
        name="foldCase";
        result.foldCase(options);
        break;
    default:
        name="";
        break; // won't happen
    }
    if(result!=output) {
        dataerrln("error: UnicodeString.%s() got a wrong result for a test case from casing.res", name);
    }
#if !UCONFIG_NO_BREAK_ITERATION
    if(whichCase==TEST_TITLE && options==0) {
        result=input;
        result.toTitle((BreakIterator *)iter, locale);
        if(result!=output) {
            dataerrln("error: UnicodeString.toTitle(options=0) got a wrong result for a test case from casing.res");
        }
    }
#endif

    // UTF-8
    char utf8In[100], utf8Out[100];
    int32_t utf8InLength, utf8OutLength, resultLength;
    UChar *buffer;

    IcuTestErrorCode errorCode(*this, "TestCasingImpl");
    LocalUCaseMapPointer csm(ucasemap_open(localeID, options, errorCode));
#if !UCONFIG_NO_BREAK_ITERATION
    if(iter!=NULL) {
        // Clone the break iterator so that the UCaseMap can safely adopt it.
        UBreakIterator *clone=ubrk_safeClone((UBreakIterator *)iter, NULL, NULL, errorCode);
        ucasemap_setBreakIterator(csm.getAlias(), clone, errorCode);
    }
#endif

    u_strToUTF8(utf8In, (int32_t)sizeof(utf8In), &utf8InLength, input.getBuffer(), input.length(), errorCode);
    switch(whichCase) {
    case TEST_LOWER:
        name="ucasemap_utf8ToLower";
        utf8OutLength=ucasemap_utf8ToLower(csm.getAlias(),
                    utf8Out, (int32_t)sizeof(utf8Out),
                    utf8In, utf8InLength, errorCode);
        break;
    case TEST_UPPER:
        name="ucasemap_utf8ToUpper";
        utf8OutLength=ucasemap_utf8ToUpper(csm.getAlias(),
                    utf8Out, (int32_t)sizeof(utf8Out),
                    utf8In, utf8InLength, errorCode);
        break;
#if !UCONFIG_NO_BREAK_ITERATION
    case TEST_TITLE:
        name="ucasemap_utf8ToTitle";
        utf8OutLength=ucasemap_utf8ToTitle(csm.getAlias(),
                    utf8Out, (int32_t)sizeof(utf8Out),
                    utf8In, utf8InLength, errorCode);
        break;
#endif
    case TEST_FOLD:
        name="ucasemap_utf8FoldCase";
        utf8OutLength=ucasemap_utf8FoldCase(csm.getAlias(),
                    utf8Out, (int32_t)sizeof(utf8Out),
                    utf8In, utf8InLength, errorCode);
        break;
    default:
        name="";
        utf8OutLength=0;
        break; // won't happen
    }
    buffer=result.getBuffer(utf8OutLength);
    u_strFromUTF8(buffer, result.getCapacity(), &resultLength, utf8Out, utf8OutLength, errorCode);
    result.releaseBuffer(errorCode.isSuccess() ? resultLength : 0);

    if(errorCode.isFailure()) {
        errcheckln(errorCode, "error: %s() got an error for a test case from casing.res - %s", name, u_errorName(errorCode));
        errorCode.reset();
    } else if(result!=output) {
        errln("error: %s() got a wrong result for a test case from casing.res", name);
        errln("expected \"" + output + "\" got \"" + result + "\"" );
    }
}

void
StringCaseTest::TestCasing() {
    UErrorCode status = U_ZERO_ERROR;
#if !UCONFIG_NO_BREAK_ITERATION
    LocalUBreakIteratorPointer iter;
#endif
    char cLocaleID[100];
    UnicodeString locale, input, output, optionsString, result;
    uint32_t options;
    int32_t whichCase, type;
    LocalPointer<TestDataModule> driver(TestDataModule::getTestDataModule("casing", *this, status));
    if(U_SUCCESS(status)) {
        for(whichCase=0; whichCase<TEST_COUNT; ++whichCase) {
#if UCONFIG_NO_BREAK_ITERATION
            if(whichCase==TEST_TITLE) {
                continue;
            }
#endif
            LocalPointer<TestData> casingTest(driver->createTestData(dataNames[whichCase], status));
            if(U_FAILURE(status)) {
                errln("TestCasing failed to createTestData(%s) - %s", dataNames[whichCase], u_errorName(status));
                break;
            }
            const DataMap *myCase = NULL;
            while(casingTest->nextCase(myCase, status)) {
                input = myCase->getString("Input", status);
                output = myCase->getString("Output", status);

                if(whichCase!=TEST_FOLD) {
                    locale = myCase->getString("Locale", status);
                }
                locale.extract(0, 0x7fffffff, cLocaleID, sizeof(cLocaleID), "");

#if !UCONFIG_NO_BREAK_ITERATION
                if(whichCase==TEST_TITLE) {
                    type = myCase->getInt("Type", status);
                    if(type>=0) {
                        iter.adoptInstead(ubrk_open((UBreakIteratorType)type, cLocaleID, NULL, 0, &status));
                    } else if(type==-2) {
                        // Open a trivial break iterator that only delivers { 0, length }
                        // or even just { 0 } as boundaries.
                        static const UChar rules[] = { 0x2e, 0x2a, 0x3b };  // ".*;"
                        UParseError parseError;
                        iter.adoptInstead(ubrk_openRules(rules, UPRV_LENGTHOF(rules), NULL, 0, &parseError, &status));
                    }
                }
#endif
                options = 0;
                if(whichCase==TEST_TITLE || whichCase==TEST_FOLD) {
                    optionsString = myCase->getString("Options", status);
                    if(optionsString.indexOf((UChar)0x54)>=0) {  // T
                        options|=U_FOLD_CASE_EXCLUDE_SPECIAL_I;
                    }
                    if(optionsString.indexOf((UChar)0x4c)>=0) {  // L
                        options|=U_TITLECASE_NO_LOWERCASE;
                    }
                    if(optionsString.indexOf((UChar)0x41)>=0) {  // A
                        options|=U_TITLECASE_NO_BREAK_ADJUSTMENT;
                    }
                }

                if(U_FAILURE(status)) {
                    dataerrln("error: TestCasing() setup failed for %s test case from casing.res: %s", dataNames[whichCase],  u_errorName(status));
                    status = U_ZERO_ERROR;
                } else {
#if UCONFIG_NO_BREAK_ITERATION
                    LocalPointer<UMemory> iter;
#endif
                    TestCasingImpl(input, output, whichCase, iter.getAlias(), cLocaleID, options);
                }

#if !UCONFIG_NO_BREAK_ITERATION
                iter.adoptInstead(NULL);
#endif
            }
        }
    }

#if !UCONFIG_NO_BREAK_ITERATION
    // more tests for API coverage
    status=U_ZERO_ERROR;
    input=UNICODE_STRING_SIMPLE("sTrA\\u00dfE").unescape();
    (result=input).toTitle(NULL);
    if(result!=UNICODE_STRING_SIMPLE("Stra\\u00dfe").unescape()) {
        dataerrln("UnicodeString::toTitle(NULL) failed.");
    }
#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");
    UnicodeString ss=UNICODE_STRING_SIMPLE("ss");
    FullCaseFoldingIterator iter;
    int32_t count=0;
    int32_t countSpecific=0;
    UChar32 c;
    UnicodeString full;
    while((c=iter.next(full))>=0) {
        ++count;
        // Check that the full Case_Folding has more than 1 code point.
        if(!full.hasMoreChar32Than(0, 0x7fffffff, 1)) {
            errln("error: FullCaseFoldingIterator.next()=U+%04lX full Case_Folding has at most 1 code point", (long)c);
            continue;
        }
        // Check that full == Case_Folding(c).
        UnicodeString cf(c);
        cf.foldCase();
        if(full!=cf) {
            errln("error: FullCaseFoldingIterator.next()=U+%04lX full Case_Folding != cf(c)", (long)c);
            continue;
        }
        // Spot-check a couple of specific cases.
        if((full==ffi && c==0xfb03) || (full==ss && (c==0xdf || c==0x1e9e))) {
            ++countSpecific;
        }
    }
    if(countSpecific!=3) {
        errln("error: FullCaseFoldingIterator did not yield exactly the expected specific cases");
    }
    if(count<70) {
        errln("error: FullCaseFoldingIterator yielded only %d (cp, full) pairs", (int)count);
    }
}

void
StringCaseTest::assertGreekUpper(const char16_t *s, const char16_t *expected) {
    UnicodeString s16(s);
    UnicodeString expected16(expected);
    UnicodeString msg = UnicodeString("UnicodeString::toUpper/Greek(\"") + s16 + "\")";
    UnicodeString result16(s16);
    result16.toUpper(GREEK_LOCALE_);
    assertEquals(msg, expected16, result16);

    msg = UnicodeString("u_strToUpper/Greek(\"") + s16 + "\") cap=";
    int32_t length = expected16.length();
    int32_t capacities[] = {
        // Keep in sync with the UTF-8 capacities near the bottom of this function.
        0, length / 2, length - 1, length, length + 1
    };
    for (int32_t i = 0; i < UPRV_LENGTHOF(capacities); ++i) {
        int32_t cap = capacities[i];
        UChar *dest16 = result16.getBuffer(expected16.length() + 1);
        u_memset(dest16, 0x55AA, result16.getCapacity());
        UErrorCode errorCode = U_ZERO_ERROR;
        length = u_strToUpper(dest16, cap, s16.getBuffer(), s16.length(), "el", &errorCode);
        assertEquals(msg + cap, expected16.length(), length);
        UErrorCode expectedErrorCode;
        if (cap < expected16.length()) {
            expectedErrorCode = U_BUFFER_OVERFLOW_ERROR;
        } else if (cap == expected16.length()) {
            expectedErrorCode = U_STRING_NOT_TERMINATED_WARNING;
        } else {
            expectedErrorCode = U_ZERO_ERROR;
            assertEquals(msg + cap + " NUL", 0, dest16[length]);
        }
        assertEquals(msg + cap + " errorCode", expectedErrorCode, errorCode);
        result16.releaseBuffer(length);
        if (cap >= expected16.length()) {
            assertEquals(msg + cap, expected16, result16);
        }
    }

    UErrorCode errorCode = U_ZERO_ERROR;
    LocalUCaseMapPointer csm(ucasemap_open("el", 0, &errorCode));
    assertSuccess("ucasemap_open", errorCode);
    std::string s8;
    s16.toUTF8String(s8);
    msg = UnicodeString("ucasemap_utf8ToUpper/Greek(\"") + s16 + "\")";
    char dest8[1000];
    length = ucasemap_utf8ToUpper(csm.getAlias(), dest8, UPRV_LENGTHOF(dest8),
                                  s8.data(), static_cast<int32_t>(s8.length()), &errorCode);
    assertSuccess("ucasemap_utf8ToUpper", errorCode);
    StringPiece result8(dest8, length);
    UnicodeString result16From8 = UnicodeString::fromUTF8(result8);
    assertEquals(msg, expected16, result16From8);

    msg += " cap=";
    capacities[1] = length / 2;
    capacities[2] = length - 1;
    capacities[3] = length;
    capacities[4] = length + 1;
    char dest8b[1000];
    int32_t expected8Length = length;  // Assuming the previous call worked.
    for (int32_t i = 0; i < UPRV_LENGTHOF(capacities); ++i) {
        int32_t cap = capacities[i];
        memset(dest8b, 0x5A, UPRV_LENGTHOF(dest8b));
        UErrorCode errorCode = U_ZERO_ERROR;
        length = ucasemap_utf8ToUpper(csm.getAlias(), dest8b, cap,
                                      s8.data(), static_cast<int32_t>(s8.length()), &errorCode);
        assertEquals(msg + cap, expected8Length, length);
        UErrorCode expectedErrorCode;
        if (cap < expected8Length) {
            expectedErrorCode = U_BUFFER_OVERFLOW_ERROR;
        } else if (cap == expected8Length) {
            expectedErrorCode = U_STRING_NOT_TERMINATED_WARNING;
        } else {
            expectedErrorCode = U_ZERO_ERROR;
            // Casts to int32_t to avoid matching UBool.
            assertEquals(msg + cap + " NUL", (int32_t)0, (int32_t)dest8b[length]);
        }
        assertEquals(msg + cap + " errorCode", expectedErrorCode, errorCode);
        if (cap >= expected8Length) {
            assertEquals(msg + cap + " (memcmp)", 0, memcmp(dest8, dest8b, expected8Length));
        }
    }
}

void
StringCaseTest::TestGreekUpper() {
    // http://bugs.icu-project.org/trac/ticket/5456
    assertGreekUpper(u"άδικος, κείμενο, ίριδα", u"ΑΔΙΚΟΣ, ΚΕΙΜΕΝΟ, ΙΡΙΔΑ");
    // https://bugzilla.mozilla.org/show_bug.cgi?id=307039
    // https://bug307039.bmoattachments.org/attachment.cgi?id=194893
    assertGreekUpper(u"Πατάτα", u"ΠΑΤΑΤΑ");
    assertGreekUpper(u"Αέρας, Μυστήριο, Ωραίο", u"ΑΕΡΑΣ, ΜΥΣΤΗΡΙΟ, ΩΡΑΙΟ");
    assertGreekUpper(u"Μαΐου, Πόρος, Ρύθμιση", u"ΜΑΪΟΥ, ΠΟΡΟΣ, ΡΥΘΜΙΣΗ");
    assertGreekUpper(u"ΰ, Τηρώ, Μάιος", u"Ϋ, ΤΗΡΩ, ΜΑΪΟΣ");
    assertGreekUpper(u"άυλος", u"ΑΫΛΟΣ");
    assertGreekUpper(u"ΑΫΛΟΣ", u"ΑΫΛΟΣ");
    assertGreekUpper(u"Άκλιτα ρήματα ή άκλιτες μετοχές", u"ΑΚΛΙΤΑ ΡΗΜΑΤΑ Ή ΑΚΛΙΤΕΣ ΜΕΤΟΧΕΣ");
    // http://www.unicode.org/udhr/d/udhr_ell_monotonic.html
    assertGreekUpper(u"Επειδή η αναγνώριση της αξιοπρέπειας", u"ΕΠΕΙΔΗ Η ΑΝΑΓΝΩΡΙΣΗ ΤΗΣ ΑΞΙΟΠΡΕΠΕΙΑΣ");
    assertGreekUpper(u"νομικού ή διεθνούς", u"ΝΟΜΙΚΟΥ Ή ΔΙΕΘΝΟΥΣ");
    // http://unicode.org/udhr/d/udhr_ell_polytonic.html
    assertGreekUpper(u"Ἐπειδὴ ἡ ἀναγνώριση", u"ΕΠΕΙΔΗ Η ΑΝΑΓΝΩΡΙΣΗ");
    assertGreekUpper(u"νομικοῦ ἢ διεθνοῦς", u"ΝΟΜΙΚΟΥ Ή ΔΙΕΘΝΟΥΣ");
    // From Google bug report
    assertGreekUpper(u"Νέο, Δημιουργία", u"ΝΕΟ, ΔΗΜΙΟΥΡΓΙΑ");
    // http://crbug.com/234797
    assertGreekUpper(u"Ελάτε να φάτε τα καλύτερα παϊδάκια!", u"ΕΛΑΤΕ ΝΑ ΦΑΤΕ ΤΑ ΚΑΛΥΤΕΡΑ ΠΑΪΔΑΚΙΑ!");
    assertGreekUpper(u"Μαΐου, τρόλεϊ", u"ΜΑΪΟΥ, ΤΡΟΛΕΪ");
    assertGreekUpper(u"Το ένα ή το άλλο.", u"ΤΟ ΕΝΑ Ή ΤΟ ΑΛΛΟ.");
    // http://multilingualtypesetting.co.uk/blog/greek-typesetting-tips/
    assertGreekUpper(u"ρωμέικα", u"ΡΩΜΕΪΚΑ");
    assertGreekUpper(u"ή.", u"Ή.");
}

void StringCaseTest::TestArmenian() {
    Locale hy("hy");  // Eastern Armenian
    Locale hyw("hyw");  // Western Armenian
    Locale root = Locale::getRoot();
    // See ICU-13416:
    // և ligature ech-yiwn
    // uppercases to ԵՒ=ech+yiwn by default and in Western Armenian,
    // but to ԵՎ=ech+vew in Eastern Armenian.
    UnicodeString s(u"և Երևանի");

    assertEquals("upper root", u"ԵՒ ԵՐԵՒԱՆԻ", UnicodeString(s).toUpper(root));
    assertEquals("upper hy", u"ԵՎ ԵՐԵՎԱՆԻ", UnicodeString(s).toUpper(hy));
    assertEquals("upper hyw", u"ԵՒ ԵՐԵՒԱՆԻ", UnicodeString(s).toUpper(hyw));

    assertEquals("title root", u"Եւ Երևանի", UnicodeString(s).toTitle(nullptr, root));
    assertEquals("title hy", u"Եվ Երևանի", UnicodeString(s).toTitle(nullptr, hy));
    assertEquals("title hyw", u"Եւ Երևանի", UnicodeString(s).toTitle(nullptr, hyw));
}

void
StringCaseTest::TestLongUpper() {
    if (quick) {
        logln("not exhaustive mode: skipping this test");
        return;
    }
    // Ticket #12663, crash with an extremely long string where
    // U+0390 maps to 0399 0308 0301 so that the result is three times as long
    // and overflows an int32_t.
    int32_t length = 0x40000004;  // more than 1G UChars
    UnicodeString s(length, (UChar32)0x390, length);
    UnicodeString result;
    UChar *dest = result.getBuffer(length + 1);
    if (s.isBogus() || dest == NULL) {
        logln("Out of memory, unable to run this test on this machine.");
        return;
    }
    IcuTestErrorCode errorCode(*this, "TestLongUpper");
    int32_t destLength = u_strToUpper(dest, result.getCapacity(),
                                      s.getBuffer(), s.length(), "", errorCode);
    result.releaseBuffer(destLength);
    if (errorCode.reset() != U_INDEX_OUTOFBOUNDS_ERROR) {
        errln("expected U_INDEX_OUTOFBOUNDS_ERROR, got %s (destLength is undefined, got %ld)",
              errorCode.errorName(), (long)destLength);
    }
}

void StringCaseTest::TestMalformedUTF8() {
    // ticket #12639
    IcuTestErrorCode errorCode(*this, "TestMalformedUTF8");
    LocalUCaseMapPointer csm(ucasemap_open("en", U_TITLECASE_NO_BREAK_ADJUSTMENT, errorCode));
    if (errorCode.isFailure()) {
        errln("ucasemap_open(English) failed - %s", errorCode.errorName());
        return;
    }
    char src[1] = { (char)0x85 };  // malformed UTF-8
    char dest[3] = { 0, 0, 0 };
    int32_t destLength;
#if !UCONFIG_NO_BREAK_ITERATION
    destLength = ucasemap_utf8ToTitle(csm.getAlias(), dest, 3, src, 1, errorCode);
    if (errorCode.isFailure() || destLength != 1 || dest[0] != src[0]) {
        errln("ucasemap_utf8ToTitle(\\x85) failed: %s destLength=%d dest[0]=0x%02x",
              errorCode.errorName(), (int)destLength, dest[0]);
    }
#endif

    errorCode.reset();
    dest[0] = 0;
    destLength = ucasemap_utf8ToLower(csm.getAlias(), dest, 3, src, 1, errorCode);
    if (errorCode.isFailure() || destLength != 1 || dest[0] != src[0]) {
        errln("ucasemap_utf8ToLower(\\x85) failed: %s destLength=%d dest[0]=0x%02x",
              errorCode.errorName(), (int)destLength, dest[0]);
    }

    errorCode.reset();
    dest[0] = 0;
    destLength = ucasemap_utf8ToUpper(csm.getAlias(), dest, 3, src, 1, errorCode);
    if (errorCode.isFailure() || destLength != 1 || dest[0] != src[0]) {
        errln("ucasemap_utf8ToUpper(\\x85) failed: %s destLength=%d dest[0]=0x%02x",
              errorCode.errorName(), (int)destLength, dest[0]);
    }

    errorCode.reset();
    dest[0] = 0;
    destLength = ucasemap_utf8FoldCase(csm.getAlias(), dest, 3, src, 1, errorCode);
    if (errorCode.isFailure() || destLength != 1 || dest[0] != src[0]) {
        errln("ucasemap_utf8FoldCase(\\x85) failed: %s destLength=%d dest[0]=0x%02x",
              errorCode.errorName(), (int)destLength, dest[0]);
    }
}

void StringCaseTest::TestBufferOverflow() {
    // Ticket #12849, incorrect result from Title Case preflight operation, 
    // when buffer overflow error is expected.
    IcuTestErrorCode errorCode(*this, "TestBufferOverflow");
    LocalUCaseMapPointer csm(ucasemap_open("en", 0, errorCode));
    if (errorCode.isFailure()) {
        errln("ucasemap_open(English) failed - %s", errorCode.errorName());
        return;
    }

    UnicodeString data("hello world");
    int32_t result;
#if !UCONFIG_NO_BREAK_ITERATION
    result = ucasemap_toTitle(csm.getAlias(), NULL, 0, data.getBuffer(), data.length(), errorCode);
    if (errorCode.get() != U_BUFFER_OVERFLOW_ERROR || result != data.length()) {
        errln("%s:%d ucasemap_toTitle(\"hello world\") failed: "
              "expected (U_BUFFER_OVERFLOW_ERROR, %d), got (%s, %d)",
              __FILE__, __LINE__, data.length(), errorCode.errorName(), result);
    }
#endif
    errorCode.reset();

    std::string data_utf8;
    data.toUTF8String(data_utf8);
#if !UCONFIG_NO_BREAK_ITERATION
    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)",
              __FILE__, __LINE__, data_utf8.length(), errorCode.errorName(), result);
    }
#endif
    errorCode.reset();
}

void StringCaseTest::TestEdits() {
    IcuTestErrorCode errorCode(*this, "TestEdits");
    Edits edits;
    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 hasChanges", edits.hasChanges());
    assertEquals("unchanged 10003 numberOfChanges", 0, edits.numberOfChanges());
    assertEquals("unchanged 10003", 0, edits.lengthDelta());
    edits.addReplace(2, 1);  // multiple short equal-lengths edits are compressed
    edits.addUnchanged(0);
    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 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, 103106, 104013 }
    };
    TestUtility::checkEditsIter(*this, u"coarse",
            edits.getCoarseIterator(), edits.getCoarseIterator(),
            coarseExpectedChanges, UPRV_LENGTHOF(coarseExpectedChanges), TRUE, errorCode);
    TestUtility::checkEditsIter(*this, u"coarse changes",
            edits.getCoarseChangesIterator(), edits.getCoarseChangesIterator(),
            coarseExpectedChanges, UPRV_LENGTHOF(coarseExpectedChanges), FALSE, errorCode);

    static const EditChange fineExpectedChanges[] = {
            { FALSE, 10003, 10003 },
            { TRUE, 2, 1 },
            { TRUE, 2, 1 },
            { TRUE, 2, 1 },
            { TRUE, 0, 10 },
            { TRUE, 100, 0 },
            { TRUE, 3000, 4000 },
            { TRUE, 100000, 100000 }
    };
    TestUtility::checkEditsIter(*this, u"fine",
            edits.getFineIterator(), edits.getFineIterator(),
            fineExpectedChanges, UPRV_LENGTHOF(fineExpectedChanges), TRUE, errorCode);
    TestUtility::checkEditsIter(*this, u"fine changes",
            edits.getFineChangesIterator(), edits.getFineChangesIterator(),
            fineExpectedChanges, UPRV_LENGTHOF(fineExpectedChanges), FALSE, errorCode);

    edits.reset();
    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, "TestCaseMapWithEdits");
    UChar dest[20];
    Edits edits;

    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, 4, 4 },
            { TRUE, 1, 1 },
            { FALSE, 2, 2 }
    };
    TestUtility::checkEditsIter(*this, u"toLower(IstanBul)",
            edits.getFineIterator(), edits.getFineIterator(),
            lowerExpectedChanges, UPRV_LENGTHOF(lowerExpectedChanges),
            TRUE, errorCode);

    edits.reset();
    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[] = {
            { FALSE, 1, 1 },
            { TRUE, 1, 1 },
            { TRUE, 1, 1 },
            { TRUE, 1, 1 },
            { TRUE, 1, 1 },
            { TRUE, 1, 1 }
    };
    TestUtility::checkEditsIter(*this, u"toUpper(Πατάτα)",
            edits.getFineIterator(), edits.getFineIterator(),
            upperExpectedChanges, UPRV_LENGTHOF(upperExpectedChanges),
            TRUE, errorCode);

    edits.reset();

#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), &edits, errorCode);
    assertEquals(u"toTitle(IjssEL IglOo)", UnicodeString(u"J"), UnicodeString(TRUE, dest, length));
    static const EditChange titleExpectedChanges[] = {
            { FALSE, 1, 1 },
            { TRUE, 1, 1 },
            { FALSE, 10, 10 }
    };
    TestUtility::checkEditsIter(*this, u"toTitle(IjssEL IglOo)",
            edits.getFineIterator(), edits.getFineIterator(),
            titleExpectedChanges, UPRV_LENGTHOF(titleExpectedChanges),
            TRUE, errorCode);
#endif

    // 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 }
    };
    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, "TestCaseMapUTF8WithEdits");
    char dest[50];
    Edits edits;

    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, 2 },
            { FALSE, 4, 4 },
            { TRUE, 1, 1 },
            { FALSE, 2, 2 }
    };
    TestUtility::checkEditsIter(*this, u"toLower(IstanBul)",
            edits.getFineIterator(), edits.getFineIterator(),
            lowerExpectedChanges, UPRV_LENGTHOF(lowerExpectedChanges),
            TRUE, errorCode);

    edits.reset();
    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[] = {
            { FALSE, 2, 2 },
            { TRUE, 2, 2 },
            { TRUE, 2, 2 },
            { TRUE, 2, 2 },
            { TRUE, 2, 2 },
            { TRUE, 2, 2 }
    };
    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",
                                  U_OMIT_UNCHANGED_TEXT |
                                  U_TITLECASE_NO_BREAK_ADJUSTMENT |
                                  U_TITLECASE_NO_LOWERCASE,
                                  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)));
    static const EditChange titleExpectedChanges[] = {
            { FALSE, 1, 1 },
            { TRUE, 1, 1 },
            { FALSE, 10, 10 }
    };
    TestUtility::checkEditsIter(*this, u"toTitle(IjssEL IglOo)",
            edits.getFineIterator(), edits.getFineIterator(),
            titleExpectedChanges, UPRV_LENGTHOF(titleExpectedChanges),
            TRUE, errorCode);
#endif

    // 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 }
    };
    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, u8"IstanBul", sink, nullptr, errorCode);
    assertEquals(u"toLower(IstanBul)", UnicodeString(u"ıb"), UnicodeString::fromUTF8(dest));
    dest.clear();
    CaseMap::utf8ToUpper("el", U_OMIT_UNCHANGED_TEXT, 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, 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,
                      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, u8"IstanBul", sink, nullptr, errorCode);
    assertEquals(u"toLower(IstanBul)", UnicodeString(u"ıstanbul"),
                 UnicodeString::fromUTF8(dest));
    dest.clear();
    CaseMap::utf8ToUpper("el", 0, 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, 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, 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.
    UnicodeString s(TRUE,
        (const UChar *)
        u"aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeeF"
        u"aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeeF"
        u"aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeeF"
        u"aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeeF"
        u"aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeeF"
        u"aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeeF", 6 * 51);
    UnicodeString expected(TRUE,
        (const UChar *)
        u"AAAAAAAAAABBBBBBBBBBCCCCCCCCCCDDDDDDDDDDEEEEEEEEEEF"
        u"AAAAAAAAAABBBBBBBBBBCCCCCCCCCCDDDDDDDDDDEEEEEEEEEEF"
        u"AAAAAAAAAABBBBBBBBBBCCCCCCCCCCDDDDDDDDDDEEEEEEEEEEF"
        u"AAAAAAAAAABBBBBBBBBBCCCCCCCCCCDDDDDDDDDDEEEEEEEEEEF"
        u"AAAAAAAAAABBBBBBBBBBCCCCCCCCCCDDDDDDDDDDEEEEEEEEEEF"
        u"AAAAAAAAAABBBBBBBBBBCCCCCCCCCCDDDDDDDDDDEEEEEEEEEEF", 6 * 51);
    s.toUpper(Locale::getRoot());
    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