// © 2017 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

// ucptrietest.c (modified from trie2test.c)
// created: 2017dec29 Markus W. Scherer

#include <stdio.h>
#include "unicode/utypes.h"
#include "unicode/ucptrie.h"
#include "unicode/umutablecptrie.h"
#include "unicode/utf.h"
#include "unicode/utf16.h"
#include "unicode/utf8.h"
#include "uassert.h"
#include "ucptrie_impl.h"
#include "utrie.h"
#include "cstring.h"
#include "cmemory.h"
#include "udataswp.h"
#include "cintltst.h"

void addUCPTrieTest(TestNode** root);

/* Values for setting possibly overlapping, out-of-order ranges of values */
typedef struct SetRange {
    UChar32 start, limit;
    uint32_t value;
} SetRange;

/*
 * Values for testing:
 * value is set from the previous boundary's limit to before
 * this boundary's limit
 *
 * There must be an entry with limit 0 and the intialValue.
 * It may be preceded by an entry with negative limit and the errorValue.
 */
typedef struct CheckRange {
    UChar32 limit;
    uint32_t value;
} CheckRange;

static int32_t
skipSpecialValues(const CheckRange checkRanges[], int32_t countCheckRanges) {
    int32_t i;
    for(i=0; i<countCheckRanges && checkRanges[i].limit<=0; ++i) {}
    return i;
}

static int32_t
getSpecialValues(const CheckRange checkRanges[], int32_t countCheckRanges,
                 uint32_t *pInitialValue, uint32_t *pErrorValue) {
    int32_t i=0;
    if(i<countCheckRanges && checkRanges[i].limit<0) {
        *pErrorValue=checkRanges[i++].value;
    } else {
        *pErrorValue=0xad;
    }
    if(i<countCheckRanges && checkRanges[i].limit==0) {
        *pInitialValue=checkRanges[i++].value;
    } else {
        *pInitialValue=0;
    }
    return i;
}

/* ucptrie_enum() callback, modifies a value */
static uint32_t U_CALLCONV
testFilter(const void *context, uint32_t value) {
    (void)context; // suppress compiler warnings about unused variable
    return value ^ 0x5555;
}

static UBool
doCheckRange(const char *name, const char *variant,
             UChar32 start, UChar32 end, uint32_t value,
             UChar32 expEnd, uint32_t expValue) {
    if (end < 0) {
        if (expEnd >= 0) {
            log_err("error: %s getRanges (%s) fails to deliver range [U+%04lx..U+%04lx].0x%lx\n",
                    name, variant, (long)start, (long)expEnd, (long)expValue);
        }
        return FALSE;
    }
    if (expEnd < 0) {
        log_err("error: %s getRanges (%s) delivers unexpected range [U+%04lx..U+%04lx].0x%lx\n",
                name, variant, (long)start, (long)end, (long)value);
        return FALSE;
    }
    if (end != expEnd || value != expValue) {
        log_err("error: %s getRanges (%s) delivers wrong range [U+%04lx..U+%04lx].0x%lx "
                "instead of [U+%04lx..U+%04lx].0x%lx\n",
                name, variant, (long)start, (long)end, (long)value,
                (long)start, (long)expEnd, (long)expValue);
        return FALSE;
    }
    return TRUE;
}

// Test iteration starting from various UTF-8/16 and trie structure boundaries.
// Also test starting partway through lead & trail surrogates for fixed-surrogate-value options,
// and partway through supplementary code points.
static UChar32 iterStarts[] = {
    0, 0x7f, 0x80, 0x7ff, 0x800, 0xfff, 0x1000,
    0xd7ff, 0xd800, 0xd888, 0xdddd, 0xdfff, 0xe000,
    0xffff, 0x10000, 0x12345, 0x10ffff, 0x110000
};

static void
testTrieGetRanges(const char *testName, const UCPTrie *trie, const UMutableCPTrie *mutableTrie,
                  UCPMapRangeOption option, uint32_t surrValue,
                  const CheckRange checkRanges[], int32_t countCheckRanges) {
    const char *const typeName = trie == NULL ? "mutableTrie" : "trie";
    const char *const optionName = option == UCPMAP_RANGE_NORMAL ? "normal" :
        option == UCPMAP_RANGE_FIXED_LEAD_SURROGATES ? "fixedLeadSurr" : "fixedAllSurr";
    char name[80];
    int32_t s;
    for (s = 0; s < UPRV_LENGTHOF(iterStarts); ++s) {
        UChar32 start = iterStarts[s];
        int32_t i, i0;
        UChar32 end, expEnd;
        uint32_t value, expValue;
        // No need to go from each iteration start to the very end.
        int32_t innerLoopCount;

        sprintf(name, "%s/%s(%s) min=U+%04lx", typeName, optionName, testName, (long)start);

        // Skip over special values and low ranges.
        for (i = 0; i < countCheckRanges && checkRanges[i].limit <= start; ++i) {}
        i0 = i;
        // without value handler
        for (innerLoopCount = 0;; ++i, start = end + 1) {
            if (i < countCheckRanges) {
                expEnd = checkRanges[i].limit - 1;
                expValue = checkRanges[i].value;
            } else {
                expEnd = -1;
                expValue = value = 0x5005;
            }
            end = trie != NULL ?
                ucptrie_getRange(trie, start, option, surrValue, NULL, NULL, &value) :
                umutablecptrie_getRange(mutableTrie, start, option, surrValue, NULL, NULL, &value);
            if (!doCheckRange(name, "without value handler", start, end, value, expEnd, expValue)) {
                break;
            }
            if (s != 0 && ++innerLoopCount == 5) { break; }
        }
        // with value handler
        for (i = i0, start = iterStarts[s], innerLoopCount = 0;; ++i, start = end + 1) {
            if (i < countCheckRanges) {
                expEnd = checkRanges[i].limit - 1;
                expValue = checkRanges[i].value ^ 0x5555;
            } else {
                expEnd = -1;
                expValue = value = 0x5005;
            }
            end = trie != NULL ?
                ucptrie_getRange(trie, start, option, surrValue ^ 0x5555, testFilter, NULL, &value) :
                umutablecptrie_getRange(mutableTrie, start, option, surrValue ^ 0x5555,
                                        testFilter, NULL, &value);
            if (!doCheckRange(name, "with value handler", start, end, value, expEnd, expValue)) {
                break;
            }
            if (s != 0 && ++innerLoopCount == 5) { break; }
        }
        // without value
        for (i = i0, start = iterStarts[s], innerLoopCount = 0;; ++i, start = end + 1) {
            if (i < countCheckRanges) {
                expEnd = checkRanges[i].limit - 1;
            } else {
                expEnd = -1;
            }
            end = trie != NULL ?
                ucptrie_getRange(trie, start, option, surrValue, NULL, NULL, NULL) :
                umutablecptrie_getRange(mutableTrie, start, option, surrValue, NULL, NULL, NULL);
            if (!doCheckRange(name, "without value", start, end, 0, expEnd, 0)) {
                break;
            }
            if (s != 0 && ++innerLoopCount == 5) { break; }
        }
    }
}

static void
testTrieGetters(const char *testName, const UCPTrie *trie,
                UCPTrieType type, UCPTrieValueWidth valueWidth,
                const CheckRange checkRanges[], int32_t countCheckRanges) {
    uint32_t initialValue, errorValue;
    uint32_t value, value2;
    UChar32 start, limit;
    int32_t i, countSpecials;
    int32_t countErrors=0;

    const char *const typeName = "trie";

    countSpecials=getSpecialValues(checkRanges, countCheckRanges, &initialValue, &errorValue);

    start=0;
    for(i=countSpecials; i<countCheckRanges; ++i) {
        limit=checkRanges[i].limit;
        value=checkRanges[i].value;

        while(start<limit) {
            if (start <= 0x7f) {
                if (valueWidth == UCPTRIE_VALUE_BITS_16) {
                    value2 = UCPTRIE_ASCII_GET(trie, UCPTRIE_16, start);
                } else if (valueWidth == UCPTRIE_VALUE_BITS_32) {
                    value2 = UCPTRIE_ASCII_GET(trie, UCPTRIE_32, start);
                } else {
                    value2 = UCPTRIE_ASCII_GET(trie, UCPTRIE_8, start);
                }
                if (value != value2) {
                    log_err("error: %s(%s).fromASCII(U+%04lx)==0x%lx instead of 0x%lx\n",
                            typeName, testName, (long)start, (long)value2, (long)value);
                    ++countErrors;
                }
            }
            if (type == UCPTRIE_TYPE_FAST) {
                if(start<=0xffff) {
                    if(valueWidth==UCPTRIE_VALUE_BITS_16) {
                        value2=UCPTRIE_FAST_BMP_GET(trie, UCPTRIE_16, start);
                    } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
                        value2=UCPTRIE_FAST_BMP_GET(trie, UCPTRIE_32, start);
                    } else {
                        value2=UCPTRIE_FAST_BMP_GET(trie, UCPTRIE_8, start);
                    }
                    if(value!=value2) {
                        log_err("error: %s(%s).fromBMP(U+%04lx)==0x%lx instead of 0x%lx\n",
                                typeName, testName, (long)start, (long)value2, (long)value);
                        ++countErrors;
                    }
                } else {
                    if(valueWidth==UCPTRIE_VALUE_BITS_16) {
                        value2 = UCPTRIE_FAST_SUPP_GET(trie, UCPTRIE_16, start);
                    } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
                        value2 = UCPTRIE_FAST_SUPP_GET(trie, UCPTRIE_32, start);
                    } else {
                        value2 = UCPTRIE_FAST_SUPP_GET(trie, UCPTRIE_8, start);
                    }
                    if(value!=value2) {
                        log_err("error: %s(%s).fromSupp(U+%04lx)==0x%lx instead of 0x%lx\n",
                                typeName, testName, (long)start, (long)value2, (long)value);
                        ++countErrors;
                    }
                }
                if(valueWidth==UCPTRIE_VALUE_BITS_16) {
                    value2 = UCPTRIE_FAST_GET(trie, UCPTRIE_16, start);
                } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
                    value2 = UCPTRIE_FAST_GET(trie, UCPTRIE_32, start);
                } else {
                    value2 = UCPTRIE_FAST_GET(trie, UCPTRIE_8, start);
                }
            } else {
                if(valueWidth==UCPTRIE_VALUE_BITS_16) {
                    value2 = UCPTRIE_SMALL_GET(trie, UCPTRIE_16, start);
                } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
                    value2 = UCPTRIE_SMALL_GET(trie, UCPTRIE_32, start);
                } else {
                    value2 = UCPTRIE_SMALL_GET(trie, UCPTRIE_8, start);
                }
            }
            if(value!=value2) {
                log_err("error: %s(%s).get(U+%04lx)==0x%lx instead of 0x%lx\n",
                        typeName, testName, (long)start, (long)value2, (long)value);
                ++countErrors;
            }
            value2=ucptrie_get(trie, start);
            if(value!=value2) {
                log_err("error: %s(%s).get(U+%04lx)==0x%lx instead of 0x%lx\n",
                        typeName, testName, (long)start, (long)value2, (long)value);
                ++countErrors;
            }
            ++start;
            if(countErrors>10) {
                return;
            }
        }
    }

    /* test linear ASCII range from the data array pointer (access to "internal" field) */
    start=0;
    for(i=countSpecials; i<countCheckRanges && start<=0x7f; ++i) {
        limit=checkRanges[i].limit;
        value=checkRanges[i].value;

        while(start<limit && start<=0x7f) {
            if(valueWidth==UCPTRIE_VALUE_BITS_16) {
                value2=trie->data.ptr16[start];
            } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
                value2=trie->data.ptr32[start];
            } else {
                value2=trie->data.ptr8[start];
            }
            if(value!=value2) {
                log_err("error: %s(%s).asciiData[U+%04lx]==0x%lx instead of 0x%lx\n",
                        typeName, testName, (long)start, (long)value2, (long)value);
                ++countErrors;
            }
            ++start;
            if(countErrors>10) {
                return;
            }
        }
    }

    /* test errorValue */
    if (type == UCPTRIE_TYPE_FAST) {
        if(valueWidth==UCPTRIE_VALUE_BITS_16) {
            value = UCPTRIE_FAST_GET(trie, UCPTRIE_16, -1);
            value2 = UCPTRIE_FAST_GET(trie, UCPTRIE_16, 0x110000);
        } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
            value = UCPTRIE_FAST_GET(trie, UCPTRIE_32, -1);
            value2 = UCPTRIE_FAST_GET(trie, UCPTRIE_32, 0x110000);
        } else {
            value = UCPTRIE_FAST_GET(trie, UCPTRIE_8, -1);
            value2 = UCPTRIE_FAST_GET(trie, UCPTRIE_8, 0x110000);
        }
    } else {
        if(valueWidth==UCPTRIE_VALUE_BITS_16) {
            value = UCPTRIE_SMALL_GET(trie, UCPTRIE_16, -1);
            value2 = UCPTRIE_SMALL_GET(trie, UCPTRIE_16, 0x110000);
        } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
            value = UCPTRIE_SMALL_GET(trie, UCPTRIE_32, -1);
            value2 = UCPTRIE_SMALL_GET(trie, UCPTRIE_32, 0x110000);
        } else {
            value = UCPTRIE_SMALL_GET(trie, UCPTRIE_8, -1);
            value2 = UCPTRIE_SMALL_GET(trie, UCPTRIE_8, 0x110000);
        }
    }
    if(value!=errorValue || value2!=errorValue) {
        log_err("error: %s(%s).get(out of range) != errorValue\n",
                typeName, testName);
    }
    value=ucptrie_get(trie, -1);
    value2=ucptrie_get(trie, 0x110000);
    if(value!=errorValue || value2!=errorValue) {
        log_err("error: %s(%s).get(out of range) != errorValue\n",
                typeName, testName);
    }
}

static void
testBuilderGetters(const char *testName, const UMutableCPTrie *mutableTrie,
                   const CheckRange checkRanges[], int32_t countCheckRanges) {
    uint32_t initialValue, errorValue;
    uint32_t value, value2;
    UChar32 start, limit;
    int32_t i, countSpecials;
    int32_t countErrors=0;

    const char *const typeName = "mutableTrie";

    countSpecials=getSpecialValues(checkRanges, countCheckRanges, &initialValue, &errorValue);

    start=0;
    for(i=countSpecials; i<countCheckRanges; ++i) {
        limit=checkRanges[i].limit;
        value=checkRanges[i].value;

        while(start<limit) {
            value2=umutablecptrie_get(mutableTrie, start);
            if(value!=value2) {
                log_err("error: %s(%s).get(U+%04lx)==0x%lx instead of 0x%lx\n",
                        typeName, testName, (long)start, (long)value2, (long)value);
                ++countErrors;
            }
            ++start;
            if(countErrors>10) {
                return;
            }
        }
    }

    /* test errorValue */
    value=umutablecptrie_get(mutableTrie, -1);
    value2=umutablecptrie_get(mutableTrie, 0x110000);
    if(value!=errorValue || value2!=errorValue) {
        log_err("error: %s(%s).get(out of range) != errorValue\n",
                typeName, testName);
    }
}

#define ACCIDENTAL_SURROGATE_PAIR(s, length, cp) (length > 0 && U16_IS_LEAD(s[length-1]) && U_IS_TRAIL(cp))

static void
testTrieUTF16(const char *testName,
              const UCPTrie *trie, UCPTrieValueWidth valueWidth,
              const CheckRange checkRanges[], int32_t countCheckRanges) {
    UChar s[30000];
    uint32_t values[16000];

    const UChar *p, *limit;

    uint32_t errorValue = ucptrie_get(trie, -1);
    uint32_t value, expected;
    UChar32 prevCP, c, c2;
    int32_t i, length, sIndex, countValues;

    /* write a string */
    prevCP=0;
    length=countValues=0;
    for(i=skipSpecialValues(checkRanges, countCheckRanges); i<countCheckRanges; ++i) {
        value=checkRanges[i].value;
        /* write three code points */
        if(!ACCIDENTAL_SURROGATE_PAIR(s, length, prevCP)) {
            U16_APPEND_UNSAFE(s, length, prevCP);   /* start of the range */
            values[countValues++]=value;
        }
        U_ASSERT(length < UPRV_LENGTHOF(s) && countValues < UPRV_LENGTHOF(values));
        c=checkRanges[i].limit;
        prevCP=(prevCP+c)/2;                    /* middle of the range */
        if(!ACCIDENTAL_SURROGATE_PAIR(s, length, prevCP)) {
            U16_APPEND_UNSAFE(s, length, prevCP);
            values[countValues++]=value;
        }
        prevCP=c;
        --c;                                    /* end of the range */
        if(!ACCIDENTAL_SURROGATE_PAIR(s, length, c)) {
            U16_APPEND_UNSAFE(s, length, c);
            values[countValues++]=value;
        }
    }
    limit=s+length;
    if(length>UPRV_LENGTHOF(s)) {
        log_err("UTF-16 test string length %d > capacity %d\n", (int)length, (int)UPRV_LENGTHOF(s));
        return;
    }
    if(countValues>UPRV_LENGTHOF(values)) {
        log_err("UTF-16 test values length %d > capacity %d\n", (int)countValues, (int)UPRV_LENGTHOF(values));
        return;
    }

    /* try forward */
    p=s;
    i=0;
    while(p<limit) {
        sIndex=(int32_t)(p-s);
        U16_NEXT(s, sIndex, length, c2);
        c=0x33;
        if(valueWidth==UCPTRIE_VALUE_BITS_16) {
            UCPTRIE_FAST_U16_NEXT(trie, UCPTRIE_16, p, limit, c, value);
        } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
            UCPTRIE_FAST_U16_NEXT(trie, UCPTRIE_32, p, limit, c, value);
        } else {
            UCPTRIE_FAST_U16_NEXT(trie, UCPTRIE_8, p, limit, c, value);
        }
        expected = U_IS_SURROGATE(c) ? errorValue : values[i];
        if(value!=expected) {
            log_err("error: wrong value from UCPTRIE_NEXT(%s)(U+%04lx): 0x%lx instead of 0x%lx\n",
                    testName, (long)c, (long)value, (long)expected);
        }
        if(c!=c2) {
            log_err("error: wrong code point from UCPTRIE_NEXT(%s): U+%04lx != U+%04lx\n",
                    testName, (long)c, (long)c2);
            continue;
        }
        ++i;
    }

    /* try backward */
    p=limit;
    i=countValues;
    while(s<p) {
        --i;
        sIndex=(int32_t)(p-s);
        U16_PREV(s, 0, sIndex, c2);
        c=0x33;
        if(valueWidth==UCPTRIE_VALUE_BITS_16) {
            UCPTRIE_FAST_U16_PREV(trie, UCPTRIE_16, s, p, c, value);
        } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
            UCPTRIE_FAST_U16_PREV(trie, UCPTRIE_32, s, p, c, value);
        } else {
            UCPTRIE_FAST_U16_PREV(trie, UCPTRIE_8, s, p, c, value);
        }
        expected = U_IS_SURROGATE(c) ? errorValue : values[i];
        if(value!=expected) {
            log_err("error: wrong value from UCPTRIE_PREV(%s)(U+%04lx): 0x%lx instead of 0x%lx\n",
                    testName, (long)c, (long)value, (long)expected);
        }
        if(c!=c2) {
            log_err("error: wrong code point from UCPTRIE_PREV(%s): U+%04lx != U+%04lx\n",
                    testName, c, c2);
        }
    }
}

static void
testTrieUTF8(const char *testName,
             const UCPTrie *trie, UCPTrieValueWidth valueWidth,
             const CheckRange checkRanges[], int32_t countCheckRanges) {
    // Note: The byte sequence comments refer to the original UTF-8 definition.
    // Starting with ICU 60, any sequence that is not a prefix of a valid one
    // is treated as multiple single-byte errors.
    // For testing, we only rely on U8_... and UCPTrie UTF-8 macros
    // iterating consistently.
    static const uint8_t illegal[]={
        0xc0, 0x80,                         /* non-shortest U+0000 */
        0xc1, 0xbf,                         /* non-shortest U+007f */
        0xc2,                               /* truncated */
        0xe0, 0x90, 0x80,                   /* non-shortest U+0400 */
        0xe0, 0xa0,                         /* truncated */
        0xed, 0xa0, 0x80,                   /* lead surrogate U+d800 */
        0xed, 0xbf, 0xbf,                   /* trail surrogate U+dfff */
        0xf0, 0x8f, 0xbf, 0xbf,             /* non-shortest U+ffff */
        0xf0, 0x90, 0x80,                   /* truncated */
        0xf4, 0x90, 0x80, 0x80,             /* beyond-Unicode U+110000 */
        0xf8, 0x80, 0x80, 0x80,             /* truncated */
        0xf8, 0x80, 0x80, 0x80, 0x80,       /* 5-byte UTF-8 */
        0xfd, 0xbf, 0xbf, 0xbf, 0xbf,       /* truncated */
        0xfd, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, /* 6-byte UTF-8 */
        0xfe,
        0xff
    };
    uint8_t s[60000];
    uint32_t values[16000];

    const uint8_t *p, *limit;

    uint32_t initialValue, errorValue;
    uint32_t value, expectedBytes, actualBytes;
    UChar32 prevCP, c;
    int32_t i, countSpecials, length, countValues;
    int32_t prev8, i8;

    countSpecials=getSpecialValues(checkRanges, countCheckRanges, &initialValue, &errorValue);

    /* write a string */
    prevCP=0;
    length=countValues=0;
    /* first a couple of trail bytes in lead position */
    s[length++]=0x80;
    values[countValues++]=errorValue;
    s[length++]=0xbf;
    values[countValues++]=errorValue;
    prev8=i8=0;
    for(i=countSpecials; i<countCheckRanges; ++i) {
        value=checkRanges[i].value;
        /* write three legal (or surrogate) code points */
        U8_APPEND_UNSAFE(s, length, prevCP);    /* start of the range */
        if(U_IS_SURROGATE(prevCP)) {
            // A surrogate byte sequence counts as 3 single-byte errors.
            values[countValues++]=errorValue;
            values[countValues++]=errorValue;
            values[countValues++]=errorValue;
        } else {
            values[countValues++]=value;
        }
        U_ASSERT(length < UPRV_LENGTHOF(s) && countValues < UPRV_LENGTHOF(values));
        c=checkRanges[i].limit;
        prevCP=(prevCP+c)/2;                    /* middle of the range */
        U8_APPEND_UNSAFE(s, length, prevCP);
        if(U_IS_SURROGATE(prevCP)) {
            // A surrogate byte sequence counts as 3 single-byte errors.
            values[countValues++]=errorValue;
            values[countValues++]=errorValue;
            values[countValues++]=errorValue;
        } else {
            values[countValues++]=value;
        }
        prevCP=c;
        --c;                                    /* end of the range */
        U8_APPEND_UNSAFE(s, length, c);
        if(U_IS_SURROGATE(c)) {
            // A surrogate byte sequence counts as 3 single-byte errors.
            values[countValues++]=errorValue;
            values[countValues++]=errorValue;
            values[countValues++]=errorValue;
        } else {
            values[countValues++]=value;
        }
        /* write an illegal byte sequence */
        if(i8<(int32_t)sizeof(illegal)) {
            U8_FWD_1(illegal, i8, sizeof(illegal));
            while(prev8<i8) {
                s[length++]=illegal[prev8++];
            }
            values[countValues++]=errorValue;
        }
    }
    /* write the remaining illegal byte sequences */
    while(i8<(int32_t)sizeof(illegal)) {
        U8_FWD_1(illegal, i8, sizeof(illegal));
        while(prev8<i8) {
            s[length++]=illegal[prev8++];
        }
        values[countValues++]=errorValue;
    }
    limit=s+length;
    if(length>UPRV_LENGTHOF(s)) {
        log_err("UTF-8 test string length %d > capacity %d\n", (int)length, (int)UPRV_LENGTHOF(s));
        return;
    }
    if(countValues>UPRV_LENGTHOF(values)) {
        log_err("UTF-8 test values length %d > capacity %d\n", (int)countValues, (int)UPRV_LENGTHOF(values));
        return;
    }

    /* try forward */
    p=s;
    i=0;
    while(p<limit) {
        prev8=i8=(int32_t)(p-s);
        U8_NEXT(s, i8, length, c);
        if(valueWidth==UCPTRIE_VALUE_BITS_16) {
            UCPTRIE_FAST_U8_NEXT(trie, UCPTRIE_16, p, limit, value);
        } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
            UCPTRIE_FAST_U8_NEXT(trie, UCPTRIE_32, p, limit, value);
        } else {
            UCPTRIE_FAST_U8_NEXT(trie, UCPTRIE_8, p, limit, value);
        }
        expectedBytes=0;
        if(value!=values[i] || i8!=(p-s)) {
            int32_t k=prev8;
            while(k<i8) {
                expectedBytes=(expectedBytes<<8)|s[k++];
            }
        }
        if(i8==(p-s)) {
            actualBytes=expectedBytes;
        } else {
            actualBytes=0;
            int32_t k=prev8;
            while(k<(p-s)) {
                actualBytes=(actualBytes<<8)|s[k++];
            }
        }
        if(value!=values[i]) {
            log_err("error: wrong value from UCPTRIE_FAST_U8_NEXT(%s)(from %d %lx->U+%04lx) (read %d bytes): "
                    "0x%lx instead of 0x%lx (from bytes %lx)\n",
                    testName, (int)prev8, (unsigned long)actualBytes, (long)c, (int)((p-s)-prev8),
                    (long)value, (long)values[i], (unsigned long)expectedBytes);
        }
        if(i8!=(p-s)) {
            log_err("error: wrong end index from UCPTRIE_FAST_U8_NEXT(%s)(from %d %lx->U+%04lx): "
                    "%ld != %ld (bytes %lx)\n",
                    testName, (int)prev8, (unsigned long)actualBytes, (long)c,
                    (long)(p-s), (long)i8, (unsigned long)expectedBytes);
            break;
        }
        ++i;
    }

    /* try backward */
    p=limit;
    i=countValues;
    while(s<p) {
        --i;
        prev8=i8=(int32_t)(p-s);
        U8_PREV(s, 0, i8, c);
        if(valueWidth==UCPTRIE_VALUE_BITS_16) {
            UCPTRIE_FAST_U8_PREV(trie, UCPTRIE_16, s, p, value);
        } else if(valueWidth==UCPTRIE_VALUE_BITS_32) {
            UCPTRIE_FAST_U8_PREV(trie, UCPTRIE_32, s, p, value);
        } else {
            UCPTRIE_FAST_U8_PREV(trie, UCPTRIE_8, s, p, value);
        }
        expectedBytes=0;
        if(value!=values[i] || i8!=(p-s)) {
            int32_t k=i8;
            while(k<prev8) {
                expectedBytes=(expectedBytes<<8)|s[k++];
            }
        }
        if(i8==(p-s)) {
            actualBytes=expectedBytes;
        } else {
            actualBytes=0;
            int32_t k=(int32_t)(p-s);
            while(k<prev8) {
                actualBytes=(actualBytes<<8)|s[k++];
            }
        }
        if(value!=values[i]) {
            log_err("error: wrong value from UCPTRIE_FAST_U8_PREV(%s)(from %d %lx->U+%04lx) (read %d bytes): "
                    "0x%lx instead of 0x%lx (from bytes %lx)\n",
                    testName, (int)prev8, (unsigned long)actualBytes, (long)c, (int)(prev8-(p-s)),
                    (long)value, (long)values[i], (unsigned long)expectedBytes);
        }
        if(i8!=(p-s)) {
            log_err("error: wrong end index from UCPTRIE_FAST_U8_PREV(%s)(from %d %lx->U+%04lx): "
                    "%ld != %ld (bytes %lx)\n",
                    testName, (int)prev8, (unsigned long)actualBytes, (long)c,
                    (long)(p-s), (long)i8, (unsigned long)expectedBytes);
            break;
        }
    }
}

static void
testTrie(const char *testName, const UCPTrie *trie,
         UCPTrieType type, UCPTrieValueWidth valueWidth,
         const CheckRange checkRanges[], int32_t countCheckRanges) {
    testTrieGetters(testName, trie, type, valueWidth, checkRanges, countCheckRanges);
    testTrieGetRanges(testName, trie, NULL, UCPMAP_RANGE_NORMAL, 0, checkRanges, countCheckRanges);
    if (type == UCPTRIE_TYPE_FAST) {
        testTrieUTF16(testName, trie, valueWidth, checkRanges, countCheckRanges);
        testTrieUTF8(testName, trie, valueWidth, checkRanges, countCheckRanges);
    }
}

static void
testBuilder(const char *testName, const UMutableCPTrie *mutableTrie,
            const CheckRange checkRanges[], int32_t countCheckRanges) {
    testBuilderGetters(testName, mutableTrie, checkRanges, countCheckRanges);
    testTrieGetRanges(testName, NULL, mutableTrie, UCPMAP_RANGE_NORMAL, 0, checkRanges, countCheckRanges);
}

static uint32_t storage[120000];
static uint32_t swapped[120000];

static void
testTrieSerialize(const char *testName, UMutableCPTrie *mutableTrie,
                  UCPTrieType type, UCPTrieValueWidth valueWidth, UBool withSwap,
                  const CheckRange checkRanges[], int32_t countCheckRanges) {
    UCPTrie *trie;
    int32_t length1, length2, length3;
    UErrorCode errorCode;

    /* clone the trie so that the caller can reuse the original */
    errorCode=U_ZERO_ERROR;
    mutableTrie = umutablecptrie_clone(mutableTrie, &errorCode);
    if(U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_clone(%s) failed - %s\n",
                testName, u_errorName(errorCode));
        return;
    }

    /*
     * This is not a loop, but simply a block that we can exit with "break"
     * when something goes wrong.
     */
    do {
        errorCode=U_ZERO_ERROR;
        trie = umutablecptrie_buildImmutable(mutableTrie, type, valueWidth, &errorCode);
        if (U_FAILURE(errorCode)) {
            log_err("error: umutablecptrie_buildImmutable(%s) failed: %s\n",
                    testName, u_errorName(errorCode));
            break;
        }
        errorCode=U_ZERO_ERROR;
        length1=ucptrie_toBinary(trie, NULL, 0, &errorCode);
        if(errorCode!=U_BUFFER_OVERFLOW_ERROR) {
            log_err("error: ucptrie_toBinary(%s) preflighting set %s != U_BUFFER_OVERFLOW_ERROR\n",
                    testName, u_errorName(errorCode));
            break;
        }
        errorCode=U_ZERO_ERROR;
        length2=ucptrie_toBinary(trie, storage, sizeof(storage), &errorCode);
        if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
            log_err("error: ucptrie_toBinary(%s) needs more memory\n", testName);
            break;
        }
        if(U_FAILURE(errorCode)) {
            log_err("error: ucptrie_toBinary(%s) failed: %s\n", testName, u_errorName(errorCode));
            break;
        }
        if(length1!=length2) {
            log_err("error: trie serialization (%s) lengths different: "
                    "preflight vs. serialize\n", testName);
            break;
        }

        testTrie(testName, trie, type, valueWidth, checkRanges, countCheckRanges);
        ucptrie_close(trie);
        trie=NULL;

        if(withSwap) {
            int32_t swappedLength;

            UDataSwapper *ds;

            /* swap to opposite-endian */
            uprv_memset(swapped, 0x55, length2);
            ds=udata_openSwapper(U_IS_BIG_ENDIAN, U_CHARSET_FAMILY,
                                 !U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, &errorCode);
            swappedLength=ucptrie_swap(ds, storage, -1, NULL, &errorCode);
            if(U_FAILURE(errorCode) || swappedLength!=length2) {
                log_err("error: ucptrie_swap(%s to OE preflighting) failed (%s) "
                        "or before/after lengths different\n",
                        testName, u_errorName(errorCode));
                udata_closeSwapper(ds);
                break;
            }
            swappedLength=ucptrie_swap(ds, storage, length2, swapped, &errorCode);
            udata_closeSwapper(ds);
            if(U_FAILURE(errorCode) || swappedLength!=length2) {
                log_err("error: ucptrie_swap(%s to OE) failed (%s) or before/after lengths different\n",
                        testName, u_errorName(errorCode));
                break;
            }

            /* swap back to platform-endian */
            uprv_memset(storage, 0xaa, length2);
            ds=udata_openSwapper(!U_IS_BIG_ENDIAN, U_CHARSET_FAMILY,
                                 U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, &errorCode);
            swappedLength=ucptrie_swap(ds, swapped, -1, NULL, &errorCode);
            if(U_FAILURE(errorCode) || swappedLength!=length2) {
                log_err("error: ucptrie_swap(%s to PE preflighting) failed (%s) "
                        "or before/after lengths different\n",
                        testName, u_errorName(errorCode));
                udata_closeSwapper(ds);
                break;
            }
            swappedLength=ucptrie_swap(ds, swapped, length2, storage, &errorCode);
            udata_closeSwapper(ds);
            if(U_FAILURE(errorCode) || swappedLength!=length2) {
                log_err("error: ucptrie_swap(%s to PE) failed (%s) or before/after lengths different\n",
                        testName, u_errorName(errorCode));
                break;
            }
        }

        trie = ucptrie_openFromBinary(type, valueWidth, storage, length2, &length3, &errorCode);
        if(U_FAILURE(errorCode)) {
            log_err("error: ucptrie_openFromBinary(%s) failed, %s\n", testName, u_errorName(errorCode));
            break;
        }
        if(type != ucptrie_getType(trie)) {
            log_err("error: trie serialization (%s) did not preserve trie type\n", testName);
            break;
        }
        if(valueWidth != ucptrie_getValueWidth(trie)) {
            log_err("error: trie serialization (%s) did not preserve data value width\n", testName);
            break;
        }
        if(length2!=length3) {
            log_err("error: trie serialization (%s) lengths different: "
                    "serialize vs. unserialize\n", testName);
            break;
        }
        /* overwrite the storage that is not supposed to be needed */
        uprv_memset((char *)storage+length3, 0xfa, (int32_t)(sizeof(storage)-length3));

        {
            errorCode=U_ZERO_ERROR;
            UCPTrie *any = ucptrie_openFromBinary(UCPTRIE_TYPE_ANY, UCPTRIE_VALUE_BITS_ANY,
                                                  storage, length3, NULL, &errorCode);
            if (U_SUCCESS(errorCode)) {
                if (type != ucptrie_getType(any)) {
                    log_err("error: ucptrie_openFromBinary("
                            "UCPTRIE_TYPE_ANY, UCPTRIE_VALUE_BITS_ANY).getType() wrong\n");
                }
                if (valueWidth != ucptrie_getValueWidth(any)) {
                    log_err("error: ucptrie_openFromBinary("
                            "UCPTRIE_TYPE_ANY, UCPTRIE_VALUE_BITS_ANY).getValueWidth() wrong\n");
                }
                ucptrie_close(any);
            } else {
                log_err("error: ucptrie_openFromBinary("
                        "UCPTRIE_TYPE_ANY, UCPTRIE_VALUE_BITS_ANY) failed - %s\n",
                        u_errorName(errorCode));
            }
        }

        errorCode=U_ZERO_ERROR;
        testTrie(testName, trie, type, valueWidth, checkRanges, countCheckRanges);
        {
            /* make a mutable trie from an immutable one */
            uint32_t value, value2;
            UMutableCPTrie *mutable2 = umutablecptrie_fromUCPTrie(trie, &errorCode);
            if(U_FAILURE(errorCode)) {
                log_err("error: umutablecptrie_fromUCPTrie(unserialized %s) failed - %s\n",
                        testName, u_errorName(errorCode));
                break;
            }

            value=umutablecptrie_get(mutable2, 0xa1);
            umutablecptrie_set(mutable2, 0xa1, 789, &errorCode);
            value2=umutablecptrie_get(mutable2, 0xa1);
            umutablecptrie_set(mutable2, 0xa1, value, &errorCode);
            if(U_FAILURE(errorCode) || value2!=789) {
                log_err("error: modifying a mutableTrie-from-UCPTrie (%s) failed - %s\n",
                        testName, u_errorName(errorCode));
            }
            testBuilder(testName, mutable2, checkRanges, countCheckRanges);
            umutablecptrie_close(mutable2);
        }
    } while(0);

    umutablecptrie_close(mutableTrie);
    ucptrie_close(trie);
}

static UMutableCPTrie *
testTrieSerializeAllValueWidth(const char *testName,
                               UMutableCPTrie *mutableTrie, UBool withClone,
                               const CheckRange checkRanges[], int32_t countCheckRanges) {
    char name[40];
    uint32_t oredValues = 0;
    int32_t i;
    for (i = 0; i < countCheckRanges; ++i) {
        oredValues |= checkRanges[i].value;
    }

    testBuilder(testName, mutableTrie, checkRanges, countCheckRanges);

    if (oredValues <= 0xffff) {
        uprv_strcpy(name, testName);
        uprv_strcat(name, ".16");
        testTrieSerialize(name, mutableTrie,
                          UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_16, withClone,
                          checkRanges, countCheckRanges);
    }

    uprv_strcpy(name, testName);
    uprv_strcat(name, ".32");
    testTrieSerialize(name, mutableTrie,
                      UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_32, withClone,
                      checkRanges, countCheckRanges);

    if (oredValues <= 0xff) {
        uprv_strcpy(name, testName);
        uprv_strcat(name, ".8");
        testTrieSerialize(name, mutableTrie,
                          UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_8, withClone,
                          checkRanges, countCheckRanges);
    }

    if (oredValues <= 0xffff) {
        uprv_strcpy(name, testName);
        uprv_strcat(name, ".small16");
        testTrieSerialize(name, mutableTrie,
                          UCPTRIE_TYPE_SMALL, UCPTRIE_VALUE_BITS_16, withClone,
                          checkRanges, countCheckRanges);
    }

    return mutableTrie;
}

static UMutableCPTrie *
makeTrieWithRanges(const char *testName, UBool withClone,
                   const SetRange setRanges[], int32_t countSetRanges,
                   const CheckRange checkRanges[], int32_t countCheckRanges) {
    UMutableCPTrie *mutableTrie;
    uint32_t initialValue, errorValue;
    uint32_t value;
    UChar32 start, limit;
    int32_t i;
    UErrorCode errorCode;

    log_verbose("\ntesting Trie '%s'\n", testName);
    errorCode=U_ZERO_ERROR;
    getSpecialValues(checkRanges, countCheckRanges, &initialValue, &errorValue);
    mutableTrie = umutablecptrie_open(initialValue, errorValue, &errorCode);
    if(U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_open(%s) failed: %s\n", testName, u_errorName(errorCode));
        return NULL;
    }

    /* set values from setRanges[] */
    for(i=0; i<countSetRanges; ++i) {
        if(withClone && i==countSetRanges/2) {
            /* switch to a clone in the middle of setting values */
            UMutableCPTrie *clone = umutablecptrie_clone(mutableTrie, &errorCode);
            if(U_FAILURE(errorCode)) {
                log_err("error: umutablecptrie_clone(%s) failed - %s\n",
                        testName, u_errorName(errorCode));
                errorCode=U_ZERO_ERROR;  /* continue with the original */
            } else {
                umutablecptrie_close(mutableTrie);
                mutableTrie = clone;
            }
        }
        start=setRanges[i].start;
        limit=setRanges[i].limit;
        value=setRanges[i].value;
        if ((limit - start) == 1) {
            umutablecptrie_set(mutableTrie, start, value, &errorCode);
        } else {
            umutablecptrie_setRange(mutableTrie, start, limit-1, value, &errorCode);
        }
    }

    if(U_SUCCESS(errorCode)) {
        return mutableTrie;
    } else {
        log_err("error: setting values into a mutable trie (%s) failed - %s\n",
                testName, u_errorName(errorCode));
        umutablecptrie_close(mutableTrie);
        return NULL;
    }
}

static void
testTrieRanges(const char *testName, UBool withClone,
               const SetRange setRanges[], int32_t countSetRanges,
               const CheckRange checkRanges[], int32_t countCheckRanges) {
    UMutableCPTrie *mutableTrie = makeTrieWithRanges(
        testName, withClone, setRanges, countSetRanges, checkRanges, countCheckRanges);
    if (mutableTrie != NULL) {
        mutableTrie = testTrieSerializeAllValueWidth(testName, mutableTrie, withClone,
                                                     checkRanges, countCheckRanges);
        umutablecptrie_close(mutableTrie);
    }
}

/* test data ----------------------------------------------------------------*/

/* set consecutive ranges, even with value 0 */
static const SetRange
setRanges1[]={
    { 0,        0x40,     0    },
    { 0x40,     0xe7,     0x34 },
    { 0xe7,     0x3400,   0    },
    { 0x3400,   0x9fa6,   0x61 },
    { 0x9fa6,   0xda9e,   0x31 },
    { 0xdada,   0xeeee,   0xff },
    { 0xeeee,   0x11111,  1    },
    { 0x11111,  0x44444,  0x61 },
    { 0x44444,  0x60003,  0    },
    { 0xf0003,  0xf0004,  0xf  },
    { 0xf0004,  0xf0006,  0x10 },
    { 0xf0006,  0xf0007,  0x11 },
    { 0xf0007,  0xf0040,  0x12 },
    { 0xf0040,  0x110000, 0    }
};

static const CheckRange
checkRanges1[]={
    { 0,        0 },
    { 0x40,     0 },
    { 0xe7,     0x34 },
    { 0x3400,   0 },
    { 0x9fa6,   0x61 },
    { 0xda9e,   0x31 },
    { 0xdada,   0 },
    { 0xeeee,   0xff },
    { 0x11111,  1 },
    { 0x44444,  0x61 },
    { 0xf0003,  0 },
    { 0xf0004,  0xf },
    { 0xf0006,  0x10 },
    { 0xf0007,  0x11 },
    { 0xf0040,  0x12 },
    { 0x110000, 0 }
};

/* set some interesting overlapping ranges */
static const SetRange
setRanges2[]={
    { 0x21,     0x7f,     0x5555 },
    { 0x2f800,  0x2fedc,  0x7a   },
    { 0x72,     0xdd,     3      },
    { 0xdd,     0xde,     4      },
    { 0x201,    0x240,    6      },  /* 3 consecutive blocks with the same pattern but */
    { 0x241,    0x280,    6      },  /* discontiguous value ranges, testing iteration */
    { 0x281,    0x2c0,    6      },
    { 0x2f987,  0x2fa98,  5      },
    { 0x2f777,  0x2f883,  0      },
    { 0x2fedc,  0x2ffaa,  1      },
    { 0x2ffaa,  0x2ffab,  2      },
    { 0x2ffbb,  0x2ffc0,  7      }
};

static const CheckRange
checkRanges2[]={
    { 0,        0 },
    { 0x21,     0 },
    { 0x72,     0x5555 },
    { 0xdd,     3 },
    { 0xde,     4 },
    { 0x201,    0 },
    { 0x240,    6 },
    { 0x241,    0 },
    { 0x280,    6 },
    { 0x281,    0 },
    { 0x2c0,    6 },
    { 0x2f883,  0 },
    { 0x2f987,  0x7a },
    { 0x2fa98,  5 },
    { 0x2fedc,  0x7a },
    { 0x2ffaa,  1 },
    { 0x2ffab,  2 },
    { 0x2ffbb,  0 },
    { 0x2ffc0,  7 },
    { 0x110000, 0 }
};

/* use a non-zero initial value */
static const SetRange
setRanges3[]={
    { 0x31,     0xa4,     1 },
    { 0x3400,   0x6789,   2 },
    { 0x8000,   0x89ab,   9 },
    { 0x9000,   0xa000,   4 },
    { 0xabcd,   0xbcde,   3 },
    { 0x55555,  0x110000, 6 },  /* highStart<U+ffff with non-initialValue */
    { 0xcccc,   0x55555,  6 }
};

static const CheckRange
checkRanges3[]={
    { 0,        9 },  /* non-zero initialValue */
    { 0x31,     9 },
    { 0xa4,     1 },
    { 0x3400,   9 },
    { 0x6789,   2 },
    { 0x9000,   9 },
    { 0xa000,   4 },
    { 0xabcd,   9 },
    { 0xbcde,   3 },
    { 0xcccc,   9 },
    { 0x110000, 6 }
};

/* empty or single-value tries, testing highStart==0 */
static const SetRange
setRangesEmpty[]={
    { 0,        0,        0 },  /* need some values for it to compile */
};

static const CheckRange
checkRangesEmpty[]={
    { 0,        3 },
    { 0x110000, 3 }
};

static const SetRange
setRangesSingleValue[]={
    { 0,        0x110000, 5 },
};

static const CheckRange
checkRangesSingleValue[]={
    { 0,        3 },
    { 0x110000, 5 }
};

static void
TrieTestSet1(void) {
    testTrieRanges("set1", FALSE,
        setRanges1, UPRV_LENGTHOF(setRanges1),
        checkRanges1, UPRV_LENGTHOF(checkRanges1));
}

static void
TrieTestSet2Overlap(void) {
    testTrieRanges("set2-overlap", FALSE,
        setRanges2, UPRV_LENGTHOF(setRanges2),
        checkRanges2, UPRV_LENGTHOF(checkRanges2));
}

static void
TrieTestSet3Initial9(void) {
    testTrieRanges("set3-initial-9", FALSE,
        setRanges3, UPRV_LENGTHOF(setRanges3),
        checkRanges3, UPRV_LENGTHOF(checkRanges3));
    testTrieRanges("set3-initial-9-clone", TRUE,
        setRanges3, UPRV_LENGTHOF(setRanges3),
        checkRanges3, UPRV_LENGTHOF(checkRanges3));
}

static void
TrieTestSetEmpty(void) {
    testTrieRanges("set-empty", FALSE,
        setRangesEmpty, 0,
        checkRangesEmpty, UPRV_LENGTHOF(checkRangesEmpty));
}

static void
TrieTestSetSingleValue(void) {
    testTrieRanges("set-single-value", FALSE,
        setRangesSingleValue, UPRV_LENGTHOF(setRangesSingleValue),
        checkRangesSingleValue, UPRV_LENGTHOF(checkRangesSingleValue));
}

static void
TrieTestSet2OverlapWithClone(void) {
    testTrieRanges("set2-overlap.withClone", TRUE,
        setRanges2, UPRV_LENGTHOF(setRanges2),
        checkRanges2, UPRV_LENGTHOF(checkRanges2));
}

/* test mutable-trie memory management -------------------------------------- */

static void
FreeBlocksTest(void) {
    static const CheckRange
    checkRanges[]={
        { 0,        1 },
        { 0x740,    1 },
        { 0x780,    2 },
        { 0x880,    3 },
        { 0x110000, 1 }
    };
    static const char *const testName="free-blocks";

    UMutableCPTrie *mutableTrie;
    int32_t i;
    UErrorCode errorCode;

    errorCode=U_ZERO_ERROR;
    mutableTrie=umutablecptrie_open(1, 0xad, &errorCode);
    if(U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_open(%s) failed: %s\n", testName, u_errorName(errorCode));
        return;
    }

    /*
     * Repeatedly set overlapping same-value ranges to stress the free-data-block management.
     * If it fails, it will overflow the data array.
     */
    for(i=0; i<(0x120000>>4)/2; ++i) {  // 4=UCPTRIE_SHIFT_3
        umutablecptrie_setRange(mutableTrie, 0x740, 0x840-1, 1, &errorCode);
        umutablecptrie_setRange(mutableTrie, 0x780, 0x880-1, 1, &errorCode);
        umutablecptrie_setRange(mutableTrie, 0x740, 0x840-1, 2, &errorCode);
        umutablecptrie_setRange(mutableTrie, 0x780, 0x880-1, 3, &errorCode);
    }
    /* make blocks that will be free during compaction */
    umutablecptrie_setRange(mutableTrie, 0x1000, 0x3000-1, 2, &errorCode);
    umutablecptrie_setRange(mutableTrie, 0x2000, 0x4000-1, 3, &errorCode);
    umutablecptrie_setRange(mutableTrie, 0x1000, 0x4000-1, 1, &errorCode);
    if(U_FAILURE(errorCode)) {
        log_err("error: setting lots of ranges into a mutable trie (%s) failed - %s\n",
                testName, u_errorName(errorCode));
        umutablecptrie_close(mutableTrie);
        return;
    }

    mutableTrie = testTrieSerializeAllValueWidth(testName, mutableTrie, FALSE,
                                                 checkRanges, UPRV_LENGTHOF(checkRanges));
    umutablecptrie_close(mutableTrie);
}

static void
GrowDataArrayTest(void) {
    static const CheckRange
    checkRanges[]={
        { 0,        1 },
        { 0x720,    2 },
        { 0x7a0,    3 },
        { 0x8a0,    4 },
        { 0x110000, 5 }
    };
    static const char *const testName="grow-data";

    UMutableCPTrie *mutableTrie;
    int32_t i;
    UErrorCode errorCode;

    errorCode=U_ZERO_ERROR;
    mutableTrie=umutablecptrie_open(1, 0xad, &errorCode);
    if(U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_open(%s) failed: %s\n", testName, u_errorName(errorCode));
        return;
    }

    /*
     * Use umutablecptrie_set() not umutablecptrie_setRange() to write non-initialValue-data.
     * Should grow/reallocate the data array to a sufficient length.
     */
    for(i=0; i<0x1000; ++i) {
        umutablecptrie_set(mutableTrie, i, 2, &errorCode);
    }
    for(i=0x720; i<0x1100; ++i) { /* some overlap */
        umutablecptrie_set(mutableTrie, i, 3, &errorCode);
    }
    for(i=0x7a0; i<0x900; ++i) {
        umutablecptrie_set(mutableTrie, i, 4, &errorCode);
    }
    for(i=0x8a0; i<0x110000; ++i) {
        umutablecptrie_set(mutableTrie, i, 5, &errorCode);
    }
    if(U_FAILURE(errorCode)) {
        log_err("error: setting lots of values into a mutable trie (%s) failed - %s\n",
                testName, u_errorName(errorCode));
        umutablecptrie_close(mutableTrie);
        return;
    }

    mutableTrie = testTrieSerializeAllValueWidth(testName, mutableTrie, FALSE,
                                                 checkRanges, UPRV_LENGTHOF(checkRanges));
    umutablecptrie_close(mutableTrie);
}

static void
ManyAllSameBlocksTest(void) {
    static const char *const testName="many-all-same";

    UMutableCPTrie *mutableTrie;
    int32_t i;
    UErrorCode errorCode;
    CheckRange checkRanges[(0x110000 >> 12) + 1];

    errorCode = U_ZERO_ERROR;
    mutableTrie = umutablecptrie_open(0xff33, 0xad, &errorCode);
    if (U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_open(%s) failed: %s\n", testName, u_errorName(errorCode));
        return;
    }
    checkRanges[0].limit = 0;
    checkRanges[0].value = 0xff33;  // initialValue

    // Many all-same-value blocks.
    for (i = 0; i < 0x110000; i += 0x1000) {
        uint32_t value = i >> 12;
        umutablecptrie_setRange(mutableTrie, i, i + 0xfff, value, &errorCode);
        checkRanges[value + 1].limit = i + 0x1000;
        checkRanges[value + 1].value = value;
    }
    for (i = 0; i < 0x110000; i += 0x1000) {
        uint32_t expected = i >> 12;
        uint32_t v0 = umutablecptrie_get(mutableTrie, i);
        uint32_t vfff = umutablecptrie_get(mutableTrie, i + 0xfff);
        if (v0 != expected || vfff != expected) {
            log_err("error: UMutableCPTrie U+%04lx unexpected value\n", (long)i);
        }
    }

    mutableTrie = testTrieSerializeAllValueWidth(testName, mutableTrie, FALSE,
                                                 checkRanges, UPRV_LENGTHOF(checkRanges));
    umutablecptrie_close(mutableTrie);
}

static void
MuchDataTest(void) {
    static const char *const testName="much-data";

    UMutableCPTrie *mutableTrie;
    int32_t r, c;
    UErrorCode errorCode = U_ZERO_ERROR;
    CheckRange checkRanges[(0x10000 >> 6) + (0x10240 >> 4) + 10];

    mutableTrie = umutablecptrie_open(0xff33, 0xad, &errorCode);
    if (U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_open(%s) failed: %s\n", testName, u_errorName(errorCode));
        return;
    }
    checkRanges[0].limit = 0;
    checkRanges[0].value = 0xff33;  // initialValue
    r = 1;

    // Add much data that does not compact well,
    // to get more than 128k data values after compaction.
    for (c = 0; c < 0x10000; c += 0x40) {
        uint32_t value = c >> 4;
        umutablecptrie_setRange(mutableTrie, c, c + 0x3f, value, &errorCode);
        checkRanges[r].limit = c + 0x40;
        checkRanges[r++].value = value;
    }
    checkRanges[r].limit = 0x20000;
    checkRanges[r++].value = 0xff33;
    for (c = 0x20000; c < 0x30230; c += 0x10) {
        uint32_t value = c >> 4;
        umutablecptrie_setRange(mutableTrie, c, c + 0xf, value, &errorCode);
        checkRanges[r].limit = c + 0x10;
        checkRanges[r++].value = value;
    }
    umutablecptrie_setRange(mutableTrie, 0x30230, 0x30233, 0x3023, &errorCode);
    checkRanges[r].limit = 0x30234;
    checkRanges[r++].value = 0x3023;
    umutablecptrie_setRange(mutableTrie, 0x30234, 0xdffff, 0x5005, &errorCode);
    checkRanges[r].limit = 0xe0000;
    checkRanges[r++].value = 0x5005;
    umutablecptrie_setRange(mutableTrie, 0xe0000, 0x10ffff, 0x9009, &errorCode);
    checkRanges[r].limit = 0x110000;
    checkRanges[r++].value = 0x9009;
    if (U_FAILURE(errorCode)) {
        log_err("error: setting lots of values into a mutable trie (%s) failed - %s\n",
                testName, u_errorName(errorCode));
        umutablecptrie_close(mutableTrie);
        return;
    }
    U_ASSERT(r <= UPRV_LENGTHOF(checkRanges));

    testBuilder(testName, mutableTrie, checkRanges, r);
    testTrieSerialize("much-data.16", mutableTrie,
                      UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_16, FALSE, checkRanges, r);
    umutablecptrie_close(mutableTrie);
}

static void testGetRangesFixedSurr(const char *testName, const UMutableCPTrie *mutableTrie,
                                   UCPMapRangeOption option,
                                   const CheckRange checkRanges[], int32_t countCheckRanges) {
    testTrieGetRanges(testName, NULL, mutableTrie, option, 5, checkRanges, countCheckRanges);
    UErrorCode errorCode = U_ZERO_ERROR;
    UMutableCPTrie *clone = umutablecptrie_clone(mutableTrie, &errorCode);
    UCPTrie *trie;
    if (U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_clone(%s) failed: %s\n", testName, u_errorName(errorCode));
        return;
    }
    trie = umutablecptrie_buildImmutable(clone, UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_16, &errorCode);
    umutablecptrie_close(clone);
    if (U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_buildImmutable(%s) failed: %s\n", testName, u_errorName(errorCode));
        return;
    }
    testTrieGetRanges(testName, trie, NULL, option, 5, checkRanges, countCheckRanges);
    ucptrie_close(trie);
}

static void
TrieTestGetRangesFixedSurr(void) {
    static const SetRange
    setRangesFixedSurr[]={
        { 0xd000, 0xd7ff, 5 },
        { 0xd7ff, 0xe001, 3 },
        { 0xe001, 0xf900, 5 },
    };

    static const CheckRange
    checkRangesFixedLeadSurr1[]={
        { 0,      0 },
        { 0xd000, 0 },
        { 0xd7ff, 5 },
        { 0xd800, 3 },
        { 0xdc00, 5 },
        { 0xe001, 3 },
        { 0xf900, 5 },
        { 0x110000, 0 }
    };

    static const CheckRange
    checkRangesFixedAllSurr1[]={
        { 0,      0 },
        { 0xd000, 0 },
        { 0xd7ff, 5 },
        { 0xd800, 3 },
        { 0xe000, 5 },
        { 0xe001, 3 },
        { 0xf900, 5 },
        { 0x110000, 0 }
    };

    static const CheckRange
    checkRangesFixedLeadSurr3[]={
        { 0,      0 },
        { 0xd000, 0 },
        { 0xdc00, 5 },
        { 0xe001, 3 },
        { 0xf900, 5 },
        { 0x110000, 0 }
    };

    static const CheckRange
    checkRangesFixedAllSurr3[]={
        { 0,      0 },
        { 0xd000, 0 },
        { 0xe000, 5 },
        { 0xe001, 3 },
        { 0xf900, 5 },
        { 0x110000, 0 }
    };

    static const CheckRange
    checkRangesFixedSurr4[]={
        { 0,      0 },
        { 0xd000, 0 },
        { 0xf900, 5 },
        { 0x110000, 0 }
    };

    UMutableCPTrie *mutableTrie = makeTrieWithRanges(
        "fixedSurr", FALSE, setRangesFixedSurr, UPRV_LENGTHOF(setRangesFixedSurr),
        checkRangesFixedLeadSurr1, UPRV_LENGTHOF(checkRangesFixedLeadSurr1));
    UErrorCode errorCode = U_ZERO_ERROR;
    if (mutableTrie == NULL) {
        return;
    }
    testGetRangesFixedSurr("fixedLeadSurr1", mutableTrie, UCPMAP_RANGE_FIXED_LEAD_SURROGATES,
                           checkRangesFixedLeadSurr1, UPRV_LENGTHOF(checkRangesFixedLeadSurr1));
    testGetRangesFixedSurr("fixedAllSurr1", mutableTrie, UCPMAP_RANGE_FIXED_ALL_SURROGATES,
                           checkRangesFixedAllSurr1, UPRV_LENGTHOF(checkRangesFixedAllSurr1));
    // Setting a range in the middle of lead surrogates makes no difference.
    umutablecptrie_setRange(mutableTrie, 0xd844, 0xd899, 5, &errorCode);
    if (U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_setRange(fixedSurr2) failed: %s\n", u_errorName(errorCode));
        umutablecptrie_close(mutableTrie);
        return;
    }
    testGetRangesFixedSurr("fixedLeadSurr2", mutableTrie, UCPMAP_RANGE_FIXED_LEAD_SURROGATES,
                           checkRangesFixedLeadSurr1, UPRV_LENGTHOF(checkRangesFixedLeadSurr1));
    // Bridge the gap before the lead surrogates.
    umutablecptrie_set(mutableTrie, 0xd7ff, 5, &errorCode);
    if (U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_set(fixedSurr3) failed: %s\n", u_errorName(errorCode));
        umutablecptrie_close(mutableTrie);
        return;
    }
    testGetRangesFixedSurr("fixedLeadSurr3", mutableTrie, UCPMAP_RANGE_FIXED_LEAD_SURROGATES,
                           checkRangesFixedLeadSurr3, UPRV_LENGTHOF(checkRangesFixedLeadSurr3));
    testGetRangesFixedSurr("fixedAllSurr3", mutableTrie, UCPMAP_RANGE_FIXED_ALL_SURROGATES,
                           checkRangesFixedAllSurr3, UPRV_LENGTHOF(checkRangesFixedAllSurr3));
    // Bridge the gap after the trail surrogates.
    umutablecptrie_set(mutableTrie, 0xe000, 5, &errorCode);
    if (U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_set(fixedSurr4) failed: %s\n", u_errorName(errorCode));
        umutablecptrie_close(mutableTrie);
        return;
    }
    testGetRangesFixedSurr("fixedSurr4", mutableTrie, UCPMAP_RANGE_FIXED_ALL_SURROGATES,
                           checkRangesFixedSurr4, UPRV_LENGTHOF(checkRangesFixedSurr4));
    umutablecptrie_close(mutableTrie);
}

static void TestSmallNullBlockMatchesFast(void) {
    // The initial builder+getRange code had a bug:
    // When there is no null data block in the fast-index range,
    // but a fast-range data block starts with enough values to match a small data block,
    // then getRange() got confused.
    // The builder must prevent this.
    static const SetRange setRanges[] = {
        { 0, 0x880, 1 },
        // U+0880..U+088F map to initial value 0, potential match for small null data block.
        { 0x890, 0x1040, 2 },
        // U+1040..U+1050 map to 0.
        // First small null data block in a small-type trie.
        // In a fast-type trie, it is ok to match a small null data block at U+1041
        // but not at U+1040.
        { 0x1051, 0x10000, 3 },
        // No fast data block (block length 64) filled with 0 regardless of trie type.
        // Need more blocks filled with 0 than the largest range above,
        // and need a highStart above that so that it actually counts.
        { 0x20000, 0x110000, 9 }
    };

    static const CheckRange checkRanges[] = {
        { 0x0880, 1 },
        { 0x0890, 0 },
        { 0x1040, 2 },
        { 0x1051, 0 },
        { 0x10000, 3 },
        { 0x20000, 0 },
        { 0x110000, 9 }
    };

    testTrieRanges("small0-in-fast", FALSE,
        setRanges, UPRV_LENGTHOF(setRanges),
        checkRanges, UPRV_LENGTHOF(checkRanges));
}

static void ShortAllSameBlocksTest(void) {
    static const char *const testName = "short-all-same";
    // Many all-same-value blocks but only of the small block length used in the mutable trie.
    // The builder code needs to turn a group of short ALL_SAME blocks below fastLimit
    // into a MIXED block, and reserve data array capacity for that.
    UErrorCode errorCode = U_ZERO_ERROR;
    UMutableCPTrie *mutableTrie = umutablecptrie_open(0, 0xad, &errorCode);
    CheckRange checkRanges[0x101];
    int32_t i;
    if (U_FAILURE(errorCode)) {
        log_err("error: umutablecptrie_open(%s) failed: %s\n", testName, u_errorName(errorCode));
        return;
    }
    for (i = 0; i < 0x1000; i += 0x10) {
        uint32_t value = i >> 4;
        umutablecptrie_setRange(mutableTrie, i, i + 0xf, value, &errorCode);
        checkRanges[value].limit = i + 0x10;
        checkRanges[value].value = value;
    }
    checkRanges[0x100].limit = 0x110000;
    checkRanges[0x100].value = 0;
    if (U_FAILURE(errorCode)) {
        log_err("error: setting values into a mutable trie (%s) failed - %s\n",
                testName, u_errorName(errorCode));
        umutablecptrie_close(mutableTrie);
        return;
    }

    mutableTrie = testTrieSerializeAllValueWidth(testName, mutableTrie, FALSE,
                                                 checkRanges, UPRV_LENGTHOF(checkRanges));
    umutablecptrie_close(mutableTrie);
}

void
addUCPTrieTest(TestNode** root) {
    addTest(root, &TrieTestSet1, "tsutil/ucptrietest/TrieTestSet1");
    addTest(root, &TrieTestSet2Overlap, "tsutil/ucptrietest/TrieTestSet2Overlap");
    addTest(root, &TrieTestSet3Initial9, "tsutil/ucptrietest/TrieTestSet3Initial9");
    addTest(root, &TrieTestSetEmpty, "tsutil/ucptrietest/TrieTestSetEmpty");
    addTest(root, &TrieTestSetSingleValue, "tsutil/ucptrietest/TrieTestSetSingleValue");
    addTest(root, &TrieTestSet2OverlapWithClone, "tsutil/ucptrietest/TrieTestSet2OverlapWithClone");
    addTest(root, &FreeBlocksTest, "tsutil/ucptrietest/FreeBlocksTest");
    addTest(root, &GrowDataArrayTest, "tsutil/ucptrietest/GrowDataArrayTest");
    addTest(root, &ManyAllSameBlocksTest, "tsutil/ucptrietest/ManyAllSameBlocksTest");
    addTest(root, &MuchDataTest, "tsutil/ucptrietest/MuchDataTest");
    addTest(root, &TrieTestGetRangesFixedSurr, "tsutil/ucptrietest/TrieTestGetRangesFixedSurr");
    addTest(root, &TestSmallNullBlockMatchesFast, "tsutil/ucptrietest/TestSmallNullBlockMatchesFast");
    addTest(root, &ShortAllSameBlocksTest, "tsutil/ucptrietest/ShortAllSameBlocksTest");
}