[apple/icu.git] / icuSources / test / cintltst / stdnmtst.c

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 2000-2016, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/
/*
* File stdnmtst.c
*
* Modification History:
*
*   Date          Name        Description
*   08/05/2000    Yves       Creation 
******************************************************************************
*/

#include "unicode/ucnv.h"
#include "unicode/ustring.h"
#include "cmemory.h"
#include "cstring.h"
#include "cintltst.h"

static void TestStandardName(void);
static void TestStandardNames(void);
static void TestCanonicalName(void);

void addStandardNamesTest(TestNode** root);


void
addStandardNamesTest(TestNode** root)
{
  addTest(root, &TestStandardName,  "tsconv/stdnmtst/TestStandardName");
  addTest(root, &TestStandardNames, "tsconv/stdnmtst/TestStandardNames");
  addTest(root, &TestCanonicalName, "tsconv/stdnmtst/TestCanonicalName");
}

static int dotestname(const char *name, const char *standard, const char *expected) {
    int res = 1;

    UErrorCode error;
    const char *tag;

    error = U_ZERO_ERROR;
    tag = ucnv_getStandardName(name, standard, &error);
    if (!tag && expected) {
        log_err_status(error, "FAIL: could not find %s standard name for %s\n", standard, name);
        res = 0;
    } else if (expected && (name == tag || uprv_strcmp(expected, tag))) {
        log_err("FAIL: expected %s for %s standard name for %s, got %s\n", expected, standard, name, tag);
        res = 0;
    }

    return res;
}

static void TestStandardName()
{
    int res = 1;

    uint16_t i, count;
    UErrorCode err;

    /* Iterate over all standards. */
    for (i = 0, count = ucnv_countStandards(); i < count-1; ++i) {
        const char *standard;

        err = U_ZERO_ERROR;
        standard = ucnv_getStandard(i, &err);
        if (U_FAILURE(err)) {
            log_err("FAIL: ucnv_getStandard(%d), error=%s\n", i, u_errorName(err));
            res = 0;
        } else if (!standard || !*standard) {
            log_err("FAIL: %s standard name at index %d\n", (standard ? "empty" :
                "null"), i);
            res = 0;
        }
    }
    err = U_ZERO_ERROR;
    /* "" must be last */
    if(!count) {
      log_data_err("No standards. You probably have no data.\n");
    } else if (*ucnv_getStandard((uint16_t)(count-1), &err) != 0) {
        log_err("FAIL: ucnv_getStandard(%d) should return ""\n", count-1);
        res = 0;
    }
    err = U_ZERO_ERROR;
    if (ucnv_getStandard(++i, &err)) {
        log_err("FAIL: ucnv_getStandard(%d) should return NULL\n", i);
        res = 0;
    }

    if (res) {
        log_verbose("PASS: iterating over standard names works\n");
    }

    /* Test for some expected results. */

    if (dotestname("ibm-1208", "MIME", "UTF-8") &&
        /*dotestname("cp1252", "MIME", "windows-1252") &&*/
        dotestname("ascii", "MIME", "US-ASCII") &&
        dotestname("csiso2022jp2", "MIME", "ISO-2022-JP-2") &&
        dotestname("Iso20-22__cN", "IANA", "ISO-2022-CN") &&
        dotestname("ascii", "IANA", "ANSI_X3.4-1968") &&
        dotestname("cp850", "IANA", "IBM850") &&
        dotestname("crazy", "MIME", NULL) &&
        dotestname("ASCII", "crazy", NULL) &&
        dotestname("LMBCS-1", "MIME", NULL))
    {
        log_verbose("PASS: getting IANA and MIME standard names works\n");
    }
}

static int dotestconv(const char *name, const char *standard, const char *expected) {
    int res = 1;

    UErrorCode error;
    const char *tag;

    error = U_ZERO_ERROR;
    tag = ucnv_getCanonicalName(name, standard, &error);
    if (tag && !expected) {
        log_err("FAIL: Unexpectedly found %s canonical name for %s, got %s\n", standard, name, tag);
        res = 0;
    }
    else if (!tag && expected) {
        log_err_status(error, "FAIL: could not find %s canonical name for %s\n", (standard ? "\"\"" : standard), name);
        res = 0;
    }
    else if (expected && (name == tag || uprv_strcmp(expected, tag) != 0)) {
        log_err("FAIL: expected %s for %s canonical name for %s, got %s\n", expected, standard, name, tag);
        res = 0;
    }
    else {
        log_verbose("PASS: (\"%s\", \"%s\") -> %s == %s \n", name, standard, tag, expected);
    }

    return res;
}

static void TestCanonicalName()
{
    /* Test for some expected results. */

    if (dotestconv("UTF-8", "IANA", "UTF-8") &&     /* default name */
        dotestconv("UTF-8", "MIME", "UTF-8") &&     /* default name */
        dotestconv("ibm-1208", "IBM", "UTF-8") &&   /* default name */
        dotestconv("ibm-5305", "IBM", "UTF-8") &&   /* non-default name */
        dotestconv("ibm-5305", "MIME", NULL) &&     /* mapping does not exist */
        dotestconv("ascii", "MIME", NULL) &&        /* mapping does not exist */
        dotestconv("ibm-1208", "IANA", NULL) &&     /* mapping does not exist */
        dotestconv("ibm-5305", "IANA", NULL) &&     /* mapping does not exist */
        dotestconv("cp1208", "", "UTF-8") &&        /* default name due to ordering */
        dotestconv("UTF16_BigEndian", "", "UTF-16BE") &&        /* non-default name due to ordering */
        dotestconv("ISO-2022-CN", "IANA", "ISO_2022,locale=zh,version=0") &&/* default name */
        dotestconv("Shift_JIS", "MIME", "ibm-943_P15A-2003") &&/* ambiguous alias */
        dotestconv("Shift_JIS", "", "ibm-943_P130-1999") &&/* ambiguous alias */
        dotestconv("ibm-943", "", "ibm-943_P15A-2003") &&/* ambiguous alias */
        dotestconv("ibm-943", "IBM", "ibm-943_P130-1999") &&/* ambiguous alias */
        dotestconv("ibm-1363", "", "ibm-1363_P11B-1998") &&/* ambiguous alias */
        dotestconv("ibm-1363", "IBM", "ibm-1363_P110-1997") &&/* ambiguous alias */
        dotestconv("crazy", "MIME", NULL) &&
        dotestconv("ASCII", "crazy", NULL))
    {
        log_verbose("PASS: getting IANA and MIME canonical names works\n");
    }
}


static UBool doTestNames(const char *name, const char *standard, const char **expected, int32_t size) {
    UErrorCode err = U_ZERO_ERROR;
    UEnumeration *myEnum = ucnv_openStandardNames(name, standard, &err);
    const char *enumName, *testName;
    int32_t enumCount = uenum_count(myEnum, &err);
    int32_t idx, len, repeatTimes = 3;
    
    if (err == U_FILE_ACCESS_ERROR) {
        log_data_err("Unable to open standard names for %s of standard: %s\n", name, standard);
        return 0;
    }
    if (size != enumCount) {
        log_err("FAIL: different size arrays for %s. Got %d. Expected %d\n", name, enumCount, size);
        return 0;
    }
    if (size < 0 && myEnum) {
        log_err("FAIL: size < 0, but recieved an actual object\n");
        return 0;
    }
    log_verbose("\n%s %s\n", name, standard);
    while (repeatTimes-- > 0) {
        for (idx = 0; idx < enumCount; idx++) {
            enumName = uenum_next(myEnum, &len, &err);
            testName = expected[idx];
            if (uprv_strcmp(enumName, testName) != 0 || U_FAILURE(err)
                || len != (int32_t)uprv_strlen(expected[idx]))
            {
                log_err("FAIL: uenum_next(%d) == \"%s\". expected \"%s\", len=%d, error=%s\n",
                    idx, enumName, testName, len, u_errorName(err));
            }
            log_verbose("%s\n", enumName);
            err = U_ZERO_ERROR;
        }
        if (enumCount >= 0) {
            /* one past the list of all names must return NULL */
            enumName = uenum_next(myEnum, &len, &err);
            if (enumName != NULL || len != 0 || U_FAILURE(err)) {
                log_err("FAIL: uenum_next(past the list) did not return NULL[0] with U_SUCCESS(). name=%s standard=%s len=%d err=%s\n", name, standard, len, u_errorName(err));
            }
        }
        log_verbose("\n    reset\n");
        uenum_reset(myEnum, &err);
        if (U_FAILURE(err)) {
            log_err("FAIL: uenum_reset() for %s{%s} failed with %s\n",
                name, standard, u_errorName(err));
            err = U_ZERO_ERROR;
        }
    }
    uenum_close(myEnum);
    return 1;
}

static UBool doTestUCharNames(const char *name, const char *standard, const char **expected, int32_t size) {
    UErrorCode err = U_ZERO_ERROR;
    UEnumeration *myEnum = ucnv_openStandardNames(name, standard, &err);
    int32_t enumCount = uenum_count(myEnum, &err);
    int32_t idx, repeatTimes = 3;
    
    if (err == U_FILE_ACCESS_ERROR) {
        log_data_err("Unable to open standard names for %s of standard: %s\n", name, standard);
        return 0;
    }
    
    if (size != enumCount) {
        log_err("FAIL: different size arrays. Got %d. Expected %d\n", enumCount, size);
        return 0;
    }
    if (size < 0 && myEnum) {
        log_err("FAIL: size < 0, but recieved an actual object\n");
        return 0;
    }
    log_verbose("\n%s %s\n", name, standard);
    while (repeatTimes-- > 0) {
        for (idx = 0; idx < enumCount; idx++) {
            UChar testName[256];
            int32_t len;
            const UChar *enumName = uenum_unext(myEnum, &len, &err);
            u_uastrncpy(testName, expected[idx], UPRV_LENGTHOF(testName));
            if (u_strcmp(enumName, testName) != 0 || U_FAILURE(err)
                || len != (int32_t)uprv_strlen(expected[idx]))
            {
                log_err("FAIL: uenum_next(%d) == \"%s\". expected \"%s\", len=%d, error=%s\n",
                    idx, enumName, testName, len, u_errorName(err));
            }
            log_verbose("%s\n", expected[idx]);
            err = U_ZERO_ERROR;
        }
        log_verbose("\n    reset\n");
        uenum_reset(myEnum, &err);
        if (U_FAILURE(err)) {
            log_err("FAIL: uenum_reset() for %s{%s} failed with %s\n",
                name, standard, u_errorName(err));
            err = U_ZERO_ERROR;
        }
    }
    uenum_close(myEnum);
    return 1;
}

static void TestStandardNames()
{
    static const char *asciiIANA[] = {
        "ANSI_X3.4-1968",
        "US-ASCII",
        "ASCII",
        "ANSI_X3.4-1986",
        "ISO_646.irv:1991",
        "ISO646-US",
        "us",
        "csASCII",
        "iso-ir-6",
        "cp367",
        "IBM367",
    };
    static const char *asciiMIME[] = {
        "US-ASCII"
    };

    static const char *iso2022MIME[] = {
        "ISO-2022-KR",
    };

    doTestNames("ASCII", "IANA", asciiIANA, UPRV_LENGTHOF(asciiIANA));
    doTestNames("US-ASCII", "IANA", asciiIANA, UPRV_LENGTHOF(asciiIANA));
    doTestNames("ASCII", "MIME", asciiMIME, UPRV_LENGTHOF(asciiMIME));
    doTestNames("ascii", "mime", asciiMIME, UPRV_LENGTHOF(asciiMIME));

    doTestNames("ASCII", "crazy", asciiMIME, -1);
    doTestNames("crazy", "MIME", asciiMIME, -1);

    doTestNames("LMBCS-1", "MIME", asciiMIME, 0);

    doTestNames("ISO_2022,locale=ko,version=0", "MIME", iso2022MIME, UPRV_LENGTHOF(iso2022MIME));
    doTestNames("csiso2022kr", "MIME", iso2022MIME, UPRV_LENGTHOF(iso2022MIME));

    log_verbose(" Testing unext()\n");
    doTestUCharNames("ASCII", "IANA", asciiIANA, UPRV_LENGTHOF(asciiIANA));

}
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
b75a7d8f A	3	/********************************************************************
b75a7d8f A	4	* COPYRIGHT:
2ca993e8	5	* Copyright (c) 2000-2016, International Business Machines Corporation and
b75a7d8f A	6	* others. All Rights Reserved.
	7	********************************************************************/
	8	/*
	9	* File stdnmtst.c
	10	*
	11	* Modification History:
	12	*
	13	* Date Name Description
	14	* 08/05/2000 Yves Creation
46f4442e	15	******************************************************************************
b75a7d8f A	16	*/
	17
	18	#include "unicode/ucnv.h"
	19	#include "unicode/ustring.h"
2ca993e8	20	#include "cmemory.h"
b75a7d8f A	21	#include "cstring.h"
	22	#include "cintltst.h"
	23
b75a7d8f A	24	static void TestStandardName(void);
	25	static void TestStandardNames(void);
	26	static void TestCanonicalName(void);
	27
	28	void addStandardNamesTest(TestNode** root);
	29
	30
	31	void
	32	addStandardNamesTest(TestNode** root)
	33	{
374ca955 A	34	addTest(root, &TestStandardName, "tsconv/stdnmtst/TestStandardName");
	35	addTest(root, &TestStandardNames, "tsconv/stdnmtst/TestStandardNames");
	36	addTest(root, &TestCanonicalName, "tsconv/stdnmtst/TestCanonicalName");
b75a7d8f A	37	}
	38
	39	static int dotestname(const char name, const char standard, const char *expected) {
	40	int res = 1;
	41
	42	UErrorCode error;
	43	const char *tag;
	44
	45	error = U_ZERO_ERROR;
	46	tag = ucnv_getStandardName(name, standard, &error);
	47	if (!tag && expected) {
729e4ab9	48	log_err_status(error, "FAIL: could not find %s standard name for %s\n", standard, name);
b75a7d8f A	49	res = 0;
	50	} else if (expected && (name == tag \|\| uprv_strcmp(expected, tag))) {
	51	log_err("FAIL: expected %s for %s standard name for %s, got %s\n", expected, standard, name, tag);
	52	res = 0;
	53	}
	54
	55	return res;
	56	}
	57
	58	static void TestStandardName()
	59	{
	60	int res = 1;
	61
	62	uint16_t i, count;
	63	UErrorCode err;
	64
	65	/* Iterate over all standards. */
	66	for (i = 0, count = ucnv_countStandards(); i < count-1; ++i) {
	67	const char *standard;
	68
	69	err = U_ZERO_ERROR;
	70	standard = ucnv_getStandard(i, &err);
	71	if (U_FAILURE(err)) {
	72	log_err("FAIL: ucnv_getStandard(%d), error=%s\n", i, u_errorName(err));
	73	res = 0;
	74	} else if (!standard \|\| !*standard) {
	75	log_err("FAIL: %s standard name at index %d\n", (standard ? "empty" :
	76	"null"), i);
	77	res = 0;
	78	}
	79	}
	80	err = U_ZERO_ERROR;
	81	/* "" must be last */
	82	if(!count) {
	83	log_data_err("No standards. You probably have no data.\n");
	84	} else if (*ucnv_getStandard((uint16_t)(count-1), &err) != 0) {
	85	log_err("FAIL: ucnv_getStandard(%d) should return ""\n", count-1);
	86	res = 0;
	87	}
	88	err = U_ZERO_ERROR;
	89	if (ucnv_getStandard(++i, &err)) {
	90	log_err("FAIL: ucnv_getStandard(%d) should return NULL\n", i);
	91	res = 0;
	92	}
	93
	94	if (res) {
	95	log_verbose("PASS: iterating over standard names works\n");
	96	}
	97
	98	/* Test for some expected results. */
	99
	100	if (dotestname("ibm-1208", "MIME", "UTF-8") &&
	101	/dotestname("cp1252", "MIME", "windows-1252") &&/
	102	dotestname("ascii", "MIME", "US-ASCII") &&
374ca955	103	dotestname("csiso2022jp2", "MIME", "ISO-2022-JP-2") &&
73c04bcf	104	dotestname("Iso20-22__cN", "IANA", "ISO-2022-CN") &&
b75a7d8f A	105	dotestname("ascii", "IANA", "ANSI_X3.4-1968") &&
	106	dotestname("cp850", "IANA", "IBM850") &&
	107	dotestname("crazy", "MIME", NULL) &&
	108	dotestname("ASCII", "crazy", NULL) &&
	109	dotestname("LMBCS-1", "MIME", NULL))
	110	{
	111	log_verbose("PASS: getting IANA and MIME standard names works\n");
	112	}
	113	}
	114
	115	static int dotestconv(const char name, const char standard, const char *expected) {
	116	int res = 1;
	117
	118	UErrorCode error;
	119	const char *tag;
	120
	121	error = U_ZERO_ERROR;
	122	tag = ucnv_getCanonicalName(name, standard, &error);
	123	if (tag && !expected) {
	124	log_err("FAIL: Unexpectedly found %s canonical name for %s, got %s\n", standard, name, tag);
	125	res = 0;
73c04bcf A	126	}
73c04bcf A	127	else if (!tag && expected) {
729e4ab9	128	log_err_status(error, "FAIL: could not find %s canonical name for %s\n", (standard ? "\"\"" : standard), name);
b75a7d8f	129	res = 0;
73c04bcf A	130	}
73c04bcf A	131	else if (expected && (name == tag \|\| uprv_strcmp(expected, tag) != 0)) {
b75a7d8f A	132	log_err("FAIL: expected %s for %s canonical name for %s, got %s\n", expected, standard, name, tag);
	133	res = 0;
	134	}
73c04bcf A	135	else {
	136	log_verbose("PASS: (\"%s\", \"%s\") -> %s == %s \n", name, standard, tag, expected);
	137	}
b75a7d8f A	138
	139	return res;
	140	}
	141
	142	static void TestCanonicalName()
	143	{
	144	/* Test for some expected results. */
	145
	146	if (dotestconv("UTF-8", "IANA", "UTF-8") && /* default name */
	147	dotestconv("UTF-8", "MIME", "UTF-8") && /* default name */
	148	dotestconv("ibm-1208", "IBM", "UTF-8") && /* default name */
	149	dotestconv("ibm-5305", "IBM", "UTF-8") && /* non-default name */
	150	dotestconv("ibm-5305", "MIME", NULL) && /* mapping does not exist */
	151	dotestconv("ascii", "MIME", NULL) && /* mapping does not exist */
	152	dotestconv("ibm-1208", "IANA", NULL) && /* mapping does not exist */
	153	dotestconv("ibm-5305", "IANA", NULL) && /* mapping does not exist */
	154	dotestconv("cp1208", "", "UTF-8") && /* default name due to ordering */
	155	dotestconv("UTF16_BigEndian", "", "UTF-16BE") && /* non-default name due to ordering */
73c04bcf A	156	dotestconv("ISO-2022-CN", "IANA", "ISO_2022,locale=zh,version=0") &&/* default name */
73c04bcf A	157	dotestconv("Shift_JIS", "MIME", "ibm-943_P15A-2003") &&/* ambiguous alias */
b75a7d8f	158	dotestconv("Shift_JIS", "", "ibm-943_P130-1999") &&/* ambiguous alias */
73c04bcf	159	dotestconv("ibm-943", "", "ibm-943_P15A-2003") &&/* ambiguous alias */
b75a7d8f A	160	dotestconv("ibm-943", "IBM", "ibm-943_P130-1999") &&/* ambiguous alias */
	161	dotestconv("ibm-1363", "", "ibm-1363_P11B-1998") &&/* ambiguous alias */
	162	dotestconv("ibm-1363", "IBM", "ibm-1363_P110-1997") &&/* ambiguous alias */
	163	dotestconv("crazy", "MIME", NULL) &&
	164	dotestconv("ASCII", "crazy", NULL))
	165	{
	166	log_verbose("PASS: getting IANA and MIME canonical names works\n");
	167	}
	168	}
	169
	170
	171	static UBool doTestNames(const char name, const char standard, const char **expected, int32_t size) {
	172	UErrorCode err = U_ZERO_ERROR;
	173	UEnumeration *myEnum = ucnv_openStandardNames(name, standard, &err);
73c04bcf	174	const char enumName, testName;
b75a7d8f	175	int32_t enumCount = uenum_count(myEnum, &err);
73c04bcf	176	int32_t idx, len, repeatTimes = 3;
729e4ab9 A	177
	178	if (err == U_FILE_ACCESS_ERROR) {
	179	log_data_err("Unable to open standard names for %s of standard: %s\n", name, standard);
	180	return 0;
	181	}
b75a7d8f	182	if (size != enumCount) {
46f4442e	183	log_err("FAIL: different size arrays for %s. Got %d. Expected %d\n", name, enumCount, size);
b75a7d8f A	184	return 0;
	185	}
	186	if (size < 0 && myEnum) {
	187	log_err("FAIL: size < 0, but recieved an actual object\n");
	188	return 0;
	189	}
	190	log_verbose("\n%s %s\n", name, standard);
	191	while (repeatTimes-- > 0) {
	192	for (idx = 0; idx < enumCount; idx++) {
73c04bcf A	193	enumName = uenum_next(myEnum, &len, &err);
73c04bcf A	194	testName = expected[idx];
b75a7d8f A	195	if (uprv_strcmp(enumName, testName) != 0 \|\| U_FAILURE(err)
	196	\|\| len != (int32_t)uprv_strlen(expected[idx]))
	197	{
	198	log_err("FAIL: uenum_next(%d) == \"%s\". expected \"%s\", len=%d, error=%s\n",
	199	idx, enumName, testName, len, u_errorName(err));
	200	}
	201	log_verbose("%s\n", enumName);
	202	err = U_ZERO_ERROR;
	203	}
73c04bcf A	204	if (enumCount >= 0) {
	205	/* one past the list of all names must return NULL */
	206	enumName = uenum_next(myEnum, &len, &err);
	207	if (enumName != NULL \|\| len != 0 \|\| U_FAILURE(err)) {
	208	log_err("FAIL: uenum_next(past the list) did not return NULL[0] with U_SUCCESS(). name=%s standard=%s len=%d err=%s\n", name, standard, len, u_errorName(err));
	209	}
	210	}
b75a7d8f A	211	log_verbose("\n reset\n");
	212	uenum_reset(myEnum, &err);
	213	if (U_FAILURE(err)) {
	214	log_err("FAIL: uenum_reset() for %s{%s} failed with %s\n",
	215	name, standard, u_errorName(err));
	216	err = U_ZERO_ERROR;
	217	}
	218	}
	219	uenum_close(myEnum);
	220	return 1;
	221	}
	222
	223	static UBool doTestUCharNames(const char name, const char standard, const char **expected, int32_t size) {
	224	UErrorCode err = U_ZERO_ERROR;
	225	UEnumeration *myEnum = ucnv_openStandardNames(name, standard, &err);
	226	int32_t enumCount = uenum_count(myEnum, &err);
	227	int32_t idx, repeatTimes = 3;
729e4ab9 A	228
	229	if (err == U_FILE_ACCESS_ERROR) {
	230	log_data_err("Unable to open standard names for %s of standard: %s\n", name, standard);
	231	return 0;
	232	}
	233
b75a7d8f A	234	if (size != enumCount) {
	235	log_err("FAIL: different size arrays. Got %d. Expected %d\n", enumCount, size);
	236	return 0;
	237	}
	238	if (size < 0 && myEnum) {
	239	log_err("FAIL: size < 0, but recieved an actual object\n");
	240	return 0;
	241	}
	242	log_verbose("\n%s %s\n", name, standard);
	243	while (repeatTimes-- > 0) {
	244	for (idx = 0; idx < enumCount; idx++) {
	245	UChar testName[256];
	246	int32_t len;
	247	const UChar *enumName = uenum_unext(myEnum, &len, &err);
2ca993e8	248	u_uastrncpy(testName, expected[idx], UPRV_LENGTHOF(testName));
b75a7d8f A	249	if (u_strcmp(enumName, testName) != 0 \|\| U_FAILURE(err)
	250	\|\| len != (int32_t)uprv_strlen(expected[idx]))
	251	{
	252	log_err("FAIL: uenum_next(%d) == \"%s\". expected \"%s\", len=%d, error=%s\n",
	253	idx, enumName, testName, len, u_errorName(err));
	254	}
	255	log_verbose("%s\n", expected[idx]);
	256	err = U_ZERO_ERROR;
	257	}
	258	log_verbose("\n reset\n");
	259	uenum_reset(myEnum, &err);
	260	if (U_FAILURE(err)) {
	261	log_err("FAIL: uenum_reset() for %s{%s} failed with %s\n",
	262	name, standard, u_errorName(err));
	263	err = U_ZERO_ERROR;
	264	}
	265	}
	266	uenum_close(myEnum);
	267	return 1;
	268	}
	269
	270	static void TestStandardNames()
	271	{
	272	static const char *asciiIANA[] = {
	273	"ANSI_X3.4-1968",
	274	"US-ASCII",
	275	"ASCII",
	276	"ANSI_X3.4-1986",
	277	"ISO_646.irv:1991",
	278	"ISO646-US",
	279	"us",
	280	"csASCII",
	281	"iso-ir-6",
	282	"cp367",
46f4442e	283	"IBM367",
b75a7d8f A	284	};
	285	static const char *asciiMIME[] = {
	286	"US-ASCII"
	287	};
	288
	289	static const char *iso2022MIME[] = {
374ca955	290	"ISO-2022-KR",
b75a7d8f A	291	};
b75a7d8f A	292
2ca993e8 A	293	doTestNames("ASCII", "IANA", asciiIANA, UPRV_LENGTHOF(asciiIANA));
	294	doTestNames("US-ASCII", "IANA", asciiIANA, UPRV_LENGTHOF(asciiIANA));
	295	doTestNames("ASCII", "MIME", asciiMIME, UPRV_LENGTHOF(asciiMIME));
	296	doTestNames("ascii", "mime", asciiMIME, UPRV_LENGTHOF(asciiMIME));
b75a7d8f A	297
	298	doTestNames("ASCII", "crazy", asciiMIME, -1);
	299	doTestNames("crazy", "MIME", asciiMIME, -1);
	300
	301	doTestNames("LMBCS-1", "MIME", asciiMIME, 0);
	302
2ca993e8 A	303	doTestNames("ISO_2022,locale=ko,version=0", "MIME", iso2022MIME, UPRV_LENGTHOF(iso2022MIME));
2ca993e8 A	304	doTestNames("csiso2022kr", "MIME", iso2022MIME, UPRV_LENGTHOF(iso2022MIME));
b75a7d8f A	305
b75a7d8f A	306	log_verbose(" Testing unext()\n");
2ca993e8	307	doTestUCharNames("ASCII", "IANA", asciiIANA, UPRV_LENGTHOF(asciiIANA));
b75a7d8f A	308
b75a7d8f A	309	}