maint/gnulib/tests/test-localename.c

/* */
This source file includes following definitions.
test_locale_name
test_locale_name_thread
test_locale_name_posix
test_locale_name_environ
test_locale_name_default
main
   1 /* Test of gl_locale_name function and its variants.
   2    Copyright (C) 2007-2021 Free Software Foundation, Inc.
   3 
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8 
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13 
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16 
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  18 
  19 #include <config.h>
  20 
  21 #include "localename.h"
  22 
  23 #include <locale.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 
  27 #include "macros.h"
  28 
  29 #if HAVE_WORKING_NEWLOCALE && HAVE_WORKING_USELOCALE && !HAVE_FAKE_LOCALES
  30 # define HAVE_GOOD_USELOCALE 1
  31 #endif
  32 
  33 
  34 #if HAVE_GOOD_USELOCALE
  35 
  36 static struct { int cat; int mask; const char *string; } const categories[] =
  37   {
  38       { LC_CTYPE,          LC_CTYPE_MASK,          "LC_CTYPE" },
  39       { LC_NUMERIC,        LC_NUMERIC_MASK,        "LC_NUMERIC" },
  40       { LC_TIME,           LC_TIME_MASK,           "LC_TIME" },
  41       { LC_COLLATE,        LC_COLLATE_MASK,        "LC_COLLATE" },
  42       { LC_MONETARY,       LC_MONETARY_MASK,       "LC_MONETARY" },
  43       { LC_MESSAGES,       LC_MESSAGES_MASK,       "LC_MESSAGES" }
  44 # ifdef LC_PAPER
  45     , { LC_PAPER,          LC_PAPER_MASK,          "LC_PAPER" }
  46 # endif
  47 # ifdef LC_NAME
  48     , { LC_NAME,           LC_NAME_MASK,           "LC_NAME" }
  49 # endif
  50 # ifdef LC_ADDRESS
  51     , { LC_ADDRESS,        LC_ADDRESS_MASK,        "LC_ADDRESS" }
  52 # endif
  53 # ifdef LC_TELEPHONE
  54     , { LC_TELEPHONE,      LC_TELEPHONE_MASK,      "LC_TELEPHONE" }
  55 # endif
  56 # ifdef LC_MEASUREMENT
  57     , { LC_MEASUREMENT,    LC_MEASUREMENT_MASK,    "LC_MEASUREMENT" }
  58 # endif
  59 # ifdef LC_IDENTIFICATION
  60     , { LC_IDENTIFICATION, LC_IDENTIFICATION_MASK, "LC_IDENTIFICATION" }
  61 # endif
  62   };
  63 
  64 #endif
  65 
  66 /* Test the gl_locale_name() function.  */
  67 static void
  68 test_locale_name (void)
     /*  */
  69 {
  70   const char *ret;
  71   const char *name;
  72 
  73   /* Check that gl_locale_name returns non-NULL.  */
  74   ASSERT (gl_locale_name (LC_MESSAGES, "LC_MESSAGES") != NULL);
  75 
  76   /* Get into a defined state,  */
  77   setlocale (LC_ALL, "en_US.UTF-8");
  78 #if HAVE_GOOD_USELOCALE
  79   uselocale (LC_GLOBAL_LOCALE);
  80 #endif
  81 
  82   /* Check that when all environment variables are unset,
  83      gl_locale_name returns the default locale.  */
  84   unsetenv ("LC_ALL");
  85   unsetenv ("LC_CTYPE");
  86   unsetenv ("LC_MESSAGES");
  87   unsetenv ("LC_NUMERIC");
  88   unsetenv ("LANG");
  89   /* Need also to unset all environment variables that specify standard or
  90      non-standard locale categories.  Otherwise, on glibc systems, when some
  91      of these variables are set and reference a nonexistent locale, the
  92      setlocale (LC_ALL, "") call below would fail.  */
  93   unsetenv ("LC_COLLATE");
  94   unsetenv ("LC_MONETARY");
  95   unsetenv ("LC_TIME");
  96   unsetenv ("LC_ADDRESS");
  97   unsetenv ("LC_IDENTIFICATION");
  98   unsetenv ("LC_MEASUREMENT");
  99   unsetenv ("LC_NAME");
 100   unsetenv ("LC_PAPER");
 101   unsetenv ("LC_TELEPHONE");
 102   ret = setlocale (LC_ALL, "");
 103   ASSERT (ret != NULL);
 104   ASSERT (strcmp (gl_locale_name (LC_MESSAGES, "LC_MESSAGES"),
 105                   gl_locale_name_default ()) == 0);
 106   ASSERT (strcmp (gl_locale_name (LC_NUMERIC, "LC_NUMERIC"),
 107                   gl_locale_name_default ()) == 0);
 108 
 109   /* Check that an empty environment variable is treated like an unset
 110      environment variable.  */
 111 
 112   setenv ("LC_ALL", "", 1);
 113   unsetenv ("LC_CTYPE");
 114   unsetenv ("LC_MESSAGES");
 115   unsetenv ("LANG");
 116   setlocale (LC_ALL, "");
 117   ASSERT (strcmp (gl_locale_name (LC_MESSAGES, "LC_MESSAGES"),
 118                   gl_locale_name_default ()) == 0);
 119 
 120   unsetenv ("LC_ALL");
 121   setenv ("LC_CTYPE", "", 1);
 122   unsetenv ("LC_MESSAGES");
 123   unsetenv ("LANG");
 124   setlocale (LC_ALL, "");
 125   ASSERT (strcmp (gl_locale_name (LC_MESSAGES, "LC_MESSAGES"),
 126                   gl_locale_name_default ()) == 0);
 127 
 128   unsetenv ("LC_ALL");
 129   unsetenv ("LC_CTYPE");
 130   setenv ("LC_MESSAGES", "", 1);
 131   unsetenv ("LANG");
 132   setlocale (LC_ALL, "");
 133   ASSERT (strcmp (gl_locale_name (LC_MESSAGES, "LC_MESSAGES"),
 134                   gl_locale_name_default ()) == 0);
 135 
 136   unsetenv ("LC_ALL");
 137   unsetenv ("LC_CTYPE");
 138   unsetenv ("LC_MESSAGES");
 139   setenv ("LANG", "", 1);
 140   setlocale (LC_ALL, "");
 141   ASSERT (strcmp (gl_locale_name (LC_MESSAGES, "LC_MESSAGES"),
 142                   gl_locale_name_default ()) == 0);
 143 
 144   /* Check that LC_ALL overrides the others, and LANG is overridden by the
 145      others.  */
 146 
 147   setenv ("LC_ALL", "C", 1);
 148   unsetenv ("LC_CTYPE");
 149   unsetenv ("LC_MESSAGES");
 150   unsetenv ("LANG");
 151   setlocale (LC_ALL, "");
 152   ASSERT (strcmp (gl_locale_name (LC_MESSAGES, "LC_MESSAGES"), "C") == 0);
 153 
 154   unsetenv ("LC_ALL");
 155   setenv ("LC_CTYPE", "C", 1);
 156   setenv ("LC_MESSAGES", "C", 1);
 157   unsetenv ("LANG");
 158   setlocale (LC_ALL, "");
 159   ASSERT (strcmp (gl_locale_name (LC_MESSAGES, "LC_MESSAGES"), "C") == 0);
 160 
 161   unsetenv ("LC_ALL");
 162   unsetenv ("LC_CTYPE");
 163   unsetenv ("LC_MESSAGES");
 164   setenv ("LANG", "C", 1);
 165   setlocale (LC_ALL, "");
 166   ASSERT (strcmp (gl_locale_name (LC_MESSAGES, "LC_MESSAGES"), "C") == 0);
 167 
 168   /* Check mixed situations.  */
 169 
 170   unsetenv ("LC_ALL");
 171   unsetenv ("LC_CTYPE");
 172   setenv ("LC_MESSAGES", "fr_FR.UTF-8", 1);
 173   setenv ("LANG", "de_DE.UTF-8", 1);
 174   if (setlocale (LC_ALL, "") != NULL)
 175     {
 176       name = gl_locale_name (LC_CTYPE, "LC_CTYPE");
 177 #if defined _WIN32 && !defined __CYGWIN__
 178       /* On native Windows, here,
 179            gl_locale_name_thread (LC_CTYPE, "LC_CTYPE")
 180          returns NULL and
 181            gl_locale_name_posix (LC_CTYPE, "LC_CTYPE")
 182          returns either "de_DE" or "de_DE.UTF-8".  */
 183       ASSERT (strcmp (name, "de_DE") == 0 || strcmp (name, "de_DE.UTF-8") == 0);
 184 #else
 185       ASSERT (strcmp (name, "de_DE.UTF-8") == 0);
 186 #endif
 187       name = gl_locale_name (LC_MESSAGES, "LC_MESSAGES");
 188       ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 189     }
 190 
 191   unsetenv ("LC_ALL");
 192   unsetenv ("LC_CTYPE");
 193   setenv ("LC_MESSAGES", "fr_FR.UTF-8", 1);
 194   unsetenv ("LANG");
 195   if (setlocale (LC_ALL, "") != NULL)
 196     {
 197       name = gl_locale_name (LC_CTYPE, "LC_CTYPE");
 198       ASSERT (strcmp (name, gl_locale_name_default ()) == 0);
 199       name = gl_locale_name (LC_MESSAGES, "LC_MESSAGES");
 200       ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 201     }
 202 
 203 #if HAVE_GOOD_USELOCALE
 204   /* Check that gl_locale_name considers the thread locale.  */
 205   {
 206     locale_t locale = newlocale (LC_ALL_MASK, "fr_FR.UTF-8", NULL);
 207     if (locale != NULL)
 208       {
 209         uselocale (locale);
 210         name = gl_locale_name (LC_CTYPE, "LC_CTYPE");
 211         ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 212         name = gl_locale_name (LC_MESSAGES, "LC_MESSAGES");
 213         ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 214         uselocale (LC_GLOBAL_LOCALE);
 215         freelocale (locale);
 216       }
 217   }
 218 
 219   /* Check that gl_locale_name distinguishes different categories of the
 220      thread locale, and that the name is the right one for each.  */
 221   {
 222     unsigned int i;
 223 
 224     for (i = 0; i < SIZEOF (categories); i++)
 225       {
 226         int category_mask = categories[i].mask;
 227         locale_t loc = newlocale (LC_ALL_MASK, "fr_FR.UTF-8", NULL);
 228         if (loc != NULL)
 229           {
 230             locale_t locale = newlocale (category_mask, "de_DE.UTF-8", loc);
 231             if (locale == NULL)
 232               freelocale (loc);
 233             else
 234               {
 235                 unsigned int j;
 236 
 237                 uselocale (locale);
 238                 for (j = 0; j < SIZEOF (categories); j++)
 239                   {
 240                     const char *name_j =
 241                       gl_locale_name (categories[j].cat, categories[j].string);
 242                     if (j == i)
 243                       ASSERT (strcmp (name_j, "de_DE.UTF-8") == 0);
 244                     else
 245                       ASSERT (strcmp (name_j, "fr_FR.UTF-8") == 0);
 246                   }
 247                 uselocale (LC_GLOBAL_LOCALE);
 248                 freelocale (locale);
 249               }
 250           }
 251       }
 252   }
 253 #endif
 254 }
 255 
 256 /* Test the gl_locale_name_thread() function.  */
 257 static void
 258 test_locale_name_thread (void)
     /*  */
 259 {
 260   /* Get into a defined state,  */
 261   setlocale (LC_ALL, "en_US.UTF-8");
 262 
 263 #if HAVE_GOOD_USELOCALE
 264   /* Check that gl_locale_name_thread returns NULL when no thread locale is
 265      set.  */
 266   uselocale (LC_GLOBAL_LOCALE);
 267   ASSERT (gl_locale_name_thread (LC_CTYPE, "LC_CTYPE") == NULL);
 268   ASSERT (gl_locale_name_thread (LC_MESSAGES, "LC_MESSAGES") == NULL);
 269 
 270   /* Check that gl_locale_name_thread considers the thread locale.  */
 271   {
 272     locale_t locale = newlocale (LC_ALL_MASK, "fr_FR.UTF-8", NULL);
 273     if (locale != NULL)
 274       {
 275         const char *name;
 276 
 277         uselocale (locale);
 278         name = gl_locale_name_thread (LC_CTYPE, "LC_CTYPE");
 279         ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 280         name = gl_locale_name_thread (LC_MESSAGES, "LC_MESSAGES");
 281         ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 282         uselocale (LC_GLOBAL_LOCALE);
 283         freelocale (locale);
 284       }
 285   }
 286 
 287   /* Check that gl_locale_name_thread distinguishes different categories of the
 288      thread locale, and that the name is the right one for each.  */
 289   {
 290     unsigned int i;
 291 
 292     for (i = 0; i < SIZEOF (categories); i++)
 293       {
 294         int category_mask = categories[i].mask;
 295         locale_t loc = newlocale (LC_ALL_MASK, "fr_FR.UTF-8", NULL);
 296         if (loc != NULL)
 297           {
 298             locale_t locale = newlocale (category_mask, "de_DE.UTF-8", loc);
 299             if (locale == NULL)
 300               freelocale (loc);
 301             else
 302               {
 303                 unsigned int j;
 304 
 305                 uselocale (locale);
 306                 for (j = 0; j < SIZEOF (categories); j++)
 307                   {
 308                     const char *name_j =
 309                       gl_locale_name_thread (categories[j].cat,
 310                                              categories[j].string);
 311                     if (j == i)
 312                       ASSERT (strcmp (name_j, "de_DE.UTF-8") == 0);
 313                     else
 314                       ASSERT (strcmp (name_j, "fr_FR.UTF-8") == 0);
 315                   }
 316                 uselocale (LC_GLOBAL_LOCALE);
 317                 freelocale (locale);
 318               }
 319           }
 320       }
 321   }
 322 
 323   /* Check that gl_locale_name_thread returns a string that is allocated with
 324      indefinite extent.  */
 325   {
 326     /* Try many locale names in turn, in order to defeat possible caches.  */
 327     static const char * const choices[] =
 328       {
 329         "C",
 330         "POSIX",
 331         "af_ZA",
 332         "af_ZA.UTF-8",
 333         "am_ET",
 334         "am_ET.UTF-8",
 335         "be_BY",
 336         "be_BY.UTF-8",
 337         "bg_BG",
 338         "bg_BG.UTF-8",
 339         "ca_ES",
 340         "ca_ES.UTF-8",
 341         "cs_CZ",
 342         "cs_CZ.UTF-8",
 343         "da_DK",
 344         "da_DK.UTF-8",
 345         "de_AT",
 346         "de_AT.UTF-8",
 347         "de_CH",
 348         "de_CH.UTF-8",
 349         "de_DE",
 350         "de_DE.UTF-8",
 351         "el_GR",
 352         "el_GR.UTF-8",
 353         "en_AU",
 354         "en_AU.UTF-8",
 355         "en_CA",
 356         "en_CA.UTF-8",
 357         "en_GB",
 358         "en_GB.UTF-8",
 359         "en_IE",
 360         "en_IE.UTF-8",
 361         "en_NZ",
 362         "en_NZ.UTF-8",
 363         "en_US",
 364         "en_US.UTF-8",
 365         "es_ES",
 366         "es_ES.UTF-8",
 367         "et_EE",
 368         "et_EE.UTF-8",
 369         "eu_ES",
 370         "eu_ES.UTF-8",
 371         "fi_FI",
 372         "fi_FI.UTF-8",
 373         "fr_BE",
 374         "fr_BE.UTF-8",
 375         "fr_CA",
 376         "fr_CA.UTF-8",
 377         "fr_CH",
 378         "fr_CH.UTF-8",
 379         "fr_FR",
 380         "fr_FR.UTF-8",
 381         "he_IL",
 382         "he_IL.UTF-8",
 383         "hr_HR",
 384         "hr_HR.UTF-8",
 385         "hu_HU",
 386         "hu_HU.UTF-8",
 387         "hy_AM",
 388         "is_IS",
 389         "is_IS.UTF-8",
 390         "it_CH",
 391         "it_CH.UTF-8",
 392         "it_IT",
 393         "it_IT.UTF-8",
 394         "ja_JP.UTF-8",
 395         "kk_KZ",
 396         "kk_KZ.UTF-8",
 397         "ko_KR.UTF-8",
 398         "lt_LT",
 399         "lt_LT.UTF-8",
 400         "nl_BE",
 401         "nl_BE.UTF-8",
 402         "nl_NL",
 403         "nl_NL.UTF-8",
 404         "no_NO",
 405         "no_NO.UTF-8",
 406         "pl_PL",
 407         "pl_PL.UTF-8",
 408         "pt_BR",
 409         "pt_BR.UTF-8",
 410         "pt_PT",
 411         "pt_PT.UTF-8",
 412         "ro_RO",
 413         "ro_RO.UTF-8",
 414         "ru_RU",
 415         "ru_RU.UTF-8",
 416         "sk_SK",
 417         "sk_SK.UTF-8",
 418         "sl_SI",
 419         "sl_SI.UTF-8",
 420         "sv_SE",
 421         "sv_SE.UTF-8",
 422         "tr_TR",
 423         "tr_TR.UTF-8",
 424         "uk_UA",
 425         "uk_UA.UTF-8",
 426         "zh_CN",
 427         "zh_CN.UTF-8",
 428         "zh_HK",
 429         "zh_HK.UTF-8",
 430         "zh_TW",
 431         "zh_TW.UTF-8"
 432       };
 433     /* Remember which locales are available.  */
 434     unsigned char /* bool */ available[SIZEOF (choices)];
 435     /* Array of remembered results of gl_locale_name_thread.  */
 436     const char *unsaved_names[SIZEOF (choices)][SIZEOF (categories)];
 437     /* Array of remembered results of gl_locale_name_thread, stored in safe
 438        memory.  */
 439     char *saved_names[SIZEOF (choices)][SIZEOF (categories)];
 440     unsigned int j;
 441 
 442     for (j = 0; j < SIZEOF (choices); j++)
 443       {
 444         locale_t locale = newlocale (LC_ALL_MASK, choices[j], NULL);
 445         available[j] = (locale != NULL);
 446         if (locale != NULL)
 447           {
 448             unsigned int i;
 449 
 450             uselocale (locale);
 451             for (i = 0; i < SIZEOF (categories); i++)
 452               {
 453                 unsaved_names[j][i] = gl_locale_name_thread (categories[i].cat, categories[i].string);
 454                 saved_names[j][i] = strdup (unsaved_names[j][i]);
 455               }
 456             uselocale (LC_GLOBAL_LOCALE);
 457             freelocale (locale);
 458           }
 459       }
 460     /* Verify the unsaved_names are still valid.  */
 461     for (j = 0; j < SIZEOF (choices); j++)
 462       if (available[j])
 463         {
 464           unsigned int i;
 465 
 466           for (i = 0; i < SIZEOF (categories); i++)
 467             ASSERT (strcmp (unsaved_names[j][i], saved_names[j][i]) == 0);
 468         }
 469     /* Allocate many locales, without freeing them.  This is an attempt at
 470        overwriting as much of the previously allocated memory as possible.  */
 471     for (j = SIZEOF (choices); j > 0; )
 472       {
 473         j--;
 474         if (available[j])
 475           {
 476             locale_t locale = newlocale (LC_ALL_MASK, choices[j], NULL);
 477             unsigned int i;
 478 
 479             ASSERT (locale != NULL);
 480             uselocale (locale);
 481             for (i = 0; i < SIZEOF (categories); i++)
 482               {
 483                 const char *name = gl_locale_name_thread (categories[i].cat, categories[i].string);
 484                 ASSERT (strcmp (unsaved_names[j][i], name) == 0);
 485               }
 486             uselocale (LC_GLOBAL_LOCALE);
 487             freelocale (locale);
 488           }
 489       }
 490     /* Verify the unsaved_names are still valid.  */
 491     for (j = 0; j < SIZEOF (choices); j++)
 492       if (available[j])
 493         {
 494           unsigned int i;
 495 
 496           for (i = 0; i < SIZEOF (categories); i++)
 497             {
 498               ASSERT (strcmp (unsaved_names[j][i], saved_names[j][i]) == 0);
 499               free (saved_names[j][i]);
 500             }
 501         }
 502   }
 503 #else
 504   /* Check that gl_locale_name_thread always returns NULL.  */
 505   ASSERT (gl_locale_name_thread (LC_CTYPE, "LC_CTYPE") == NULL);
 506   ASSERT (gl_locale_name_thread (LC_MESSAGES, "LC_MESSAGES") == NULL);
 507 #endif
 508 }
 509 
 510 /* Test the gl_locale_name_posix() function.  */
 511 static void
 512 test_locale_name_posix (void)
     /*  */
 513 {
 514   const char *ret;
 515   const char *name;
 516 
 517   /* Get into a defined state,  */
 518   setlocale (LC_ALL, "en_US.UTF-8");
 519 #if HAVE_GOOD_USELOCALE
 520   uselocale (LC_GLOBAL_LOCALE);
 521 #endif
 522 
 523   /* Check that when all environment variables are unset,
 524      gl_locale_name_posix returns either NULL or the default locale.  */
 525   unsetenv ("LC_ALL");
 526   unsetenv ("LC_CTYPE");
 527   unsetenv ("LC_MESSAGES");
 528   unsetenv ("LC_NUMERIC");
 529   unsetenv ("LANG");
 530   /* Need also to unset all environment variables that specify standard or
 531      non-standard locale categories.  Otherwise, on glibc systems, when some
 532      of these variables are set and reference a nonexistent locale, the
 533      setlocale (LC_ALL, "") call below would fail.  */
 534   unsetenv ("LC_COLLATE");
 535   unsetenv ("LC_MONETARY");
 536   unsetenv ("LC_TIME");
 537   unsetenv ("LC_ADDRESS");
 538   unsetenv ("LC_IDENTIFICATION");
 539   unsetenv ("LC_MEASUREMENT");
 540   unsetenv ("LC_NAME");
 541   unsetenv ("LC_PAPER");
 542   unsetenv ("LC_TELEPHONE");
 543   ret = setlocale (LC_ALL, "");
 544   ASSERT (ret != NULL);
 545   name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 546   ASSERT (name == NULL || strcmp (name, gl_locale_name_default ()) == 0);
 547   name = gl_locale_name_posix (LC_NUMERIC, "LC_NUMERIC");
 548   ASSERT (name == NULL || strcmp (name, gl_locale_name_default ()) == 0);
 549 
 550   /* Check that an empty environment variable is treated like an unset
 551      environment variable.  */
 552 
 553   setenv ("LC_ALL", "", 1);
 554   unsetenv ("LC_CTYPE");
 555   unsetenv ("LC_MESSAGES");
 556   unsetenv ("LANG");
 557   setlocale (LC_ALL, "");
 558   name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 559   ASSERT (name == NULL || strcmp (name, gl_locale_name_default ()) == 0);
 560 
 561   unsetenv ("LC_ALL");
 562   setenv ("LC_CTYPE", "", 1);
 563   unsetenv ("LC_MESSAGES");
 564   unsetenv ("LANG");
 565   setlocale (LC_ALL, "");
 566   name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 567   ASSERT (name == NULL || strcmp (name, gl_locale_name_default ()) == 0);
 568 
 569   unsetenv ("LC_ALL");
 570   unsetenv ("LC_CTYPE");
 571   setenv ("LC_MESSAGES", "", 1);
 572   unsetenv ("LANG");
 573   setlocale (LC_ALL, "");
 574   name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 575   ASSERT (name == NULL || strcmp (name, gl_locale_name_default ()) == 0);
 576 
 577   unsetenv ("LC_ALL");
 578   unsetenv ("LC_CTYPE");
 579   unsetenv ("LC_MESSAGES");
 580   setenv ("LANG", "", 1);
 581   setlocale (LC_ALL, "");
 582   name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 583   ASSERT (name == NULL || strcmp (name, gl_locale_name_default ()) == 0);
 584 
 585   /* Check that LC_ALL overrides the others, and LANG is overridden by the
 586      others.  */
 587 
 588   setenv ("LC_ALL", "C", 1);
 589   unsetenv ("LC_CTYPE");
 590   unsetenv ("LC_MESSAGES");
 591   unsetenv ("LANG");
 592   setlocale (LC_ALL, "");
 593   name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 594   ASSERT (strcmp (name, "C") == 0);
 595 
 596   unsetenv ("LC_ALL");
 597   setenv ("LC_CTYPE", "C", 1);
 598   setenv ("LC_MESSAGES", "C", 1);
 599   unsetenv ("LANG");
 600   setlocale (LC_ALL, "");
 601   name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 602   ASSERT (strcmp (name, "C") == 0);
 603 
 604   unsetenv ("LC_ALL");
 605   unsetenv ("LC_CTYPE");
 606   unsetenv ("LC_MESSAGES");
 607   setenv ("LANG", "C", 1);
 608   setlocale (LC_ALL, "");
 609   name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 610   ASSERT (strcmp (name, "C") == 0);
 611 
 612   /* Check mixed situations.  */
 613 
 614   unsetenv ("LC_ALL");
 615   unsetenv ("LC_CTYPE");
 616   setenv ("LC_MESSAGES", "fr_FR.UTF-8", 1);
 617   setenv ("LANG", "de_DE.UTF-8", 1);
 618   if (setlocale (LC_ALL, "") != NULL)
 619     {
 620       name = gl_locale_name_posix (LC_CTYPE, "LC_CTYPE");
 621 #if defined _WIN32 && !defined __CYGWIN__
 622       ASSERT (strcmp (name, "de_DE") == 0 || strcmp (name, "de_DE.UTF-8") == 0);
 623 #else
 624       ASSERT (strcmp (name, "de_DE.UTF-8") == 0);
 625 #endif
 626       name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 627       ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 628     }
 629 
 630   unsetenv ("LC_ALL");
 631   unsetenv ("LC_CTYPE");
 632   setenv ("LC_MESSAGES", "fr_FR.UTF-8", 1);
 633   unsetenv ("LANG");
 634   if (setlocale (LC_ALL, "") != NULL)
 635     {
 636       name = gl_locale_name_posix (LC_CTYPE, "LC_CTYPE");
 637       ASSERT (name == NULL || strcmp (name, gl_locale_name_default ()) == 0);
 638       name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 639       ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 640     }
 641 
 642 #if HAVE_GOOD_USELOCALE
 643   /* Check that gl_locale_name_posix ignores the thread locale.  */
 644   {
 645     locale_t locale = newlocale (LC_ALL_MASK, "fr_FR.UTF-8", NULL);
 646     if (locale != NULL)
 647       {
 648         unsetenv ("LC_ALL");
 649         unsetenv ("LC_CTYPE");
 650         unsetenv ("LC_MESSAGES");
 651         setenv ("LANG", "C", 1);
 652         setlocale (LC_ALL, "");
 653         uselocale (locale);
 654         name = gl_locale_name_posix (LC_MESSAGES, "LC_MESSAGES");
 655         ASSERT (strcmp (name, "C") == 0);
 656         uselocale (LC_GLOBAL_LOCALE);
 657         freelocale (locale);
 658       }
 659   }
 660 #endif
 661 }
 662 
 663 /* Test the gl_locale_name_environ() function.  */
 664 static void
 665 test_locale_name_environ (void)
     /*  */
 666 {
 667   const char *name;
 668 
 669   /* Get into a defined state,  */
 670   setlocale (LC_ALL, "en_US.UTF-8");
 671 #if HAVE_GOOD_USELOCALE
 672   uselocale (LC_GLOBAL_LOCALE);
 673 #endif
 674 
 675   /* Check that when all environment variables are unset,
 676      gl_locale_name_environ returns NULL.  */
 677   unsetenv ("LC_ALL");
 678   unsetenv ("LC_CTYPE");
 679   unsetenv ("LC_MESSAGES");
 680   unsetenv ("LC_NUMERIC");
 681   unsetenv ("LANG");
 682   ASSERT (gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES") == NULL);
 683   ASSERT (gl_locale_name_environ (LC_NUMERIC, "LC_NUMERIC") == NULL);
 684 
 685   /* Check that an empty environment variable is treated like an unset
 686      environment variable.  */
 687 
 688   setenv ("LC_ALL", "", 1);
 689   unsetenv ("LC_CTYPE");
 690   unsetenv ("LC_MESSAGES");
 691   unsetenv ("LANG");
 692   ASSERT (gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES") == NULL);
 693 
 694   unsetenv ("LC_ALL");
 695   setenv ("LC_CTYPE", "", 1);
 696   unsetenv ("LC_MESSAGES");
 697   unsetenv ("LANG");
 698   ASSERT (gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES") == NULL);
 699 
 700   unsetenv ("LC_ALL");
 701   unsetenv ("LC_CTYPE");
 702   setenv ("LC_MESSAGES", "", 1);
 703   unsetenv ("LANG");
 704   ASSERT (gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES") == NULL);
 705 
 706   unsetenv ("LC_ALL");
 707   unsetenv ("LC_CTYPE");
 708   unsetenv ("LC_MESSAGES");
 709   setenv ("LANG", "", 1);
 710   ASSERT (gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES") == NULL);
 711 
 712   /* Check that LC_ALL overrides the others, and LANG is overridden by the
 713      others.  */
 714 
 715   setenv ("LC_ALL", "C", 1);
 716   unsetenv ("LC_CTYPE");
 717   unsetenv ("LC_MESSAGES");
 718   unsetenv ("LANG");
 719   name = gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES");
 720   ASSERT (strcmp (name, "C") == 0);
 721 
 722   unsetenv ("LC_ALL");
 723   setenv ("LC_CTYPE", "C", 1);
 724   setenv ("LC_MESSAGES", "C", 1);
 725   unsetenv ("LANG");
 726   name = gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES");
 727   ASSERT (strcmp (name, "C") == 0);
 728 
 729   unsetenv ("LC_ALL");
 730   unsetenv ("LC_CTYPE");
 731   unsetenv ("LC_MESSAGES");
 732   setenv ("LANG", "C", 1);
 733   name = gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES");
 734   ASSERT (strcmp (name, "C") == 0);
 735 
 736   /* Check mixed situations.  */
 737 
 738   unsetenv ("LC_ALL");
 739   unsetenv ("LC_CTYPE");
 740   setenv ("LC_MESSAGES", "fr_FR.UTF-8", 1);
 741   setenv ("LANG", "de_DE.UTF-8", 1);
 742   name = gl_locale_name_environ (LC_CTYPE, "LC_CTYPE");
 743   ASSERT (strcmp (name, "de_DE.UTF-8") == 0);
 744   name = gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES");
 745   ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 746 
 747   unsetenv ("LC_ALL");
 748   unsetenv ("LC_CTYPE");
 749   setenv ("LC_MESSAGES", "fr_FR.UTF-8", 1);
 750   unsetenv ("LANG");
 751   name = gl_locale_name_environ (LC_CTYPE, "LC_CTYPE");
 752   ASSERT (name == NULL);
 753   name = gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES");
 754   ASSERT (strcmp (name, "fr_FR.UTF-8") == 0);
 755 
 756 #if HAVE_GOOD_USELOCALE
 757   /* Check that gl_locale_name_environ ignores the thread locale.  */
 758   {
 759     locale_t locale = newlocale (LC_ALL_MASK, "fr_FR.UTF-8", NULL);
 760     if (locale != NULL)
 761       {
 762         unsetenv ("LC_ALL");
 763         unsetenv ("LC_CTYPE");
 764         unsetenv ("LC_MESSAGES");
 765         setenv ("LANG", "C", 1);
 766         setlocale (LC_ALL, "");
 767         uselocale (locale);
 768         name = gl_locale_name_environ (LC_MESSAGES, "LC_MESSAGES");
 769         ASSERT (strcmp (name, "C") == 0);
 770         uselocale (LC_GLOBAL_LOCALE);
 771         freelocale (locale);
 772       }
 773   }
 774 #endif
 775 }
 776 
 777 /* Test the gl_locale_name_default() function.  */
 778 static void
 779 test_locale_name_default (void)
     /*  */
 780 {
 781   const char *name = gl_locale_name_default ();
 782 
 783   ASSERT (name != NULL);
 784 
 785   /* Only Mac OS X and Windows have a facility for the user to set the default
 786      locale.  */
 787 #if !((defined __APPLE__ && defined __MACH__) || (defined _WIN32 || defined __CYGWIN__))
 788   ASSERT (strcmp (name, "C") == 0);
 789 #endif
 790 
 791 #if HAVE_GOOD_USELOCALE
 792   /* Check that gl_locale_name_default ignores the thread locale.  */
 793   {
 794     locale_t locale = newlocale (LC_ALL_MASK, "fr_FR.UTF-8", NULL);
 795     if (locale != NULL)
 796       {
 797         uselocale (locale);
 798         ASSERT (strcmp (gl_locale_name_default (), name) == 0);
 799         uselocale (LC_GLOBAL_LOCALE);
 800         freelocale (locale);
 801       }
 802   }
 803 #endif
 804 }
 805 
 806 int
 807 main ()
     /*  */
 808 {
 809   test_locale_name ();
 810   test_locale_name_thread ();
 811   test_locale_name_posix ();
 812   test_locale_name_environ ();
 813   test_locale_name_default ();
 814 
 815   return 0;
 816 }
/* */
root/maint/gnulib/tests/test-localename.c

DEFINITIONS
