自学教程：C++ ucol_setAttribute函数代码示例

void UCAConformanceTest::setCollShifted(UCollator *coll) {  ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);  ucol_setAttribute(coll, UCOL_CASE_FIRST, UCOL_OFF, &status);  ucol_setAttribute(coll, UCOL_CASE_LEVEL, UCOL_OFF, &status);  ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_QUATERNARY, &status);  ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);}

void IntlCollator::createCollator(ExecState& state){    VM& vm = state.vm();    auto scope = DECLARE_CATCH_SCOPE(vm);    ASSERT(!m_collator);    if (!m_initializedCollator) {        initializeCollator(state, jsUndefined(), jsUndefined());        ASSERT_UNUSED(scope, !scope.exception());    }    UErrorCode status = U_ZERO_ERROR;    auto collator = std::unique_ptr<UCollator, UCollatorDeleter>(ucol_open(m_locale.utf8().data(), &status));    if (U_FAILURE(status))        return;    UColAttributeValue strength = UCOL_PRIMARY;    UColAttributeValue caseLevel = UCOL_OFF;    switch (m_sensitivity) {    case Sensitivity::Base:        break;    case Sensitivity::Accent:        strength = UCOL_SECONDARY;        break;    case Sensitivity::Case:        caseLevel = UCOL_ON;        break;    case Sensitivity::Variant:        strength = UCOL_TERTIARY;        break;    default:        ASSERT_NOT_REACHED();    }    ucol_setAttribute(collator.get(), UCOL_STRENGTH, strength, &status);    ucol_setAttribute(collator.get(), UCOL_CASE_LEVEL, caseLevel, &status);    ucol_setAttribute(collator.get(), UCOL_NUMERIC_COLLATION, m_numeric ? UCOL_ON : UCOL_OFF, &status);    // FIXME: Setting UCOL_ALTERNATE_HANDLING to UCOL_SHIFTED causes punctuation and whitespace to be    // ignored. There is currently no way to ignore only punctuation.    ucol_setAttribute(collator.get(), UCOL_ALTERNATE_HANDLING, m_ignorePunctuation ? UCOL_SHIFTED : UCOL_DEFAULT, &status);    // "The method is required to return 0 when comparing Strings that are considered canonically    // equivalent by the Unicode standard."    ucol_setAttribute(collator.get(), UCOL_NORMALIZATION_MODE, UCOL_ON, &status);    if (U_FAILURE(status))        return;    m_collator = WTFMove(collator);}

static const UCollator *MakeRootCollator() {  UErrorCode ErrorCode = U_ZERO_ERROR;  UCollator *root = ucol_open("", &ErrorCode);  if (U_FAILURE(ErrorCode)) {    swift::crash("ucol_open: Failure setting up default collation.");  }  ucol_setAttribute(root, UCOL_NORMALIZATION_MODE, UCOL_ON, &ErrorCode);  ucol_setAttribute(root, UCOL_STRENGTH, UCOL_TERTIARY, &ErrorCode);  ucol_setAttribute(root, UCOL_NUMERIC_COLLATION, UCOL_OFF, &ErrorCode);  ucol_setAttribute(root, UCOL_CASE_LEVEL, UCOL_OFF, &ErrorCode);  if (U_FAILURE(ErrorCode)) {    swift::crash("ucol_setAttribute: Failure setting up default collation.");  }  return root;}

static ErlDrvData couch_drv_start(ErlDrvPort port, char *buff){    UErrorCode status = U_ZERO_ERROR;    couch_drv_data* pData = (couch_drv_data*)driver_alloc(sizeof(couch_drv_data));    if (pData == NULL)        return ERL_DRV_ERROR_GENERAL;    pData->port = port;    pData->coll = ucol_open("", &status);    if (U_FAILURE(status)) {        couch_drv_stop((ErlDrvData)pData);        return ERL_DRV_ERROR_GENERAL;    }    pData->collNoCase = ucol_open("", &status);    if (U_FAILURE(status)) {        couch_drv_stop((ErlDrvData)pData);        return ERL_DRV_ERROR_GENERAL;    }    ucol_setAttribute(pData->collNoCase, UCOL_STRENGTH, UCOL_PRIMARY, &status);    if (U_FAILURE(status)) {        couch_drv_stop((ErlDrvData)pData);        return ERL_DRV_ERROR_GENERAL;    }    return (ErlDrvData)pData;}

MojErr MojDbTextCollator::init(const MojChar* locale, MojDbCollationStrength level){	MojAssert(locale);	MojAssert(!m_ucol);	UCollationStrength strength = UCOL_PRIMARY;	switch (level) {	case MojDbCollationPrimary:		strength = UCOL_PRIMARY;		break;	case MojDbCollationSecondary:		strength = UCOL_SECONDARY;		break;	case MojDbCollationTertiary:		strength = UCOL_TERTIARY;		break;	case MojDbCollationIdentical:		strength = UCOL_IDENTICAL;		break;	default:		MojAssertNotReached();	}	UErrorCode status = U_ZERO_ERROR;	m_ucol = ucol_open(locale, &status);	MojUnicodeErrCheck(status);	MojAssert(m_ucol);	ucol_setAttribute(m_ucol, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);	MojUnicodeErrCheck(status);	ucol_setStrength(m_ucol, strength);	return MojErrNone;}

void RuleBasedCollator::setStrength(ECollationStrength newStrength){    checkOwned();    UErrorCode intStatus = U_ZERO_ERROR;    UCollationStrength strength = getUCollationStrength(newStrength);    ucol_setAttribute(ucollator, UCOL_STRENGTH, strength, &intStatus);}

static int32_tsortkey_from_unicode (UChar *input, uint8_t **output){    UErrorCode status = U_ZERO_ERROR;    UCollator * collator = ucol_open ("", &status);    int32_t size;    if (icu_failure (status))        return 0;    ucol_setAttribute (collator, UCOL_NUMERIC_COLLATION, UCOL_ON, &status);    if (icu_failure (status))        return 0;    *output = (uint8_t *) palloc (sizeof (uint8_t) * PREALLOC_SIZE);    size = ucol_getSortKey (collator, input, -1, *output, PREALLOC_SIZE);    if (size > PREALLOC_SIZE)    {        pfree (*output);        *output = (uint8_t *) palloc (sizeof (uint8_t) * size);        ucol_getSortKey (collator, input, -1, *output, size);    }    ucol_close (collator);    if (size < 1)    {        ereport(ERROR, (errmsg("ICU sortkey is zero")));    }    return size;}

static voidTestFCDCrash(void) {    static const char *test[] = {    "Gr//u00F6//u00DFe",    "Grossist"    };    char *icuDataDir = safeGetICUDataDirectory();    UErrorCode status = U_ZERO_ERROR;    UCollator *coll = ucol_open("es", &status);    if(U_FAILURE(status)) {        log_err("Couldn't open collator/n");        return;    }    ucol_close(coll);    coll = NULL;    u_cleanup();    u_setDataDirectory(icuDataDir);    coll = ucol_open("de_DE", &status);    if(U_FAILURE(status)) {        log_err("Couldn't open collator/n");        return;    }    ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);    genericOrderingTest(coll, test, 2);    ucol_close(coll);    free(icuDataDir);}

static inticu_Collator_set_upper_first(icu_Collator *self, PyObject *val, void *closure) {    UErrorCode status = U_ZERO_ERROR;    ucol_setAttribute(self->collator, UCOL_CASE_FIRST, (val == Py_None) ? UCOL_OFF : ((PyObject_IsTrue(val)) ? UCOL_UPPER_FIRST : UCOL_LOWER_FIRST), &status);    if (U_FAILURE(status)) { PyErr_SetString(PyExc_ValueError, u_errorName(status)); return -1; }    return 0;}

U_CAPI void U_EXPORT2ucol_setStrength(    UCollator                *coll,            UCollationStrength        strength){    UErrorCode status = U_ZERO_ERROR;    ucol_setAttribute(coll, UCOL_STRENGTH, strength, &status);}

static void TestSecondary(){    int32_t i,j, testAcuteSize;    UCollationResult expected=UCOL_EQUAL;    UErrorCode status = U_ZERO_ERROR;    myCollation = ucol_open("fr_CA", &status);    if(U_FAILURE(status)) {        log_err_status(status, "ERROR: in creation of rule based collator: %s/n", myErrorName(status));        return;    }    ucol_setAttribute(myCollation, UCOL_STRENGTH, UCOL_SECONDARY, &status);    if(U_FAILURE(status)) {        log_err("ERROR: in creation of rule based collator: %s/n", myErrorName(status));        return;    }    log_verbose("Testing fr_CA Collation with Secondary strength/n");    /*test acute and grave ordering (compare to french collation)*/    testAcuteSize = UPRV_LENGTHOF(testAcute);    for (i = 0; i < testAcuteSize; i++)    {        for (j = 0; j < testAcuteSize; j++)        {            if (i <  j) expected = UCOL_LESS;            if (i == j) expected = UCOL_EQUAL;            if (i >  j) expected = UCOL_GREATER;            doTest(myCollation, testAcute[i], testAcute[j], expected );        }    }    ucol_close(myCollation);}

static voidTestFCDCrash(void) {    static const char *test[] = {    "Gr//u00F6//u00DFe",    "Grossist"    };    UErrorCode status = U_ZERO_ERROR;    UCollator *coll = ucol_open("es", &status);    if(U_FAILURE(status)) {        log_err_status(status, "Couldn't open collator -> %s/n", u_errorName(status));        return;    }    ucol_close(coll);    coll = NULL;    ctest_resetICU();    coll = ucol_open("de_DE", &status);    if(U_FAILURE(status)) {        log_err_status(status, "Couldn't open collator -> %s/n", u_errorName(status));        return;    }    ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);    genericOrderingTest(coll, test, 2);    ucol_close(coll);}

void Collator::createCollator() const{    ASSERT(!m_collator);    UErrorCode status = U_ZERO_ERROR;    {        Locker<Mutex> lock(cachedCollatorMutex());        if (cachedCollator) {            const char* cachedCollatorLocale = ucol_getLocaleByType(cachedCollator, ULOC_REQUESTED_LOCALE, &status);            ASSERT(U_SUCCESS(status));            ASSERT(cachedCollatorLocale);            UColAttributeValue cachedCollatorLowerFirst = ucol_getAttribute(cachedCollator, UCOL_CASE_FIRST, &status);            ASSERT(U_SUCCESS(status));            // FIXME: default locale is never matched, because ucol_getLocaleByType returns the actual one used, not 0.            if (m_locale && 0 == strcmp(cachedCollatorLocale, m_locale)                && ((UCOL_LOWER_FIRST == cachedCollatorLowerFirst && m_lowerFirst) || (UCOL_UPPER_FIRST == cachedCollatorLowerFirst && !m_lowerFirst))) {                m_collator = cachedCollator;                cachedCollator = 0;                return;            }        }    }    m_collator = ucol_open(m_locale, &status);    if (U_FAILURE(status)) {        status = U_ZERO_ERROR;        m_collator = ucol_open("", &status); // Fallback to Unicode Collation Algorithm.    }    ASSERT(U_SUCCESS(status));    ucol_setAttribute(m_collator, UCOL_CASE_FIRST, m_lowerFirst ? UCOL_LOWER_FIRST : UCOL_UPPER_FIRST, &status);    ASSERT(U_SUCCESS(status));}

//static void NativeCollation_setAttribute(JNIEnv* env, jclass, jint address, jint type, jint value) {JNIEXPORT void JNICALLJava_com_ibm_icu4jni_text_NativeCollation_setAttribute(JNIEnv* env, jclass,		jint address, jint type, jint value) {	UErrorCode status = U_ZERO_ERROR;	ucol_setAttribute(toCollator(address), (UColAttribute) type,			(UColAttributeValue) value, &status);	icu4jni_error(env, status);}

//static void NativeCollation_setNormalization(JNIEnv* env, jclass, jint address, jint mode) {JNIEXPORT void JNICALLJava_com_ibm_icu4jni_text_NativeCollation_setNormalization(JNIEnv* env, jclass,		jint address, jint mode) {	UErrorCode status = U_ZERO_ERROR;	ucol_setAttribute(toCollator(address), UCOL_NORMALIZATION_MODE,			UColAttributeValue(mode), &status);	icu4jni_error(env, status);}

/** * call-seq: *     collator.set_attr(attribute, value) *     collator[attribute]=value  *  * Universal attribute setter. See above for valid attributes and their values **/VALUE icu4r_col_set_attr(VALUE self, VALUE obj, VALUE new_val){    UErrorCode status = U_ZERO_ERROR;    Check_Type(obj, T_FIXNUM);    Check_Type(new_val, T_FIXNUM);    ucol_setAttribute(UCOLLATOR(self), FIX2INT(obj), FIX2INT(new_val), &status);    ICU_RAISE(status);    return Qnil;}

MojErr MojDbTextCollator::init(const MojChar* locale, MojDbCollationStrength level){    LOG_TRACE("Entering function %s", __FUNCTION__);	MojAssert(locale);	MojAssert(!m_ucol);	UCollationStrength strength = UCOL_PRIMARY;	switch (level) {	case MojDbCollationPrimary:		strength = UCOL_PRIMARY;		break;	case MojDbCollationSecondary:		strength = UCOL_SECONDARY;		break;	case MojDbCollationTertiary:		strength = UCOL_TERTIARY;		break;    case MojDbCollationQuaternary:        strength = UCOL_QUATERNARY;        break;	case MojDbCollationIdentical:		strength = UCOL_IDENTICAL;		break;	default:		MojAssertNotReached();	}	UErrorCode status = U_ZERO_ERROR;	m_ucol = ucol_open(locale, &status);	MojUnicodeErrCheck(status);	MojAssert(m_ucol);	ucol_setAttribute(m_ucol, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);    if (level == MojDbCollationIdentical) {        // Combination of IDENTICAL and NUMERIC option cover full-width comparison and ["001","01","1"] ordering.        // NUMERIC option converts number charcter to numeric "a021" -> ["a",21]        ucol_setAttribute(m_ucol, UCOL_NUMERIC_COLLATION, UCOL_ON, &status);    }	MojUnicodeErrCheck(status);	ucol_setStrength(m_ucol, strength);	return MojErrNone;}

static bool HHVM_METHOD(Collator, setAttribute, int64_t attr, int64_t val) {  FETCH_COL(data, this_, false);  data->clearError();  UErrorCode error = U_ZERO_ERROR;  ucol_setAttribute(data->collator(), (UColAttribute)attr,                                      (UColAttributeValue)val, &error);  if (U_FAILURE(error)) {    data->setError(error, "Error setting attribute value");    return false;  }  return true;}

static int do_iterator_options(ErlNifEnv* env, UCollator* col,     const ERL_NIF_TERM in, unsigned int& i) {    ERL_NIF_TERM out, list;    ERL_NIF_TERM* tuple;    unsigned int count;    UErrorCode status = U_ZERO_ERROR;    int32_t len;     char    value[ATOM_LEN], key[ATOM_LEN];    int     parsed_value,    parsed_key;        i = 0;    if (!enif_get_list_length(env, in, &count))         return 0;    list = in;    while (enif_get_list_cell(env, list, &out, &list)) {        if (enif_get_tuple(env, out, &len, (const ERL_NIF_TERM**) &tuple)            && (len == 2)) {             /* Set an attribute start */            if (!(enif_get_atom(env, tuple[0], (char*) key,                           ATOM_LEN, ERL_NIF_LATIN1)                && enif_get_atom(env, tuple[1], (char*) value,                         ATOM_LEN, ERL_NIF_LATIN1)))                 return 0;                                parsed_key   = parseAttrKey(key);            parsed_value = parseAttrValue(value);            if ((parsed_value == -1) || (parsed_key == -1))                 return 0;             ucol_setAttribute(col,                (UColAttribute)      parsed_key,                (UColAttributeValue) parsed_value,                &status);            if (U_FAILURE(status))                return 0;                        /* Set an attribute end */        } else             return 0;    }    return 1;}

/* * To collator returned by this function is owned by the callee and must be *closed when this method returns * with a U_SUCCESS UErrorCode. * * On error, the return value is undefined. */UCollator* GetCollatorForLocaleAndOptions(const char* lpLocaleName, int32_t options, UErrorCode* pErr){    UCollator* pColl = nullptr;    pColl = ucol_open(lpLocaleName, pErr);    if ((options & CompareOptionsIgnoreCase) == CompareOptionsIgnoreCase)    {        ucol_setAttribute(pColl, UCOL_STRENGTH, UCOL_SECONDARY, pErr);    }    return pColl;}

/** Test Choo-on kigoo*/static void TestChooonKigoo(void){    int32_t i;    UErrorCode status = U_ZERO_ERROR;    myCollation = ucol_open("ja_JP", &status);    if (U_FAILURE(status))    {        log_err_status(status, "ERROR: in creation of rule based collator: %s/n",            myErrorName(status));        return;    }    log_verbose("Testing Japanese Choo-on Kigoo Characters Collation/n");    ucol_setAttribute(myCollation, UCOL_STRENGTH, UCOL_QUATERNARY, &status);    ucol_setAttribute(myCollation, UCOL_CASE_LEVEL, UCOL_ON, &status);    for (i = 0; i < 7 ; i++) {        doTest(myCollation, testChooonKigooCases[i], testChooonKigooCases[i + 1],            UCOL_LESS);    }    ucol_close(myCollation);}

bool c_Collator::t_setattribute(int64_t attr, int64_t val) {  if (!m_ucoll) {    raise_warning("setattribute called on uninitialized Collator object");    return false;  }  m_errcode.clearError();  UErrorCode error = U_ZERO_ERROR;  ucol_setAttribute(m_ucoll, (UColAttribute)attr,                    (UColAttributeValue)val, &error);  if (U_FAILURE(error)) {    m_errcode.setError(error, "Error setting attribute value");    return false;  }  return true;}

bool c_Collator::t_setattribute(int64_t attr, int64_t val) {  if (!m_ucoll) {    raise_warning("setattribute called on uninitialized Collator object");    return false;  }  m_errcode.clear();  ucol_setAttribute(m_ucoll, (UColAttribute)attr,                    (UColAttributeValue)val, &(m_errcode.code));  s_intl_error->m_error.clear();  s_intl_error->m_error.code = m_errcode.code;  if (U_FAILURE(m_errcode.code)) {    m_errcode.custom_error_message = "Error setting attribute value";    s_intl_error->m_error.custom_error_message = m_errcode.custom_error_message;    return false;  }  return true;}

nsresult nsCollationMacUC::EnsureCollator(const int32_t newStrength) {  NS_ENSURE_TRUE(mInit, NS_ERROR_NOT_INITIALIZED);  if (mHasCollator && (mLastStrength == newStrength))    return NS_OK;  nsresult res;  res = CleanUpCollator();  NS_ENSURE_SUCCESS(res, res);  if (mUseICU) {    NS_ENSURE_TRUE(mLocaleICU, NS_ERROR_NOT_INITIALIZED);    UErrorCode status;    status = U_ZERO_ERROR;    mCollatorICU = ucol_open(mLocaleICU, &status);    NS_ENSURE_TRUE(U_SUCCESS(status), NS_ERROR_FAILURE);    UCollationStrength strength;    UColAttributeValue caseLevel;    res = ConvertStrength(newStrength, &strength, &caseLevel);    NS_ENSURE_SUCCESS(res, res);    status = U_ZERO_ERROR;    ucol_setAttribute(mCollatorICU, UCOL_STRENGTH, strength, &status);    NS_ENSURE_TRUE(U_SUCCESS(status), NS_ERROR_FAILURE);    ucol_setAttribute(mCollatorICU, UCOL_CASE_LEVEL, caseLevel, &status);    NS_ENSURE_TRUE(U_SUCCESS(status), NS_ERROR_FAILURE);    ucol_setAttribute(mCollatorICU, UCOL_ALTERNATE_HANDLING, UCOL_DEFAULT, &status);    NS_ENSURE_TRUE(U_SUCCESS(status), NS_ERROR_FAILURE);    ucol_setAttribute(mCollatorICU, UCOL_NUMERIC_COLLATION, UCOL_OFF, &status);    NS_ENSURE_TRUE(U_SUCCESS(status), NS_ERROR_FAILURE);    ucol_setAttribute(mCollatorICU, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);    NS_ENSURE_TRUE(U_SUCCESS(status), NS_ERROR_FAILURE);    ucol_setAttribute(mCollatorICU, UCOL_CASE_FIRST, UCOL_DEFAULT, &status);    NS_ENSURE_TRUE(U_SUCCESS(status), NS_ERROR_FAILURE);  } else {    OSStatus err;    UCCollateOptions newOptions;    res = StrengthToOptions(newStrength, &newOptions);    NS_ENSURE_SUCCESS(res, res);    LocaleOperationVariant opVariant = 0; // default variant for now    err = ::UCCreateCollator(mLocale, opVariant, newOptions, &mCollator);    NS_ENSURE_TRUE((err == noErr), NS_ERROR_FAILURE);  }  mHasCollator = true;  mLastStrength = newStrength;  return NS_OK;}

static void TestTertiary( ){    int32_t i;    UErrorCode status = U_ZERO_ERROR;    myCollation = ucol_open("ja_JP", &status);    if(U_FAILURE(status)){        log_err_status(status, "ERROR: in creation of rule based collator: %s/n", myErrorName(status));        return;    }    log_verbose("Testing Kanna(Japan) Collation with Tertiary strength/n");    ucol_setStrength(myCollation, UCOL_TERTIARY);    ucol_setAttribute(myCollation, UCOL_CASE_LEVEL, UCOL_ON, &status);    for (i = 0; i < 6 ; i++)    {        doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);    }    ucol_close(myCollation);}

/** Test Small, Large letters*/static void TestSmallLarge(void){    int32_t i;    UErrorCode status = U_ZERO_ERROR;    myCollation = ucol_open("ja_JP", &status);    if (U_FAILURE(status))    {        log_err_status(status, "ERROR: in creation of rule based collator: %s/n",            myErrorName(status));        return;    }    log_verbose("Testing Japanese Small and Large Characters Collation/n");    ucol_setStrength(myCollation, UCOL_TERTIARY);    ucol_setAttribute(myCollation, UCOL_CASE_LEVEL, UCOL_ON, &status);    for (i = 0; i < 3 ; i++)        doTest(myCollation, testSmallLargeCases[i], testSmallLargeCases[i + 1],        UCOL_LESS);    ucol_close(myCollation);}

void genericLocaleStarterWithOptionsAndResult(const char *locale, const char * const s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize, UCollationResult result) {  UErrorCode status = U_ZERO_ERROR;  uint32_t i;  UCollator *coll = ucol_open(locale, &status);  log_verbose("Locale starter for %s/n", locale);  if(U_SUCCESS(status)) {    log_verbose("Setting attributes/n");    for(i = 0; i < attsize; i++) {      ucol_setAttribute(coll, attrs[i], values[i], &status);    }    genericOrderingTestWithResult(coll, s, size, result);  } else {    log_err("Unable to open collator for locale %s/n", locale);  }  ucol_close(coll);}

/* currently not used with options */void genericRulesStarterWithOptionsAndResult(const char *rules, const char * const s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize, UCollationResult result) {  UErrorCode status = U_ZERO_ERROR;  UChar rlz[RULE_BUFFER_LEN] = { 0 };  uint32_t rlen = u_unescape(rules, rlz, RULE_BUFFER_LEN);  uint32_t i;  UCollator *coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);  log_verbose("Rules starter for %s/n", rules);  if(U_SUCCESS(status)) {    log_verbose("Setting attributes/n");    for(i = 0; i < attsize; i++) {      ucol_setAttribute(coll, attrs[i], values[i], &status);    }    genericOrderingTestWithResult(coll, s, size, result);  } else {    log_err("Unable to open collator with rules %s/n", rules);  }  ucol_close(coll);}

static void TestTertiary( ){    int32_t i;    UErrorCode status = U_ZERO_ERROR;    myCollation = ucol_open("fr_CA", &status);    if(U_FAILURE(status) || !myCollation) {        log_err_status(status, "ERROR: in creation of rule based collator: %s/n", myErrorName(status));        return;    }    ucol_setAttribute(myCollation, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);    if(U_FAILURE(status)) {        log_err("ERROR: in creation of rule based collator: %s/n", myErrorName(status));        return;    }    log_verbose("Testing fr_CA Collation with Tertiary strength/n");    ucol_setStrength(myCollation, UCOL_QUATERNARY);    for (i = 0; i < 12 ; i++)    {        doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);    }    ucol_close(myCollation);}