Line data Source code
1 : #include "test.h"
2 :
3 : static struct margs_tests args;
4 :
5 1 : TEST(args_NULL) {
6 1 : TEST_ASSERT(read_opt(0, NULL, NULL) == 0, "Not handling null arguments");
7 1 : return TEST_SUCCESS;
8 : }
9 :
10 1 : TEST(args_NULL_1) {
11 1 : TEST_ASSERT(read_opt(10, NULL, NULL) == 0, "Not handling null arguments");
12 1 : return TEST_SUCCESS;
13 : }
14 :
15 1 : TEST(args_NULL_2) {
16 1 : char *tab[] = {"test", "test2"};
17 1 : TEST_ASSERT(read_opt(0, tab, NULL) == 0, "Not handling null arguments");
18 1 : return TEST_SUCCESS;
19 : }
20 :
21 1 : TEST(args_NULL_3) {
22 1 : char *tab[] = {"test", "test2"};
23 1 : TEST_ASSERT(read_opt(10, tab, NULL) == 0, "Not handling null arguments");
24 1 : return TEST_SUCCESS;
25 : }
26 :
27 1 : TEST(args_NULL_4) {
28 1 : char *tab[] = {"test", "test2"};
29 : margs_t t;
30 :
31 1 : TEST_ASSERT(read_opt(0, tab, &t) == 0, "Not handling null arguments");
32 1 : return TEST_SUCCESS;
33 : }
34 :
35 1 : TEST(args_NULL_5) {
36 : margs_t t;
37 :
38 1 : TEST_ASSERT(read_opt(10, NULL, &t) == 0, "Not handling null arguments");
39 1 : return TEST_SUCCESS;
40 : }
41 :
42 1 : TEST(args_empty_1) {
43 : margs_t t;
44 1 : char *tab[] = {"", "", ""};
45 :
46 1 : TEST_ASSERT(read_opt(3, tab, &t) == 0, "Not handling null arguments");
47 1 : return TEST_SUCCESS;
48 : }
49 :
50 1 : TEST(args_empty_2) {
51 : margs_t t;
52 1 : char *tab[] = {NULL, NULL, NULL};
53 :
54 1 : TEST_ASSERT(read_opt(3, tab, &t) == 0, "Not handling null arguments");
55 1 : return TEST_SUCCESS;
56 : }
57 :
58 :
59 1 : TEST(args_unhandled_1) {
60 1 : margs_t opt[] = {
61 : {'z', "zoiberg", "No idea.", false, NULL},
62 : ARGS_EOL
63 : };
64 1 : char *av[] = {"./tests", "oui", "--allow"};
65 : pid_t pid;
66 : int st, fd[2];
67 :
68 1 : pipe(fd);
69 1 : fflush(stdout);
70 1 : if ((pid = fork()) == 0) {
71 :
72 1 : DUP_ALL_OUTPUTS(fd);
73 1 : TEST_ASSERT(read_opt(sizeof(av), av, opt) == 0, "Not handling properly unknown arguments");
74 : } else {
75 1 : WAIT_AND_CLOSE(pid, st, fd);
76 1 : TEST_ASSERT((WEXITSTATUS(st) == 1), "Wrong return");
77 : }
78 1 : return TEST_SUCCESS;
79 : }
80 :
81 1 : TEST(args_unhandled_2) {
82 1 : margs_t opt[] = {
83 : {'z', "zoiberg", "No idea.", false, NULL},
84 : ARGS_EOL
85 : };
86 1 : char *av[] = {"./test", "---wrong-option"};
87 : int st, fd[2];
88 : pid_t pid;
89 :
90 1 : pipe(fd);
91 1 : if ((pid = fork()) == 0) {
92 1 : DUP_ALL_OUTPUTS(fd);
93 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling triple '-' arguments");
94 1 : exit(0);
95 : } else {
96 1 : WAIT_AND_CLOSE(pid, st, fd);
97 1 : TEST_ASSERT((WEXITSTATUS(st) == 0), "Wrong return");
98 : }
99 1 : return TEST_SUCCESS;
100 : }
101 :
102 1 : TEST(args_unhandled_3) {
103 1 : margs_t opt[] = {
104 : {'z', "zoiberg", "No idea.", false, NULL},
105 : ARGS_EOL
106 : };
107 1 : char *av[] = {"./test", "-", "<-", "Single dash"};
108 : int st, fd[2];
109 : pid_t pid;
110 :
111 1 : pipe(fd);
112 1 : if ((pid = fork()) == 0) {
113 1 : DUP_ALL_OUTPUTS(fd);
114 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling alone '-' in arguments");
115 1 : exit(0);
116 : } else {
117 1 : WAIT_AND_CLOSE(pid, st, fd);
118 1 : TEST_ASSERT((WEXITSTATUS(st) == 0), "Wrong return");
119 : }
120 1 : return TEST_SUCCESS;
121 : }
122 :
123 1 : TEST(args_unhandled_4) {
124 1 : margs_t opt[] = {
125 : {'z', "zoiberg", "No idea.", false, NULL},
126 : ARGS_EOL
127 : };
128 1 : char *av[] = {"./test", "-q"};
129 : int st, fd[2];
130 : pid_t pid;
131 :
132 1 : pipe(fd);
133 1 : if ((pid = fork()) == 0) {
134 1 : DUP_ALL_OUTPUTS(fd);
135 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling unknown option");
136 0 : exit(0);
137 : } else {
138 1 : WAIT_AND_CLOSE(pid, st, fd);
139 1 : TEST_ASSERT((WEXITSTATUS(st) == 1), "Wrong return");
140 : }
141 1 : return TEST_SUCCESS;
142 : }
143 :
144 1 : TEST(args_unhandled_5) {
145 1 : margs_t opt[] = {
146 : {'z', "zoiberg", "No idea.", false, NULL},
147 : ARGS_EOL
148 : };
149 1 : char *av[] = {"./test", "--"};
150 : int st, fd[2];
151 : pid_t pid;
152 :
153 1 : pipe(fd);
154 1 : if ((pid = fork()) == 0) {
155 1 : DUP_ALL_OUTPUTS(fd);
156 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling double dash without option");
157 1 : exit(0);
158 : } else {
159 1 : WAIT_AND_CLOSE(pid, st, fd);
160 1 : TEST_ASSERT((WEXITSTATUS(st) == 0), "Wrong return");
161 : }
162 1 : return TEST_SUCCESS;
163 : }
164 :
165 1 : TEST(args_unhandled_6) {
166 1 : margs_t opt[] = {
167 : {'z', "zoiberg", "No idea.", false, NULL},
168 : ARGS_EOL
169 : };
170 1 : char *av[] = {"./test", "-"};
171 : int st, fd[2];
172 : pid_t pid;
173 :
174 1 : pipe(fd);
175 1 : if ((pid = fork()) == 0) {
176 1 : DUP_ALL_OUTPUTS(fd);
177 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling single dash without option");
178 1 : exit(1);
179 : } else {
180 1 : WAIT_AND_CLOSE(pid, st, fd);
181 1 : TEST_ASSERT((WEXITSTATUS(st) == 1), "Wrong return");
182 : }
183 1 : return TEST_SUCCESS;
184 : }
185 :
186 1 : TEST(args_help_1) {
187 1 : margs_t opt[] = {
188 : {'z', "zoiberg", "No idea.", false, NULL},
189 : ARGS_EOL
190 : };
191 1 : char *av[] = {"./test", "-h"};
192 : int st, fd[2];
193 : pid_t pid;
194 :
195 1 : pipe(fd);
196 1 : if ((pid = fork()) == 0) {
197 1 : DUP_ALL_OUTPUTS(fd);
198 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling -h arguments");
199 0 : exit(5);
200 : } else {
201 1 : WAIT_AND_CLOSE(pid, st, fd);
202 1 : TEST_ASSERT((WEXITSTATUS(st) == 0), "Wrong return");
203 : }
204 1 : return TEST_SUCCESS;
205 : }
206 :
207 1 : TEST(args_help_2) {
208 1 : margs_t opt[] = {
209 : {'z', "zoiberg", "No idea.", false, NULL},
210 : ARGS_EOL
211 : };
212 1 : char *av[] = {"./test", "--help"};
213 : int st, fd[2];
214 : pid_t pid;
215 :
216 1 : pipe(fd);
217 1 : if ((pid = fork()) == 0) {
218 1 : DUP_ALL_OUTPUTS(fd);
219 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling --help arguments");
220 0 : exit(5);
221 : } else {
222 1 : WAIT_AND_CLOSE(pid, st, fd);
223 1 : TEST_ASSERT((WEXITSTATUS(st) == 0), "Wrong return");
224 : }
225 1 : return TEST_SUCCESS;
226 : }
227 :
228 1 : TEST(args_version_1) {
229 1 : margs_t opt[] = {
230 : {'z', "zoiberg", "No idea.", false, NULL},
231 : ARGS_EOL
232 : };
233 1 : char *av[] = {"./test", "-V"};
234 : int st, fd[2];
235 : pid_t pid;
236 :
237 1 : pipe(fd);
238 1 : if ((pid = fork()) == 0) {
239 1 : DUP_ALL_OUTPUTS(fd);
240 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling --version arguments");
241 0 : exit(5);
242 : } else {
243 1 : WAIT_AND_CLOSE(pid, st, fd);
244 1 : TEST_ASSERT((WEXITSTATUS(st) == 0), "Wrong return");
245 : }
246 1 : return TEST_SUCCESS;
247 : }
248 :
249 1 : TEST(args_version_2) {
250 1 : margs_t opt[] = {
251 : {'z', "zoiberg", "No idea.", false, NULL},
252 : ARGS_EOL
253 : };
254 1 : char *av[] = {"./test", "--version"};
255 : int st, fd[2];
256 : pid_t pid;
257 :
258 1 : pipe(fd);
259 1 : if ((pid = fork()) == 0) {
260 1 : DUP_ALL_OUTPUTS(fd);
261 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling -v arguments");
262 0 : exit(5);
263 : } else {
264 1 : WAIT_AND_CLOSE(pid, st, fd);
265 1 : TEST_ASSERT((WEXITSTATUS(st) == 0), "Wrong return");
266 : }
267 1 : return TEST_SUCCESS;
268 : }
269 :
270 1 : TEST(args_base_1) {
271 1 : margs_t opt[] = OPT_DEF(false);
272 1 : char *av[] = {"./test", "-q"};
273 :
274 1 : reset_args();
275 1 : TEST_ASSERT((read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 1), "Wrong return");
276 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
277 1 : TEST_ASSERT(args.opt_w != true, "Argument not read");
278 1 : return TEST_SUCCESS;
279 : }
280 :
281 1 : TEST(args_base_2) {
282 1 : margs_t opt[] = OPT_DEF(false);
283 1 : char *av[] = {"./test", "-qw"};
284 :
285 1 : reset_args();
286 1 : TEST_ASSERT((read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 2), "Wrong return");
287 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
288 1 : TEST_ASSERT(args.opt_w == true, "Argument not read");
289 1 : TEST_ASSERT(args.opt_e != true, "Argument not read");
290 1 : return TEST_SUCCESS;
291 : }
292 :
293 1 : TEST(args_base_3) {
294 1 : margs_t opt[] = OPT_DEF(false);
295 1 : char *av[] = {"./test", "-q", "-w"};
296 :
297 1 : reset_args();
298 1 : TEST_ASSERT((read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 2), "Wrong return");
299 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
300 1 : TEST_ASSERT(args.opt_w == true, "Argument not read");
301 1 : TEST_ASSERT(args.opt_e != true, "Argument not read");
302 1 : return TEST_SUCCESS;
303 : }
304 :
305 1 : TEST(args_base_4) {
306 1 : margs_t opt[] = OPT_DEF(false);
307 1 : char *av[] = {"./test", "--qwerty", "-w"};
308 :
309 1 : reset_args();
310 1 : TEST_ASSERT((read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 2), "Wrong return");
311 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
312 1 : TEST_ASSERT(args.opt_w == true, "Argument not read");
313 1 : TEST_ASSERT(args.opt_e != true, "Argument not read");
314 1 : return TEST_SUCCESS;
315 : }
316 :
317 1 : TEST(args_base_5) {
318 1 : margs_t opt[] = OPT_DEF(false);
319 1 : char *av[] = {"./test", "--qwerty", "--wertyu"};
320 :
321 1 : reset_args();
322 1 : TEST_ASSERT((read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 2), "Wrong return");
323 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
324 1 : TEST_ASSERT(args.opt_w == true, "Argument not read");
325 1 : TEST_ASSERT(args.opt_e != true, "Argument not read");
326 1 : return TEST_SUCCESS;
327 : }
328 :
329 1 : TEST(args_base_6) {
330 1 : margs_t opt[] = OPT_DEF(false);
331 1 : char *av[] = {"./test", "-qwerty"};
332 :
333 1 : reset_args();
334 1 : TEST_ASSERT((read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 6), "Wrong return");
335 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
336 1 : TEST_ASSERT(args.opt_w == true, "Argument not read");
337 1 : TEST_ASSERT(args.opt_e == true, "Argument not read");
338 1 : TEST_ASSERT(args.opt_r == true, "Argument not read");
339 1 : TEST_ASSERT(args.opt_t == true, "Argument not read");
340 1 : TEST_ASSERT(args.opt_y == true, "Argument not read");
341 1 : return TEST_SUCCESS;
342 : }
343 :
344 1 : TEST(args_base_7) {
345 1 : margs_t opt[] = OPT_DEF(false);
346 1 : char *av[] = {"./test", "--qwerty", "--wertyu", "--ertyui", "--rtyuio", "--tyuiop", "--yuiop["};
347 :
348 1 : reset_args();
349 1 : TEST_ASSERT((read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 6), "Wrong return");
350 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
351 1 : TEST_ASSERT(args.opt_w == true, "Argument not read");
352 1 : TEST_ASSERT(args.opt_e == true, "Argument not read");
353 1 : TEST_ASSERT(args.opt_r == true, "Argument not read");
354 1 : TEST_ASSERT(args.opt_t == true, "Argument not read");
355 1 : TEST_ASSERT(args.opt_y == true, "Argument not read");
356 1 : return TEST_SUCCESS;
357 : }
358 :
359 1 : TEST(args_missing_value_1) {
360 1 : margs_t opt[] = OPT_DEF(true);
361 1 : char *av[] = {"./test", "-q"};
362 : int st, fd[2];
363 : pid_t pid;
364 :
365 1 : reset_args();
366 1 : pipe(fd);
367 1 : if ((pid = fork()) == 0) {
368 1 : DUP_ALL_OUTPUTS(fd);
369 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling missing argument");
370 0 : exit(5);
371 : } else {
372 1 : WAIT_AND_CLOSE(pid, st, fd);
373 1 : TEST_ASSERT((WEXITSTATUS(st) == 1), "Wrong return");
374 : }
375 1 : return TEST_SUCCESS;
376 : }
377 :
378 1 : TEST(args_missing_value_2) {
379 1 : margs_t opt[] = OPT_DEF(true);
380 1 : char *av[] = {"./test", "--qwerty"};
381 : int st, fd[2];
382 : pid_t pid;
383 :
384 1 : reset_args();
385 1 : pipe(fd);
386 1 : if ((pid = fork()) == 0) {
387 1 : DUP_ALL_OUTPUTS(fd);
388 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 0, "Not handling missing argument");
389 0 : exit(5);
390 : } else {
391 1 : WAIT_AND_CLOSE(pid, st, fd);
392 1 : TEST_ASSERT((WEXITSTATUS(st) == 1), "Wrong return");
393 : }
394 1 : return TEST_SUCCESS;
395 : }
396 :
397 1 : TEST(args_value_1) {
398 1 : margs_t opt[] = OPT_DEF(true);
399 1 : char *av[] = {"./test", "-q", "toto"};
400 :
401 1 : reset_args();
402 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 1, "Wrong return");
403 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
404 1 : TEST_ASSERT(strcmp(args.str_q, "toto") == 0, "Value not read");
405 1 : return TEST_SUCCESS;
406 : }
407 :
408 1 : TEST(args_value_2) {
409 1 : margs_t opt[] = OPT_DEF(true);
410 1 : char *av[] = {"./test", "--qwerty=toto"};
411 :
412 1 : reset_args();
413 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 1, "Wrong return");
414 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
415 1 : TEST_ASSERT(strcmp(args.str_q, "toto") == 0, "Value not read");
416 1 : return TEST_SUCCESS;
417 : }
418 :
419 1 : TEST(args_value_3) {
420 1 : margs_t opt[] = OPT_DEF(true);
421 1 : char *av[] = {"./test", "--qwerty=toto", "-w", "tata"};
422 :
423 1 : reset_args();
424 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 2, "Wrong return");
425 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
426 1 : TEST_ASSERT(strcmp(args.str_q, "toto") == 0, "Value not read");
427 1 : TEST_ASSERT(args.opt_w == true, "Argument not read");
428 1 : TEST_ASSERT(strcmp(args.str_w, "tata") == 0, "Value not read");
429 1 : return TEST_SUCCESS;
430 : }
431 :
432 1 : TEST(args_value_4) {
433 1 : margs_t opt[] = OPT_DEF(true);
434 1 : char *av[] = {"./test", "--qwerty=toto", "--wertyu=tata"};
435 :
436 1 : reset_args();
437 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 2, "Wrong return");
438 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
439 1 : TEST_ASSERT(strcmp(args.str_q, "toto") == 0, "Value not read");
440 1 : TEST_ASSERT(args.opt_w == true, "Argument not read");
441 1 : TEST_ASSERT(strcmp(args.str_w, "tata") == 0, "Value not read");
442 1 : return TEST_SUCCESS;
443 : }
444 :
445 1 : TEST(args_word_only_1) {
446 1 : margs_t opt[] = {
447 : {0, "qwerty", "qwerty", false, &callback_q},
448 : ARGS_EOL
449 : };
450 1 : char *av[] = {"./test", "--qwerty"};
451 :
452 1 : reset_args();
453 1 : TEST_ASSERT(read_opt(sizeof(av) / sizeof(av[0]), av, opt) == 1, "Wrong return");
454 1 : TEST_ASSERT(args.opt_q == true, "Argument not read");
455 1 : TEST_ASSERT(args.opt_w == false, "Wrong argument");
456 1 : return TEST_SUCCESS;
457 : }
458 :
459 :
460 12 : void callback_q(const char *s) {
461 12 : args.opt_q = true;
462 12 : if (s == NULL)
463 8 : strcpy(args.str_q, "");
464 : else
465 4 : strcpy(args.str_q, s);
466 12 : }
467 :
468 8 : void callback_w(const char *s) {
469 8 : args.opt_w = true;
470 8 : if (s == NULL)
471 6 : strcpy(args.str_w, "");
472 : else
473 2 : strcpy(args.str_w, s);
474 8 : }
475 :
476 2 : void callback_e(const char *s) {
477 2 : args.opt_e = true;
478 2 : if (s == NULL)
479 2 : strcpy(args.str_e, "");
480 : else
481 0 : strcpy(args.str_e, s);
482 2 : }
483 :
484 2 : void callback_r(const char *s) {
485 2 : args.opt_r = true;
486 2 : if (s == NULL)
487 2 : strcpy(args.str_r, "");
488 : else
489 0 : strcpy(args.str_r, s);
490 2 : }
491 :
492 2 : void callback_t(const char *s) {
493 2 : args.opt_t = true;
494 2 : if (s == NULL)
495 2 : strcpy(args.str_t, "");
496 : else
497 0 : strcpy(args.str_t, s);
498 2 : }
499 :
500 2 : void callback_y(const char *s) {
501 2 : args.opt_y = true;
502 2 : if (s == NULL)
503 2 : strcpy(args.str_y, "");
504 : else
505 0 : strcpy(args.str_y, s);
506 2 : }
507 :
508 14 : void reset_args(void) {
509 14 : args.opt_q = false;
510 14 : args.opt_w = false;
511 14 : args.opt_e = false;
512 14 : args.opt_r = false;
513 14 : args.opt_t = false;
514 14 : args.opt_y = false;
515 14 : strcpy(args.str_q, "");
516 14 : strcpy(args.str_w, "");
517 14 : strcpy(args.str_e, "");
518 14 : strcpy(args.str_r, "");
519 14 : strcpy(args.str_t, "");
520 14 : strcpy(args.str_y, "");
521 14 : }
522 :
523 1 : void register_args_tests(void) {
524 1 : reg_test("m_args", args_NULL);
525 1 : reg_test("m_args", args_NULL_1);
526 1 : reg_test("m_args", args_NULL_2);
527 1 : reg_test("m_args", args_NULL_3);
528 1 : reg_test("m_args", args_NULL_4);
529 1 : reg_test("m_args", args_NULL_5);
530 1 : reg_test("m_args", args_empty_1);
531 1 : reg_test("m_args", args_empty_2);
532 1 : reg_test("m_args", args_unhandled_1);
533 1 : reg_test("m_args", args_unhandled_2);
534 1 : reg_test("m_args", args_unhandled_3);
535 1 : reg_test("m_args", args_unhandled_4);
536 1 : reg_test("m_args", args_unhandled_5);
537 1 : reg_test("m_args", args_unhandled_6);
538 1 : reg_test("m_args", args_help_1);
539 1 : reg_test("m_args", args_help_2);
540 1 : reg_test("m_args", args_version_1);
541 1 : reg_test("m_args", args_version_2);
542 1 : reg_test("m_args", args_base_1);
543 1 : reg_test("m_args", args_base_2);
544 1 : reg_test("m_args", args_base_3);
545 1 : reg_test("m_args", args_base_4);
546 1 : reg_test("m_args", args_base_5);
547 1 : reg_test("m_args", args_base_6);
548 1 : reg_test("m_args", args_base_7);
549 1 : reg_test("m_args", args_missing_value_1);
550 1 : reg_test("m_args", args_missing_value_2);
551 1 : reg_test("m_args", args_value_1);
552 1 : reg_test("m_args", args_value_2);
553 1 : reg_test("m_args", args_value_3);
554 1 : reg_test("m_args", args_value_4);
555 1 : reg_test("m_args", args_word_only_1);
556 1 : }
|
