cgit.sxemacs.org Git - sxemacs/blob - src/tests.c

   1 /* C support for testing SXEmacs - see tests/automated/c-tests.el
   2    Copyright (C) 2000 Martin Buchholz
   3
   4 This file is part of SXEmacs
   5
   6 SXEmacs is free software: you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation, either version 3 of the License, or
   9 (at your option) any later version.
  10
  11 SXEmacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  18
  19
  20 /* Author: Martin Buchholz
  21
  22    This file provides support for running tests for SXEmacs that cannot
  23    be written entirely in Lisp.  These tests are run automatically via
  24    tests/automated/c-tests.el, or can be run by hand using M-x */
  25
  26 #include <config.h>
  27 #include "lisp.h"
  28 #include "buffer.h"
  29 #include "lstream.h"
  30 #include "opaque.h"
  31
  32 static Lisp_Object Vtest_function_list;
  33
  34 DEFUN("test-data-format-conversion", Ftest_data_format_conversion, 0, 0, "",    /*
  35 Test TO_EXTERNAL_FORMAT() and TO_INTERNAL_FORMAT()
  36 */
  37       ())
  38 {
  39         void *ptr;
  40         size_t len;
  41         Lisp_Object string, opaque;
  42
  43         Bufbyte int_foo[] = "\n\nfoo\nbar";
  44         Extbyte ext_unix[] = "\n\nfoo\nbar";
  45
  46         Extbyte ext_dos[] = "\r\n\r\nfoo\r\nbar";
  47         Extbyte ext_mac[] = "\r\rfoo\rbar";
  48         Lisp_Object opaque_dos = make_opaque(ext_dos, sizeof(ext_dos) - 1);
  49         Lisp_Object string_foo = make_string(int_foo, sizeof(int_foo) - 1);
  50
  51         Extbyte ext_latin[] = "f\372b\343\340";
  52         Bufbyte int_latin1[] = "f\201\372b\201\343\201\340";
  53         Bufbyte int_latin2[] = "f\202\372b\202\343\202\340";
  54 #ifdef MULE
  55         Extbyte ext_latin12[] = "f\033-A\372b\343\340\033-B";
  56         Extbyte ext_tilde[] = "f~b~~";
  57         Lisp_Object string_latin2 =
  58             make_string(int_latin2, sizeof(int_latin2) - 1);
  59 #endif
  60         Lisp_Object opaque_latin =
  61             make_opaque(ext_latin, sizeof(ext_latin) - 1);
  62         Lisp_Object opaque0_latin = make_opaque(ext_latin, sizeof(ext_latin));
  63         Lisp_Object string_latin1 =
  64             make_string(int_latin1, sizeof(int_latin1) - 1);
  65
  66         /* Check for expected strings before and after conversion.
  67            Conversions depend on whether MULE is defined,
  68            and on whether FILE_CODING is defined. */
  69 #ifdef MULE
  70 #define DFC_CHECK_DATA_COND_MULE(ptr,len,                       \
  71                                  constant_string_mule,          \
  72                                  constant_string_non_mule)      \
  73     DFC_CHECK_DATA (ptr, len, constant_string_mule)
  74 #define DFC_CHECK_DATA_COND_MULE_NUL(ptr,len,                   \
  75                                      constant_string_mule,      \
  76                                      constant_string_non_mule)  \
  77     DFC_CHECK_DATA_NUL (ptr, len, constant_string_mule)
  78 #else
  79 #define DFC_CHECK_DATA_COND_MULE(ptr,len,                       \
  80                                  constant_string_mule,          \
  81                                  constant_string_non_mule)      \
  82     DFC_CHECK_DATA (ptr, len, constant_string_non_mule)
  83 #define DFC_CHECK_DATA_COND_MULE_NUL(ptr,len,                   \
  84                                      constant_string_mule,      \
  85                                      constant_string_non_mule)  \
  86     DFC_CHECK_DATA_NUL (ptr, len, constant_string_non_mule)
  87 #endif
  88
  89 #ifdef FILE_CODING
  90 #define DFC_CHECK_DATA_COND_EOL(ptr,len,                        \
  91                                  constant_string_eol,           \
  92                                  constant_string_non_eol)       \
  93     DFC_CHECK_DATA (ptr, len, constant_string_eol)
  94 #define DFC_CHECK_DATA_COND_EOL_NUL(ptr,len,                    \
  95                                      constant_string_eol,       \
  96                                      constant_string_non_eol)   \
  97     DFC_CHECK_DATA_NUL (ptr, len, constant_string_eol)
  98 #else
  99 #define DFC_CHECK_DATA_COND_EOL(ptr,len,                        \
 100                                  constant_string_eol,           \
 101                                  constant_string_non_eol)       \
 102     DFC_CHECK_DATA (ptr, len, constant_string_non_eol)
 103 #define DFC_CHECK_DATA_COND_EOL_NUL(ptr,len,                    \
 104                                      constant_string_eol,       \
 105                                      constant_string_non_eol)   \
 106     DFC_CHECK_DATA_NUL (ptr, len, constant_string_non_eol)
 107 #endif
 108
 109         /* Check for expected strings before and after conversion. */
 110 #define DFC_CHECK_DATA(ptr,len, constant_string) do {   \
 111     assert ((len) == sizeof (constant_string) - 1);     \
 112     assert (!memcmp (ptr, constant_string, len));       \
 113   } while (0)
 114
 115         /* Macro version that includes the trailing NULL byte. */
 116 #define DFC_CHECK_DATA_NUL(ptr,len,constant_string) do {\
 117     assert ((len) == sizeof (constant_string));         \
 118     assert (!memcmp (ptr, constant_string, len));       \
 119   } while (0)
 120
 121 #ifdef MULE
 122         ptr = NULL, len = rand();
 123         TO_EXTERNAL_FORMAT(DATA, (int_latin2, sizeof(int_latin2)),
 124                            ALLOCA, (ptr, len),
 125                            Fget_coding_system(intern("iso-8859-2")));
 126         DFC_CHECK_DATA_NUL(ptr, len, ext_latin);
 127
 128         ptr = NULL, len = rand();
 129         TO_EXTERNAL_FORMAT(LISP_STRING, string_latin2,
 130                            ALLOCA, (ptr, len),
 131                            Fget_coding_system(intern("iso-8859-2")));
 132         DFC_CHECK_DATA(ptr, len, ext_latin);
 133
 134         ptr = NULL, len = rand();
 135         TO_EXTERNAL_FORMAT(LISP_STRING, string_latin1,
 136                            ALLOCA, (ptr, len),
 137                            Fget_coding_system(intern("iso-8859-2")));
 138         DFC_CHECK_DATA(ptr, len, ext_latin12);
 139
 140         ptr = NULL, len = rand();
 141         TO_EXTERNAL_FORMAT(DATA, (int_latin2, sizeof(int_latin2) - 1),
 142                            MALLOC, (ptr, len),
 143                            Fget_coding_system(intern("iso-8859-2")));
 144         DFC_CHECK_DATA(ptr, len, ext_latin);
 145         xfree(ptr);
 146
 147         TO_EXTERNAL_FORMAT(DATA, (int_latin2, sizeof(int_latin2) - 1),
 148                            LISP_OPAQUE, opaque,
 149                            Fget_coding_system(intern("iso-8859-2")));
 150         DFC_CHECK_DATA(XOPAQUE_DATA(opaque), XOPAQUE_SIZE(opaque), ext_latin);
 151
 152         ptr = NULL, len = rand();
 153         TO_INTERNAL_FORMAT(DATA, (ext_latin, sizeof(ext_latin) - 1),
 154                            ALLOCA, (ptr, len), intern("iso-8859-2"));
 155         DFC_CHECK_DATA(ptr, len, int_latin2);
 156
 157         ptr = NULL, len = rand();
 158         TO_INTERNAL_FORMAT(DATA, (ext_latin, sizeof(ext_latin) - 1),
 159                            MALLOC, (ptr, len), intern("iso-8859-2"));
 160         DFC_CHECK_DATA(ptr, len, int_latin2);
 161         xfree(ptr);
 162
 163         TO_INTERNAL_FORMAT(DATA, (ext_latin, sizeof(ext_latin) - 1),
 164                            LISP_STRING, string, intern("iso-8859-2"));
 165         DFC_CHECK_DATA(XSTRING_DATA(string), XSTRING_LENGTH(string),
 166                        int_latin2);
 167
 168         TO_INTERNAL_FORMAT(LISP_OPAQUE, opaque_latin,
 169                            LISP_STRING, string, intern("iso-8859-2"));
 170         DFC_CHECK_DATA(XSTRING_DATA(string), XSTRING_LENGTH(string),
 171                        int_latin2);
 172
 173         TO_INTERNAL_FORMAT(LISP_OPAQUE, opaque0_latin,
 174                            LISP_STRING, string, intern("iso-8859-2"));
 175         DFC_CHECK_DATA_NUL(XSTRING_DATA(string), XSTRING_LENGTH(string),
 176                            int_latin2);
 177
 178         {
 179                 Lisp_Object tmp = Fcurrent_buffer();
 180                 TO_INTERNAL_FORMAT(LISP_OPAQUE, opaque0_latin,
 181                                    LISP_BUFFER, tmp,
 182                                    intern("iso-8859-2"));
 183                 DFC_CHECK_DATA_NUL(BUF_BYTE_ADDRESS
 184                                    (current_buffer, BUF_PT(current_buffer)),
 185                                    sizeof(int_latin2), int_latin2);
 186
 187                 TO_INTERNAL_FORMAT(LISP_OPAQUE, opaque_latin,
 188                                    LISP_BUFFER, tmp,
 189                                    intern("iso-8859-1"));
 190                 DFC_CHECK_DATA(BUF_BYTE_ADDRESS(current_buffer,
 191                                                 BUF_PT(current_buffer)),
 192                                sizeof(int_latin1) - 1, int_latin1);
 193         }
 194         TO_INTERNAL_FORMAT(DATA, (ext_latin12, sizeof(ext_latin12) - 1),
 195                            ALLOCA, (ptr, len), intern("iso-8859-2"));
 196         DFC_CHECK_DATA(ptr, len, int_latin1);
 197
 198 #endif                          /* MULE */
 199
 200         ptr = NULL, len = rand();
 201         TO_EXTERNAL_FORMAT(DATA, (int_latin1, sizeof(int_latin1) - 1),
 202                            ALLOCA, (ptr, len), Qbinary);
 203         DFC_CHECK_DATA_COND_MULE(ptr, len, ext_latin, int_latin1);
 204
 205         ptr = NULL, len = rand();
 206         TO_EXTERNAL_FORMAT(DATA, (int_latin1, sizeof(int_latin1)),
 207                            ALLOCA, (ptr, len), Qbinary);
 208         DFC_CHECK_DATA_COND_MULE_NUL(ptr, len, ext_latin, int_latin1);
 209
 210         ptr = NULL, len = rand();
 211         TO_EXTERNAL_FORMAT(DATA, (int_latin2, sizeof(int_latin2) - 1),
 212                            ALLOCA, (ptr, len), Fget_coding_system(Qbinary));
 213         DFC_CHECK_DATA_COND_MULE(ptr, len, ext_tilde, int_latin2);
 214
 215         ptr = NULL, len = rand();
 216         TO_EXTERNAL_FORMAT(DATA, (int_latin1, sizeof(int_latin1) - 1),
 217                            ALLOCA, (ptr, len), intern("iso-8859-1"));
 218         DFC_CHECK_DATA_COND_MULE(ptr, len, ext_latin, int_latin1);
 219
 220         ptr = NULL, len = rand();
 221         TO_EXTERNAL_FORMAT(LISP_STRING, string_latin1,
 222                            ALLOCA, (ptr, len), Qbinary);
 223         DFC_CHECK_DATA_COND_MULE(ptr, len, ext_latin, int_latin1);
 224
 225         ptr = NULL, len = rand();
 226         TO_EXTERNAL_FORMAT(LISP_STRING, string_latin1,
 227                            ALLOCA, (ptr, len), Fget_coding_system(Qbinary));
 228         DFC_CHECK_DATA_COND_MULE(ptr, len, ext_latin, int_latin1);
 229
 230         ptr = NULL, len = rand();
 231         TO_EXTERNAL_FORMAT(LISP_STRING, string_latin1,
 232                            ALLOCA, (ptr, len), intern("iso-8859-1"));
 233         DFC_CHECK_DATA_COND_MULE(ptr, len, ext_latin, int_latin1);
 234
 235         ptr = NULL, len = rand();
 236         TO_EXTERNAL_FORMAT(DATA, (int_latin1, sizeof(int_latin1) - 1),
 237                            MALLOC, (ptr, len), Qbinary);
 238         DFC_CHECK_DATA_COND_MULE(ptr, len, ext_latin, int_latin1);
 239         xfree(ptr);
 240
 241         ptr = NULL, len = rand();
 242         TO_EXTERNAL_FORMAT(DATA, (int_latin2, sizeof(int_latin2)),
 243                            MALLOC, (ptr, len), Fget_coding_system(Qbinary));
 244         DFC_CHECK_DATA_COND_MULE_NUL(ptr, len, ext_tilde, int_latin2);
 245         xfree(ptr);
 246
 247         ptr = NULL, len = rand();
 248         TO_EXTERNAL_FORMAT(DATA, (int_latin1, sizeof(int_latin1) - 1),
 249                            MALLOC, (ptr, len), intern("iso-8859-1"));
 250         DFC_CHECK_DATA_COND_MULE(ptr, len, ext_latin, int_latin1);
 251         xfree(ptr);
 252
 253         TO_EXTERNAL_FORMAT(DATA, (int_latin1, sizeof(int_latin1) - 1),
 254                            LISP_OPAQUE, opaque, Qbinary);
 255         DFC_CHECK_DATA_COND_MULE(XOPAQUE_DATA(opaque),
 256                                  XOPAQUE_SIZE(opaque), ext_latin, int_latin1);
 257
 258         TO_EXTERNAL_FORMAT(DATA, (int_latin2, sizeof(int_latin2)),
 259                            LISP_OPAQUE, opaque, Fget_coding_system(Qbinary));
 260         DFC_CHECK_DATA_COND_MULE_NUL(XOPAQUE_DATA(opaque),
 261                                      XOPAQUE_SIZE(opaque), ext_tilde,
 262                                      int_latin2);
 263
 264         TO_EXTERNAL_FORMAT(DATA, (int_latin1, sizeof(int_latin1) - 1),
 265                            LISP_OPAQUE, opaque, intern("iso-8859-1"));
 266         DFC_CHECK_DATA_COND_MULE(XOPAQUE_DATA(opaque),
 267                                  XOPAQUE_SIZE(opaque), ext_latin, int_latin1);
 268
 269         ptr = NULL, len = rand();
 270         TO_INTERNAL_FORMAT(DATA, (ext_latin, sizeof(ext_latin) - 1),
 271                            ALLOCA, (ptr, len), Qbinary);
 272         DFC_CHECK_DATA_COND_MULE(ptr, len, int_latin1, ext_latin);
 273
 274         ptr = NULL, len = rand();
 275         TO_INTERNAL_FORMAT(DATA, (ext_latin, sizeof(ext_latin)),
 276                            ALLOCA, (ptr, len), intern("iso-8859-1"));
 277         DFC_CHECK_DATA_COND_MULE_NUL(ptr, len, int_latin1, ext_latin);
 278
 279         ptr = NULL, len = rand();
 280         TO_INTERNAL_FORMAT(DATA, (ext_latin, sizeof(ext_latin)),
 281                            MALLOC, (ptr, len), intern("iso-8859-1"));
 282         DFC_CHECK_DATA_COND_MULE_NUL(ptr, len, int_latin1, ext_latin);
 283         xfree(ptr);
 284
 285         ptr = NULL, len = rand();
 286         TO_INTERNAL_FORMAT(DATA, (ext_latin, sizeof(ext_latin)),
 287                            MALLOC, (ptr, len), Qnil);
 288         DFC_CHECK_DATA_COND_MULE_NUL(ptr, len, int_latin1, ext_latin);
 289         xfree(ptr);
 290
 291         TO_INTERNAL_FORMAT(DATA, (ext_latin, sizeof(ext_latin) - 1),
 292                            LISP_STRING, string, intern("iso-8859-1"));
 293         DFC_CHECK_DATA_COND_MULE(XSTRING_DATA(string),
 294                                  XSTRING_LENGTH(string), int_latin1, ext_latin);
 295
 296         TO_INTERNAL_FORMAT(LISP_OPAQUE, opaque_latin,
 297                            LISP_STRING, string, intern("iso-8859-1"));
 298         DFC_CHECK_DATA_COND_MULE(XSTRING_DATA(string),
 299                                  XSTRING_LENGTH(string), int_latin1, ext_latin);
 300
 301         TO_INTERNAL_FORMAT(LISP_OPAQUE, opaque0_latin,
 302                            LISP_STRING, string, intern("iso-8859-1"));
 303         DFC_CHECK_DATA_COND_MULE_NUL(XSTRING_DATA(string),
 304                                      XSTRING_LENGTH(string), int_latin1,
 305                                      ext_latin);
 306
 307         ptr = NULL, len = rand();
 308         TO_EXTERNAL_FORMAT(DATA, (int_foo, sizeof(int_foo)),
 309                            MALLOC, (ptr, len), Fget_coding_system(Qbinary));
 310         DFC_CHECK_DATA_COND_EOL_NUL(ptr, len, ext_unix, int_foo);
 311         xfree(ptr);
 312
 313         ptr = NULL, len = rand();
 314         TO_EXTERNAL_FORMAT(DATA, (int_foo, sizeof(int_foo) - 1),
 315                            LISP_OPAQUE, opaque, intern("raw-text-mac"));
 316         DFC_CHECK_DATA_COND_EOL(XOPAQUE_DATA(opaque),
 317                                 XOPAQUE_SIZE(opaque), ext_mac, int_foo);
 318
 319         ptr = NULL, len = rand();
 320         TO_EXTERNAL_FORMAT(LISP_STRING, string_foo,
 321                            ALLOCA, (ptr, len), intern("raw-text-dos"));
 322         DFC_CHECK_DATA_COND_EOL(ptr, len, ext_dos, int_foo);
 323
 324         ptr = NULL, len = rand();
 325         TO_EXTERNAL_FORMAT(DATA, (int_foo, sizeof(int_foo) - 1),
 326                            ALLOCA, (ptr, len), intern("raw-text-unix"));
 327         DFC_CHECK_DATA_COND_EOL(ptr, len, ext_unix, int_foo);
 328
 329         ptr = NULL, len = rand();
 330         TO_EXTERNAL_FORMAT(LISP_STRING, string_foo,
 331                            MALLOC, (ptr, len), intern("no-conversion-mac"));
 332         DFC_CHECK_DATA_COND_EOL(ptr, len, ext_mac, int_foo);
 333         xfree(ptr);
 334
 335         ptr = NULL, len = rand();
 336         TO_EXTERNAL_FORMAT(DATA, (int_foo, sizeof(int_foo) - 1),
 337                            ALLOCA, (ptr, len),
 338                            Fget_coding_system(intern("no-conversion-dos")));
 339         DFC_CHECK_DATA_COND_EOL(ptr, len, ext_dos, int_foo);
 340
 341         ptr = NULL, len = rand();
 342         TO_EXTERNAL_FORMAT(DATA, (int_foo, sizeof(int_foo)),
 343                            ALLOCA, (ptr, len), intern("no-conversion-unix"));
 344         DFC_CHECK_DATA_COND_EOL_NUL(ptr, len, ext_unix, int_foo);
 345
 346 #ifdef FILE_CODING
 347         {
 348                 Lisp_Object tmp = Fcurrent_buffer();
 349                 TO_INTERNAL_FORMAT(LISP_OPAQUE, opaque_dos,
 350                                    LISP_BUFFER, tmp, intern("undecided"));
 351                 DFC_CHECK_DATA(BUF_BYTE_ADDRESS(current_buffer,
 352                                                 BUF_PT(current_buffer)),
 353                                sizeof(int_foo) - 1, int_foo);
 354         }
 355 #endif  /* FILE_CODING */
 356
 357         TO_INTERNAL_FORMAT(DATA, (ext_mac, sizeof(ext_mac) - 1),
 358                            LISP_STRING, string, intern("iso-8859-1"));
 359         DFC_CHECK_DATA_COND_EOL(XSTRING_DATA(string),
 360                                 XSTRING_LENGTH(string), int_foo, ext_mac);
 361
 362         {
 363                 Lisp_Object stream =
 364                     make_fixed_buffer_input_stream(ext_dos,
 365                                                    sizeof(ext_dos) - 1);
 366                 TO_INTERNAL_FORMAT(LISP_LSTREAM, stream, LISP_STRING, string,
 367                                    intern("iso-8859-1"));
 368                 DFC_CHECK_DATA_COND_EOL(XSTRING_DATA(string),
 369                                         XSTRING_LENGTH(string), int_foo,
 370                                         ext_dos);
 371         }
 372
 373         TO_INTERNAL_FORMAT(DATA, (ext_unix, sizeof(ext_unix) - 1),
 374                            LISP_STRING, string, intern("no-conversion"));
 375         DFC_CHECK_DATA_COND_EOL(XSTRING_DATA(string),
 376                                 XSTRING_LENGTH(string), int_foo, ext_unix);
 377
 378         ptr = NULL, len = rand();
 379         TO_EXTERNAL_FORMAT(LISP_OPAQUE, opaque_dos,
 380                            ALLOCA, (ptr, len), Qbinary);
 381         DFC_CHECK_DATA(ptr, len, ext_dos);
 382
 383         return intern("PASS");
 384 }
 385 \f
 386 #define TESTS_DEFSUBR(Fname) do {               \
 387   DEFSUBR (Fname);                              \
 388   Vtest_function_list =                         \
 389     Fcons (intern (subr_name (&S##Fname)),      \
 390            Vtest_function_list);                \
 391 } while (0)
 392
 393 void syms_of_tests(void)
 394 {
 395         Vtest_function_list = Qnil;
 396
 397         TESTS_DEFSUBR(Ftest_data_format_conversion);
 398         /* Add other test functions here with TESTS_DEFSUBR */
 399 }
 400
 401 void vars_of_tests(void)
 402 {
 403         DEFVAR_LISP("test-function-list", &Vtest_function_list  /*
 404 List of all test functions defined in tests.c.
 405 For use by the automated test suite.  See tests/automated/c-tests.
 406                                                                  */ );
 407 }