Ne.app NeANT
The Ne.app NeANT User module of the NeANT distribution.
0.char.cpp
Go to the documentation of this file.
1
28#include <rw_char.h>
29#include <rw_printf.h>
30#include <rw_driver.h>
31
32#include <stdlib.h> // for free()
33#include <string.h> // for memset(), size_t, strlen()
34
35
37static void
38test_user_traits_char ()
39{
41 rw_info (0, 0, 0, "template class UserTraits<char>");
42
43 rw_warn (0, 0, 0, "UserTraits<char> not exercised");
44}
45
46
48static void
49test_user_traits_wchar ()
50{
52 rw_info (0, 0, 0, "template class UserTraits<wchar_t>");
53
54 rw_warn (0, 0, 0, "UserTraits<wchar_t> not exercised");
55}
56
57
59static void
60test_user_traits_user_char ()
61{
63 rw_info (0, 0, 0, "template class UserTraits<UserChar>");
64
65 const UserChar src [] = {
66 { 1, 2 }, { 0, 0 }, { 3, 4 }, { 5, 6 }, { 7, 8 }, { 0, 0 }
67 };
68
69 const size_t nsrc = sizeof src / sizeof *src;
70
71 UserChar dst [nsrc];
72
73 typedef UserTraits<UserChar> Traits;
74 typedef UserTraits<UserChar>::MemFun MemFun;
75
77 Traits::n_calls_ [MemFun::assign] = 0;
78
79 Traits::assign (dst [0], src [0]);
80 rw_assert (dst [0].f == src [0].f && dst [0].c == src [0].c, 0, __LINE__,
81 "UserTraits::assign(char_type&, const char_type&)");
82
83 rw_assert (1 == Traits::n_calls_ [MemFun::assign], 0, __LINE__,
84 "UserTraits::assign(char_type&, const char_type&)");
85
87 Traits::n_calls_ [MemFun::eq] = 0;
88
89 bool eq = Traits::eq (dst [0], src [0]);
90 rw_assert (eq, 0, __LINE__,
91 "UserTraits::eq(const char_type&, const char_type&)");
92
93 rw_assert (1 == Traits::n_calls_ [MemFun::eq], 0, __LINE__,
94 "UserTraits::eq(const char_type&, const char_type&)");
95
97 Traits::n_calls_ [MemFun::lt] = 0;
98
99 bool lt = Traits::lt (dst [0], src [0]);
100 rw_assert (!lt, 0, __LINE__,
101 "UserTraits::lt(const char_type&, const char_type&)");
102
103 rw_assert (1 == Traits::n_calls_ [MemFun::lt], 0, __LINE__,
104 "UserTraits::lt(const char_type&, const char_type&)");
105
106 lt = Traits::lt (src [0], src [1]);
107 rw_assert (eq, 0, __LINE__,
108 "UserTraits::lt(const char_type&, const char_type&)");
109
110 rw_assert (2 == Traits::n_calls_ [MemFun::lt], 0, __LINE__,
111 "UserTraits::lt(const char_type&, const char_type&)");
112
114 Traits::n_calls_ [MemFun::compare] = 0;
115
116 int compare = Traits::compare (src, src, nsrc);
117 rw_assert (0 == compare, 0, __LINE__,
118 "UserTraits::compare(const char_type*, const char_type*) "
119 "== 0, got %d", compare);
120
121 rw_assert (1 == Traits::n_calls_ [MemFun::compare], 0, __LINE__,
122 "UserTraits::compare(const char_type*, const char_type*)");
123
124 compare = Traits::compare (src, src + 1, nsrc - 1);
125 rw_assert (+1 == compare, 0, __LINE__,
126 "UserTraits::compare(const char_type*, const char_type*) "
127 "== +1, got %d", compare);
128
129 rw_assert (2 == Traits::n_calls_ [MemFun::compare], 0, __LINE__,
130 "UserTraits::compare(const char_type*, const char_type*)");
131
132 compare = Traits::compare (src + 1, src, nsrc - 1);
133 rw_assert (-1 == compare, 0, __LINE__,
134 "UserTraits::compare(const char_type*, const char_type*) "
135 "== -1, got %d", compare);
136
137 rw_assert (3 == Traits::n_calls_ [MemFun::compare], 0, __LINE__,
138 "UserTraits::compare(const char_type*, const char_type*)");
139
141 Traits::n_calls_ [MemFun::length] = 0;
142
143 size_t length = Traits::length (src);
144 rw_assert (1 == length, 0, __LINE__,
145 "UserTraits::length(const char_type*)");
146
147 rw_assert (1 == Traits::n_calls_ [MemFun::length], 0, __LINE__,
148 "UserTraits::length(const char_type*)");
149
150 length = Traits::length (src + 1);
151 rw_assert (0 == length, 0, __LINE__,
152 "UserTraits::length(const char_type*)");
153
154 rw_assert (2 == Traits::n_calls_ [MemFun::length], 0, __LINE__,
155 "UserTraits::length(const char_type*)");
156
157 length = Traits::length (src + 2);
158 rw_assert (nsrc - 3 == length, 0, __LINE__,
159 "UserTraits::length(const char_type*) == %zu, got %zu",
160 nsrc - 3, length);
161
162 rw_assert (3 == Traits::n_calls_ [MemFun::length], 0, __LINE__,
163 "UserTraits::length(const char_type*)");
164
166 Traits::n_calls_ [MemFun::find] = 0;
167
168 const UserChar *find = Traits::find (src, nsrc, src [0]);
169 rw_assert (src == find, 0, __LINE__,
170 "UserTraits::find(const char_type*, size_t, const char_type&)");
171
172 rw_assert (1 == Traits::n_calls_ [MemFun::find], 0, __LINE__,
173 "UserTraits::find(const char_type*, size_t, const char_type&)");
174
175 find = Traits::find (src, nsrc, src [1]);
176 rw_assert (src + 1 == find, 0, __LINE__,
177 "UserTraits::find(const char_type*, size_t, const char_type&)");
178
179 rw_assert (2 == Traits::n_calls_ [MemFun::find], 0, __LINE__,
180 "UserTraits::find(const char_type*, size_t, const char_type&)");
181
182 find = Traits::find (src, nsrc, src [2]);
183 rw_assert (src + 2 == find, 0, __LINE__,
184 "UserTraits::find(const char_type*, size_t, const char_type&)");
185
186 rw_assert (3 == Traits::n_calls_ [MemFun::find], 0, __LINE__,
187 "UserTraits::find(const char_type*, size_t, const char_type&)");
188
189 find = Traits::find (src + 1, nsrc - 1, src [0]);
190 rw_assert (0 == find, 0, __LINE__,
191 "UserTraits::find(const char_type*, size_t, const char_type&)");
192
193 rw_assert (4 == Traits::n_calls_ [MemFun::find], 0, __LINE__,
194 "UserTraits::find(const char_type*, size_t, const char_type&)");
195
197 Traits::n_calls_ [MemFun::copy] = 0;
198
199 const UserChar uc = { -1, 1 };
200
201 memset (dst, 0, sizeof dst);
202 dst [0] = uc;
203
204 const UserChar *copy = Traits::copy (dst, src, 0);
205 rw_assert (dst == copy, 0, __LINE__,
206 "UserTraits::copy(char_type*, const char_type*, size_t)");
207
208 rw_assert (Traits::eq (dst [0], uc), 0, __LINE__,
209 "UserTraits::copy(char_type*, const char_type*, size_t)");
210
211 rw_assert (1 == Traits::n_calls_ [MemFun::copy], 0, __LINE__,
212 "UserTraits::copy(char_type*, const char_type*, size_t)");
213
214 memset (dst, 0, sizeof dst);
215 dst [1] = uc;
216
217 copy = Traits::copy (dst, src, 1);
218
219 rw_assert (dst == copy, 0, __LINE__,
220 "UserTraits::copy(char_type*, const char_type*, size_t)");
221
222 rw_assert (Traits::eq (dst [0], src [0]) && Traits::eq (dst [1], uc),
223 0, __LINE__,
224 "UserTraits::copy(char_type*, const char_type*, size_t)");
225
226 rw_assert (2 == Traits::n_calls_ [MemFun::copy], 0, __LINE__,
227 "UserTraits::copy(char_type*, const char_type*, size_t)");
228
230 Traits::n_calls_ [MemFun::move] = 0;
231
232 memset (dst, 0, sizeof dst);
233 dst [0] = uc;
234
235 const UserChar *move = Traits::move (dst, src, 0);
236 rw_assert (dst == move, 0, __LINE__,
237 "UserTraits::move(char_type*, const char_type*, size_t)");
238
239 rw_assert (Traits::eq (dst [0], uc), 0, __LINE__,
240 "UserTraits::move(char_type*, const char_type*, size_t)");
241
242 rw_assert (1 == Traits::n_calls_ [MemFun::move], 0, __LINE__,
243 "UserTraits::move(char_type*, const char_type*, size_t)");
244
245 memset (dst, 0, sizeof dst);
246 dst [1] = uc;
247
248 move = Traits::move (dst, src, 1);
249
250 rw_assert (dst == move, 0, __LINE__,
251 "UserTraits::move(char_type*, const char_type*, size_t)");
252
253 rw_assert (Traits::eq (dst [0], src [0]) && Traits::eq (dst [1], uc),
254 0, __LINE__,
255 "UserTraits::move(char_type*, const char_type*, size_t)");
256
257 rw_assert (2 == Traits::n_calls_ [MemFun::move], 0, __LINE__,
258 "UserTraits::move(char_type*, const char_type*, size_t)");
259
260
261 memcpy (dst, src, sizeof dst);
262 move = Traits::move (dst, dst + 1, 1);
263
264 rw_assert (dst == move, 0, __LINE__,
265 "UserTraits::move(char_type*, const char_type*, size_t)");
266
267 rw_assert ( Traits::eq (dst [0], src [1])
268 && Traits::eq (dst [1], src [1]),
269 0, __LINE__,
270 "UserTraits::move(char_type*, const char_type*, size_t)");
271
272 rw_assert (3 == Traits::n_calls_ [MemFun::move], 0, __LINE__,
273 "UserTraits::move(char_type*, const char_type*, size_t)");
274
275 memcpy (dst, src, sizeof dst);
276 move = Traits::move (dst, dst + 1, 2);
277
278 rw_assert (dst == move, 0, __LINE__,
279 "UserTraits::move(char_type*, const char_type*, size_t)");
280
281 rw_assert ( Traits::eq (dst [0], src [1])
282 && Traits::eq (dst [1], src [2])
283 && Traits::eq (dst [2], src [2]),
284 0, __LINE__,
285 "UserTraits::move(char_type*, const char_type*, size_t)");
286
287 rw_assert (4 == Traits::n_calls_ [MemFun::move], 0, __LINE__,
288 "UserTraits::move(char_type*, const char_type*, size_t)");
289
290 memcpy (dst, src, sizeof dst);
291 move = Traits::move (dst + 1, dst, 1);
292
293 rw_assert (dst + 1 == move, 0, __LINE__,
294 "UserTraits::move(char_type*, const char_type*, size_t)");
295
296 rw_assert ( Traits::eq (dst [0], src [0])
297 && Traits::eq (dst [1], src [0])
298 && Traits::eq (dst [2], src [2]),
299 0, __LINE__,
300 "UserTraits::move(char_type*, const char_type*, size_t)");
301
302 rw_assert (5 == Traits::n_calls_ [MemFun::move], 0, __LINE__,
303 "UserTraits::move(char_type*, const char_type*, size_t)");
304
305 memcpy (dst, src, sizeof dst);
306 move = Traits::move (dst + 1, dst, 2);
307
308 rw_assert (dst + 1 == move, 0, __LINE__,
309 "UserTraits::move(char_type*, const char_type*, size_t)");
310
311 rw_assert ( Traits::eq (dst [0], src [0])
312 && Traits::eq (dst [1], src [0])
313 && Traits::eq (dst [2], src [1])
314 && Traits::eq (dst [3], src [3]),
315 0, __LINE__,
316 "UserTraits::move(char_type*, const char_type*, size_t)");
317
318 rw_assert (6 == Traits::n_calls_ [MemFun::move], 0, __LINE__,
319 "UserTraits::move(char_type*, const char_type*, size_t)");
320
322 Traits::n_calls_ [MemFun::assign] = 0;
323
324 memset (dst, 0, sizeof dst);
325 dst [0] = uc;
326
327 const UserChar *assign = Traits::assign (dst, 0, src [0]);
328
329 rw_assert (dst == assign, 0, __LINE__,
330 "UserTraits::assign(char_type*, size_t, const char_type&)");
331
332 rw_assert (Traits::eq (dst [0], uc), 0, __LINE__,
333 "UserTraits::assign(char_type*, size_t, const char_type&)");
334
335 rw_assert (1 == Traits::n_calls_ [MemFun::assign2], 0, __LINE__,
336 "UserTraits::assign(char_type*, size_t, const char_type&)");
337
338 memset (dst, 0, sizeof dst);
339 dst [1] = uc;
340
341 assign = Traits::assign (dst, 1, src [0]);
342 rw_assert (dst == assign, 0, __LINE__,
343 "UserTraits::assign(char_type*, size_t, const char_type&)");
344
345 rw_assert (Traits::eq (dst [0], src [0]) && Traits::eq (dst [1], uc),
346 0, __LINE__,
347 "UserTraits::assign(char_type*, size_t, const char_type&)");
348
349 rw_assert (2 == Traits::n_calls_ [MemFun::assign2], 0, __LINE__,
350 "UserTraits::assign(char_type*, size_t, const char_type&)");
351
352 memset (dst, 0, sizeof dst);
353 dst [2] = uc;
354
355 assign = Traits::assign (dst, 2, src [0]);
356 rw_assert (dst == assign, 0, __LINE__,
357 "UserTraits::assign(char_type*, size_t, const char_type&)");
358
359 rw_assert ( Traits::eq (dst [0], src [0])
360 && Traits::eq (dst [1], src [0])
361 && Traits::eq (dst [2], uc),
362 0, __LINE__,
363 "UserTraits::assign(char_type*, size_t, const char_type&)");
364
365 rw_assert (3 == Traits::n_calls_ [MemFun::assign2], 0, __LINE__,
366 "UserTraits::assign(char_type*, size_t, const char_type&)");
367
369 rw_warn (0, 0, 0, "UserTraits<UserChar>::not_eof() not exercised");
370 rw_warn (0, 0, 0, "UserTraits<UserChar>::eof() not exercised");
371 rw_warn (0, 0, 0, "UserTraits<UserChar>::to_char_type() not exercised");
372 rw_warn (0, 0, 0, "UserTraits<UserChar>::to_int_type() not exercised");
373 rw_warn (0, 0, 0, "UserTraits<UserChar>::eq_int_type() not exercised");
374}
375
376
378static void
379test_rw_widen ()
380{
382 rw_info (0, 0, 0, "rw_widen(char*, const char*, size_t)");
383
384 static const char src [] = "abcdefgh";
385 const size_t nsrc = sizeof src - 1;
386 static const char null [nsrc + 1] = "";
387 char cdst [nsrc + 1];
388
389 for (size_t i = 0; i != nsrc + 1; ++i) {
390
391 memset (cdst, 0, sizeof cdst);
392
393 const char* const ret = i < nsrc ?
394 rw_widen (cdst, src, i) : rw_widen (cdst, src);
395
396 rw_assert (cdst == ret, 0, __LINE__,
397 "rw_widen(char*, %{#s}%{?}, %zu%{;})",
398 src, i < nsrc, i);
399
400 rw_assert (0 == memcmp (cdst, src, i) && '\0' == cdst [i],
401 0, __LINE__,
402 "rw_widen(char*, %{#s}%{?}, %zu%{;}) == %{#*s}, got %{#*s}",
403 src, i < nsrc, i, int (i), src, int (i + 1), cdst);
404 }
405
406 memset (cdst, '@', sizeof cdst);
407 rw_widen (cdst, 0, sizeof cdst);
408
409 rw_assert (0 == memcmp (cdst, null, sizeof cdst), 0, __LINE__,
410 "rw_widen(char*, %{#s}, %zu) == %{#*s}, got %{#*s}",
411 0, sizeof cdst, int (sizeof cdst), null,
412 int (sizeof cdst), cdst);
413
415 rw_info (0, 0, 0, "rw_widen(wchar_t*, const char*, size_t)");
416
417#ifndef _RWSTD_NO_WCHAR_T
418
419 static const wchar_t wsrc [] = L"abcdefgh";
420 static const wchar_t wnull [nsrc + 1] = L"";
421 wchar_t wdst [nsrc + 1];
422
423 for (size_t i = 0; i != nsrc + 1; ++i) {
424
425 memset (wdst, 0, sizeof wdst);
426
427 const wchar_t* const ret = i < nsrc ?
428 rw_widen (wdst, src, i) : rw_widen (wdst, src);
429
430 rw_assert (wdst == ret, 0, __LINE__,
431 "rw_widen(wchar_t*, %{#s}%{?}, %zu%{;})",
432 src, i < nsrc, i);
433
434 rw_assert ( 0 == memcmp (wdst, wsrc, i * sizeof *wdst)
435 && '\0' == wdst [i],
436 0, __LINE__,
437 "rw_widen(wchar_t*, %{#s}%{?}, %zu%{;}) == L%{#*ls}, "
438 "got L%{#*ls}",
439 src, i < nsrc, i, int (i), wsrc, int (i + 1), wdst);
440 }
441
442 memset (wdst, '@', sizeof wdst);
443 rw_widen (wdst, 0, sizeof wdst / sizeof *wdst);
444
445 rw_assert (0 == memcmp (wdst, wnull, sizeof wdst), 0, __LINE__,
446 "rw_widen(wchar_t*, %{#s}, %zu) == %{#*s}, got L%{#*ls}",
447 0, sizeof wdst, int (sizeof wdst / sizeof *wdst), wnull,
448 int (sizeof wdst / sizeof *wdst), wdst);
449
450#else // if defined (_RWSTD_NO_WCHAR_T)
451
452 rw_note (0, 0, 0, "_RWSTD_NO_WCHAR_T #defined, wchar_t test disabled");
453
454#endif // _RWSTD_NO_WCHAR_T
455
457 rw_info (0, 0, 0, "rw_widen(UserChar*, const char*, size_t)");
458
459 static const UserChar usrc [] = {
460 { 0, 'a' }, { 0, 'b' }, { 0, 'c' }, { 0, 'd' },
461 { 0, 'e' }, { 0, 'f' }, { 0, 'g' }, { 0, 'h' },
462 { 0, '\0' }
463 };
464 static const UserChar unull [] = {
465 { 0, '\0' }, { 0, '\0' }, { 0, '\0' }, { 0, '\0' },
466 { 0, '\0' }, { 0, '\0' }, { 0, '\0' }, { 0, '\0' },
467 { 0, '\0' }
468 };
469
470 typedef UserTraits<UserChar> Traits;
471
472 UserChar udst [nsrc + 1];
473
474 for (size_t i = 0; i != nsrc + 1; ++i) {
475
476 memset (udst, 0, sizeof udst);
477
478 const UserChar* const ret = i < nsrc ?
479 rw_widen (udst, src, i) : rw_widen (udst, src);
480
481 rw_assert (udst == ret, 0, __LINE__,
482 "rw_widen(UserChar*, %{#s}%{?}, %zu%{;})",
483 src, i < nsrc, i);
484
485 rw_assert ( 0 == Traits::compare (udst, usrc, i)
486 && 0 == udst [i].f && 0 == udst [i].c,
487 0, __LINE__,
488 "rw_widen(UserChar*, %{#s}%{?}, %zu%{;})",
489 src, i < nsrc, i);
490 }
491
492 memset (udst, 1, sizeof udst);
493 rw_widen (udst, 0, sizeof udst / sizeof *udst);
494
495 rw_assert (0 == Traits::compare (udst, unull, nsrc + 1), 0, __LINE__,
496 "rw_widen(UserChar*, %{#s}, %zu)",
497 0, sizeof udst, int (sizeof udst), wnull);
498}
499
500
502static void
503test_rw_expand ()
504{
506 rw_info (0, 0, 0, "rw_expand(char*, const char*, size_t, size_t*)");
507
508#undef TEST
509#define TEST(str, expstr) \
510 do { \
511 const size_t str_size = sizeof str - 1; \
512 const size_t exp_size = sizeof expstr - 1; \
513 size_t len; \
514 char* const res = rw_expand ((char*)0, str, str_size, &len); \
515 rw_assert ( 0 == memcmp (res, expstr, exp_size) \
516 && exp_size == len, \
517 0, __LINE__, \
518 "rw_expand((char*)0, %{#*s}, %zu, ...) == " \
519 "%{#*s} (length %zu), got %{#*s} (length %zu)", \
520 int (str_size), str, str_size, \
521 int (exp_size), expstr, exp_size, \
522 int (len), res, len); \
523 delete[] res; \
524 } while (0)
525
526 TEST ("", "");
527 TEST ("\0", "\0");
528 TEST ("a", "a");
529 TEST ("a\0", "a\0");
530 TEST ("ab", "ab");
531 TEST ("abc", "abc");
532 TEST ("a\0b", "a\0b");
533 TEST ("a\0b\0c\0", "a\0b\0c\0");
534 TEST ("\0\0\0", "\0\0\0");
535
536 TEST ("\0@0", "");
537 TEST ("a@0", "");
538 TEST ("\0@1", "\0");
539 TEST ("a@1", "a");
540 TEST ("\0@2", "\0\0");
541 TEST ("a@2", "aa");
542 TEST ("a@2\0", "aa\0");
543 TEST ("a@3", "aaa");
544 TEST ("a@1b", "ab");
545 TEST ("a@2b", "aab");
546 TEST ("a@3b", "aaab");
547 TEST ("a@2\0\0", "aa\0\0");
548 TEST ("\0@2b", "\0\0b");
549 TEST ("a@3bc", "aaabc");
550 TEST ("a@3b@1c", "aaabc");
551 TEST ("a@3b@2c", "aaabbc");
552 TEST ("a@3b@2c@1", "aaabbc");
553 TEST ("a@3b@3c@2", "aaabbbcc");
554
556 rw_info (0, 0, 0, "rw_expand(wchar_t*, const char*, size_t, size_t*)");
557
558#ifndef _RWSTD_NO_WCHAR_T
559
560# undef TEST
561#define TEST(str, expstr) \
562 do { \
563 const size_t str_size = sizeof str - 1; \
564 const size_t exp_size = sizeof expstr / sizeof *expstr - 1; \
565 size_t len; \
566 wchar_t* const res = rw_expand ((wchar_t*)0, str, str_size, &len); \
567 rw_assert ( 0 == memcmp (res, expstr, exp_size * sizeof *res) \
568 && exp_size == len, \
569 0, __LINE__, \
570 "rw_expand((wchar_t*)0, %{#*s}, %zu, ...) == " \
571 "%{#*ls} (length %zu), got %{#*ls} (length %zu)", \
572 int (str_size), str, str_size, \
573 int (exp_size), expstr, exp_size, \
574 int (len), res, len); \
575 delete[] res; \
576 } while (0)
577
578 TEST ("", L"");
579 TEST ("\0", L"\0");
580 TEST ("a", L"a");
581 TEST ("a\0", L"a\0");
582 TEST ("ab", L"ab");
583 TEST ("abc", L"abc");
584 TEST ("a\0b", L"a\0b");
585 TEST ("a\0b\0c\0", L"a\0b\0c\0");
586 TEST ("\0\0\0", L"\0\0\0");
587
588 TEST ("\0@0", L"");
589 TEST ("a@0", L"");
590 TEST ("\0@1", L"\0");
591 TEST ("a@1", L"a");
592 TEST ("\0@2", L"\0\0");
593 TEST ("a@2", L"aa");
594 TEST ("a@2\0", L"aa\0");
595 TEST ("\0@2a", L"\0\0a");
596 TEST ("a@3", L"aaa");
597 TEST ("a@1b", L"ab");
598 TEST ("a@2b", L"aab");
599 TEST ("a@3b", L"aaab");
600 TEST ("a@2\0\0", L"aa\0\0");
601 TEST ("\0@2b", L"\0\0b");
602 TEST ("a@3bc", L"aaabc");
603 TEST ("a@3b@1c", L"aaabc");
604 TEST ("a@3b@2c", L"aaabbc");
605 TEST ("a@3b@2c@1", L"aaabbc");
606 TEST ("a@3b@3c@2", L"aaabbbcc");
607
608#else // if defined (_RWSTD_NO_WCHAR_T)
609
610 rw_note (0, 0, 0, "_RWSTD_NO_WCHAR_T #defined, wchar_t test disabled");
611
612#endif // _RWSTD_NO_WCHAR_T
613
615 rw_info (0, 0, 0, "rw_expand(UserChar*, const char*, size_t, size_t*)");
616
617 rw_warn (0, 0, 0, "rw_expand(UserChar*, const char*, size_t, size_t*) "
618 "not exercised");
619}
620
621
622
624static void
625test_rw_narrow ()
626{
628 rw_info (0, 0, 0, "rw_narrow(char*, const char*, size_t)");
629
630 static const char src [] = "abcdefgh";
631 const size_t nsrc = sizeof src - 1;
632 static const char null [nsrc + 1] = "";
633 char cdst [nsrc + 1];
634
635 for (size_t i = 0; i != nsrc + 1; ++i) {
636
637 memset (cdst, 0, sizeof cdst);
638
639 const char* const ret = i < nsrc ?
640 rw_narrow (cdst, src, i) : rw_narrow (cdst, src);
641
642 rw_assert (cdst == ret, 0, __LINE__,
643 "rw_narrow(char*, %{#s}%{?}, %zu%{;})",
644 src, i < nsrc, i);
645
646 rw_assert (0 == memcmp (cdst, src, i) && '\0' == cdst [i],
647 0, __LINE__,
648 "rw_narrow(char*, %{#s}%{?}, %zu%{;}) == %{#*s}, got %{#*s}",
649 src, i < nsrc, i, int (i), src, int (i + 1), cdst);
650 }
651
652 memset (cdst, '@', sizeof cdst);
653 rw_narrow (cdst, (const char*)0, sizeof cdst);
654
655 rw_assert (0 == memcmp (cdst, null, sizeof cdst), 0, __LINE__,
656 "rw_narrow(char*, %{#s}, %zu) == %{#*s}, got %{#*s}",
657 0, sizeof cdst, int (sizeof cdst), null,
658 int (sizeof cdst), cdst);
659
661 rw_info (0, 0, 0, "rw_narrow(wchar_t*, const wchar_t*, size_t)");
662
663#ifndef _RWSTD_NO_WCHAR_T
664
665 static const wchar_t wsrc [] = L"abcdefgh";
666
667 for (size_t i = 0; i != nsrc + 1; ++i) {
668
669 memset (cdst, 0, sizeof cdst);
670
671 const char* const ret = i < nsrc ?
672 rw_narrow (cdst, wsrc, i) : rw_narrow (cdst, wsrc);
673
674 rw_assert (cdst == ret, 0, __LINE__,
675 "rw_narrow(char*, %{#s}%{?}, %zu%{;})",
676 src, i < nsrc, i);
677
678 rw_assert (0 == memcmp (cdst, src, i) && '\0' == cdst [i],
679 0, __LINE__,
680 "rw_narrow(char*, L%{#*ls}%{?}, %zu%{;}) == %{#*s}, "
681 "got %{#*s}",
682 int (i), src, i < nsrc, i, int (i), wsrc,
683 int (i + 1), cdst);
684 }
685
686 memset (cdst, '@', sizeof cdst);
687 rw_narrow (cdst, (const wchar_t*)0, sizeof cdst);
688
689 rw_assert (0 == memcmp (cdst, null, nsrc + 1), 0, __LINE__,
690 "rw_narrow(char*, %{#s}, %zu) == %{#*s}, got %{#*s}",
691 0, sizeof cdst, int (sizeof null), null,
692 int (sizeof cdst), cdst);
693
694#else // if defined (_RWSTD_NO_WCHAR_T)
695
696 rw_note (0, 0, 0, "_RWSTD_NO_WCHAR_T #defined, wchar_t test disabled");
697
698#endif // _RWSTD_NO_WCHAR_T
699
701 rw_info (0, 0, 0, "rw_narrow(char*, const UserChar*, size_t)");
702
703 static const UserChar usrc [] = {
704 { 0, 'a' }, { 0, 'b' }, { 0, 'c' }, { 0, 'd' },
705 { 0, 'e' }, { 0, 'f' }, { 0, 'g' }, { 0, 'h' },
706 { 0, '\0' }
707 };
708
709 for (size_t i = 0; i != nsrc + 1; ++i) {
710
711 memset (cdst, 0, sizeof cdst);
712
713 const char* const ret = i < nsrc ?
714 rw_narrow (cdst, usrc, i) : rw_narrow (cdst, usrc);
715
716 rw_assert (cdst == ret, 0, __LINE__,
717 "rw_narrow(char*, %{#s}%{?}, %zu%{;})",
718 src, i < nsrc, i);
719
720 rw_assert (0 == memcmp (cdst, src, i) && 0 == cdst [i],
721 0, __LINE__,
722 "rw_narrow(char*, %{#s}%{?}, %zu%{;})",
723 src, i < nsrc, i);
724 }
725
726 memset (cdst, '@', sizeof cdst);
727 rw_narrow (cdst, (const UserChar*)0, sizeof cdst);
728
729 rw_assert (0 == memcmp (cdst, null, nsrc + 1), 0, __LINE__,
730 "rw_narrow(char*, %{#s}, %zu)",
731 0, sizeof cdst);
732}
733
734
736static const UserChar*
737make_user_string (const char *s, size_t len)
738{
739 static UserChar usrbuf [32];
740 memset (usrbuf, 0, sizeof usrbuf);
741
742 if (s) {
743 for (size_t i = 0; i != len; ++i) {
744
745 typedef unsigned char UChar;
746
747 usrbuf [i].f = 0;
748 usrbuf [i].c = UChar (s [i]);
749 }
750 return usrbuf;
751 }
752
753 return 0;
754}
755
756
757static void
758test_rw_match ()
759{
761 rw_info (0, 0, 0, "rw_match(char*, const char*, size_t)");
762
763 size_t result;
764
765#undef TEST
766#define TEST(s1, s2, len, expect) \
767 result = rw_match ((const char*)s1, (const char*)s2, size_t (len)); \
768 rw_assert (expect == result, \
769 0, __LINE__, \
770 "rw_match(%{#*s}, %{#*s}, %zu) == %zu, got %zu", \
771 int (sizeof s1 - 1), s1, int (sizeof s2 - 1), s2, len, \
772 expect, result)
773
774 TEST (0, 0, -1, 0);
775 TEST ("", 0, -1, 0);
776 TEST (0, "", -1, 0);
777 TEST ("", "", -1, 1);
778
779 // same as above but using the <char>@<count> directive
780 TEST ("a@0", "", -1, 1);
781 TEST ("", "b@0", -1, 1);
782 TEST ("a@0", "b@0", -1, 1);
783
784 // when invoked with NULL as the first argument returns
785 // the length of the second string with all directives
786 // expanded
787 TEST (0, "a", -1, 1);
788 TEST (0, "ab", -1, 2);
789 TEST (0, "abc", -1, 3);
790 TEST (0, "a@0", -1, 0);
791 TEST (0, "a@1", -1, 1);
792 TEST (0, "a@2", -1, 2);
793 TEST (0, "a@2b@0", -1, 2);
794 TEST (0, "a@2b@1", -1, 3);
795 TEST (0, "a@2b@2", -1, 4);
796
797 // same as above but with the arguments reversed
798 TEST ("a", 0, -1, 1);
799 TEST ("ab", 0, -1, 2);
800 TEST ("abc", 0, -1, 3);
801 TEST ("a@0", 0, -1, 0);
802 TEST ("a@1", 0, -1, 1);
803 TEST ("a@2", 0, -1, 2);
804 TEST ("a@2b@0", 0, -1, 2);
805 TEST ("a@2b@1", 0, -1, 3);
806 TEST ("a@2b@2", 0, -1, 4);
807
808 TEST ("", "a", -1, 0);
809 TEST ("a", "", -1, 0);
810 TEST ("a", "a", -1, 2);
811
812 // same as above but using the <char>@<count> directive
813 TEST ("", "a@1", -1, 0);
814 TEST ("a@1", "", -1, 0);
815 TEST ("a", "a@1", -1, 2);
816 TEST ("a@1", "a", -1, 2);
817 TEST ("a@1", "a@1", -1, 2);
818
819 TEST ("\0ab", "\0ac", 2, 2);
820 TEST ("\0@0ab", "ab", 2, 2);
821 TEST ("\0@0a\0@0b", "ab", 2, 2);
822 TEST ("\0@1ab", "\0@1ac", 2, 2);
823 TEST ("\0@1ab", "\0@1ac", 2, 2);
824 TEST ("a\0@0b", "a\0@0c", -1, 2);
825 TEST ("a\0@0b", "a\0@1c", -1, 2);
826 TEST ("a\0@1b", "a\0@0c", -1, 2);
827 TEST ("a\0@1b", "a\0@1c", -1, 2);
828
829 TEST ("a\0bc", "a\0bd", -1, 2);
830 TEST ("a\0bc", "a\0bd", 0, 0);
831 TEST ("a\0bc", "a\0bd", 1, 1);
832 TEST ("a\0bc", "a\0bd", 2, 2);
833 TEST ("a\0bc", "a\0bd", 3, 3);
834 TEST ("a\0bc", "a\0bd", 4, 3);
835
836 TEST ("aaaaa", "a@5", -1, 6);
837 TEST ("aaaaaa@0", "a@5", -1, 6);
838 TEST ("aaaaa@1", "a@5", -1, 6);
839 TEST ("aaaa@2", "a@5", -1, 6);
840 TEST ("aaa@3", "a@5", -1, 6);
841 TEST ("aa@4", "a@5", -1, 6);
842 TEST ("a@5", "a@5", -1, 6);
843 TEST ("a@4a", "a@5", -1, 6);
844 TEST ("a@3aa", "a@5", -1, 6);
845 TEST ("a@2aaa", "a@5", -1, 6);
846 TEST ("a@1aaaa", "a@5", -1, 6);
847 TEST ("a@0aaaaa", "a@5", -1, 6);
848
849 TEST ("a@0a@1a@2a@3", "a@3a@2a@1a@0", -1, 7);
850 TEST ("a@0a@1a@2a@3", "a@3a@2a@1a@0", 0, 0);
851 TEST ("a@0a@1a@2a@3", "a@3a@2a@1a@0", 1, 1);
852 TEST ("a@0a@1a@2a@3", "a@3a@2a@1a@0", 2, 2);
853 TEST ("a@0a@1a@2a@3", "a@3a@2a@1a@0", 3, 3);
854 TEST ("a@0a@1a@2a@3", "a@3a@2a@1a@0", 4, 4);
855 TEST ("a@0a@1a@2a@3", "a@3a@2a@1a@0", 5, 5);
856 TEST ("a@0a@1a@2a@3", "a@3a@2a@1a@0", 6, 6);
857 TEST ("a@0a@1a@2a@3", "a@3a@2a@1a@0", 7, 7);
858
859 TEST ("a@0\0a@1a@2\0a@3\0", "\0a@3\0a@2a@1a@0\0", 10, 10);
860 TEST ("a@0*a@1a@2\0a@3\0", "\0a@3\0a@2a@1a@0\0", 10, 0);
861 TEST ("a@0\0a@1a@2*a@3\0", "\0a@3\0a@2a@1a@0\0", 10, 4);
862 TEST ("a@0\0a@1a@2\0a@3*", "\0a@3\0a@2a@1a@0\0", 10, 8);
863 TEST ("a@11aa@12aaa@13b", "a@13aa@12aaa@11c", -1, 39);
864
865 // invalid directives
866 TEST ("a@b", "a@0a@b", -1, 4);
867 TEST ("a@b@c", "a@0a@b@c", -1, 6);
868
870 // exercise Unicode escape sequences
871 TEST ("<U0>", "", -1, 1);
872 TEST ("<U00>", "", -1, 1);
873 TEST ("<U000>", "", -1, 1);
874 TEST ("<U0000>", "", -1, 1);
875 TEST ("", "<U0>", -1, 1);
876 TEST ("", "<U00>", -1, 1);
877 TEST ("", "<U000>", -1, 1);
878 TEST ("", "<U0000>", -1, 1);
879 TEST ("<U0>", "<U0000>", -1, 1);
880 TEST ("<U00>", "<U000>", -1, 1);
881 TEST ("<U000>", "<U00>", -1, 1);
882 TEST ("<U0000>", "<U0>", -1, 1);
883
884 TEST ("<U1>", 0, -1, 1);
885 TEST ("<U1><U02>", 0, -1, 2);
886 TEST ("<U1><U02><U003>", 0, -1, 3);
887 TEST ("<U1><U02><U003><U0004>", 0, -1, 4);
888
889#if 'A' == 0x41 // ASCII
890 TEST ("<UA>", "\n", -1, 2);
891 TEST ("<U0A>", "\n", -1, 2);
892 TEST ("<U00A>", "\n", -1, 2);
893 TEST ("<U000A>", "\n", -1, 2);
894 TEST ("<U0000A>", "\n", -1, 2);
895 TEST ("<U41>", "A", -1, 2);
896 TEST ("<U41>A", "AA", -1, 3);
897 TEST ("A<U41>A", "AAA", -1, 4);
898 TEST ("A<U41>@3A", "AAAAA", -1, 6);
899
900 TEST ("<U41>@0<U42>@1<U43>@2<U44>@3", "BCCDDD", -1, 7);
901#elif 'A' == 0xC1 // EBCDIC
902 TEST ("<U25>", "\n", -1, 2);
903 TEST ("<U025>", "\n", -1, 2);
904 TEST ("<U025>", "\n", -1, 2);
905 TEST ("<U0025>", "\n", -1, 2);
906 TEST ("<UC1>", "A", -1, 2);
907 TEST ("<UC1>A", "AA", -1, 3);
908 TEST ("A<UC1>A", "AAA", -1, 4);
909 TEST ("A<UC1>@3A", "AAAAA", -1, 6);
910
911 TEST ("<UC1>@0<UC2>@1<UC3>@2<UC4>@3", "BCCDDD", -1, 7);
912#else // unknown
913 rw_warn (0, 0, "unknown character set (neither ASCII nor EBCDIC)");
914#endif
915
917 rw_info (0, 0, 0, "rw_match(char*, const wchar_t*, size_t)");
918
919#ifndef _RWSTD_NO_WCHAR_T
920
921#undef TEST
922#define TEST(s1, s2, len, expect) \
923 result = rw_match ((const char*)s1, (const wchar_t*)s2, size_t (len)); \
924 rw_assert (expect == result, \
925 0, __LINE__, \
926 "rw_match(%{#*s}, L%{#*ls}, %zu) == %zu, got %zu", \
927 int (sizeof s1 - 1), s1, \
928 int (sizeof (s2) / sizeof *(s2) - 1), s2, len, \
929 expect, result)
930
931 TEST (0, (wchar_t*)0, -1, 0);
932 TEST ("", (wchar_t*)0, -1, 0);
933 TEST (0, L"", -1, 0);
934 TEST ("", L"", -1, 1);
935
936 // same as above but using the <char>@<count> directive
937 TEST ("a@0", L"", -1, 1);
938 TEST ("", L"", -1, 1);
939 TEST ("a@0", L"", -1, 1);
940
941 // when invoked with NULL as the first argument returns
942 // the length of the second string with all directives
943 // expanded
944 TEST (0, L"a", -1, 1);
945 TEST (0, L"ab", -1, 2);
946 TEST (0, L"abc", -1, 3);
947 TEST (0, L"abcd", -1, 4);
948 TEST (0, L"abcde", -1, 5);
949 TEST (0, L"abcdef", -1, 6);
950
951 // same as above but with the arguments reversed
952 TEST ("a", (wchar_t*)0, -1, 1);
953 TEST ("ab", (wchar_t*)0, -1, 2);
954 TEST ("abc", (wchar_t*)0, -1, 3);
955 TEST ("a@0", (wchar_t*)0, -1, 0);
956 TEST ("a@1", (wchar_t*)0, -1, 1);
957 TEST ("a@2", (wchar_t*)0, -1, 2);
958 TEST ("a@2b@0", (wchar_t*)0, -1, 2);
959 TEST ("a@2b@1", (wchar_t*)0, -1, 3);
960 TEST ("a@2b@2", (wchar_t*)0, -1, 4);
961
962 TEST ("", L"a", -1, 0);
963 TEST ("a", L"", -1, 0);
964 TEST ("a", L"a", -1, 2);
965
966 // same as above but using the <char>@<count> directive
967 TEST ("a@1", L"", -1, 0);
968 TEST ("a@1", L"a", -1, 2);
969
970 TEST ("\0ab", L"\0ac", 2, 2);
971 TEST ("\0@0ab", L"ab", 2, 2);
972 TEST ("\0@0a\0@0b", L"ab", 2, 2);
973 TEST ("a\0@0b", L"a\0\0", -1, 2);
974 TEST ("a\0@1b", L"a\0\0", -1, 2);
975
976 TEST ("a\0bc", L"a\0bd", -1, 2);
977 TEST ("a\0bc", L"a\0bd", 0, 0);
978 TEST ("a\0bc", L"a\0bd", 1, 1);
979 TEST ("a\0bc", L"a\0bd", 2, 2);
980 TEST ("a\0bc", L"a\0bd", 3, 3);
981 TEST ("a\0bc", L"a\0bd", 4, 3);
982
983 TEST ("aaaaa", L"aaaaa", -1, 6);
984 TEST ("aaaaaa@0", L"aaaaa", -1, 6);
985 TEST ("aaaaa@1", L"aaaaa", -1, 6);
986 TEST ("aaaa@2", L"aaaaa", -1, 6);
987 TEST ("aaa@3", L"aaaaa", -1, 6);
988 TEST ("aa@4", L"aaaaa", -1, 6);
989 TEST ("a@5", L"aaaaa", -1, 6);
990 TEST ("a@4a", L"aaaaa", -1, 6);
991 TEST ("a@3aa", L"aaaaa", -1, 6);
992 TEST ("a@2aaa", L"aaaaa", -1, 6);
993 TEST ("a@1aaaa", L"aaaaa", -1, 6);
994 TEST ("a@0aaaaa", L"aaaaa", -1, 6);
995
996 TEST ("a@0a@1a@2a@3", L"aaaaaa", -1, 7);
997 TEST ("a@0a@1a@2a@3", L"aaaaaa", 0, 0);
998 TEST ("a@0a@1a@2a@3", L"aaaaaa", 1, 1);
999 TEST ("a@0a@1a@2a@3", L"aaaaaa", 2, 2);
1000 TEST ("a@0a@1a@2a@3", L"aaaaaa", 3, 3);
1001 TEST ("a@0a@1a@2a@3", L"aaaaaa", 4, 4);
1002 TEST ("a@0a@1a@2a@3", L"aaaaaa", 5, 5);
1003 TEST ("a@0a@1a@2a@3", L"aaaaaa", 6, 6);
1004 TEST ("a@0a@1a@2a@3", L"aaaaaa", 7, 7);
1005
1006 TEST ("a@0\0a@1a@2\0a@3\0", L"\0aaa\0aaa\0", 10, 10);
1007 TEST ("a@0*a@1a@2\0a@3\0", L"\0aaa\0aaa\0", 10, 0);
1008 TEST ("a@0\0a@1a@2*a@3\0", L"\0aaa\0aaa\0", 10, 4);
1009 TEST ("a@0\0a@1a@2\0a@3*", L"\0aaa\0aaa\0", 10, 8);
1010
1011 // invalid directives
1012 TEST ("a@b", L"a@b", -1, 4);
1013 TEST ("a@b@c", L"a@b@c", -1, 6);
1014
1015#else // if defined (_RWSTD_NO_WCHAR_T)
1016
1017 rw_note (0, 0, 0, "_RWSTD_NO_WCHAR_T #defined, wchar_t test disabled");
1018
1019#endif // _RWSTD_NO_WCHAR_T
1020
1022 rw_info (0, 0, 0, "rw_match(char*, const UserChar*, size_t)");
1023
1024#undef TEST
1025#define TEST(s1, s2, len, expect) \
1026 result = rw_match ((const char*)s1, \
1027 make_user_string (s2, sizeof (s2)), size_t (len)); \
1028 rw_assert (expect == result, \
1029 0, __LINE__, \
1030 "rw_match(%{#*s}, %{#*s}, %zu) == %zu, got %zu", \
1031 int (sizeof s1 - 1), s1, int (sizeof s2 - 1), s2, len, \
1032 expect, result)
1033
1034 TEST (0, 0, -1, 0);
1035 TEST ("", 0, -1, 0);
1036 TEST (0, "", -1, 0);
1037 TEST ("", "", -1, 1);
1038
1039 // same as above but using the <char>@<count> directive
1040 TEST ("a@0", "", -1, 1);
1041 TEST ("", "", -1, 1);
1042 TEST ("a@0", "", -1, 1);
1043
1044 // when invoked with NULL as the first string returns
1045 // the length of the second string (if non-NULL)
1046 TEST (0, "a", -1, 1);
1047 TEST (0, "ab", -1, 2);
1048 TEST (0, "abc", -1, 3);
1049
1050 // same as above but with the arguments reversed
1051 TEST ("a", 0, -1, 1);
1052 TEST ("ab", 0, -1, 2);
1053 TEST ("abc", 0, -1, 3);
1054
1055 TEST ("", "a", -1, 0);
1056 TEST ("a", "", -1, 0);
1057 TEST ("a", "a", -1, 2);
1058
1059 // same as above but using the <char>@<count> directive
1060 TEST ("a@1", "", -1, 0);
1061 TEST ("a@1", "a", -1, 2);
1062
1063 TEST ("\0ab", "\0ac", 2, 2);
1064 TEST ("\0@0ab", "ab", 2, 2);
1065 TEST ("\0@0a\0@0b", "ab", 2, 2);
1066 TEST ("a\0@0b", "a\0\0", -1, 2);
1067 TEST ("a\0@1b", "a\0\0", -1, 2);
1068
1069 TEST ("a\0bc", "a\0bd", -1, 2);
1070 TEST ("a\0bc", "a\0bd", 0, 0);
1071 TEST ("a\0bc", "a\0bd", 1, 1);
1072 TEST ("a\0bc", "a\0bd", 2, 2);
1073 TEST ("a\0bc", "a\0bd", 3, 3);
1074 TEST ("a\0bc", "a\0bd", 4, 3);
1075
1076 TEST ("aaaaa", "aaaaa", -1, 6);
1077 TEST ("aaaaaa@0", "aaaaa", -1, 6);
1078 TEST ("aaaaa@1", "aaaaa", -1, 6);
1079 TEST ("aaaa@2", "aaaaa", -1, 6);
1080 TEST ("aaa@3", "aaaaa", -1, 6);
1081 TEST ("aa@4", "aaaaa", -1, 6);
1082 TEST ("a@5", "aaaaa", -1, 6);
1083 TEST ("a@4a", "aaaaa", -1, 6);
1084 TEST ("a@3aa", "aaaaa", -1, 6);
1085 TEST ("a@2aaa", "aaaaa", -1, 6);
1086 TEST ("a@1aaaa", "aaaaa", -1, 6);
1087 TEST ("a@0aaaaa", "aaaaa", -1, 6);
1088
1089 TEST ("a@0a@1a@2a@3", "aaaaaa", -1, 7);
1090 TEST ("a@0a@1a@2a@3", "aaaaaa", 0, 0);
1091 TEST ("a@0a@1a@2a@3", "aaaaaa", 1, 1);
1092 TEST ("a@0a@1a@2a@3", "aaaaaa", 2, 2);
1093 TEST ("a@0a@1a@2a@3", "aaaaaa", 3, 3);
1094 TEST ("a@0a@1a@2a@3", "aaaaaa", 4, 4);
1095 TEST ("a@0a@1a@2a@3", "aaaaaa", 5, 5);
1096 TEST ("a@0a@1a@2a@3", "aaaaaa", 6, 6);
1097 TEST ("a@0a@1a@2a@3", "aaaaaa", 7, 7);
1098
1099 TEST ("a@0\0a@1a@2\0a@3\0", "\0aaa\0aaa\0", 10, 10);
1100 TEST ("a@0*a@1a@2\0a@3\0", "\0aaa\0aaa\0", 10, 0);
1101 TEST ("a@0\0a@1a@2*a@3\0", "\0aaa\0aaa\0", 10, 4);
1102 TEST ("a@0\0a@1a@2\0a@3*", "\0aaa\0aaa\0", 10, 8);
1103
1104 // invalid directives
1105 TEST ("a@b", "a@b", -1, 4);
1106 TEST ("a@b@c", "a@b@c", -1, 6);
1107}
1108
1109
1111static void
1112test_formatting ()
1113{
1115 rw_info (0, 0, 0, "\"%s\": formatting directive", "%{/Gs}");
1116
1117 const int wchsize = int (sizeof (wchar_t));
1118 const int usrsize = int (sizeof (UserChar));
1119
1120 char *str;
1121
1122#undef TEST
1123#define TEST(fmt, arg0, arg1, arg2, expect_str) \
1124 str = rw_sprintfa (fmt, arg0, arg1, arg2); \
1125 rw_assert (str && 0 == strcmp (str, expect_str), \
1126 0, __LINE__, \
1127 "rw_printf(%#s, ...) == %#s; got %#s", \
1128 fmt, expect_str, str); \
1129 free (str)
1130
1131 TEST (">%{/Gs}<", (char*)0, 0, 0, ">(null)<");
1132 TEST (">%{/Gs}<", "", 0, 0, ">\"\"<");
1133 TEST (">%{/Gs}<", "a", 0, 0, ">\"a\"<");
1134 TEST (">%{/Gs}<", "ab", 0, 0, ">\"ab\"<");
1135 TEST (">%{/Gs}<", "abc", 0, 0, ">\"abc\"<");
1136 TEST (">%{/Gs}<", "x\0z", 0, 0, ">\"x\"<");
1137
1138 TEST (">%{/*Gs}<", 1, "abc", 0, ">\"abc\"<");
1139 TEST (">%{/*.*Gs}<", 1, 2, "abc", ">\"ab\"<");
1140 TEST (">%{/.*Gs}<", 2, "abc", 0, ">\"ab\"<");
1141 TEST (">%{/.*Gs}<", 3, "x\0z", 0, ">\"x\\0z\"<");
1142
1143 TEST (">%{/*Gs}<", wchsize, (wchar_t*)0, 0, ">(null)<");
1144 TEST (">%{/*Gs}<", wchsize, L"", 0, ">\"\"<");
1145 TEST (">%{/*Gs}<", wchsize, L"a", 0, ">\"a\"<");
1146 TEST (">%{/*Gs}<", wchsize, L"ab", 0, ">\"ab\"<");
1147 TEST (">%{/*Gs}<", wchsize, L"abc", 0, ">\"abc\"<");
1148 TEST (">%{/*Gs}<", wchsize, L"x\0z", 0, ">\"x\"<");
1149 TEST (">%{/*.*Gs}<", wchsize, 2, L"abc", ">\"ab\"<");
1150 TEST (">%{/*.*Gs}<", wchsize, 3, L"x\0z",">\"x\\0z\"<");
1151
1152#define US(s) make_user_string (s, sizeof (s))
1153
1154 TEST (">%{/*Gs}<", usrsize, (UserChar*)0, 0, ">(null)<");
1155 TEST (">%{/*Gs}<", usrsize, US (""), 0, ">\"\"<");
1156 TEST (">%{/*Gs}<", usrsize, US ("a"), 0, ">\"a\"<");
1157 TEST (">%{/*Gs}<", usrsize, US ("ab"), 0, ">\"ab\"<");
1158 TEST (">%{/*Gs}<", usrsize, US ("abc"), 0, ">\"abc\"<");
1159 TEST (">%{/*Gs}<", usrsize, US ("x\0z"), 0, ">\"x\"<");
1160 TEST (">%{/*.*Gs}<", usrsize, 2, US ("abc"), ">\"ab\"<");
1161 TEST (">%{/*.*Gs}<", usrsize, 3, US ("x\0z"), ">\"x\\0z\"<");
1162}
1163
1164
1166static int opt_user_traits;
1167static int opt_user_traits_char;
1168static int opt_user_traits_wchar;
1169static int opt_user_traits_user_char;
1170static int opt_rw_widen;
1171static int opt_rw_expand;
1172static int opt_rw_narrow;
1173static int opt_rw_match;
1174static int opt_formatting;
1175
1176
1177static int
1178run_test (int, char*[])
1179{
1180 if (opt_user_traits < 0) {
1181 rw_note (0, 0, 0, "UserTraits tests disabled");
1182 }
1183 else {
1184 if (opt_user_traits_char < 0) {
1185 rw_note (0, 0, 0, "UserTraits<char> tests disabled");
1186 }
1187 else {
1188 test_user_traits_char ();
1189 }
1190
1191 if (opt_user_traits_wchar < 0) {
1192 rw_note (0, 0, 0, "UserTraits<wchar_t> tests disabled");
1193 }
1194 else {
1195 test_user_traits_wchar ();
1196 }
1197
1198 if (opt_user_traits_user_char < 0) {
1199 rw_note (0, 0, 0, "UserTraits<UserChar> tests disabled");
1200 }
1201 else {
1202 test_user_traits_user_char ();
1203 }
1204 }
1205
1206#undef TEST
1207#define TEST(fun) \
1208 if (opt_ ## fun < 0) \
1209 rw_note (0, 0, 0, "%s() tests disabled", #fun); \
1210 else \
1211 test_ ## fun ()
1212
1213 TEST (rw_widen);
1214 TEST (rw_expand);
1215 TEST (rw_narrow);
1216 TEST (rw_match);
1217 TEST (formatting);
1218
1219 return 0;
1220}
1221
1222
1224int main (int argc, char *argv[])
1225{
1226 return rw_test (argc, argv, __FILE__,
1227 "",
1228 0,
1229 run_test,
1230 "|-UserTraits~ "
1231 "|-UserTraits<char>~ "
1232 "|-UserTraits<wchar_t>~ "
1233 "|-UserTraits<UserChar>~ "
1234 "|-rw_widen~ "
1235 "|-rw_expand~ "
1236 "|-rw_narrow~ "
1237 "|-rw_macth~ "
1238 "|-formatting~",
1239 &opt_user_traits,
1240 &opt_user_traits_char,
1241 &opt_user_traits_wchar,
1242 &opt_user_traits_user_char,
1243 &opt_rw_widen,
1244 &opt_rw_expand,
1245 &opt_rw_narrow,
1246 &opt_rw_match,
1247 &opt_formatting,
1248 0);
1249}
US
#define US(s)
TEST
#define TEST(str, expstr)
i
#define i
Definition 17.names.cpp:126
f
#define f
Definition 17.names.cpp:119
Traits
#define Traits
Definition 17.names.cpp:556
c
#define c
Definition 17.names.cpp:111
s
#define s
Definition rw_alg_test.h:221
len
#define len
Definition 17.names.cpp:488
result
volatile int result
Definition 18.limits.traps.stdcxx-624.cpp:35
nsrc
const MyBuffer< char > nsrc[]
Definition 22.locale.codecvt.mt.cpp:135
wsrc
const MyBuffer< wchar_t > wsrc[]
Definition 22.locale.codecvt.mt.cpp:149
run_test
void run_test(const ForwardIterator &dummy, T *, Predicate *pred)
Definition 25.find.first.cpp:275
main
#define main
Definition BAD_ALLOC_COPY_CTOR.cpp:32
str
const char * str
Definition exec.cpp:170
detail::value_t::null
@ null
null value
rw_char.h
rw_expand
_TEST_EXPORT char * rw_expand(char *, const char *, _RWSTD_SIZE_T=_RWSTD_SIZE_MAX, _RWSTD_SIZE_T *=0)
rw_narrow
_TEST_EXPORT char * rw_narrow(char *, const char *, _RWSTD_SIZE_T=_RWSTD_SIZE_MAX)
rw_widen
_TEST_EXPORT char * rw_widen(char *, const char *, _RWSTD_SIZE_T=_RWSTD_SIZE_MAX)
rw_match
_TEST_EXPORT _RWSTD_SIZE_T rw_match(const char *, const char *, _RWSTD_SIZE_T=_RWSTD_SIZE_MAX)
rw_driver.h
rw_test
_TEST_EXPORT int rw_test(int argc, char *argv[], const char *filename, const char *clause, const char *comment, int(*testfun)(int, char **), const char *optspec,...)
rw_info
_TEST_EXPORT int rw_info(int, const char *, int, const char *,...)
Definition driver.cpp:1681
rw_note
_TEST_EXPORT int rw_note(int, const char *, int, const char *,...)
Definition driver.cpp:1664
rw_assert
_TEST_EXPORT int rw_assert(int, const char *, int, const char *,...)
Definition driver.cpp:1630
rw_warn
_TEST_EXPORT int rw_warn(int, const char *, int, const char *,...)
Definition driver.cpp:1647
rw_printf.h
MemFun
MemFun
Definition rw_streambuf.h:41
UChar
unsigned char UChar
Definition collate.cpp:122
UserChar::c
unsigned char c
Definition rw_char.h:50
UserChar::f
long double f
Definition rw_char.h:43
Generated by doxygen 1.9.8