//static jint NativeCollation_previous(JNIEnv* env, jclass, jint address) { JNIEXPORT jint JNICALL Java_com_ibm_icu4jni_text_NativeCollation_previous(JNIEnv* env, jclass, jint address) { UErrorCode status = U_ZERO_ERROR; jint result = ucol_previous(toCollationElements(address), &status); icu4jni_error(env, status); return result; }
const CEI *Target::prevCE(int32_t offset) { UErrorCode status = U_ZERO_ERROR; int32_t low = -1, high = -1; uint32_t order; UBool cont = FALSE; if (offset >= bufferMin && offset < bufferMax) { return &ceb[offset]; } if (bufferMax >= bufferSize || offset != bufferMax) { return NULL; } do { high = ucol_getOffset(elements); order = ucol_previous(elements, &status); low = ucol_getOffset(elements); if (order == (uint32_t)UCOL_NULLORDER) { break; } cont = isContinuation(order); order &= strengthMask; if (toShift && variableTop > order && (order & UCOL_PRIMARYORDERMASK) != 0) { if (strength >= UCOL_QUATERNARY) { order &= UCOL_PRIMARYORDERMASK; } else { order = UCOL_IGNORABLE; } } } while (order == UCOL_IGNORABLE); bufferMax += 1; if (cont) { order |= UCOL_CONTINUATION_MARKER; } ceb[offset].order = order; ceb[offset].lowOffset = low; ceb[offset].highOffset = high; return &ceb[offset]; }
/** * Get the ordering priority of the previous collation element in the string. * @param status the error code status. * @return the previous element's ordering. Returns NULLORDER if an error has * occured or if the start of string has been reached. */ int32_t CollationElementIterator::previous(UErrorCode& status) { return ucol_previous(m_data_, &status); }
void backAndForth(UCollationElements *iter) { /* Run through the iterator forwards and stick it into an array */ int32_t index, o; UErrorCode status = U_ZERO_ERROR; int32_t orderLength = 0; int32_t *orders; orders= getOrders(iter, &orderLength); /* Now go through it backwards and make sure we get the same values */ index = orderLength; ucol_reset(iter); /* synwee : changed */ while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) { if (o != orders[-- index]) { if (o == 0) index ++; else { while (index > 0 && orders[-- index] == 0) { } if (o != orders[index]) { log_err("Mismatch at index : 0x%x\n", index); return; } } } } while (index != 0 && orders[index - 1] == 0) { index --; } if (index != 0) { log_err("Didn't get back to beginning - index is %d\n", index); ucol_reset(iter); log_err("\nnext: "); if ((o = ucol_next(iter, &status)) != UCOL_NULLORDER) { log_err("Error at %x\n", o); } log_err("\nprev: "); if ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) { log_err("Error at %x\n", o); } log_verbose("\n"); } free(orders); }
static jint NativeCollation_previous(JNIEnv* env, jclass, jlong address) { UErrorCode status = U_ZERO_ERROR; jint result = ucol_previous(toCollationElements(address), &status); maybeThrowIcuException(env, "ucol_previous", status); return result; }
void backAndForth(UCollationElements *iter) { /* Run through the iterator forwards and stick it into an array */ int32_t idx, o; UErrorCode status = U_ZERO_ERROR; int32_t orderLength = 0; OrderAndOffset *orders = getOrders(iter, &orderLength); /* Now go through it backwards and make sure we get the same values */ idx = orderLength; ucol_reset(iter); /* synwee : changed */ while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) { #if TEST_OFFSETS int32_t offset = #endif ucol_getOffset(iter); idx -= 1; if (o != orders[idx].order) { if (o == 0) idx ++; else { while (idx > 0 && orders[-- idx].order == 0) { /* nothing... */ } if (o != orders[idx].order) { log_err("Mismatched order at index %d: 0x%8.8X vs. 0x%8.8X\n", idx, orders[idx].order, o); goto bail; } } } #if TEST_OFFSETS if (offset != orders[idx].offset) { log_err("Mismatched offset at index %d: %d vs. %d\n", idx, orders[idx].offset, offset); goto bail; } #endif } while (idx != 0 && orders[idx - 1].order == 0) { idx -= 1; } if (idx != 0) { log_err("Didn't get back to beginning - index is %d\n", idx); ucol_reset(iter); log_err("\nnext: "); if ((o = ucol_next(iter, &status)) != UCOL_NULLORDER) { log_err("Error at %x\n", o); } log_err("\nprev: "); if ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) { log_err("Error at %x\n", o); } log_verbose("\n"); } bail: free(orders); }
static jint NativeCollation_previous(JNIEnv* env, jclass, jint address) { UErrorCode status = U_ZERO_ERROR; jint result = ucol_previous(toCollationElements(address), &status); icu4jni_error(env, status); return result; }
/** @bug 4108762 * Test for getMaxExpansion() */ static void TestMaxExpansion() { UErrorCode status = U_ZERO_ERROR; UCollator *coll ;/*= ucol_open("en_US", &status);*/ UChar ch = 0; UChar32 unassigned = 0xEFFFD; UChar supplementary[2]; uint32_t stringOffset = 0; UBool isError = FALSE; uint32_t sorder = 0; UCollationElements *iter ;/*= ucol_openElements(coll, &ch, 1, &status);*/ uint32_t temporder = 0; UChar rule[256]; u_uastrcpy(rule, "&a < ab < c/aba < d < z < ch"); coll = ucol_openRules(rule, u_strlen(rule), UCOL_DEFAULT, UCOL_DEFAULT_STRENGTH,NULL, &status); if(U_SUCCESS(status) && coll) { iter = ucol_openElements(coll, &ch, 1, &status); while (ch < 0xFFFF && U_SUCCESS(status)) { int count = 1; uint32_t order; int32_t size = 0; ch ++; ucol_setText(iter, &ch, 1, &status); order = ucol_previous(iter, &status); /* thai management */ if (order == 0) order = ucol_previous(iter, &status); while (U_SUCCESS(status) && ucol_previous(iter, &status) != UCOL_NULLORDER) { count ++; } size = ucol_getMaxExpansion(iter, order); if (U_FAILURE(status) || size < count) { log_err("Failure at codepoint %d, maximum expansion count < %d\n", ch, count); } } /* testing for exact max expansion */ ch = 0; while (ch < 0x61) { uint32_t order; int32_t size; ucol_setText(iter, &ch, 1, &status); order = ucol_previous(iter, &status); size = ucol_getMaxExpansion(iter, order); if (U_FAILURE(status) || size != 1) { log_err("Failure at codepoint %d, maximum expansion count < %d\n", ch, 1); } ch ++; } ch = 0x63; ucol_setText(iter, &ch, 1, &status); temporder = ucol_previous(iter, &status); if (U_FAILURE(status) || ucol_getMaxExpansion(iter, temporder) != 3) { log_err("Failure at codepoint %d, maximum expansion count != %d\n", ch, 3); } ch = 0x64; ucol_setText(iter, &ch, 1, &status); temporder = ucol_previous(iter, &status); if (U_FAILURE(status) || ucol_getMaxExpansion(iter, temporder) != 1) { log_err("Failure at codepoint %d, maximum expansion count != %d\n", ch, 3); } U16_APPEND(supplementary, stringOffset, 2, unassigned, isError); (void)isError; /* Suppress set but not used warning. */ ucol_setText(iter, supplementary, 2, &status); sorder = ucol_previous(iter, &status); if (U_FAILURE(status) || ucol_getMaxExpansion(iter, sorder) != 2) { log_err("Failure at codepoint %d, maximum expansion count < %d\n", ch, 2); } /* testing jamo */ ch = 0x1165; ucol_setText(iter, &ch, 1, &status); temporder = ucol_previous(iter, &status); if (U_FAILURE(status) || ucol_getMaxExpansion(iter, temporder) > 3) { log_err("Failure at codepoint %d, maximum expansion count > %d\n", ch, 3); } ucol_closeElements(iter); ucol_close(coll); /* testing special jamo &a<\u1160 */ rule[0] = 0x26; rule[1] = 0x71; rule[2] = 0x3c; rule[3] = 0x1165; rule[4] = 0x2f; rule[5] = 0x71; rule[6] = 0x71; rule[7] = 0x71; rule[8] = 0x71; rule[9] = 0; coll = ucol_openRules(rule, u_strlen(rule), UCOL_DEFAULT, UCOL_DEFAULT_STRENGTH,NULL, &status); iter = ucol_openElements(coll, &ch, 1, &status); temporder = ucol_previous(iter, &status); if (U_FAILURE(status) || ucol_getMaxExpansion(iter, temporder) != 6) { log_err("Failure at codepoint %d, maximum expansion count > %d\n", ch, 5); } ucol_closeElements(iter); ucol_close(coll); } else { log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status)); } }
static void TestBug672() { UErrorCode status = U_ZERO_ERROR; UChar pattern[20]; UChar text[50]; int i; int result[3][3]; u_uastrcpy(pattern, "resume"); u_uastrcpy(text, "Time to resume updating my resume."); for (i = 0; i < 3; ++ i) { UCollator *coll = ucol_open(LOCALES[i], &status); UCollationElements *pitr = ucol_openElements(coll, pattern, -1, &status); UCollationElements *titer = ucol_openElements(coll, text, -1, &status); if (U_FAILURE(status)) { log_err_status(status, "ERROR: in creation of either the collator or the collation iterator :%s\n", myErrorName(status)); return; } log_verbose("locale tested %s\n", LOCALES[i]); while (ucol_next(pitr, &status) != UCOL_NULLORDER && U_SUCCESS(status)) { } if (U_FAILURE(status)) { log_err("ERROR: reversing collation iterator :%s\n", myErrorName(status)); return; } ucol_reset(pitr); ucol_setOffset(titer, u_strlen(pattern), &status); if (U_FAILURE(status)) { log_err("ERROR: setting offset in collator :%s\n", myErrorName(status)); return; } result[i][0] = ucol_getOffset(titer); log_verbose("Text iterator set to offset %d\n", result[i][0]); /* Use previous() */ ucol_previous(titer, &status); result[i][1] = ucol_getOffset(titer); log_verbose("Current offset %d after previous\n", result[i][1]); /* Add one to index */ log_verbose("Adding one to current offset...\n"); ucol_setOffset(titer, ucol_getOffset(titer) + 1, &status); if (U_FAILURE(status)) { log_err("ERROR: setting offset in collator :%s\n", myErrorName(status)); return; } result[i][2] = ucol_getOffset(titer); log_verbose("Current offset in text = %d\n", result[i][2]); ucol_closeElements(pitr); ucol_closeElements(titer); ucol_close(coll); } if (uprv_memcmp(result[0], result[1], 3) != 0 || uprv_memcmp(result[1], result[2], 3) != 0) { log_err("ERROR: Different locales have different offsets at the same character\n"); } }
/** * Test for getOffset() and setOffset() */ static void TestOffset() { UErrorCode status= U_ZERO_ERROR; UCollator *en_us=NULL; UCollationElements *iter, *pristine; int32_t offset; OrderAndOffset *orders; int32_t orderLength=0; int count = 0; UChar test1[50]; UChar test2[50]; u_uastrcpy(test1, "What subset of all possible test cases?"); u_uastrcpy(test2, "has the highest probability of detecting"); en_us = ucol_open("en_US", &status); log_verbose("Testing getOffset and setOffset for collations\n"); iter = ucol_openElements(en_us, test1, u_strlen(test1), &status); if(U_FAILURE(status)){ log_err_status(status, "ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n", myErrorName(status)); ucol_close(en_us); return; } /* testing boundaries */ ucol_setOffset(iter, 0, &status); if (U_FAILURE(status) || ucol_previous(iter, &status) != UCOL_NULLORDER) { log_err("Error: After setting offset to 0, we should be at the end " "of the backwards iteration"); } ucol_setOffset(iter, u_strlen(test1), &status); if (U_FAILURE(status) || ucol_next(iter, &status) != UCOL_NULLORDER) { log_err("Error: After setting offset to end of the string, we should " "be at the end of the backwards iteration"); } /* Run all the way through the iterator, then get the offset */ orders = getOrders(iter, &orderLength); offset = ucol_getOffset(iter); if (offset != u_strlen(test1)) { log_err("offset at end != length %d vs %d\n", offset, u_strlen(test1) ); } /* Now set the offset back to the beginning and see if it works */ pristine=ucol_openElements(en_us, test1, u_strlen(test1), &status); if(U_FAILURE(status)){ log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n", myErrorName(status)); ucol_close(en_us); return; } status = U_ZERO_ERROR; ucol_setOffset(iter, 0, &status); if (U_FAILURE(status)) { log_err("setOffset failed. %s\n", myErrorName(status)); } else { assertEqual(iter, pristine); } ucol_closeElements(pristine); ucol_closeElements(iter); free(orders); /* testing offsets in normalization buffer */ test1[0] = 0x61; test1[1] = 0x300; test1[2] = 0x316; test1[3] = 0x62; test1[4] = 0; ucol_setAttribute(en_us, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); iter = ucol_openElements(en_us, test1, 4, &status); if(U_FAILURE(status)){ log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n", myErrorName(status)); ucol_close(en_us); return; } count = 0; while (ucol_next(iter, &status) != UCOL_NULLORDER && U_SUCCESS(status)) { switch (count) { case 0: if (ucol_getOffset(iter) != 1) { log_err("ERROR: Offset of iteration should be 1\n"); } break; case 3: if (ucol_getOffset(iter) != 4) { log_err("ERROR: Offset of iteration should be 4\n"); } break; default: if (ucol_getOffset(iter) != 3) { log_err("ERROR: Offset of iteration should be 3\n"); } } count ++; } ucol_reset(iter); count = 0; while (ucol_previous(iter, &status) != UCOL_NULLORDER && U_SUCCESS(status)) { switch (count) { case 0: case 1: if (ucol_getOffset(iter) != 3) { log_err("ERROR: Offset of iteration should be 3\n"); } break; case 2: if (ucol_getOffset(iter) != 1) { log_err("ERROR: Offset of iteration should be 1\n"); } break; default: if (ucol_getOffset(iter) != 0) { log_err("ERROR: Offset of iteration should be 0\n"); } } count ++; } if(U_FAILURE(status)){ log_err("ERROR: in iterating collation elements %s\n", myErrorName(status)); } ucol_closeElements(iter); ucol_close(en_us); }
static void TestSearchCollatorElements(void) { const TSCEItem * tsceItemPtr; for (tsceItemPtr = tsceItems; tsceItemPtr->locale != NULL; tsceItemPtr++) { UErrorCode status = U_ZERO_ERROR; UCollator* ucol = ucol_open(tsceItemPtr->locale, &status); if ( U_SUCCESS(status) ) { UCollationElements * uce = ucol_openElements(ucol, tsceText, kLen_tsceText, &status); if ( U_SUCCESS(status) ) { int32_t offset, element; const int32_t * nextOffsetPtr; const int32_t * limitOffsetPtr; nextOffsetPtr = tsceItemPtr->offsets; limitOffsetPtr = tsceItemPtr->offsets + tsceItemPtr->offsetsLen; do { offset = ucol_getOffset(uce); element = ucol_next(uce, &status); log_verbose("(%s) offset=%2d ce=%08x\n", tsceItemPtr->locale, offset, element); if ( element == 0 ) { log_err("error, locale %s, ucol_next returned element 0\n", tsceItemPtr->locale ); } if ( nextOffsetPtr < limitOffsetPtr ) { if (offset != *nextOffsetPtr) { log_err("error, locale %s, expected ucol_next -> ucol_getOffset %d, got %d\n", tsceItemPtr->locale, *nextOffsetPtr, offset ); nextOffsetPtr = limitOffsetPtr; break; } nextOffsetPtr++; } else { log_err("error, locale %s, ucol_next returned more elements than expected\n", tsceItemPtr->locale ); } } while ( U_SUCCESS(status) && element != UCOL_NULLORDER ); if ( nextOffsetPtr < limitOffsetPtr ) { log_err("error, locale %s, ucol_next returned fewer elements than expected\n", tsceItemPtr->locale ); } ucol_setOffset(uce, kLen_tsceText, &status); status = U_ZERO_ERROR; nextOffsetPtr = tsceItemPtr->offsets + tsceItemPtr->offsetsLen; limitOffsetPtr = tsceItemPtr->offsets; do { offset = ucol_getOffset(uce); element = ucol_previous(uce, &status); if ( element == 0 ) { log_err("error, locale %s, ucol_previous returned element 0\n", tsceItemPtr->locale ); } if ( nextOffsetPtr > limitOffsetPtr ) { nextOffsetPtr--; if (offset != *nextOffsetPtr) { log_err("error, locale %s, expected ucol_previous -> ucol_getOffset %d, got %d\n", tsceItemPtr->locale, *nextOffsetPtr, offset ); nextOffsetPtr = limitOffsetPtr; break; } } else { log_err("error, locale %s, ucol_previous returned more elements than expected\n", tsceItemPtr->locale ); } } while ( U_SUCCESS(status) && element != UCOL_NULLORDER ); if ( nextOffsetPtr > limitOffsetPtr ) { log_err("error, locale %s, ucol_previous returned fewer elements than expected\n", tsceItemPtr->locale ); } ucol_closeElements(uce); } else { log_err("error, locale %s, ucol_openElements failed: %s\n", tsceItemPtr->locale, u_errorName(status) ); } ucol_close(ucol); } else { log_data_err("error, locale %s, ucol_open failed: %s\n", tsceItemPtr->locale, u_errorName(status) ); } } }