xref: /illumos-gate/usr/src/test/libc-tests/tests/getlocname.c (revision 004345e48064ccd168d15f66eba2031c6090ccee)

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2025 Oxide Computer Company
 */

/*
 * Tests for getlocalename_l(3C). The libc tests depends on locale/ar,
 * locale/de, locale/en, and locale/ja. We limit ourselves to these locales,
 * plus C.UTF-8. We use a combination of global locales set via setlocale(),
 * locales set with uselocale(), and composite locale.
 */

#include <err.h>
#include <stdlib.h>
#include <locale.h>
#include <sys/sysmacros.h>
#include <sys/debug.h>
#include <stdbool.h>
#include <string.h>

typedef struct {
	int lc_cat;
	const char *lc_name;
} lc_cat_t;

static const lc_cat_t lc_cats[] = {
	{ LC_CTYPE, "LC_CTYPE" },
	{ LC_NUMERIC, "LC_NUMERIC" },
	{ LC_TIME, "LC_TIME" },
	{ LC_COLLATE, "LC_COLLATE" },
	{ LC_MONETARY, "LC_MONETARY" },
	{ LC_MESSAGES, "LC_MESSAGES" },
	{ LC_ALL, "LC_ALL" }
};
CTASSERT(ARRAY_SIZE(lc_cats) == LC_ALL + 1);

typedef struct {
	int lc_cat;
	int lc_mask;
	const char *lc_loc;
} lc_comp_t;

static const lc_comp_t composite[] = {
	{ LC_CTYPE, LC_CTYPE_MASK, "en_US.UTF-8" },
	{ LC_NUMERIC, LC_NUMERIC_MASK, "en_GB.UTF-8" },
	{ LC_TIME, LC_TIME_MASK, "de_DE.UTF-8" },
	{ LC_COLLATE, LC_COLLATE_MASK, "ar_EG.UTF-8" },
	{ LC_MONETARY, LC_MONETARY_MASK, "ja_JP.UTF-8" },
	{ LC_MESSAGES, LC_MESSAGES_MASK, "C.UTF-8" }
};

static const char *locales[] = { "C.UTF-8", "ja_JP.UTF-8", "de_DE.UTF-8",
	"en_US.UTF-8", "en_GB.UTF-8" };

/*
 * Check each category of a locale. These are ordered in exp by their LC_ type
 * category.
 */
static bool
locname_check(const char *desc, locale_t loc, const char **exp_names)
{
	bool ret = true;

	for (size_t i = 0; i < ARRAY_SIZE(lc_cats); i++) {
		const char *catname = lc_cats[i].lc_name;
		const char *exp = exp_names[lc_cats[i].lc_cat];
		const char *name = getlocalename_l(lc_cats[i].lc_cat, loc);
		if (name == NULL) {
			warnx("TEST FAILED: %s: failed to get locale name for "
			    "category %s: expected %s", desc, catname, exp);
			ret = false;
			continue;
		}

		if (strcmp(name, exp) != 0) {
			warnx("TEST FAILED: %s: got incorrect value for "
			    "category %s: expected %s, but got %s", desc,
			    catname, exp, name);
			ret = false;
		} else {
			(void) printf("TEST PASSED: %s: category %s\n", desc,
			    catname);
		}
	}

	return (ret);
}

/*
 * A small wrapper for names that are uniform.
 */
static bool
locname_check_all(const char *desc, locale_t loc, const char *exp)
{
	const char *names[LC_ALL + 1] = { exp, exp, exp, exp, exp, exp, exp };

	return (locname_check(desc, loc, names));
}

/*
 * Change each locale category one at a time and ensure that we get the expected
 * locale. Then set it as the global locale and ensure that this is what we
 * expect. We start from C. We track the names based on an array indexed by the
 * different categories and use the fact that they're ordered to know what to
 * check against.
 *
 * We also test setting the global locale to the result of this to ensure that
 * the results of composite locales are usable.
 */
static bool
locname_composite(void)
{
	bool ret = true;
	const char *names[LC_ALL + 1] = { "C", "C", "C", "C", "C", "C", NULL };
	locale_t loc = newlocale(LC_ALL_MASK, "C", NULL);

	if (loc == NULL) {
		errx(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to create "
		    "base C locale for composite tests");
	}

	for (size_t i = 0; i < ARRAY_SIZE(composite); i++) {
		char cname[1024], desc[1024];

		names[composite[i].lc_cat] = composite[i].lc_loc;
		(void) snprintf(cname, sizeof (cname), "%s/%s/%s/%s/%s/%s",
		    names[0], names[1], names[2], names[3], names[4], names[5]);
		names[LC_ALL] = cname;

		loc = newlocale(composite[i].lc_mask, composite[i].lc_loc,
		    loc);
		if (loc == NULL) {
			err(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to "
			    "evolve composite locale to %s", cname);
		}

		(void) snprintf(desc, sizeof (desc), "composite %s (%d)",
		    composite[i].lc_loc, composite[i].lc_cat);
		if (!locname_check(desc, loc, names))
			ret = false;

		if (setlocale(LC_ALL, getlocalename_l(LC_ALL, loc)) == NULL) {
			err(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to "
			    "set global locale to composite %s", cname);
		}

		(void) snprintf(desc, sizeof (desc), "global composite %s (%d)",
		    composite[i].lc_loc, composite[i].lc_cat);
		if (!locname_check(desc, loc, names))
			ret = false;
	}
	freelocale(loc);

	return (ret);
}

static bool
locname_invalid(void)
{
	bool ret = true;

	if (getlocalename_l(LC_ALL, NULL) != NULL) {
		ret = false;
		warnx("TEST FAILED: passing invalid locale: string incorrectly "
		    "returned");
	} else {
		(void) printf("TEST PASSED: invalid locale\n");
	}

	if (getlocalename_l(12345, LC_GLOBAL_LOCALE) != NULL) {
		ret = false;
		warnx("TEST FAILED: passing invalid category (1): string "
		    "incorrectly returned");
	} else {
		(void) printf("TEST PASSED: invalid category (1)\n");
	}

	if (getlocalename_l(0x7777, uselocale(NULL)) != NULL) {
		ret = false;
		warnx("TEST FAILED: passing invalid category (2): string "
		    "incorrectly returned");
	} else {
		(void) printf("TEST PASSED: invalid category (2)\n");
	}

	return (ret);
}

int
main(void)
{
	int ret = EXIT_SUCCESS;

	/*
	 * The default locale should be C.
	 */
	if (!locname_check_all("global locale: default", LC_GLOBAL_LOCALE, "C"))
		ret = EXIT_FAILURE;

	/*
	 * Test non-composite locales. We always do the thread-specific locale
	 * first so that way we can catch an erroneous locale.
	 */
	for (size_t i = 0; i < ARRAY_SIZE(locales); i++) {
		char desc[1024];
		locale_t loc;

		loc = newlocale(LC_ALL_MASK, locales[i], NULL);
		if (loc == NULL) {
			err(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to "
			    "construct locale %s", locales[i]);
		}

		(void) snprintf(desc, sizeof (desc),
		    "%s: newlocale", locales[i]);
		if (!locname_check_all(desc, loc, locales[i]))
			ret = EXIT_FAILURE;

		(void) snprintf(desc, sizeof (desc),
		    "%s: thread locale", locales[i]);
		if (uselocale(loc) == NULL) {
			err(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to "
			    "transition thread to thread-specific locale %s, "
			    "cannot continue", locales[i]);
		}
		if (!locname_check_all(desc, uselocale(NULL), locales[i]))
			ret = EXIT_FAILURE;
		if (uselocale(LC_GLOBAL_LOCALE) == NULL) {
			err(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to "
			    "transition thread back to global locale, cannot "
			    "continue");
		}
		freelocale(loc);

		(void) snprintf(desc, sizeof (desc),
		    "%s: global locale", locales[i]);
		if (setlocale(LC_ALL, locales[i]) == NULL) {
			errx(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to "
			    "set global locale to %s", locales[i]);
		}
		if (!locname_check_all(desc, LC_GLOBAL_LOCALE, locales[i]))
			ret = EXIT_FAILURE;
	}

	if (!locname_composite())
		ret = EXIT_FAILURE;

	if (!locname_invalid())
		ret = EXIT_FAILURE;

	if (ret == EXIT_SUCCESS) {
		(void) printf("All tests completed successfully\n");
	}

	return (ret);
}