pintos-os.org Git - pspp/blob - tests/test-quotearg.c

   1 /* Test of quotearg family of functions.
   2    Copyright (C) 2008 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, or (at your option)
   7    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, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 /* Written by Eric Blake <ebb9@byu.net>, 2008.  */
  19
  20 #include <config.h>
  21
  22 #include "quotearg.h"
  23
  24 #include <ctype.h>
  25 #include <stdbool.h>
  26 #include <stdint.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #if ENABLE_NLS
  32 /* On Linux, gettext is optionally defined as a forwarding macro,
  33    which would cause syntax errors in our definition below.  But on
  34    platforms that require -lintl, we cannot #undef gettext, since we
  35    want to provide the entry point libintl_gettext.  So we disable
  36    optimizations to avoid the Linux macros.  */
  37 # undef __OPTIMIZE__
  38 # include <libintl.h>
  39
  40 /* These quotes are borrowed from a pt_PT.utf8 translation.  */
  41 # define LQ "\302\253"
  42 # define RQ "\302\273"
  43 #endif
  44
  45 #define ASSERT(expr) \
  46   do                                                                         \
  47     {                                                                        \
  48       if (!(expr))                                                           \
  49         {                                                                    \
  50           fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
  51           abort ();                                                          \
  52         }                                                                    \
  53     }                                                                        \
  54   while (0)
  55
  56 struct result_strings {
  57   char const *str1; /* Translation of "".  */
  58   char const *str2; /* Translation of "\0""1\0".  */
  59   size_t len2; /* Length of str2.  */
  60   char const *str3; /* Translation of "simple".  */
  61   char const *str4; /* Translation of " \t\n'\"\033?""?/\\".  */
  62   char const *str5; /* Translation of "a:b".  */
  63 };
  64
  65 struct result_groups {
  66   struct result_strings group1; /* Via quotearg_buffer.  */
  67   struct result_strings group2; /* Via quotearg{,_mem}.  */
  68   struct result_strings group3; /* Via quotearg_colon{,_mem}.  */
  69 };
  70
  71 static struct result_strings inputs = {
  72   "", "\0001\0", 3, "simple", " \t\n'\"\033?""?/\\", "a:b"
  73 };
  74
  75 static struct result_groups results_g[] = {
  76   /* literal_quoting_style */
  77   { { "", "\0""1\0", 3, "simple", " \t\n'\"\033?""?/\\", "a:b" },
  78     { "", "1", 1, "simple", " \t\n'\"\033?""?/\\", "a:b" },
  79     { "", "1", 1, "simple", " \t\n'\"\033?""?/\\", "a:b" } },
  80
  81   /* shell_quoting_style */
  82   { { "''", "\0""1\0", 3, "simple", "' \t\n'\\''\"\033?""?/\\'", "a:b" },
  83     { "''", "1", 1, "simple", "' \t\n'\\''\"\033?""?/\\'", "a:b" },
  84     { "''", "1", 1, "simple", "' \t\n'\\''\"\033?""?/\\'", "'a:b'" } },
  85
  86   /* shell_always_quoting_style */
  87   { { "''", "'\0""1\0'", 5, "'simple'", "' \t\n'\\''\"\033?""?/\\'", "'a:b'" },
  88     { "''", "'1'", 3, "'simple'", "' \t\n'\\''\"\033?""?/\\'", "'a:b'" },
  89     { "''", "'1'", 3, "'simple'", "' \t\n'\\''\"\033?""?/\\'", "'a:b'" } },
  90
  91   /* c_quoting_style */
  92   { { "\"\"", "\"\\0001\\0\"", 9, "\"simple\"",
  93       "\" \\t\\n'\\\"\\033?""?/\\\\\"", "\"a:b\"" },
  94     { "\"\"", "\"\\0001\\0\"", 9, "\"simple\"",
  95       "\" \\t\\n'\\\"\\033?""?/\\\\\"", "\"a:b\"" },
  96     { "\"\"", "\"\\0001\\0\"", 9, "\"simple\"",
  97       "\" \\t\\n'\\\"\\033?""?/\\\\\"", "\"a\\:b\"" } },
  98
  99   /* c_maybe_quoting_style */
 100   { { "", "\"\\0001\\0\"", 9, "simple", "\" \\t\\n'\\\"\\033?""?/\\\\\"",
 101       "a:b" },
 102     { "", "\"\\0001\\0\"", 9, "simple", "\" \\t\\n'\\\"\\033?""?/\\\\\"",
 103       "a:b" },
 104     { "", "\"\\0001\\0\"", 9, "simple", "\" \\t\\n'\\\"\\033?""?/\\\\\"",
 105       "\"a:b\"" } },
 106
 107   /* escape_quoting_style */
 108   { { "", "\\0001\\0", 7, "simple", " \\t\\n'\"\\033?""?/\\\\", "a:b" },
 109     { "", "\\0001\\0", 7, "simple", " \\t\\n'\"\\033?""?/\\\\", "a:b" },
 110     { "", "\\0001\\0", 7, "simple", " \\t\\n'\"\\033?""?/\\\\", "a\\:b" } },
 111
 112   /* locale_quoting_style */
 113   { { "`'", "`\\0001\\0'", 9, "`simple'", "` \\t\\n\\'\"\\033?""?/\\\\'",
 114       "`a:b'" },
 115     { "`'", "`\\0001\\0'", 9, "`simple'", "` \\t\\n\\'\"\\033?""?/\\\\'",
 116       "`a:b'" },
 117     { "`'", "`\\0001\\0'", 9, "`simple'", "` \\t\\n\\'\"\\033?""?/\\\\'",
 118       "`a\\:b'" } },
 119
 120   /* clocale_quoting_style */
 121   { { "\"\"", "\"\\0001\\0\"", 9, "\"simple\"",
 122       "\" \\t\\n'\\\"\\033?""?/\\\\\"", "\"a:b\"" },
 123     { "\"\"", "\"\\0001\\0\"", 9, "\"simple\"",
 124       "\" \\t\\n'\\\"\\033?""?/\\\\\"", "\"a:b\"" },
 125     { "\"\"", "\"\\0001\\0\"", 9, "\"simple\"",
 126       "\" \\t\\n'\\\"\\033?""?/\\\\\"", "\"a\\:b\"" } }
 127 };
 128
 129 static struct result_groups flag_results[] = {
 130   /* literal_quoting_style and QA_ELIDE_NULL_BYTES */
 131   { { "", "1", 1, "simple", " \t\n'\"\033?""?/\\", "a:b" },
 132     { "", "1", 1, "simple", " \t\n'\"\033?""?/\\", "a:b" },
 133     { "", "1", 1, "simple", " \t\n'\"\033?""?/\\", "a:b" } },
 134
 135   /* c_quoting_style and QA_ELIDE_OUTER_QUOTES */
 136   { { "", "\"\\0001\\0\"", 9, "simple", "\" \\t\\n'\\\"\\033?""?/\\\\\"",
 137       "a:b" },
 138     { "", "\"\\0001\\0\"", 9, "simple", "\" \\t\\n'\\\"\\033?""?/\\\\\"",
 139       "a:b" },
 140     { "", "\"\\0001\\0\"", 9, "simple", "\" \\t\\n'\\\"\\033?""?/\\\\\"",
 141       "\"a:b\"" } },
 142
 143   /* c_quoting_style and QA_SPLIT_TRIGRAPHS */
 144   { { "\"\"", "\"\\0001\\0\"", 9, "\"simple\"",
 145       "\" \\t\\n'\\\"\\033?\"\"?/\\\\\"", "\"a:b\"" },
 146     { "\"\"", "\"\\0001\\0\"", 9, "\"simple\"",
 147       "\" \\t\\n'\\\"\\033?\"\"?/\\\\\"", "\"a:b\"" },
 148     { "\"\"", "\"\\0001\\0\"", 9, "\"simple\"",
 149       "\" \\t\\n'\\\"\\033?\"\"?/\\\\\"", "\"a\\:b\"" } }
 150 };
 151
 152 #if ENABLE_NLS
 153 static struct result_groups locale_results[] = {
 154   /* locale_quoting_style */
 155   { { LQ RQ, LQ "\\0001\\0" RQ, 11, LQ "simple" RQ,
 156       LQ " \\t\\n'\"\\033?""?/\\\\" RQ, LQ "a:b" RQ },
 157     { LQ RQ, LQ "\\0001\\0" RQ, 11, LQ "simple" RQ,
 158       LQ " \\t\\n'\"\\033?""?/\\\\" RQ, LQ "a:b" RQ },
 159     { LQ RQ, LQ "\\0001\\0" RQ, 11, LQ "simple" RQ,
 160       LQ " \\t\\n'\"\\033?""?/\\\\" RQ, LQ "a\\:b" RQ } },
 161
 162   /* clocale_quoting_style */
 163   { { LQ RQ, LQ "\\0001\\0" RQ, 11, LQ "simple" RQ,
 164       LQ " \\t\\n'\"\\033?""?/\\\\" RQ, LQ "a:b" RQ },
 165     { LQ RQ, LQ "\\0001\\0" RQ, 11, LQ "simple" RQ,
 166       LQ " \\t\\n'\"\\033?""?/\\\\" RQ, LQ "a:b" RQ },
 167     { LQ RQ, LQ "\\0001\\0" RQ, 11, LQ "simple" RQ,
 168       LQ " \\t\\n'\"\\033?""?/\\\\" RQ, LQ "a\\:b" RQ } }
 169 };
 170 #endif /* ENABLE_NLS */
 171
 172 static void
 173 compare (char const *a, size_t la, char const *b, size_t lb)
 174 {
 175   ASSERT (la == lb);
 176   ASSERT (memcmp (a, b, la) == 0);
 177   ASSERT (b[lb] == '\0');
 178 }
 179
 180 static void
 181 compare_strings (char *(func) (char const *, size_t *),
 182                  struct result_strings *results)
 183 {
 184   size_t len;
 185   char *p;
 186
 187   len = 0;
 188   p = func (inputs.str1, &len);
 189   compare (results->str1, strlen (results->str1), p, len);
 190
 191   len = inputs.len2;
 192   p = func (inputs.str2, &len);
 193   compare (results->str2, results->len2, p, len);
 194
 195   len = SIZE_MAX;
 196   p = func (inputs.str3, &len);
 197   compare (results->str3, strlen (results->str3), p, len);
 198
 199   len = strlen (inputs.str4);
 200   p = func (inputs.str4, &len);
 201   compare (results->str4, strlen (results->str4), p, len);
 202
 203   len = SIZE_MAX;
 204   p = func (inputs.str5, &len);
 205   compare (results->str5, strlen (results->str5), p, len);
 206 }
 207
 208 static char *
 209 use_quotearg_buffer (const char *str, size_t *len)
 210 {
 211   static char buf[100];
 212   size_t size;
 213   memset (buf, 0xa5, 100);
 214   size = quotearg_buffer (buf, 100, str, *len, NULL);
 215   *len = size;
 216   ASSERT ((unsigned char) buf[size + 1] == 0xa5);
 217   return buf;
 218 }
 219
 220 static char *
 221 use_quotearg (const char *str, size_t *len)
 222 {
 223   char *p = *len == SIZE_MAX ? quotearg (str) : quotearg_mem (str, *len);
 224   *len = strlen (p);
 225   return p;
 226 }
 227
 228 static char *
 229 use_quotearg_colon (const char *str, size_t *len)
 230 {
 231   char *p = (*len == SIZE_MAX ? quotearg_colon (str)
 232              : quotearg_colon_mem (str, *len));
 233   *len = strlen (p);
 234   return p;
 235 }
 236
 237 #if ENABLE_NLS
 238 /* True if the locale should be faked.  */
 239 static bool fake_locale;
 240
 241 /* A replacement gettext that allows testing of locale quotes without
 242    requiring a locale.  */
 243 char *
 244 gettext (char const *str)
 245 {
 246   if (fake_locale)
 247     {
 248       static char lq[] = LQ;
 249       static char rq[] = RQ;
 250       if (strcmp (str, "`") == 0)
 251         return lq;
 252       if (strcmp (str, "'") == 0)
 253         return rq;
 254     }
 255   return (char *) str;
 256 }
 257
 258 char *
 259 dgettext (char const *d, char const *str)
 260 {
 261   return gettext (str);
 262 }
 263
 264 char *
 265 dcgettext (char const *d, char const *str, int c)
 266 {
 267   return gettext (str);
 268 }
 269 #endif /* ENABLE_NLS */
 270
 271 int
 272 main ()
 273 {
 274   int i;
 275
 276   /* This program is hard-wired to the C locale since it does not call
 277      setlocale.  */
 278   ASSERT (!isprint ('\033'));
 279   for (i = literal_quoting_style; i <= clocale_quoting_style; i++)
 280     {
 281       set_quoting_style (NULL, i);
 282       compare_strings (use_quotearg_buffer, &results_g[i].group1);
 283       compare_strings (use_quotearg, &results_g[i].group2);
 284       compare_strings (use_quotearg_colon, &results_g[i].group3);
 285     }
 286
 287   set_quoting_style (NULL, literal_quoting_style);
 288   ASSERT (set_quoting_flags (NULL, QA_ELIDE_NULL_BYTES) == 0);
 289   compare_strings (use_quotearg_buffer, &flag_results[0].group1);
 290   compare_strings (use_quotearg, &flag_results[0].group2);
 291   compare_strings (use_quotearg_colon, &flag_results[0].group3);
 292
 293   set_quoting_style (NULL, c_quoting_style);
 294   ASSERT (set_quoting_flags (NULL, QA_ELIDE_OUTER_QUOTES)
 295           == QA_ELIDE_NULL_BYTES);
 296   compare_strings (use_quotearg_buffer, &flag_results[1].group1);
 297   compare_strings (use_quotearg, &flag_results[1].group2);
 298   compare_strings (use_quotearg_colon, &flag_results[1].group3);
 299
 300   ASSERT (set_quoting_flags (NULL, QA_SPLIT_TRIGRAPHS)
 301           == QA_ELIDE_OUTER_QUOTES);
 302   compare_strings (use_quotearg_buffer, &flag_results[2].group1);
 303   compare_strings (use_quotearg, &flag_results[2].group2);
 304   compare_strings (use_quotearg_colon, &flag_results[2].group3);
 305
 306   ASSERT (set_quoting_flags (NULL, 0) == QA_SPLIT_TRIGRAPHS);
 307
 308 #if ENABLE_NLS
 309   /* Rather than change locales, and require a .gmo file with
 310      translations for "`" and "'" that match our expectations, we
 311      merely override the gettext function to satisfy the link
 312      dependencies of quotearg.c.  */
 313   fake_locale = true;
 314
 315   set_quoting_style (NULL, locale_quoting_style);
 316   compare_strings (use_quotearg_buffer, &locale_results[0].group1);
 317   compare_strings (use_quotearg, &locale_results[0].group2);
 318   compare_strings (use_quotearg_colon, &locale_results[0].group3);
 319
 320   set_quoting_style (NULL, clocale_quoting_style);
 321   compare_strings (use_quotearg_buffer, &locale_results[1].group1);
 322   compare_strings (use_quotearg, &locale_results[1].group2);
 323   compare_strings (use_quotearg_colon, &locale_results[1].group3);
 324 #endif /* ENABLE_NLS */
 325
 326   quotearg_free ();
 327   return 0;
 328 }