Debian Codegraph @

utest/bxstring_test.c

raw
1 /*
2 * boxes - Command line filter to draw/remove ASCII boxes around text
3 * Copyright (c) 1999-2024 Thomas Jensen and the boxes contributors
4 *
5 * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
6 * License, version 3, as published by the Free Software Foundation.
7 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
8 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
9 * details.
10 * You should have received a copy of the GNU General Public License along with this program.
11 * If not, see <https://www.gnu.org/licenses/>.
12 *
13 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
14 */
15
16 /*
17 * Unit tests of the 'bxstring' module
18 */
19
20 #include "config.h"
21
22 #include <setjmp.h>
23 #include <stdarg.h>
24 #include <stddef.h>
25 #include <unistr.h>
26
27 #include <cmocka.h>
28 #include <string.h>
29
30 #include "boxes.h"
31 #include "bxstring.h"
32 #include "bxstring_test.h"
33 #include "global_mock.h"
34 #include "tools.h"
35 #include "unicode.h"
36 #include "utest_tools.h"
37
38
39
40 void test_ascii_simple(void **state)
41 {
42 UNUSED(state);
43
44 bxstr_t *actual = bxs_from_ascii("foo");
45
46 assert_non_null(actual);
47 assert_non_null(actual->memory);
48 assert_string_equal("foo", actual->ascii);
49 assert_int_equal(0, (int) actual->indent);
50 assert_int_equal(3, (int) actual->num_columns);
51 assert_int_equal(3, (int) actual->num_chars);
52 assert_int_equal(3, (int) actual->num_chars_visible);
53 assert_int_equal(0, (int) actual->num_chars_invisible);
54 assert_int_equal(0, (int) actual->trailing);
55 int expected_indexes[] = {0, 1, 2};
56 assert_array_equal(expected_indexes, actual->first_char, 3);
57 assert_array_equal(expected_indexes, actual->visible_char, 3);
58
59 bxs_free(actual);
60 }
61
62
63
64 void test_ascii_illegalchar(void **state)
65 {
66 UNUSED(state);
67
68 bxstr_t *actual = bxs_from_ascii("illegal \b backspace");
69
70 assert_null(actual);
71 assert_int_equal(1, collect_err_size);
72 assert_string_equal("boxes: illegal character '\b' (0x00000008) encountered in string\n", collect_err[0]);
73 }
74
75
76
77 void test_ascii_null(void **state)
78 {
79 UNUSED(state);
80
81 bxstr_t *actual = bxs_from_ascii(NULL);
82
83 assert_null(actual);
84 assert_int_equal(1, collect_err_size);
85 assert_string_equal("boxes: internal error: from_ascii() called with NULL\n", collect_err[0]);
86 }
87
88
89
90 void test_ansi_unicode_book(void **state)
91 {
92 UNUSED(state);
93
94 uint32_t *ustr32 = u32_strconv_from_arg(
95 "\x1b[38;5;203m \x1b[0m \x1b[38;5;198m x\x1b[0mxx\x1b[38;5;208m\xc3\xa4\x1b[0m\x1b[38;5;203mb\x1b[0m ",
96 "UTF-8");
97 assert_non_null(ustr32);
98 bxstr_t *actual = bxs_from_unicode(ustr32);
99
100 assert_non_null(actual);
101 assert_non_null(actual->memory);
102 assert_string_equal(" xxxxb ", actual->ascii); // 'ä' replaced by 'x'
103 assert_int_equal(4, (int) actual->indent);
104 assert_int_equal(10, (int) actual->num_columns);
105 assert_int_equal(70, (int) actual->num_chars);
106 assert_int_equal(10, (int) actual->num_chars_visible);
107 assert_int_equal(60, (int) actual->num_chars_invisible);
108 assert_int_equal(1, (int) actual->trailing);
109 int expected_firstchar_idx[] = {0, 16, 17, 18, 30, 35, 36, 37, 53, 69, 70};
110 assert_array_equal(expected_firstchar_idx, actual->first_char, 11);
111 int expected_vischar_idx[] = {11, 16, 17, 29, 30, 35, 36, 48, 64, 69, 70};
112 assert_array_equal(expected_vischar_idx, actual->visible_char, 11);
113
114 BFREE(ustr32);
115 bxs_free(actual);
116 }
117
118
119
120 void test_ansi_unicode_space_kinds(void **state)
121 {
122 UNUSED(state);
123
124 uint32_t *ustr32 = u32_strconv_from_arg("\xe2\x80\x83\xe2\x80\x82 X", /* em-space, en-space, space, x */
125 "UTF-8");
126 assert_non_null(ustr32);
127 bxstr_t *actual = bxs_from_unicode(ustr32);
128
129 assert_non_null(actual);
130 assert_non_null(actual->memory);
131 assert_string_equal(" X", actual->ascii);
132 assert_int_equal(3, (int) actual->indent);
133 assert_int_equal(4, (int) actual->num_columns);
134 assert_int_equal(4, (int) actual->num_chars);
135 assert_int_equal(4, (int) actual->num_chars_visible);
136 assert_int_equal(0, (int) actual->num_chars_invisible);
137 assert_int_equal(0, (int) actual->trailing);
138 int expected_firstchar_idx[] = {0, 1, 2, 3};
139 assert_array_equal(expected_firstchar_idx, actual->first_char, 4);
140 int expected_vischar_idx[] = {0, 1, 2, 3};
141 assert_array_equal(expected_vischar_idx, actual->visible_char, 4);
142
143 BFREE(ustr32);
144 bxs_free(actual);
145 }
146
147
148
149 void test_ansi_unicode_chinese(void **state)
150 {
151 UNUSED(state);
152
153 uint32_t *ustr32 = u32_strconv_from_arg(
154 "\xe5\x85\xac\xe7\x88\xb8\xe8\xa6\x81\xe9\x81\x93\xef\xbc\x81", /* 公爸要道! */
155 "UTF-8");
156 assert_non_null(ustr32);
157 bxstr_t *actual = bxs_from_unicode(ustr32);
158
159 assert_non_null(actual);
160 assert_non_null(actual->memory);
161 assert_string_equal("xxxxxxxxxx", actual->ascii);
162 assert_int_equal(0, (int) actual->indent);
163 assert_int_equal(10, (int) actual->num_columns);
164 assert_int_equal(5, (int) actual->num_chars);
165 assert_int_equal(5, (int) actual->num_chars_visible);
166 assert_int_equal(0, (int) actual->num_chars_invisible);
167 assert_int_equal(0, (int) actual->trailing);
168 int expected_firstchar_idx[] = {0, 1, 2, 3, 4};
169 assert_array_equal(expected_firstchar_idx, actual->first_char, 5);
170 int expected_vischar_idx[] = {0, 1, 2, 3, 4};
171 assert_array_equal(expected_vischar_idx, actual->visible_char, 5);
172
173 BFREE(ustr32);
174 bxs_free(actual);
175 }
176
177
178
179 void test_ansi_unicode_empty(void **state)
180 {
181 UNUSED(state);
182
183 uint32_t *ustr32 = u32_strconv_from_arg("", "UTF-8");
184 assert_non_null(ustr32);
185 bxstr_t *actual = bxs_from_unicode(ustr32);
186
187 assert_non_null(actual);
188 assert_non_null(actual->memory);
189 assert_string_equal("", actual->ascii);
190 assert_int_equal(0, (int) actual->indent);
191 assert_int_equal(0, (int) actual->num_columns);
192 assert_int_equal(0, (int) actual->num_chars);
193 assert_int_equal(0, (int) actual->num_chars_visible);
194 assert_int_equal(0, (int) actual->num_chars_invisible);
195 assert_int_equal(0, (int) actual->trailing);
196 int expected_firstchar_idx[] = {};
197 assert_array_equal(expected_firstchar_idx, actual->first_char, 0);
198 int expected_vischar_idx[] = {};
199 assert_array_equal(expected_vischar_idx, actual->visible_char, 0);
200
201 BFREE(ustr32);
202 bxs_free(actual);
203 }
204
205
206
207 void test_ansi_unicode_blanks(void **state)
208 {
209 UNUSED(state);
210
211 uint32_t *ustr32 = u32_strconv_from_arg(" ", "UTF-8");
212 assert_non_null(ustr32);
213 bxstr_t *actual = bxs_from_unicode(ustr32);
214
215 assert_non_null(actual);
216 assert_non_null(actual->memory);
217 assert_string_equal(" ", actual->ascii);
218 assert_int_equal(4, (int) actual->indent);
219 assert_int_equal(4, (int) actual->num_columns);
220 assert_int_equal(4, (int) actual->num_chars);
221 assert_int_equal(4, (int) actual->num_chars_visible);
222 assert_int_equal(0, (int) actual->num_chars_invisible);
223 assert_int_equal(0, (int) actual->trailing);
224 int expected_firstchar_idx[] = {0, 1, 2, 3};
225 assert_array_equal(expected_firstchar_idx, actual->first_char, 0);
226 int expected_vischar_idx[] = {0, 1, 2, 3};
227 assert_array_equal(expected_vischar_idx, actual->visible_char, 0);
228
229 BFREE(ustr32);
230 bxs_free(actual);
231 }
232
233
234
235 void test_ansi_unicode_invisible_only(void **state)
236 {
237 UNUSED(state);
238
239 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;203m\x1b[0m\x1b[38;5;198m\x1b[m", "UTF-8");
240 assert_non_null(ustr32);
241 bxstr_t *actual = bxs_from_unicode(ustr32);
242
243 assert_non_null(actual);
244 assert_non_null(actual->memory);
245 assert_string_equal("", actual->ascii);
246 assert_int_equal(0, (int) actual->indent);
247 assert_int_equal(0, (int) actual->num_columns);
248 assert_int_equal(29, (int) actual->num_chars);
249 assert_int_equal(0, (int) actual->num_chars_visible);
250 assert_int_equal(29, (int) actual->num_chars_invisible);
251 assert_int_equal(0, (int) actual->trailing);
252 int expected_firstchar_idx[] = {29};
253 assert_array_equal(expected_firstchar_idx, actual->first_char, 1);
254 int expected_vischar_idx[] = {29};
255 assert_array_equal(expected_vischar_idx, actual->visible_char, 1);
256
257 BFREE(ustr32);
258 bxs_free(actual);
259 }
260
261
262
263 void test_ansi_unicode_illegalchar(void **state)
264 {
265 UNUSED(state);
266
267 uint32_t *ustr32 = u32_strconv_from_arg("illegal \b backspace", "UTF-8");
268 assert_non_null(ustr32);
269 bxstr_t *actual = bxs_from_unicode(ustr32);
270 BFREE(ustr32);
271
272 assert_null(actual);
273 assert_int_equal(1, collect_err_size);
274 assert_string_equal("boxes: illegal character '\b' (0x00000008) encountered in string\n", collect_err[0]);
275 }
276
277
278
279 void test_ansi_unicode_tabs(void **state)
280 {
281 UNUSED(state);
282
283 uint32_t *ustr32 = u32_strconv_from_arg(" \t", "ASCII");
284 assert_non_null(ustr32);
285 bxstr_t *actual = bxs_from_unicode(ustr32);
286
287 assert_non_null(actual);
288 assert_non_null(actual->memory);
289 assert_string_equal(" ", actual->ascii); /* tab converted to space in ascii representation */
290 assert_int_equal(2, (int) actual->indent);
291 assert_int_equal(2, (int) actual->num_columns);
292 assert_int_equal(2, (int) actual->num_chars);
293 assert_int_equal(2, (int) actual->num_chars_visible);
294 assert_int_equal(0, (int) actual->num_chars_invisible);
295 assert_int_equal(0, (int) actual->trailing);
296 int expected_firstchar_idx[] = {0, 1, 2};
297 assert_array_equal(expected_firstchar_idx, actual->first_char, 3);
298 int expected_vischar_idx[] = {0, 1, 2};
299 assert_array_equal(expected_vischar_idx, actual->visible_char, 3);
300
301 BFREE(ustr32);
302 bxs_free(actual);
303 }
304
305
306
307 void test_ansi_unicode_broken_escapes(void **state)
308 {
309 UNUSED(state);
310
311 /* "\x1b[38;5;203 X" is the first escape sequence, followed by
312 * "X " (visible) and
313 * "\x1b[0m" (regular escape sequence) and
314 * "__" (visible)
315 * "\x1b[38;5;203m" (regular, invisible)
316 * "b" (visible)
317 * "\x1b[" (broken, counts as invisible, and belonging to the previous 'b')
318 */
319 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;203 XX \x1b[0m__\x1b[38;5;203mb\x1b[", "ASCII");
320 assert_non_null(ustr32);
321 bxstr_t *actual = bxs_from_unicode(ustr32);
322
323 assert_non_null(actual);
324 assert_non_null(actual->memory);
325 assert_string_equal("X __b", actual->ascii);
326 assert_int_equal(0, (int) actual->indent);
327 assert_int_equal(5, (int) actual->num_columns);
328 assert_int_equal(34, (int) actual->num_chars);
329 assert_int_equal(5, (int) actual->num_chars_visible);
330 assert_int_equal(29, (int) actual->num_chars_invisible);
331 assert_int_equal(0, (int) actual->trailing);
332 int expected_firstchar_idx[] = {0, 13, 18, 19, 20, 34};
333 assert_array_equal(expected_firstchar_idx, actual->first_char, 6);
334 int expected_vischar_idx[] = {12, 13, 18, 19, 31, 34};
335 assert_array_equal(expected_vischar_idx, actual->visible_char, 6);
336
337 BFREE(ustr32);
338 bxs_free(actual);
339 }
340
341
342
343 void test_ansi_unicode_null(void **state)
344 {
345 UNUSED(state);
346
347 bxstr_t *actual = bxs_from_unicode(NULL);
348
349 assert_null(actual);
350 assert_int_equal(1, collect_err_size);
351 assert_string_equal("boxes: internal error: bxs_from_unicode() called with NULL\n", collect_err[0]);
352 }
353
354
355
356 void test_ansi_unicode_tc183(void **state)
357 {
358 UNUSED(state);
359
360 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;43m|\x1b[39m\x1b[38;5;49m \x1b[39m X", "ASCII");
361 assert_non_null(ustr32);
362 bxstr_t *actual = bxs_from_unicode(ustr32);
363
364 assert_non_null(actual);
365 assert_non_null(actual->memory);
366 assert_string_equal("| X", actual->ascii);
367 assert_int_equal(0, (int) actual->indent);
368 assert_int_equal(7, (int) actual->num_columns);
369 assert_int_equal(37, (int) actual->num_chars);
370 assert_int_equal(7, (int) actual->num_chars_visible);
371 assert_int_equal(30, (int) actual->num_chars_invisible);
372 assert_int_equal(0, (int) actual->trailing);
373 int expected_firstchar_idx[] = {0, 16, 32, 33, 34, 35, 36, 37};
374 assert_array_equal(expected_firstchar_idx, actual->first_char, 8);
375 int expected_vischar_idx[] = {10, 26, 32, 33, 34, 35, 36, 37};
376 assert_array_equal(expected_vischar_idx, actual->visible_char, 8);
377
378 BFREE(ustr32);
379 bxs_free(actual);
380 }
381
382
383
384 void test_bxs_new_empty_string(void **state)
385 {
386 UNUSED(state);
387
388 bxstr_t *actual = bxs_new_empty_string();
389
390 assert_non_null(actual);
391 assert_non_null(actual->memory);
392 assert_int_equal(1, is_char_at(actual->memory, 0, char_nul));
393 assert_string_equal("", actual->ascii);
394 assert_int_equal(0, (int) actual->indent);
395 assert_int_equal(0, (int) actual->num_columns);
396 assert_int_equal(0, (int) actual->num_chars);
397 assert_int_equal(0, (int) actual->num_chars_visible);
398 assert_int_equal(0, (int) actual->num_chars_invisible);
399 assert_int_equal(0, (int) actual->trailing);
400 int expected_firstchar_idx[] = {0};
401 assert_array_equal(expected_firstchar_idx, actual->first_char, 1);
402 int expected_vischar_idx[] = {0};
403 assert_array_equal(expected_vischar_idx, actual->visible_char, 1);
404
405 bxs_free(actual);
406 }
407
408
409
410 void test_bxs_strdup(void **state)
411 {
412 UNUSED(state);
413
414 bxstr_t *actual = bxs_strdup(NULL);
415 assert_null(actual);
416
417 uint32_t *ustr32 = u32_strconv_from_arg(" x\x1b[38;5;203mc\x1b[0m\x1b[38;5;198mc\x1b[0mx ", "UTF-8");
418 assert_non_null(ustr32);
419 bxstr_t *bxstr = bxs_from_unicode(ustr32);
420 actual = bxs_strdup(bxstr);
421
422 assert_non_null(actual);
423 assert_non_null(actual->memory);
424 assert_string_equal(" xccx ", actual->ascii);
425 assert_int_equal(1, (int) actual->indent);
426 assert_int_equal(7, (int) actual->num_columns);
427 assert_int_equal(37, (int) actual->num_chars);
428 assert_int_equal(7, (int) actual->num_chars_visible);
429 assert_int_equal(30, (int) actual->num_chars_invisible);
430 assert_int_equal(2, (int) actual->trailing);
431 int expected_firstchar_idx[] = {0, 1, 2, 18, 34, 35, 36, 37};
432 assert_array_equal(expected_firstchar_idx, actual->first_char, 8);
433 int expected_vischar_idx[] = {0, 1, 13, 29, 34, 35, 36, 37};
434 assert_array_equal(expected_vischar_idx, actual->visible_char, 8);
435
436 BFREE(ustr32);
437 bxs_free(actual);
438 bxs_free(bxstr);
439 }
440
441
442
443 void test_bxs_cut_front(void **state)
444 {
445 UNUSED(state);
446
447 bxstr_t *actual = bxs_cut_front(NULL, 1);
448 assert_null(actual);
449
450 uint32_t *ustr32 = u32_strconv_from_arg(" x\x1b[38;5;203mx\x1b[0m\x1b[38;5;198mf\x1b[0moo", "ASCII");
451 assert_non_null(ustr32);
452 bxstr_t *input = bxs_from_unicode(ustr32);
453 actual = bxs_cut_front(input, 3);
454
455 assert_non_null(actual);
456 assert_non_null(actual->memory);
457 assert_string_equal("foo", actual->ascii);
458 assert_int_equal(0, (int) actual->indent);
459 assert_int_equal(3, (int) actual->num_columns);
460 assert_int_equal(18, (int) actual->num_chars);
461 assert_int_equal(3, (int) actual->num_chars_visible);
462 assert_int_equal(15, (int) actual->num_chars_invisible);
463 assert_int_equal(0, (int) actual->trailing);
464 int expected_firstchar_idx[] = {0, 16, 17, 18};
465 assert_array_equal(expected_firstchar_idx, actual->first_char, 4);
466 int expected_vischar_idx[] = {11, 16, 17, 18};
467 assert_array_equal(expected_vischar_idx, actual->visible_char, 4);
468 bxs_free(actual);
469
470 actual = bxs_cut_front(input, 1000);
471 assert_non_null(actual);
472 assert_non_null(actual->memory);
473 assert_string_equal("", actual->ascii);
474 assert_int_equal(0, (int) actual->indent);
475 assert_int_equal(0, (int) actual->num_columns);
476 assert_int_equal(0, (int) actual->num_chars);
477 assert_int_equal(0, (int) actual->num_chars_visible);
478 assert_int_equal(0, (int) actual->num_chars_invisible);
479 assert_int_equal(0, (int) actual->trailing);
480 bxs_free(actual);
481
482 BFREE(ustr32);
483 bxs_free(input);
484 }
485
486
487
488 void test_bxs_cut_front_zero(void **state)
489 {
490 UNUSED(state);
491
492 uint32_t *ustr32 = u32_strconv_from_arg(" x\x1b[38;5;203mx\x1b[0m\x1b[38;5;198mf\x1b[0moo", "ASCII");
493 assert_non_null(ustr32);
494 bxstr_t *input = bxs_from_unicode(ustr32);
495
496 bxstr_t *actual = actual = bxs_cut_front(input, 0);
497 assert_non_null(actual);
498 assert_non_null(actual->memory);
499 assert_string_equal(" xxfoo", actual->ascii);
500 assert_int_equal(1, (int) actual->indent);
501 assert_int_equal(6, (int) actual->num_columns);
502 assert_int_equal(36, (int) actual->num_chars);
503 assert_int_equal(6, (int) actual->num_chars_visible);
504 assert_int_equal(30, (int) actual->num_chars_invisible);
505 assert_int_equal(0, (int) actual->trailing);
506 int expected_firstchar_idx[] = {0, 1, 2, 18, 34, 35, 36};
507 assert_array_equal(expected_firstchar_idx, actual->first_char, 7);
508 int expected_vischar_idx[] = {0, 1, 13, 29, 34, 35, 36};
509 assert_array_equal(expected_vischar_idx, actual->visible_char, 7);
510
511 bxs_free(actual);
512 BFREE(ustr32);
513 bxs_free(input);
514 }
515
516
517
518 void test_bxs_first_char_ptr_errors(void **state)
519 {
520 UNUSED(state);
521
522 uint32_t *actual = bxs_first_char_ptr(NULL, 0);
523 assert_null(actual);
524
525 uint32_t *ustr32 = u32_strconv_from_arg("ab\x1b[38;5;203mc\x1b[0m\x1b[38;5;198md\x1b[0me", "ASCII");
526 assert_non_null(ustr32);
527 bxstr_t *input = bxs_from_unicode(ustr32);
528 actual = bxs_first_char_ptr(input, 1000);
529 assert_non_null(actual);
530 assert_true(u32_is_blank(actual));
531
532 bxs_free(input);
533 BFREE(ustr32);
534 }
535
536
537
538 void test_bxs_last_char_ptr(void **state)
539 {
540 UNUSED(state);
541
542 uint32_t *ustr32 = u32_strconv_from_arg("abc", "ASCII");
543 assert_non_null(ustr32);
544 bxstr_t *input = bxs_from_unicode(ustr32);
545
546 assert_null(bxs_last_char_ptr(NULL));
547
548 uint32_t *actual = bxs_last_char_ptr(input);
549 assert_true(*actual == char_nul);
550 assert_int_equal(3, actual - input->memory);
551
552 BFREE(ustr32);
553 bxs_free(input);
554 }
555
556
557
558 void test_bxs_unindent_ptr_null(void **state)
559 {
560 UNUSED(state);
561
562 uint32_t *actual = bxs_unindent_ptr(NULL);
563 assert_null(actual);
564 }
565
566
567
568 void test_bxs_trimdup_null(void **state)
569 {
570 UNUSED(state);
571
572 bxstr_t *actual = bxs_trimdup(NULL, 0, 0);
573 assert_null(actual);
574 assert_int_equal(0, collect_err_size);
575 }
576
577
578
579 void test_bxs_trimdup_invalid_startidx(void **state)
580 {
581 UNUSED(state);
582
583 bxstr_t *input = bxs_from_ascii("foo");
584 bxstr_t *actual = bxs_trimdup(input, 1000, 1000);
585
586 assert_null(actual);
587 assert_int_equal(1, collect_err_size);
588 assert_string_equal("boxes: internal error: start_idx out of bounds in bxs_trimdup()\n", collect_err[0]);
589
590 bxs_free(input);
591 }
592
593
594
595 void test_bxs_trimdup_invalid_endidx(void **state)
596 {
597 UNUSED(state);
598
599 bxstr_t *input = bxs_from_ascii("foo");
600 bxstr_t *actual = bxs_trimdup(input, 0, 1000);
601
602 assert_null(actual);
603 assert_int_equal(1, collect_err_size);
604 assert_string_equal("boxes: internal error: end_idx out of bounds in bxs_trimdup()\n", collect_err[0]);
605
606 bxs_free(input);
607 }
608
609
610
611 void test_bxs_trimdup_invalid_endidx2(void **state)
612 {
613 UNUSED(state);
614
615 bxstr_t *input = bxs_from_ascii("foo");
616 bxstr_t *actual = bxs_trimdup(input, 2, 1);
617
618 assert_null(actual);
619 assert_int_equal(1, collect_err_size);
620 assert_string_equal("boxes: internal error: end_idx before start_idx in bxs_trimdup()\n", collect_err[0]);
621
622 bxs_free(input);
623 }
624
625
626
627 void test_bxs_trimdup_normal(void **state)
628 {
629 UNUSED(state);
630
631 bxstr_t *input = bxs_from_ascii("A, foo, B");
632 bxstr_t *actual = bxs_trimdup(input, 2, 6);
633
634 assert_non_null(actual);
635 assert_string_equal("foo", actual->ascii);
636 assert_int_equal(3, actual->num_chars);
637
638 bxs_free(input);
639 bxs_free(actual);
640 }
641
642
643
644 void test_bxs_trimdup_vanish(void **state)
645 {
646 UNUSED(state);
647
648 bxstr_t *input = bxs_from_ascii("A, , B");
649 bxstr_t *actual = bxs_trimdup(input, 2, 6);
650
651 assert_non_null(actual);
652 assert_string_equal("", actual->ascii);
653 assert_int_equal(0, actual->num_chars);
654
655 bxs_free(input);
656 bxs_free(actual);
657 }
658
659
660
661 void test_bxs_trimdup_ansi(void **state)
662 {
663 UNUSED(state);
664
665 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;203m \x1b[0m \x1b[38;5;203m \x1b[0m"
666 "\x1b[38;5;203mX\x1b[0m\x1b[38;5;203mX\x1b[0m\x1b[38;5;198m \x1b[0m ", "UTF-8");
667 assert_non_null(ustr32);
668 bxstr_t *input = bxs_from_unicode(ustr32);
669 assert_int_equal(7, input->num_chars_visible);
670 assert_int_equal(3, input->indent);
671 assert_int_equal(2, input->trailing);
672
673 bxstr_t *actual = bxs_trimdup(input, 0, input->num_chars_visible);
674
675 assert_non_null(actual);
676 assert_string_equal("XX", actual->ascii);
677 assert_int_equal(32, actual->num_chars);
678 assert_int_equal(30, actual->num_chars_invisible);
679 assert_int_equal(2, actual->num_chars_visible);
680 assert_int_equal(2, actual->num_columns);
681 assert_int_equal(0, actual->indent);
682
683 BFREE(ustr32);
684 bxs_free(input);
685 bxs_free(actual);
686 }
687
688
689
690 void test_bxs_trimdup_ansi_same(void **state)
691 {
692 UNUSED(state);
693
694 uint32_t *ustr32 = u32_strconv_from_arg("X \x1b[38;5;203mX\x1b[0m\x1b[38;5;198m \x1b[0mX", "UTF-8");
695 assert_non_null(ustr32);
696 bxstr_t *input = bxs_from_unicode(ustr32);
697 assert_int_equal(5, input->num_chars_visible);
698 assert_int_equal(0, input->indent);
699 assert_int_equal(0, input->trailing);
700
701 bxstr_t *actual = bxs_trimdup(input, 0, input->num_chars_visible);
702
703 assert_non_null(actual);
704 assert_string_equal("X X X", actual->ascii);
705 assert_int_equal(input->indent, actual->indent);
706 assert_int_equal(input->num_columns, actual->num_columns);
707 assert_int_equal(input->num_chars, actual->num_chars);
708 assert_int_equal(input->num_chars_visible, actual->num_chars_visible);
709 assert_int_equal(input->num_chars_invisible, actual->num_chars_invisible);
710 assert_int_equal(input->trailing, actual->trailing);
711 assert_memory_equal(input->memory, actual->memory, input->num_chars * sizeof(ucs4_t));
712 assert_memory_equal(input->ascii, actual->ascii, input->num_columns * sizeof(char));
713 assert_memory_equal(input->first_char, actual->first_char, input->num_chars_visible * sizeof(size_t));
714 assert_memory_equal(input->visible_char, actual->visible_char, input->num_chars_visible * sizeof(size_t));
715
716 BFREE(ustr32);
717 bxs_free(input);
718 bxs_free(actual);
719 }
720
721
722
723 void test_bxs_substr_errors(void **state)
724 {
725 UNUSED(state);
726
727 uint32_t *ustr32 = u32_strconv_from_arg("ab\x1b[38;5;203mc\x1b[0m\x1b[38;5;198md\x1b[0me", "ASCII");
728 assert_non_null(ustr32);
729 bxstr_t *input = bxs_from_unicode(ustr32);
730
731 bxstr_t *actual = bxs_substr(NULL, 0, 0);
732 assert_null(actual);
733
734 actual = bxs_substr(input, 1000, input->num_chars);
735 assert_non_null(actual);
736 assert_true(bxs_is_empty(actual));
737 bxs_free(actual);
738
739 actual = bxs_substr(input, input->num_chars - 1, 1000);
740 assert_non_null(actual);
741 assert_string_equal("e", actual->ascii);
742 assert_int_equal(1, actual->num_chars);
743 bxs_free(actual);
744
745 actual = bxs_substr(input, 3, 0); /* start_idx > end_idx */
746 assert_null(actual);
747 assert_int_equal(1, collect_err_size);
748 assert_string_equal("boxes: internal error: end_idx before start_idx in bxs_substr()\n", collect_err[0]);
749
750 BFREE(ustr32);
751 bxs_free(input);
752 }
753
754
755
756 void test_bxs_strcat_empty(void **state)
757 {
758 UNUSED(state);
759
760 uint32_t *ustr32 = u32_strconv_from_arg("x", "UTF-8");
761 assert_non_null(ustr32);
762 bxstr_t *bxstr = bxs_from_unicode(ustr32);
763
764 bxstr_t *actual = bxs_strcat(NULL, ustr32);
765 assert_non_null(actual);
766 assert_string_equal("x", actual->ascii);
767 bxs_free(actual);
768
769 actual = bxs_strcat(bxstr, NULL);
770 assert_non_null(actual);
771 assert_string_equal("x", actual->ascii);
772 bxs_free(actual);
773
774 BFREE(ustr32);
775 bxs_free(bxstr);
776 }
777
778
779
780 void test_bxs_strcat_empty2(void **state)
781 {
782 UNUSED(state);
783
784 uint32_t *ustr32_x = u32_strconv_from_arg("x", "UTF-8");
785 uint32_t *ustr32_empty = u32_strconv_from_arg("", "UTF-8");
786 assert_non_null(ustr32_x);
787 assert_non_null(ustr32_empty);
788 bxstr_t *bxstr = bxs_from_unicode(ustr32_x);
789
790 bxstr_t *actual = bxs_strcat(bxstr, ustr32_empty);
791 assert_non_null(actual);
792 assert_string_equal("x", actual->ascii);
793
794 BFREE(ustr32_x);
795 BFREE(ustr32_empty);
796 bxs_free(actual);
797 bxs_free(bxstr);
798 }
799
800
801
802 void test_bxs_strcat_empty3(void **state)
803 {
804 UNUSED(state);
805
806 uint32_t *ustr32_empty = u32_strconv_from_arg("", "UTF-8");
807 uint32_t *ustr32_x = u32_strconv_from_arg("x", "UTF-8");
808 assert_non_null(ustr32_empty);
809 assert_non_null(ustr32_x);
810 bxstr_t *bxstr = bxs_from_unicode(ustr32_empty);
811
812 bxstr_t *actual = bxs_strcat(bxstr, ustr32_x);
813 assert_non_null(actual);
814 assert_string_equal("x", actual->ascii);
815
816 BFREE(ustr32_empty);
817 BFREE(ustr32_x);
818 bxs_free(actual);
819 bxs_free(bxstr);
820 }
821
822
823
824 void test_bxs_strcat(void **state)
825 {
826 UNUSED(state);
827
828 uint32_t *ustr32_1 = u32_strconv_from_arg("\x1b[38;5;203mA\x1b[0m\x1b[38;5;198mB\x1b[0m", "UTF-8");
829 uint32_t *ustr32_2 = u32_strconv_from_arg("-\x1b[38;5;203ma\x1b[0m\x1b[38;5;198mb\x1b[0m", "UTF-8");
830 assert_non_null(ustr32_1);
831 assert_non_null(ustr32_2);
832 bxstr_t *bxstr = bxs_from_unicode(ustr32_1);
833 bxstr_t *actual = bxs_strcat(bxstr, ustr32_2);
834
835 assert_non_null(actual);
836 assert_non_null(actual->memory);
837 assert_string_equal("AB-ab", actual->ascii);
838 assert_int_equal(0, (int) actual->indent);
839 assert_int_equal(5, (int) actual->num_columns);
840 assert_int_equal(65, (int) actual->num_chars);
841 assert_int_equal(5, (int) actual->num_chars_visible);
842 assert_int_equal(60, (int) actual->num_chars_invisible);
843 assert_int_equal(0, (int) actual->trailing);
844 int expected_firstchar_idx[] = {0, 16, 32, 33, 49, 65};
845 assert_array_equal(expected_firstchar_idx, actual->first_char, 6);
846 int expected_vischar_idx[] = {11, 27, 32, 44, 60, 65};
847 assert_array_equal(expected_vischar_idx, actual->visible_char, 6);
848
849 BFREE(ustr32_1);
850 BFREE(ustr32_2);
851 bxs_free(actual);
852 bxs_free(bxstr);
853 }
854
855
856
857 void test_bxs_strchr(void **state)
858 {
859 UNUSED(state);
860
861 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;203ma\x1b[0m\x1b[38;5;198mb\x1b[0m", "UTF-8");
862 assert_non_null(ustr32);
863 bxstr_t *bxstr = bxs_from_unicode(ustr32);
864
865 ucs4_t char_a = 0x00000061;
866 ucs4_t char_m = 0x0000006D;
867
868 uint32_t *found = bxs_strchr(bxstr, char_a, NULL);
869 assert_int_equal(11, found - bxstr->memory);
870
871 found = bxs_strchr(bxstr, char_m, NULL);
872 assert_null(found);
873
874 found = bxs_strchr(NULL, char_a, NULL);
875 assert_null(found);
876
877 BFREE(ustr32);
878 bxs_free(bxstr);
879 }
880
881
882
883 void test_bxs_strchr_empty(void **state)
884 {
885 UNUSED(state);
886
887 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;203m\x1b[0m", "UTF-8");
888 assert_non_null(ustr32);
889 bxstr_t *bxstr = bxs_from_unicode(ustr32);
890
891 ucs4_t char_m = 0x0000006D;
892 uint32_t *found = bxs_strchr(bxstr, char_m, NULL);
893 assert_null(found);
894
895 BFREE(ustr32);
896 bxs_free(bxstr);
897 }
898
899
900
901 void test_bxs_strchr_cursor(void **state)
902 {
903 UNUSED(state);
904
905 uint32_t *ustr32 = u32_strconv_from_arg("foo, \x1b[38;5;203mBAR\x1b[0m, \x1b[38;5;198mBAZ\x1b[0m", "UTF-8");
906 assert_non_null(ustr32);
907 bxstr_t *bxstr = bxs_from_unicode(ustr32);
908 ucs4_t char_comma = 0x0000002C; /* ',' */
909
910 int cursor = -1;
911 uint32_t *found = bxs_strchr(bxstr, char_comma, &cursor);
912 assert_non_null(found);
913 assert_int_equal(3, cursor);
914 assert_memory_equal(&char_comma, found, sizeof(ucs4_t));
915
916 found = bxs_strchr(bxstr, char_comma, &cursor);
917 assert_non_null(found);
918 assert_int_equal(8, cursor);
919 assert_memory_equal(&char_comma, found, sizeof(ucs4_t));
920
921 found = bxs_strchr(bxstr, char_comma, &cursor);
922 assert_null(found);
923 assert_int_equal(8, cursor);
924
925 BFREE(ustr32);
926 bxs_free(bxstr);
927 }
928
929
930
931 void test_bxs_trim(void **state)
932 {
933 UNUSED(state);
934
935 uint32_t *ustr32 = /* em-space */
936 u32_strconv_from_arg("\xe2\x80\x83 \x1b[38;5;203m \x1b[0mtrimmed\x1b[38;5;198m \x1b[0m ", "UTF-8");
937 bxstr_t *bxstr = bxs_from_unicode(ustr32);
938 assert_int_equal(3, (int) bxstr->indent);
939
940 bxstr_t *actual = bxs_trim(bxstr);
941
942 assert_non_null(actual);
943 assert_non_null(actual->memory);
944 assert_string_equal("trimmed", actual->ascii);
945 assert_int_equal(0, (int) actual->indent);
946 assert_int_equal(7, (int) actual->num_columns);
947 assert_int_equal(7, (int) actual->num_chars);
948 assert_int_equal(7, (int) actual->num_chars_visible);
949 assert_int_equal(0, (int) actual->num_chars_invisible);
950 assert_int_equal(0, (int) actual->trailing);
951 int expected_firstchar_idx[] = {0, 1, 2, 3, 4, 5, 6, 7};
952 assert_array_equal(expected_firstchar_idx, actual->first_char, 8);
953 int expected_vischar_idx[] = {0, 1, 2, 3, 4, 5, 6, 7};
954 assert_array_equal(expected_vischar_idx, actual->visible_char, 8);
955
956 BFREE(ustr32);
957 bxs_free(actual);
958 bxs_free(bxstr);
959 }
960
961
962
963 void test_bxs_trim_blanks(void **state)
964 {
965 UNUSED(state);
966 /* em-space */
967 uint32_t *ustr32 = u32_strconv_from_arg(" \xe2\x80\x83\x1b[38;5;203m \x1b[0m \x1b[38;5;198m \x1b[0m ", "UTF-8");
968 bxstr_t *bxstr = bxs_from_unicode(ustr32);
969 assert_int_equal(7, (int) bxstr->indent);
970 assert_int_equal(0, (int) bxstr->trailing);
971
972 bxstr_t *actual = bxs_trim(bxstr);
973
974 assert_non_null(actual);
975 assert_non_null(actual->memory);
976 assert_string_equal("", actual->ascii);
977 assert_int_equal(0, (int) actual->indent);
978 assert_int_equal(0, (int) actual->num_columns);
979 assert_int_equal(0, (int) actual->num_chars);
980 assert_int_equal(0, (int) actual->num_chars_visible);
981 assert_int_equal(0, (int) actual->num_chars_invisible);
982 assert_int_equal(0, (int) actual->trailing);
983 int expected_firstchar_idx[] = {0};
984 assert_array_equal(expected_firstchar_idx, actual->first_char, 1);
985 int expected_vischar_idx[] = {0};
986 assert_array_equal(expected_vischar_idx, actual->visible_char, 1);
987
988 BFREE(ustr32);
989 bxs_free(actual);
990 bxs_free(bxstr);
991 }
992
993
994
995 void test_bxs_trim_none(void **state)
996 {
997 UNUSED(state);
998
999 bxstr_t *actual = bxs_trim(NULL);
1000 assert_null(actual);
1001
1002 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;203mX\x1b[0mX\x1b[38;5;198mX\x1b[0mX", "ASCII");
1003 bxstr_t *bxstr = bxs_from_unicode(ustr32);
1004
1005 actual = bxs_trim(bxstr);
1006
1007 assert_non_null(actual);
1008 assert_non_null(actual->memory);
1009 assert_string_equal("XXXX", actual->ascii);
1010 assert_int_equal(0, (int) actual->indent);
1011 assert_int_equal(4, (int) actual->num_columns);
1012 assert_int_equal(34, (int) actual->num_chars);
1013 assert_int_equal(4, (int) actual->num_chars_visible);
1014 assert_int_equal(30, (int) actual->num_chars_invisible);
1015 assert_int_equal(0, (int) actual->trailing);
1016 int expected_firstchar_idx[] = {0, 16, 17, 33, 34};
1017 assert_array_equal(expected_firstchar_idx, actual->first_char, 5);
1018 int expected_vischar_idx[] = {11, 16, 28, 33, 34};
1019 assert_array_equal(expected_vischar_idx, actual->visible_char, 5);
1020
1021 BFREE(ustr32);
1022 bxs_free(actual);
1023 bxs_free(bxstr);
1024 }
1025
1026
1027
1028 void test_bxs_ltrim2(void **state)
1029 {
1030 UNUSED(state);
1031
1032 uint32_t *ustr32 = u32_strconv_from_arg("\xe2\x80\x83 \x1b[38;5;203m\xe2\x80\x82\x1b[0m X", "UTF-8");
1033 /* em-space, space, en-space, space, X */
1034 bxstr_t *bxstr = bxs_from_unicode(ustr32);
1035 uint32_t *expected = u32_strconv_from_arg("\x1b[38;5;203m\xe2\x80\x82\x1b[0m X", "UTF-8");
1036
1037 uint32_t *actual = bxs_ltrim(bxstr, 2);
1038
1039 assert_non_null(actual);
1040 assert_int_equal(0, u32_strcmp(expected, actual));
1041
1042 BFREE(ustr32);
1043 BFREE(actual);
1044 BFREE(expected);
1045 bxs_free(bxstr);
1046 }
1047
1048
1049
1050 void test_bxs_ltrim5(void **state)
1051 {
1052 UNUSED(state);
1053
1054 uint32_t *ustr32 = u32_strconv_from_arg("\xe2\x80\x83 \x1b[38;5;203m\xe2\x80\x82\x1b[0m abc", "UTF-8");
1055 /* em-space, space, en-space, space, abc */
1056 bxstr_t *bxstr = bxs_from_unicode(ustr32);
1057 uint32_t *expected = u32_strconv_from_arg("abc", "ASCII");
1058
1059 uint32_t *actual = bxs_ltrim(bxstr, 5);
1060
1061 assert_non_null(actual);
1062 assert_int_equal(0, u32_strcmp(expected, actual));
1063
1064 BFREE(ustr32);
1065 BFREE(actual);
1066 BFREE(expected);
1067 bxs_free(bxstr);
1068 }
1069
1070
1071
1072 void test_bxs_ltrim_empty(void **state)
1073 {
1074 UNUSED(state);
1075
1076 uint32_t *actual = bxs_ltrim(NULL, 2);
1077 assert_null(actual);
1078
1079 uint32_t *ustr32 = u32_strconv_from_arg("\xe2\x80\x83 \x1b[38;5;203m\xe2\x80\x82\x1b[0m X", "UTF-8");
1080 /* em-space, space, en-space, space, X */
1081 bxstr_t *bxstr = bxs_from_unicode(ustr32);
1082
1083 actual = bxs_ltrim(bxstr, 0);
1084 assert_ptr_not_equal(ustr32, actual);
1085 assert_int_equal(0, u32_strcmp(ustr32, actual));
1086
1087 BFREE(ustr32);
1088 BFREE(actual);
1089 bxs_free(bxstr);
1090 }
1091
1092
1093
1094 void test_bxs_ltrim_max(void **state)
1095 {
1096 UNUSED(state);
1097
1098 uint32_t *ustr32 = u32_strconv_from_arg("\xe2\x80\x83 \x1b[38;5;203m\xe2\x80\x82\x1b[0m ", "UTF-8");
1099 /* em-space, space, en-space, space */
1100 bxstr_t *bxstr = bxs_from_unicode(ustr32);
1101 uint32_t *expected = new_empty_string32();
1102
1103 uint32_t *actual = bxs_ltrim(bxstr, 20);
1104
1105 assert_non_null(actual);
1106 assert_int_equal(0, u32_strlen(actual));
1107 assert_int_equal(0, u32_strcmp(expected, actual));
1108
1109 BFREE(ustr32);
1110 BFREE(actual);
1111 BFREE(expected);
1112 bxs_free(bxstr);
1113 }
1114
1115
1116
1117 void test_bxs_rtrim(void **state)
1118 {
1119 UNUSED(state);
1120
1121 uint32_t *ustr32 = u32_strconv_from_arg("xx\x1b[38;5;203m \x1b[0m \x1b[38;5;198m \x1b[0m ", "UTF-8");
1122 assert_non_null(ustr32);
1123 bxstr_t *bxstr = bxs_from_unicode(ustr32);
1124 bxstr_t *actual = bxs_rtrim(bxstr);
1125
1126 assert_non_null(actual);
1127 assert_non_null(actual->memory);
1128 assert_string_equal("xx", actual->ascii);
1129 assert_int_equal(0, (int) actual->indent);
1130 assert_int_equal(2, (int) actual->num_columns);
1131 assert_int_equal(2, (int) actual->num_chars);
1132 assert_int_equal(2, (int) actual->num_chars_visible);
1133 assert_int_equal(0, (int) actual->num_chars_invisible);
1134 assert_int_equal(0, (int) actual->trailing);
1135 int expected_firstchar_idx[] = {0, 1, 2};
1136 assert_array_equal(expected_firstchar_idx, actual->first_char, 3);
1137 int expected_vischar_idx[] = {0, 1, 2};
1138 assert_array_equal(expected_vischar_idx, actual->visible_char, 3);
1139
1140 BFREE(ustr32);
1141 bxs_free(actual);
1142 bxs_free(bxstr);
1143 }
1144
1145
1146
1147 void test_bxs_rtrim_empty(void **state)
1148 {
1149 UNUSED(state);
1150
1151 bxstr_t *actual = bxs_rtrim(NULL);
1152 assert_null(actual);
1153
1154 uint32_t *ustr32 = u32_strconv_from_arg("X\x1b[38;5;203m \x1b[0mX", "UTF-8");
1155 assert_non_null(ustr32);
1156 bxstr_t *bxstr = bxs_from_unicode(ustr32);
1157 actual = bxs_rtrim(bxstr);
1158
1159 assert_non_null(actual);
1160 assert_non_null(actual->memory);
1161 assert_string_equal("X X", actual->ascii);
1162 assert_int_equal(0, (int) actual->indent);
1163 assert_int_equal(3, (int) actual->num_columns);
1164 assert_int_equal(18, (int) actual->num_chars);
1165 assert_int_equal(3, (int) actual->num_chars_visible);
1166 assert_int_equal(15, (int) actual->num_chars_invisible);
1167 assert_int_equal(0, (int) actual->trailing);
1168 int expected_firstchar_idx[] = {0, 1, 17, 18};
1169 assert_array_equal(expected_firstchar_idx, actual->first_char, 4);
1170 int expected_vischar_idx[] = {0, 12, 17, 18};
1171 assert_array_equal(expected_vischar_idx, actual->visible_char, 4);
1172
1173 BFREE(ustr32);
1174 bxs_free(actual);
1175 bxs_free(bxstr);
1176 }
1177
1178
1179
1180 void test_bxs_prepend_spaces_null(void **state)
1181 {
1182 UNUSED(state);
1183
1184 bxstr_t *actual = bxs_prepend_spaces(NULL, 2);
1185 assert_non_null(actual);
1186 assert_string_equal(" ", actual->ascii);
1187 assert_int_equal(2, (int) actual->num_chars);
1188 assert_int_equal(2, (int) actual->num_chars_visible);
1189 assert_int_equal(0, (int) actual->num_chars_invisible);
1190
1191 bxs_free(actual);
1192 }
1193
1194
1195
1196 void test_bxs_append_spaces(void **state)
1197 {
1198 UNUSED(state);
1199
1200 bxs_append_spaces(NULL, 2);
1201
1202 uint32_t *ustr32 = u32_strconv_from_arg("X\x1b[38;5;203mY\x1b[0mZ", "UTF-8");
1203 assert_non_null(ustr32);
1204 bxstr_t *bxstr = bxs_from_unicode(ustr32);
1205 bxs_append_spaces(bxstr, 0);
1206
1207 bxs_append_spaces(bxstr, 3);
1208 assert_non_null(bxstr->memory);
1209 assert_string_equal("XYZ ", bxstr->ascii);
1210 assert_int_equal(0, (int) bxstr->indent);
1211 assert_int_equal(6, (int) bxstr->num_columns);
1212 assert_int_equal(21, (int) bxstr->num_chars);
1213 assert_int_equal(6, (int) bxstr->num_chars_visible);
1214 assert_int_equal(15, (int) bxstr->num_chars_invisible);
1215 assert_int_equal(3, (int) bxstr->trailing);
1216 int expected_firstchar_idx[] = {0, 1, 17, 18, 19, 20, 21};
1217 assert_array_equal(expected_firstchar_idx, bxstr->first_char, 7);
1218 int expected_vischar_idx[] = {0, 12, 17, 18, 19, 20, 21};
1219 assert_array_equal(expected_vischar_idx, bxstr->visible_char, 7);
1220
1221 BFREE(ustr32);
1222 bxs_free(bxstr);
1223 }
1224
1225
1226
1227 void test_bxs_to_output(void **state)
1228 {
1229 UNUSED(state);
1230
1231 char *actual = bxs_to_output(NULL);
1232 assert_string_equal("NULL", actual);
1233
1234 BFREE(actual);
1235
1236 bxstr_t *bxstr = bxs_from_ascii("foobar");
1237 actual = bxs_to_output(bxstr);
1238 assert_string_equal("foobar", actual);
1239
1240 BFREE(actual);
1241 bxs_free(bxstr);
1242 }
1243
1244
1245
1246 void test_bxs_is_empty_null(void **state)
1247 {
1248 UNUSED(state);
1249
1250 int actual = bxs_is_empty(NULL);
1251 assert_int_equal(1, actual);
1252 }
1253
1254
1255
1256 void test_bxs_is_blank(void **state)
1257 {
1258 UNUSED(state);
1259
1260 assert_int_equal(1, bxs_is_blank(NULL));
1261
1262 bxstr_t *bxstr = bxs_new_empty_string();
1263 assert_int_equal(1, bxs_is_blank(bxstr));
1264 bxs_free(bxstr);
1265
1266 uint32_t *ustr32 = u32_strconv_from_arg(" \x1b[38;5;203m \x1b[0m \x1b[38;5;203m\x1b[0m", "ASCII");
1267 assert_non_null(ustr32);
1268 bxstr = bxs_from_unicode(ustr32);
1269 assert_int_equal(1, bxs_is_blank(bxstr));
1270 BFREE(ustr32);
1271 bxs_free(bxstr);
1272
1273 ustr32 = u32_strconv_from_arg("\x1b[38;5;203m\x1b[0m", "ASCII");
1274 assert_non_null(ustr32);
1275 bxstr = bxs_from_unicode(ustr32);
1276 assert_int_equal(1, bxs_is_blank(bxstr));
1277 BFREE(ustr32);
1278 bxs_free(bxstr);
1279
1280 ustr32 = u32_strconv_from_arg("x", "ASCII");
1281 assert_non_null(ustr32);
1282 bxstr = bxs_from_unicode(ustr32);
1283 assert_int_equal(0, bxs_is_blank(bxstr));
1284 BFREE(ustr32);
1285 bxs_free(bxstr);
1286 }
1287
1288
1289
1290 void test_bxs_is_visible_char(void **state)
1291 {
1292 UNUSED(state);
1293
1294 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;203mX\x1b[0m \x1b[38;5;203mY\x1b[0m", "ASCII");
1295 assert_non_null(ustr32);
1296 bxstr_t *input = bxs_from_unicode(ustr32);
1297
1298 assert_int_equal(0, bxs_is_visible_char(NULL, 4));
1299 assert_int_equal(0, bxs_is_visible_char(input, 1000));
1300 assert_int_equal(0, bxs_is_visible_char(input, 0));
1301 assert_int_equal(0, bxs_is_visible_char(input, 1));
1302 assert_int_equal(0, bxs_is_visible_char(input, 31));
1303 assert_int_equal(0, bxs_is_visible_char(input, 32));
1304 assert_int_equal(0, bxs_is_visible_char(input, 33));
1305
1306 assert_int_equal(1, bxs_is_visible_char(input, 11));
1307 assert_int_equal(1, bxs_is_visible_char(input, 16));
1308 assert_int_equal(1, bxs_is_visible_char(input, 28));
1309
1310 BFREE(ustr32);
1311 bxs_free(input);
1312 }
1313
1314
1315
1316 void test_bxs_filter_visible(void **state)
1317 {
1318 UNUSED(state);
1319
1320 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;203mX\x1b[0m \x1b[38;5;203mY\x1b[0m", "ASCII");
1321 assert_non_null(ustr32);
1322 bxstr_t *input = bxs_from_unicode(ustr32);
1323 uint32_t *expected = u32_strconv_from_arg("X Y", "ASCII");
1324
1325 uint32_t *actual = bxs_filter_visible(input);
1326 assert_int_equal(0, u32_strcmp(expected, actual));
1327
1328 actual = bxs_filter_visible(NULL);
1329 assert_null(actual);
1330
1331 BFREE(actual);
1332 BFREE(expected);
1333 BFREE(ustr32);
1334 bxs_free(input);
1335 }
1336
1337
1338
1339 void test_bxs_filter_visible_none(void **state)
1340 {
1341 UNUSED(state);
1342
1343 uint32_t *ustr32 = u32_strconv_from_arg("plain", "ASCII");
1344 assert_non_null(ustr32);
1345 bxstr_t *input = bxs_from_unicode(ustr32);
1346 uint32_t *expected = u32_strconv_from_arg("plain", "ASCII");
1347
1348 uint32_t *actual = bxs_filter_visible(input);
1349 assert_int_equal(0, u32_strcmp(expected, actual));
1350
1351 BFREE(actual);
1352 BFREE(expected);
1353 BFREE(ustr32);
1354 bxs_free(input);
1355 }
1356
1357
1358
1359 void test_bxs_strcmp(void **state)
1360 {
1361 UNUSED(state);
1362
1363 int actual = bxs_strcmp(NULL, NULL);
1364 assert_int_equal(0, actual);
1365
1366 bxstr_t *bxstr1 = bxs_from_ascii("alice");
1367 bxstr_t *bxstr2 = bxs_from_ascii("bob");
1368
1369 actual = bxs_strcmp(NULL, bxstr1);
1370 assert_int_equal(1, actual);
1371
1372 actual = bxs_strcmp(bxstr1, NULL);
1373 assert_int_equal(-1, actual);
1374
1375 actual = bxs_strcmp(bxstr1, bxstr2);
1376 assert_int_equal(-1, actual);
1377
1378 actual = bxs_strcmp(bxstr2, bxstr1);
1379 assert_int_equal(1, actual);
1380
1381 bxs_free(bxstr1);
1382 bxs_free(bxstr2);
1383 }
1384
1385
1386
1387 void test_bxs_valid_anywhere_error(void **state)
1388 {
1389 UNUSED(state);
1390
1391 size_t error_pos = 42;
1392
1393 assert_int_equal(0, bxs_valid_anywhere(NULL, NULL));
1394 assert_int_equal(0, bxs_valid_anywhere(NULL, &error_pos));
1395 assert_int_equal(0, (int) error_pos);
1396
1397 bxstr_t *bxstr = bxs_from_ascii("illegal X backspace");
1398 ucs4_t char_backspace = 0x00000008;
1399 bxstr->memory[8] = char_backspace;
1400 assert_int_equal(0, bxs_valid_anywhere(bxstr, NULL));
1401
1402 bxs_free(bxstr);
1403 }
1404
1405
1406
1407 void test_bxs_valid_in_filename_error(void **state)
1408 {
1409 UNUSED(state);
1410
1411 uint32_t *ustr32 = u32_strconv_from_arg("\x1b[38;5;203m\x1b[0m", "ASCII");
1412 bxstr_t *bxstr_no_vis = bxs_from_unicode(ustr32);
1413 BFREE(ustr32);
1414 ustr32 = u32_strconv_from_arg("\x1b[38;5;203m_VISIBLE_\x1b[0m", "ASCII");
1415 bxstr_t *bxstr_vis_invis = bxs_from_unicode(ustr32);
1416
1417 assert_int_equal(0, bxs_valid_in_filename(bxstr_no_vis, NULL));
1418 assert_int_equal(0, bxs_valid_in_filename(bxstr_vis_invis, NULL));
1419
1420 BFREE(ustr32);
1421 bxs_free(bxstr_no_vis);
1422 bxs_free(bxstr_vis_invis);
1423 }
1424
1425
1426
1427 void test_bxs_free_null(void **state)
1428 {
1429 UNUSED(state);
1430
1431 bxstr_t *bstr = (bxstr_t *) calloc(1, sizeof(bxstr_t));
1432 bstr->ascii = NULL;
1433 bstr->memory = NULL;
1434 bstr->first_char = NULL;
1435 bstr->visible_char = NULL;
1436
1437 bxs_free(bstr);
1438 bxs_free(NULL);
1439 }
1440
1441
1442
1443 void test_bxs_concat(void **state)
1444 {
1445 UNUSED(state);
1446
1447 bxstr_t *actual = bxs_concat(0);
1448 assert_non_null(actual);
1449 assert_string_equal("", actual->ascii);
1450 assert_int_equal(0, actual->num_chars);
1451
1452 uint32_t *s1 = u32_strconv_from_arg("\x1b[38;5;203mX\x1b[0m", "ASCII");
1453 uint32_t *s2 = u32_strconv_from_arg("---", "ASCII");
1454 uint32_t *s3 = u32_strconv_from_arg("ÄÖÜ\x1b[38;5;203m!\x1b[0m", "UTF-8");
1455 uint32_t *s4 = u32_strconv_from_arg(" ", "ASCII");
1456 actual = bxs_concat(5, s1, s2, s3, s4, s4);
1457
1458 assert_non_null(actual);
1459 assert_string_equal("X---xxx! ", actual->ascii);
1460 assert_int_equal(12, actual->num_chars_visible);
1461 assert_int_equal(30, actual->num_chars_invisible);
1462 assert_int_equal(42, actual->num_chars);
1463 assert_int_equal(4, actual->trailing);
1464 assert_int_equal(0, actual->indent);
1465 assert_int_equal(12, actual->num_columns);
1466
1467 BFREE(s1);
1468 BFREE(s2);
1469 BFREE(s3);
1470 BFREE(s4);
1471 bxs_free(actual);
1472 }
1473
1474
1475
1476 void test_bxs_concat_nullarg(void **state)
1477 {
1478 UNUSED(state);
1479
1480 uint32_t *s1 = u32_strconv_from_arg("\x1b[38;5;203mAB", "ASCII");
1481 uint32_t *s2 = u32_strconv_from_arg("-CD-", "ASCII");
1482 uint32_t *s3 = u32_strconv_from_arg("-EF\x1b[0m", "ASCII");
1483 bxstr_t *actual = bxs_concat(4, s1, s2, NULL, s3);
1484
1485 assert_non_null(actual);
1486 assert_string_equal("AB-CD-(NULL)-EF", actual->ascii);
1487 assert_int_equal(15, actual->num_chars_visible);
1488 assert_int_equal(15, actual->num_chars_invisible);
1489 assert_int_equal(30, actual->num_chars);
1490 assert_int_equal(0, actual->trailing);
1491 assert_int_equal(0, actual->indent);
1492 assert_int_equal(15, actual->num_columns);
1493
1494 BFREE(s1);
1495 BFREE(s2);
1496 BFREE(s3);
1497 bxs_free(actual);
1498 }
1499
1500
1501 /* vim: set cindent sw=4: */