Mercurial > hg > xemacs-beta

comparison src/tests.c @ 4747:294a86d29f99

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Eliminate C asserts from c-tests.
author Stephen J. Turnbull <stephen@xemacs.org>
date Mon, 16 Nov 2009 12:00:38 +0900
parents 4d0f773d5e21
children b8afe0f9cbe3
comparison
equal deleted inserted replaced
4746:ae862598ee56 4747:294a86d29f99
36 #include "file-coding.h" /* XCODING_SYSTEM_EOL_TYPE and its values */ 36 #include "file-coding.h" /* XCODING_SYSTEM_EOL_TYPE and its values */
37 37
38 static Lisp_Object Vtest_function_list; 38 static Lisp_Object Vtest_function_list;
39 39
40 DEFUN ("test-data-format-conversion", Ftest_data_format_conversion, 0, 0, "", /* 40 DEFUN ("test-data-format-conversion", Ftest_data_format_conversion, 0, 0, "", /*
41 Test TO_EXTERNAL_FORMAT() and TO_INTERNAL_FORMAT() 41 Return list of results of test TO_EXTERNAL_FORMAT() and TO_INTERNAL_FORMAT().
42 For use by the automated test suite. See tests/automated/c-tests.
43
44 Each element is a list (DESCRIPTION, STATUS, REASON).
45 DESCRIPTION is a string describing the test.
46 STATUS is a symbol, either t (pass) or nil (fail).
47 REASON is nil or a string describing the failure (not required).
42 */ 48 */
43 ()) 49 ())
44 { 50 {
45 void *ptr; Bytecount len; 51 void *ptr; Bytecount len;
46 Lisp_Object string, opaque; 52 Lisp_Object string, opaque, conversion_result = Qnil;
47 53
48 Ibyte int_foo[] = "\n\nfoo\nbar"; 54 Ibyte int_foo[] = "\n\nfoo\nbar";
49 Extbyte ext_unix[]= "\n\nfoo\nbar"; 55 Extbyte ext_unix[]= "\n\nfoo\nbar";
50 56
51 Extbyte ext_dos[] = "\r\n\r\nfoo\r\nbar"; 57 Extbyte ext_dos[] = "\r\n\r\nfoo\r\nbar";
73 /* #### Any code below that uses iso-latin-2-with-esc is ill-conceived. */ 79 /* #### Any code below that uses iso-latin-2-with-esc is ill-conceived. */
74 80
75 #ifdef MULE 81 #ifdef MULE
76 #define DFC_CHECK_DATA_COND_MULE(ptr,len, \ 82 #define DFC_CHECK_DATA_COND_MULE(ptr,len, \
77 constant_string_mule, \ 83 constant_string_mule, \
78 constant_string_non_mule) \ 84 constant_string_non_mule, \
79 DFC_CHECK_DATA (ptr, len, constant_string_mule) 85 description) \
86 DFC_CHECK_DATA (ptr, len, constant_string_mule, description)
80 #define DFC_CHECK_DATA_COND_MULE_NUL(ptr,len, \ 87 #define DFC_CHECK_DATA_COND_MULE_NUL(ptr,len, \
81 constant_string_mule, \ 88 constant_string_mule, \
82 constant_string_non_mule) \ 89 constant_string_non_mule, \
83 DFC_CHECK_DATA_NUL (ptr, len, constant_string_mule) 90 description) \
91 DFC_CHECK_DATA_NUL (ptr, len, constant_string_mule, description)
84 #else 92 #else
85 #define DFC_CHECK_DATA_COND_MULE(ptr,len, \ 93 #define DFC_CHECK_DATA_COND_MULE(ptr,len, \
86 constant_string_mule, \ 94 constant_string_mule, \
87 constant_string_non_mule) \ 95 constant_string_non_mule, \
88 DFC_CHECK_DATA (ptr, len, constant_string_non_mule) 96 description) \
97 DFC_CHECK_DATA (ptr, len, constant_string_non_mule, description)
89 #define DFC_CHECK_DATA_COND_MULE_NUL(ptr,len, \ 98 #define DFC_CHECK_DATA_COND_MULE_NUL(ptr,len, \
90 constant_string_mule, \ 99 constant_string_mule, \
91 constant_string_non_mule) \ 100 constant_string_non_mule, \
92 DFC_CHECK_DATA_NUL (ptr, len, constant_string_non_mule) 101 description) \
102 DFC_CHECK_DATA_NUL (ptr, len, constant_string_non_mule, description)
93 #endif 103 #endif
94 104
95 /* These now only apply to base coding systems, and 105 /* These now only apply to base coding systems, and
96 need to test `eol-detection-enabled-p' at runtime. */ 106 need to test `eol-detection-enabled-p' at runtime. */
97 #define DFC_CHECK_DATA_COND_EOL(ptr,len, \ 107 #define DFC_CHECK_DATA_COND_EOL(ptr,len, \
98 constant_string_eol, \ 108 constant_string_eol, \
99 constant_string_non_eol) do { \ 109 constant_string_non_eol, \
100 if (autodetect_eol_p) \ 110 description) do { \
101 DFC_CHECK_DATA (ptr, len, constant_string_eol); \ 111 if (autodetect_eol_p) \
102 else \ 112 DFC_CHECK_DATA (ptr, len, constant_string_eol, description); \
103 DFC_CHECK_DATA (ptr, len, constant_string_non_eol); \ 113 else \
114 DFC_CHECK_DATA (ptr, len, constant_string_non_eol, description); \
104 } while (0) 115 } while (0)
105 #define DFC_CHECK_DATA_COND_EOL_NUL(ptr,len, \ 116 #define DFC_CHECK_DATA_COND_EOL_NUL(ptr,len, \
106 constant_string_eol, \ 117 constant_string_eol, \
107 constant_string_non_eol) do { \ 118 constant_string_non_eol, \
108 if (autodetect_eol_p) \ 119 description) do { \
109 DFC_CHECK_DATA_NUL (ptr, len, constant_string_eol); \ 120 if (autodetect_eol_p) \
110 else \ 121 DFC_CHECK_DATA_NUL (ptr, len, constant_string_eol, description); \
111 DFC_CHECK_DATA_NUL (ptr, len, constant_string_non_eol); \ 122 else \
123 DFC_CHECK_DATA_NUL (ptr, len, constant_string_non_eol, description); \
112 } while (0) 124 } while (0)
113 125
114 /* Check for expected strings before and after conversion. */ 126 /* Check for expected strings before and after conversion. */
115 #define DFC_CHECK_DATA(ptr,len, constant_string) do { \ 127 #define DFC_CHECK_DATA(ptr,len,constant_string,test) do { \
116 assert ((len) == sizeof (constant_string) - 1); \ 128 DFC_INITIALIZE (test); \
117 assert (!memcmp (ptr, constant_string, len)); \ 129 DFC_CHECK_LENGTH (len, sizeof (constant_string) - 1, test); \
130 DFC_CHECK_CONTENT (ptr, constant_string, len, test); \
131 DFC_RESULT_PASS (test); \
118 } while (0) 132 } while (0)
119 133
120 /* Macro version that includes the trailing NULL byte. */ 134 /* Macro version that includes the trailing NULL byte. */
121 #define DFC_CHECK_DATA_NUL(ptr,len,constant_string) do {\ 135 #define DFC_CHECK_DATA_NUL(ptr,len,constant_string,test) do { \
122 assert ((len) == sizeof (constant_string)); \ 136 DFC_INITIALIZE (test); \
123 assert (!memcmp (ptr, constant_string, len)); \ 137 DFC_CHECK_LENGTH (len, sizeof (constant_string), test); \
138 DFC_CHECK_CONTENT (ptr, constant_string, len, test); \
139 DFC_RESULT_PASS (test); \
124 } while (0) 140 } while (0)
125 141
142 /* WARNING WARNING WARNING!
143 The following macros are NOT protected by "do { ... } while (0)"!!
144 */
145
146 #define DFC_INITIALIZE(test_name) if (0)
147
148 #define DFC_CHECK_LENGTH(len1,len2,str1) \
149 else if ((len1) != (len2)) \
150 conversion_result = \
151 Fcons (list3 (build_string(str1), Qnil, build_string("wrong length")), \
152 conversion_result)
153
154 #define DFC_CHECK_CONTENT(str1,str2,len1,str3) \
155 else if (memcmp (str1, str2, len1)) \
156 conversion_result = \
157 Fcons (list3 (build_string(str3), Qnil, \
158 build_string("octet comparison failed")), \
159 conversion_result)
160
161 #define DFC_RESULT_PASS(str1) \
162 else \
163 conversion_result = \
164 Fcons (list3 (build_string(str1), Qt, Qnil), \
165 conversion_result)
166
126 #ifdef MULE 167 #ifdef MULE
127 ptr = NULL, len = rand(); 168 ptr = NULL, len = rand();
128 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2)), 169 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2)),
129 ALLOCA, (ptr, len), 170 ALLOCA, (ptr, len),
130 intern ("iso-8859-2")); 171 intern ("iso-8859-2"));
131 DFC_CHECK_DATA_NUL (ptr, len, ext_latin); 172 DFC_CHECK_DATA_NUL (ptr, len, ext_latin,
173 "Latin-2 DATA, ALLOCA, Latin 2/NUL");
132 174
133 ptr = NULL, len = rand(); 175 ptr = NULL, len = rand();
134 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin2, 176 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin2,
135 ALLOCA, (ptr, len), 177 ALLOCA, (ptr, len),
136 intern ("iso-8859-2")); 178 intern ("iso-8859-2"));
137 DFC_CHECK_DATA (ptr, len, ext_latin); 179 DFC_CHECK_DATA (ptr, len, ext_latin,
180 "Latin-2 Lisp string, ALLOCA, Latin 2");
138 181
139 ptr = NULL, len = rand(); 182 ptr = NULL, len = rand();
140 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1, 183 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1,
141 ALLOCA, (ptr, len), 184 ALLOCA, (ptr, len),
142 intern ("iso-latin-2-with-esc")); 185 intern ("iso-latin-2-with-esc"));
143 DFC_CHECK_DATA (ptr, len, ext_latin12); 186 DFC_CHECK_DATA (ptr, len, ext_latin12,
187 "Latin-1 Lisp string, ALLOCA, Latin 2/ESC");
144 188
145 ptr = NULL, len = rand(); 189 ptr = NULL, len = rand();
146 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2) - 1), 190 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2) - 1),
147 MALLOC, (ptr, len), 191 MALLOC, (ptr, len),
148 intern ("iso-8859-2")); 192 intern ("iso-8859-2"));
149 DFC_CHECK_DATA (ptr, len, ext_latin); 193 DFC_CHECK_DATA (ptr, len, ext_latin, "Latin-2 DATA, MALLOC, Latin-2");
150 xfree (ptr, void *); 194 xfree (ptr, void *);
151 195
152 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2) - 1), 196 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2) - 1),
153 LISP_OPAQUE, opaque, 197 LISP_OPAQUE, opaque,
154 intern ("iso-8859-2")); 198 intern ("iso-8859-2"));
155 DFC_CHECK_DATA (XOPAQUE_DATA (opaque), XOPAQUE_SIZE (opaque), ext_latin); 199 DFC_CHECK_DATA (XOPAQUE_DATA (opaque), XOPAQUE_SIZE (opaque), ext_latin,
200 "Latin-2 DATA, Lisp opaque, Latin-2");
156 201
157 ptr = NULL, len = rand(); 202 ptr = NULL, len = rand();
158 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), 203 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1),
159 ALLOCA, (ptr, len), 204 ALLOCA, (ptr, len),
160 intern ("iso-latin-2-with-esc")); 205 intern ("iso-latin-2-with-esc"));
161 DFC_CHECK_DATA (ptr, len, int_latin2); 206 DFC_CHECK_DATA (ptr, len, int_latin2,
207 "Latin-2/ESC, ALLOCA, Latin-1 DATA");
162 208
163 ptr = NULL, len = rand(); 209 ptr = NULL, len = rand();
164 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), 210 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1),
165 MALLOC, (ptr, len), 211 MALLOC, (ptr, len),
166 intern ("iso-latin-2-with-esc")); 212 intern ("iso-latin-2-with-esc"));
167 DFC_CHECK_DATA (ptr, len, int_latin2); 213 DFC_CHECK_DATA (ptr, len, int_latin2,
214 "Latin-2/ESC, MALLOC, Latin-1 DATA");
168 xfree (ptr, void *); 215 xfree (ptr, void *);
169 216
170 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), 217 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1),
171 LISP_STRING, string, 218 LISP_STRING, string,
172 intern ("iso-latin-2-with-esc")); 219 intern ("iso-latin-2-with-esc"));
173 DFC_CHECK_DATA (XSTRING_DATA (string), XSTRING_LENGTH (string), int_latin2); 220 DFC_CHECK_DATA (XSTRING_DATA (string), XSTRING_LENGTH (string), int_latin2,
221 "Latin-2/ESC, Lisp string, Latin-2");
174 222
175 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_latin, 223 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_latin,
176 LISP_STRING, string, 224 LISP_STRING, string,
177 intern ("iso-latin-2-with-esc")); 225 intern ("iso-latin-2-with-esc"));
178 DFC_CHECK_DATA (XSTRING_DATA (string), XSTRING_LENGTH (string), int_latin2); 226 DFC_CHECK_DATA (XSTRING_DATA (string), XSTRING_LENGTH (string), int_latin2,
227 "Lisp opaque, Lisp string, Latin-2/ESC");
179 228
180 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque0_latin, 229 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque0_latin,
181 LISP_STRING, string, 230 LISP_STRING, string,
182 intern ("iso-latin-2-with-esc")); 231 intern ("iso-latin-2-with-esc"));
183 DFC_CHECK_DATA_NUL (XSTRING_DATA (string), XSTRING_LENGTH (string), int_latin2); 232 DFC_CHECK_DATA_NUL (XSTRING_DATA (string), XSTRING_LENGTH (string), int_latin2,
233 "Lisp opaque, Lisp string, Latin-2/ESC/NUL");
184 234
185 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque0_latin, 235 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque0_latin,
186 LISP_BUFFER, Fcurrent_buffer(), 236 LISP_BUFFER, Fcurrent_buffer(),
187 intern ("iso-latin-2-with-esc")); 237 intern ("iso-latin-2-with-esc"));
188 DFC_CHECK_DATA_NUL (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)), 238 DFC_CHECK_DATA_NUL (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)),
189 sizeof (int_latin2), int_latin2); 239 sizeof (int_latin2), int_latin2,
240 "Lisp opaque, Lisp buffer, Latin-2/ESC/NUL");
190 241
191 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_latin, 242 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_latin,
192 LISP_BUFFER, Fcurrent_buffer(), 243 LISP_BUFFER, Fcurrent_buffer(),
193 intern ("iso-8859-1")); 244 intern ("iso-8859-1"));
194 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)), 245 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)),
195 sizeof (int_latin1) - 1, int_latin1); 246 sizeof (int_latin1) - 1, int_latin1,
247 "Lisp opaque, Lisp buffer, Latin-1");
196 248
197 TO_INTERNAL_FORMAT (DATA, (ext_latin12, sizeof (ext_latin12) - 1), 249 TO_INTERNAL_FORMAT (DATA, (ext_latin12, sizeof (ext_latin12) - 1),
198 ALLOCA, (ptr, len), 250 ALLOCA, (ptr, len),
199 intern ("iso-latin-2-with-esc")); 251 intern ("iso-latin-2-with-esc"));
200 DFC_CHECK_DATA (ptr, len, int_latin1); 252 DFC_CHECK_DATA (ptr, len, int_latin1, "DATA, ALLOCA, Latin-1");
201 253
202 #endif /* MULE */ 254 #endif /* MULE */
203 255
204 ptr = NULL, len = rand(); 256 ptr = NULL, len = rand();
205 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), 257 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1),
206 ALLOCA, (ptr, len), 258 ALLOCA, (ptr, len),
207 Qbinary); 259 Qbinary);
208 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); 260 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1,
261 "Latin-1 DATA, ALLOCA, binary");
209 262
210 ptr = NULL, len = rand(); 263 ptr = NULL, len = rand();
211 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1)), 264 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1)),
212 ALLOCA, (ptr, len), 265 ALLOCA, (ptr, len),
213 Qbinary); 266 Qbinary);
214 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, ext_latin, int_latin1); 267 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, ext_latin, int_latin1,
268 "Latin-1 DATA, ALLOCA, binary/NUL");
215 269
216 ptr = NULL, len = rand(); 270 ptr = NULL, len = rand();
217 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2) - 1), 271 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2) - 1),
218 ALLOCA, (ptr, len), 272 ALLOCA, (ptr, len),
219 Qbinary); 273 Qbinary);
220 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_tilde, int_latin2); 274 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_tilde, int_latin2,
275 "Latin-2 DATA, ALLOCA, binary");
221 276
222 ptr = NULL, len = rand(); 277 ptr = NULL, len = rand();
223 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), 278 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1),
224 ALLOCA, (ptr, len), 279 ALLOCA, (ptr, len),
225 intern ("iso-8859-1")); 280 intern ("iso-8859-1"));
226 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); 281 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1,
282 "Latin-1 DATA, ALLOCA, Latin-1");
227 283
228 284
229 ptr = NULL, len = rand(); 285 ptr = NULL, len = rand();
230 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1, 286 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1,
231 ALLOCA, (ptr, len), 287 ALLOCA, (ptr, len),
232 Qbinary); 288 Qbinary);
233 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); 289 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1,
290 "Latin-1 Lisp string, ALLOCA, binary");
234 291
235 ptr = NULL, len = rand(); 292 ptr = NULL, len = rand();
236 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1, 293 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1,
237 ALLOCA, (ptr, len), 294 ALLOCA, (ptr, len),
238 Qbinary); 295 Qbinary);
239 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); 296 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1,
297 "Latin-1 Lisp string, ALLOCA, binary");
240 298
241 ptr = NULL, len = rand(); 299 ptr = NULL, len = rand();
242 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1, 300 TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1,
243 ALLOCA, (ptr, len), 301 ALLOCA, (ptr, len),
244 intern ("iso-8859-1")); 302 intern ("iso-8859-1"));
245 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); 303 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1,
304 "Latin-1 Lisp string, ALLOCA, Latin-1");
246 305
247 ptr = NULL, len = rand(); 306 ptr = NULL, len = rand();
248 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), 307 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1),
249 MALLOC, (ptr, len), 308 MALLOC, (ptr, len),
250 Qbinary); 309 Qbinary);
251 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); 310 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1,
311 "Latin-1 DATA, MALLOC, binary");
252 xfree (ptr, void *); 312 xfree (ptr, void *);
253 313
254 ptr = NULL, len = rand(); 314 ptr = NULL, len = rand();
255 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2)), 315 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2)),
256 MALLOC, (ptr, len), 316 MALLOC, (ptr, len),
257 Qbinary); 317 Qbinary);
258 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, ext_tilde, int_latin2); 318 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, ext_tilde, int_latin2,
319 "Latin-2 DATA, MALLOC, binary/NUL");
259 xfree (ptr, void *); 320 xfree (ptr, void *);
260 321
261 ptr = NULL, len = rand(); 322 ptr = NULL, len = rand();
262 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), 323 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1),
263 MALLOC, (ptr, len), 324 MALLOC, (ptr, len),
264 intern ("iso-8859-1")); 325 intern ("iso-8859-1"));
265 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); 326 DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1,
327 "Latin-1 DATA, MALLOC, Latin-1");
266 xfree (ptr, void *); 328 xfree (ptr, void *);
267 329
268 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), 330 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1),
269 LISP_OPAQUE, opaque, 331 LISP_OPAQUE, opaque,
270 Qbinary); 332 Qbinary);
271 DFC_CHECK_DATA_COND_MULE (XOPAQUE_DATA (opaque), 333 DFC_CHECK_DATA_COND_MULE (XOPAQUE_DATA (opaque),
272 XOPAQUE_SIZE (opaque), ext_latin, int_latin1); 334 XOPAQUE_SIZE (opaque), ext_latin, int_latin1,
335 "Latin-1 DATA, Lisp opaque, binary");
273 336
274 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2)), 337 TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2)),
275 LISP_OPAQUE, opaque, 338 LISP_OPAQUE, opaque,
276 Qbinary); 339 Qbinary);
277 DFC_CHECK_DATA_COND_MULE_NUL (XOPAQUE_DATA (opaque), 340 DFC_CHECK_DATA_COND_MULE_NUL (XOPAQUE_DATA (opaque),
278 XOPAQUE_SIZE (opaque), ext_tilde, int_latin2); 341 XOPAQUE_SIZE (opaque), ext_tilde, int_latin2,
342 "Latin-2 DATA, Lisp opaque, binary");
279 343
280 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), 344 TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1),
281 LISP_OPAQUE, opaque, 345 LISP_OPAQUE, opaque,
282 intern ("iso-8859-1")); 346 intern ("iso-8859-1"));
283 DFC_CHECK_DATA_COND_MULE (XOPAQUE_DATA (opaque), 347 DFC_CHECK_DATA_COND_MULE (XOPAQUE_DATA (opaque),
284 XOPAQUE_SIZE (opaque), ext_latin, int_latin1); 348 XOPAQUE_SIZE (opaque), ext_latin, int_latin1,
349 "Latin-1 DATA, Lisp opaque, Latin-1");
285 350
286 ptr = NULL, len = rand(); 351 ptr = NULL, len = rand();
287 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), 352 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1),
288 ALLOCA, (ptr, len), 353 ALLOCA, (ptr, len),
289 Qbinary); 354 Qbinary);
290 DFC_CHECK_DATA_COND_MULE (ptr, len, int_latin1, ext_latin); 355 DFC_CHECK_DATA_COND_MULE (ptr, len, int_latin1, ext_latin,
356 "Latin-1 DATA, ALLOCA, binary");
291 357
292 ptr = NULL, len = rand(); 358 ptr = NULL, len = rand();
293 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin)), 359 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin)),
294 ALLOCA, (ptr, len), 360 ALLOCA, (ptr, len),
295 intern ("iso-8859-1")); 361 intern ("iso-8859-1"));
296 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, int_latin1, ext_latin); 362 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, int_latin1, ext_latin,
363 "Latin-1 DATA, ALLOCA, Latin-1");
297 364
298 ptr = NULL, len = rand(); 365 ptr = NULL, len = rand();
299 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin)), 366 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin)),
300 MALLOC, (ptr, len), 367 MALLOC, (ptr, len),
301 intern ("iso-8859-1")); 368 intern ("iso-8859-1"));
302 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, int_latin1, ext_latin); 369 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, int_latin1, ext_latin,
370 "Latin-1 DATA, MALLOC, Latin-1");
303 xfree (ptr, void *); 371 xfree (ptr, void *);
304 372
305 ptr = NULL, len = rand(); 373 ptr = NULL, len = rand();
306 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin)), 374 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin)),
307 MALLOC, (ptr, len), 375 MALLOC, (ptr, len),
308 Qnil); 376 Qnil);
309 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, int_latin1, ext_latin); 377 DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, int_latin1, ext_latin,
378 "Latin-1 DATA, MALLOC, nil");
310 xfree (ptr, void *); 379 xfree (ptr, void *);
311 380
312 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), 381 TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1),
313 LISP_STRING, string, 382 LISP_STRING, string,
314 intern ("iso-8859-1")); 383 intern ("iso-8859-1"));
315 DFC_CHECK_DATA_COND_MULE (XSTRING_DATA (string), 384 DFC_CHECK_DATA_COND_MULE (XSTRING_DATA (string),
316 XSTRING_LENGTH (string), int_latin1, ext_latin); 385 XSTRING_LENGTH (string), int_latin1, ext_latin,
386 "Latin-1 DATA, Lisp stirng, Latin-1");
317 387
318 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_latin, 388 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_latin,
319 LISP_STRING, string, 389 LISP_STRING, string,
320 intern ("iso-8859-1")); 390 intern ("iso-8859-1"));
321 DFC_CHECK_DATA_COND_MULE (XSTRING_DATA (string), 391 DFC_CHECK_DATA_COND_MULE (XSTRING_DATA (string),
322 XSTRING_LENGTH (string), int_latin1, ext_latin); 392 XSTRING_LENGTH (string), int_latin1, ext_latin,
393 "Latin-1 Lisp opaque, Lisp string, Latin-1");
323 394
324 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque0_latin, 395 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque0_latin,
325 LISP_STRING, string, 396 LISP_STRING, string,
326 intern ("iso-8859-1")); 397 intern ("iso-8859-1"));
327 DFC_CHECK_DATA_COND_MULE_NUL (XSTRING_DATA (string), 398 DFC_CHECK_DATA_COND_MULE_NUL (XSTRING_DATA (string),
328 XSTRING_LENGTH (string), int_latin1, ext_latin); 399 XSTRING_LENGTH (string), int_latin1, ext_latin,
400 "Latin-1 Lisp opaque, Lisp string, Latin-1/NUL");
329 401
330 /* This next group used to use the COND_EOL macros, but with the new Mule, 402 /* This next group used to use the COND_EOL macros, but with the new Mule,
331 they all specify an EOL convention, and all XEmacsen can grok them. */ 403 they all specify an EOL convention, and all XEmacsen can grok them. */
332 ptr = NULL, len = rand(); 404 ptr = NULL, len = rand();
333 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo)), 405 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo)),
334 MALLOC, (ptr, len), 406 MALLOC, (ptr, len),
335 Qbinary); 407 Qbinary);
336 DFC_CHECK_DATA_NUL (ptr, len, ext_unix); 408 DFC_CHECK_DATA_NUL (ptr, len, ext_unix,
409 "ASCII DATA, MALLOC, binary/LF/NUL");
337 xfree (ptr, void *); 410 xfree (ptr, void *);
338 411
339 ptr = NULL, len = rand(); 412 ptr = NULL, len = rand();
340 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo) - 1), 413 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo) - 1),
341 LISP_OPAQUE, opaque, 414 LISP_OPAQUE, opaque,
342 intern ("raw-text-mac")); 415 intern ("raw-text-mac"));
343 DFC_CHECK_DATA (XOPAQUE_DATA (opaque), XOPAQUE_SIZE (opaque), ext_mac); 416 DFC_CHECK_DATA (XOPAQUE_DATA (opaque), XOPAQUE_SIZE (opaque), ext_mac,
417 "ASCII DATA, Lisp opaque, binary/CR");
344 418
345 ptr = NULL, len = rand(); 419 ptr = NULL, len = rand();
346 TO_EXTERNAL_FORMAT (LISP_STRING, string_foo, 420 TO_EXTERNAL_FORMAT (LISP_STRING, string_foo,
347 ALLOCA, (ptr, len), 421 ALLOCA, (ptr, len),
348 intern ("raw-text-dos")); 422 intern ("raw-text-dos"));
349 DFC_CHECK_DATA (ptr, len, ext_dos); 423 DFC_CHECK_DATA (ptr, len, ext_dos, "ASCII Lisp string, ALLOCA, binary/CRLF");
350 424
351 ptr = NULL, len = rand(); 425 ptr = NULL, len = rand();
352 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo) - 1), 426 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo) - 1),
353 ALLOCA, (ptr, len), 427 ALLOCA, (ptr, len),
354 intern ("raw-text-unix")); 428 intern ("raw-text-unix"));
355 DFC_CHECK_DATA (ptr, len, ext_unix); 429 DFC_CHECK_DATA (ptr, len, ext_unix, "ASCII DATA, ALLOCA, binary/LF");
356 430
357 ptr = NULL, len = rand(); 431 ptr = NULL, len = rand();
358 TO_EXTERNAL_FORMAT (LISP_STRING, string_foo, 432 TO_EXTERNAL_FORMAT (LISP_STRING, string_foo,
359 MALLOC, (ptr, len), 433 MALLOC, (ptr, len),
360 intern ("no-conversion-mac")); 434 intern ("no-conversion-mac"));
361 DFC_CHECK_DATA (ptr, len, ext_mac); 435 DFC_CHECK_DATA (ptr, len, ext_mac, "ASCII Lisp string, MALLOC, binary/CR");
362 xfree (ptr, void *); 436 xfree (ptr, void *);
363 437
364 ptr = NULL, len = rand(); 438 ptr = NULL, len = rand();
365 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo) - 1), 439 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo) - 1),
366 ALLOCA, (ptr, len), 440 ALLOCA, (ptr, len),
367 intern ("no-conversion-dos")); 441 intern ("no-conversion-dos"));
368 DFC_CHECK_DATA (ptr, len, ext_dos); 442 DFC_CHECK_DATA (ptr, len, ext_dos, "ASCII DATA, ALLOCA, binary/CRLF");
369 443
370 ptr = NULL, len = rand(); 444 ptr = NULL, len = rand();
371 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo)), 445 TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo)),
372 ALLOCA, (ptr, len), 446 ALLOCA, (ptr, len),
373 intern ("no-conversion-unix")); 447 intern ("no-conversion-unix"));
374 DFC_CHECK_DATA_NUL (ptr, len, ext_unix); 448 DFC_CHECK_DATA_NUL (ptr, len, ext_unix, "ASCII DATA, ALLOCA, binary/LF/NUL");
375 449
376 /* Oh, Lawdy, Lawdy, Lawdy, this done broke mah heart! 450 /* Oh, Lawdy, Lawdy, Lawdy, this done broke mah heart!
377 451
378 I tried using the technique 452 I tried using the technique
379 453
399 Lisp_Object cs_to_use = Fget_coding_system (intern ("undecided-unix")); 473 Lisp_Object cs_to_use = Fget_coding_system (intern ("undecided-unix"));
400 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_dos, 474 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_dos,
401 LISP_BUFFER, Fcurrent_buffer(), 475 LISP_BUFFER, Fcurrent_buffer(),
402 cs_to_use); 476 cs_to_use);
403 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)), 477 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)),
404 sizeof (ext_dos) - 1, ext_dos); 478 sizeof (ext_dos) - 1, ext_dos,
479 "DOS Lisp opaque, Lisp buffer, undecided-unix");
405 480
406 /* Check eol autodetection works when enabled -- honest. */ 481 /* Check eol autodetection works when enabled -- honest. */
407 cs_to_use = 482 cs_to_use =
408 Fget_coding_system (call2 483 Fget_coding_system (call2
409 (intern ("coding-system-change-eol-conversion"), 484 (intern ("coding-system-change-eol-conversion"),
411 XCODING_SYSTEM_EOL_TYPE (cs_to_use) = EOL_AUTODETECT; 486 XCODING_SYSTEM_EOL_TYPE (cs_to_use) = EOL_AUTODETECT;
412 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_dos, 487 TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_dos,
413 LISP_BUFFER, Fcurrent_buffer(), 488 LISP_BUFFER, Fcurrent_buffer(),
414 cs_to_use); 489 cs_to_use);
415 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)), 490 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)),
416 sizeof (int_foo) - 1, int_foo); 491 sizeof (int_foo) - 1, int_foo,
492 "DOS Lisp opaque, Lisp buffer, undecided");
417 /* reset to default */ 493 /* reset to default */
418 XCODING_SYSTEM_EOL_TYPE (cs_to_use) = 494 XCODING_SYSTEM_EOL_TYPE (cs_to_use) =
419 autodetect_eol_p ? EOL_AUTODETECT : EOL_LF; 495 autodetect_eol_p ? EOL_AUTODETECT : EOL_LF;
420 } 496 }
421 497
425 LISP_BUFFER, Fcurrent_buffer(), 501 LISP_BUFFER, Fcurrent_buffer(),
426 intern ("undecided")); 502 intern ("undecided"));
427 if (autodetect_eol_p) 503 if (autodetect_eol_p)
428 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, 504 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer,
429 BUF_PT (current_buffer)), 505 BUF_PT (current_buffer)),
430 sizeof (int_foo) - 1, int_foo); 506 sizeof (int_foo) - 1, int_foo,
507 "DOS Lisp opaque, Lisp buffer, autodetect eol");
431 else 508 else
432 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, 509 DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer,
433 BUF_PT (current_buffer)), 510 BUF_PT (current_buffer)),
434 sizeof (ext_dos) - 1, ext_dos); 511 sizeof (ext_dos) - 1, ext_dos,
512 "DOS Lisp opaque, Lisp buffer, no autodetect eol");
435 513
436 TO_INTERNAL_FORMAT (DATA, (ext_mac, sizeof (ext_mac) - 1), 514 TO_INTERNAL_FORMAT (DATA, (ext_mac, sizeof (ext_mac) - 1),
437 LISP_STRING, string, 515 LISP_STRING, string,
438 intern ("iso-8859-1")); 516 intern ("iso-8859-1"));
439 DFC_CHECK_DATA_COND_EOL (XSTRING_DATA (string), 517 DFC_CHECK_DATA_COND_EOL (XSTRING_DATA (string),
440 XSTRING_LENGTH (string), int_foo, ext_mac); 518 XSTRING_LENGTH (string), int_foo, ext_mac,
441 519 "Mac DATA, Lisp string, Latin-1/EOL");
442 { 520 {
443 Lisp_Object stream = 521 Lisp_Object stream =
444 make_fixed_buffer_input_stream (ext_dos, sizeof (ext_dos) - 1); 522 make_fixed_buffer_input_stream (ext_dos, sizeof (ext_dos) - 1);
445 TO_INTERNAL_FORMAT (LISP_LSTREAM, stream, 523 TO_INTERNAL_FORMAT (LISP_LSTREAM, stream,
446 LISP_STRING, string, 524 LISP_STRING, string,
447 intern ("iso-8859-1")); 525 intern ("iso-8859-1"));
448 DFC_CHECK_DATA_COND_EOL (XSTRING_DATA (string), 526 DFC_CHECK_DATA_COND_EOL (XSTRING_DATA (string),
449 XSTRING_LENGTH (string), int_foo, ext_dos); 527 XSTRING_LENGTH (string), int_foo, ext_dos,
528 "DOS lstream, Lisp string, Latin-1/EOL");
450 } 529 }
451 530
452 TO_INTERNAL_FORMAT (DATA, (ext_unix, sizeof (ext_unix) - 1), 531 TO_INTERNAL_FORMAT (DATA, (ext_unix, sizeof (ext_unix) - 1),
453 LISP_STRING, string, 532 LISP_STRING, string,
454 intern ("no-conversion")); 533 intern ("no-conversion"));
455 DFC_CHECK_DATA_COND_EOL (XSTRING_DATA (string), 534 DFC_CHECK_DATA_COND_EOL (XSTRING_DATA (string),
456 XSTRING_LENGTH (string), int_foo, ext_unix); 535 XSTRING_LENGTH (string), int_foo, ext_unix,
457 536 "Unix DATA, Lisp string, no-conversion");
458 537
459 ptr = NULL, len = rand(); 538 ptr = NULL, len = rand();
460 TO_EXTERNAL_FORMAT (LISP_OPAQUE, opaque_dos, 539 TO_EXTERNAL_FORMAT (LISP_OPAQUE, opaque_dos,
461 ALLOCA, (ptr, len), 540 ALLOCA, (ptr, len),
462 Qbinary); 541 Qbinary);
463 DFC_CHECK_DATA (ptr, len, ext_dos); 542 DFC_CHECK_DATA (ptr, len, ext_dos, "DOS Lisp opaque, ALLOCA, binary");
464 543
465 return intern ("PASS"); 544 return conversion_result;
466 } 545 }
467 546
468 547
469 /* Hash Table testing */ 548 /* Hash Table testing */
470 549
508 DEFUN ("test-hash-tables", Ftest_hash_tables, 0, 0, "", /* 587 DEFUN ("test-hash-tables", Ftest_hash_tables, 0, 0, "", /*
509 Test C interface to hash tables. 588 Test C interface to hash tables.
510 */ 589 */
511 ()) 590 ())
512 { 591 {
592 Lisp_Object hash_result = Qnil;
593
513 test_hash_tables_data data; 594 test_hash_tables_data data;
514 data.hash_table = make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, 595 data.hash_table = make_lisp_hash_table (50, HASH_TABLE_NON_WEAK,
515 HASH_TABLE_EQUAL); 596 HASH_TABLE_EQUAL);
516 597
517 Fputhash (make_int (1), make_int (2), data.hash_table); 598 Fputhash (make_int (1), make_int (2), data.hash_table);
518 Fputhash (make_int (3), make_int (4), data.hash_table); 599 Fputhash (make_int (3), make_int (4), data.hash_table);
519 600
520 data.sum = 0; 601 data.sum = 0;
521 elisp_maphash_unsafe (test_hash_tables_mapper, 602 elisp_maphash_unsafe (test_hash_tables_mapper,
522 data.hash_table, (void *) &data); 603 data.hash_table, (void *) &data);
523 assert (data.sum == 2 + 4); 604 hash_result = Fcons (list3 (build_string ("simple mapper"),
605 (data.sum == 2 + 4) ? Qt : Qnil,
606 build_string ("sum != 2 + 4")),
607 hash_result);
524 608
525 data.sum = 0; 609 data.sum = 0;
526 elisp_maphash (test_hash_tables_modifying_mapper, 610 elisp_maphash (test_hash_tables_modifying_mapper,
527 data.hash_table, (void *) &data); 611 data.hash_table, (void *) &data);
528 assert (data.sum == 2 + 4); 612 hash_result = Fcons (list3 (build_string ("modifying mapper"),
613 (data.sum == 2 + 4) ? Qt : Qnil,
614 build_string ("sum != 2 + 4")),
615 hash_result);
529 616
530 /* hash table now contains: (1, 2) (3, 4) (-1, 2*2) (-3, 2*4) */ 617 /* hash table now contains: (1, 2) (3, 4) (-1, 2*2) (-3, 2*4) */
531 618
532 data.sum = 0; 619 data.sum = 0;
533 elisp_maphash_unsafe (test_hash_tables_mapper, 620 elisp_maphash_unsafe (test_hash_tables_mapper,
534 data.hash_table, (void *) &data); 621 data.hash_table, (void *) &data);
535 assert (data.sum == 3 * (2 + 4)); 622 hash_result = Fcons (list3 (build_string ("simple mapper"),
623 (data.sum == 3 * (2 + 4)) ? Qt : Qnil,
624 build_string ("sum != 3 * (2 + 4)")),
625 hash_result);
536 626
537 /* Remove entries with negative keys, added by modifying mapper */ 627 /* Remove entries with negative keys, added by modifying mapper */
538 elisp_map_remhash (test_hash_tables_predicate, 628 elisp_map_remhash (test_hash_tables_predicate,
539 data.hash_table, 0); 629 data.hash_table, 0);
540 630
541 data.sum = 0; 631 data.sum = 0;
542 elisp_maphash_unsafe (test_hash_tables_mapper, 632 elisp_maphash_unsafe (test_hash_tables_mapper,
543 data.hash_table, (void *) &data); 633 data.hash_table, (void *) &data);
544 assert (data.sum == 2 + 4); 634 hash_result = Fcons (list3 (build_string ("remove negatives mapper"),
545 635 (data.sum == 2 + 4) ? Qt : Qnil,
546 return intern ("PASS"); 636 build_string ("sum != 2 + 4")),
637 hash_result);
638
639 return hash_result;
547 } 640 }
548 641
549 642
550 643
551 #ifdef NEW_GC 644 #ifdef NEW_GC
581 DEFVAR_LISP ("test-function-list", &Vtest_function_list /* 674 DEFVAR_LISP ("test-function-list", &Vtest_function_list /*
582 List of all test functions defined in tests.c. 675 List of all test functions defined in tests.c.
583 For use by the automated test suite. See tests/automated/c-tests. 676 For use by the automated test suite. See tests/automated/c-tests.
584 */ ); 677 */ );
585 } 678 }
679