source: mainline/uspace/lib/ui/test/filelist.c@ f9c4c433

Last change on this file since f9c4c433 was f9c4c433, checked in by Jiri Svoboda <jiri@…>, 4 weeks ago

Create new file in Navigator (WIP)
  • Property mode set to 100644
File size: 30.3 KB
Line 
1/*
2 * Copyright (c) 2025 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <errno.h>
30#include <io/kbd_event.h>
31#include <io/pos_event.h>
32#include <pcut/pcut.h>
33#include <stdio.h>
34#include <ui/ui.h>
35#include <ui/filelist.h>
36#include <ui/scrollbar.h>
37#include <vfs/vfs.h>
38#include "../private/filelist.h"
39#include "../private/list.h"
40
41PCUT_INIT;
42
43PCUT_TEST_SUITE(file_list);
44
45/** Test response */
46typedef struct {
47 bool activate_req;
48 ui_file_list_t *activate_req_file_list;
49
50 bool selected;
51 ui_file_list_t *selected_file_list;
52 const char *selected_fname;
53} test_resp_t;
54
55static void test_file_list_activate_req(ui_file_list_t *, void *);
56static void test_file_list_selected(ui_file_list_t *, void *, const char *);
57
58static ui_file_list_cb_t test_cb = {
59 .activate_req = test_file_list_activate_req,
60 .selected = test_file_list_selected
61};
62
63/** Create and destroy file list. */
64PCUT_TEST(create_destroy)
65{
66 ui_t *ui;
67 ui_window_t *window;
68 ui_wnd_params_t params;
69 ui_file_list_t *flist;
70 errno_t rc;
71
72 rc = ui_create_disp(NULL, &ui);
73 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
74
75 ui_wnd_params_init(&params);
76 params.caption = "Test";
77
78 rc = ui_window_create(ui, &params, &window);
79 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
80
81 rc = ui_file_list_create(window, true, &flist);
82 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
83
84 ui_file_list_destroy(flist);
85 ui_window_destroy(window);
86 ui_destroy(ui);
87}
88
89/** ui_file_list_set_cb() sets callback */
90PCUT_TEST(set_cb)
91{
92 ui_t *ui;
93 ui_window_t *window;
94 ui_wnd_params_t params;
95 ui_file_list_t *flist;
96 errno_t rc;
97 test_resp_t resp;
98
99 rc = ui_create_disp(NULL, &ui);
100 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
101
102 ui_wnd_params_init(&params);
103 params.caption = "Test";
104
105 rc = ui_window_create(ui, &params, &window);
106 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
107
108 rc = ui_file_list_create(window, true, &flist);
109 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
110
111 ui_file_list_set_cb(flist, &test_cb, &resp);
112 PCUT_ASSERT_EQUALS(&test_cb, flist->cb);
113 PCUT_ASSERT_EQUALS(&resp, flist->cb_arg);
114
115 ui_file_list_destroy(flist);
116 ui_window_destroy(window);
117 ui_destroy(ui);
118}
119
120/** Test ui_file_list_paint() */
121PCUT_TEST(paint)
122{
123 ui_t *ui;
124 ui_window_t *window;
125 ui_wnd_params_t params;
126 ui_file_list_t *flist;
127 errno_t rc;
128
129 rc = ui_create_disp(NULL, &ui);
130 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
131
132 ui_wnd_params_init(&params);
133 params.caption = "Test";
134
135 rc = ui_window_create(ui, &params, &window);
136 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
137
138 rc = ui_file_list_create(window, true, &flist);
139 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
140
141 rc = ui_file_list_paint(flist);
142 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
143
144 ui_file_list_destroy(flist);
145 ui_window_destroy(window);
146 ui_destroy(ui);
147}
148
149/** ui_file_list_ctl() returns a valid UI control */
150PCUT_TEST(ctl)
151{
152 ui_t *ui;
153 ui_window_t *window;
154 ui_wnd_params_t params;
155 ui_file_list_t *flist;
156 ui_control_t *control;
157 errno_t rc;
158
159 rc = ui_create_disp(NULL, &ui);
160 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
161
162 ui_wnd_params_init(&params);
163 params.caption = "Test";
164
165 rc = ui_window_create(ui, &params, &window);
166 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
167
168 rc = ui_file_list_create(window, true, &flist);
169 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
170
171 control = ui_file_list_ctl(flist);
172 PCUT_ASSERT_NOT_NULL(control);
173
174 ui_file_list_destroy(flist);
175 ui_window_destroy(window);
176 ui_destroy(ui);
177}
178
179/** ui_file_list_set_rect() sets internal field */
180PCUT_TEST(set_rect)
181{
182 ui_t *ui;
183 ui_window_t *window;
184 ui_wnd_params_t params;
185 ui_file_list_t *flist;
186 gfx_rect_t rect;
187 errno_t rc;
188
189 rc = ui_create_disp(NULL, &ui);
190 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
191
192 ui_wnd_params_init(&params);
193 params.caption = "Test";
194
195 rc = ui_window_create(ui, &params, &window);
196 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
197
198 rc = ui_file_list_create(window, true, &flist);
199 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
200
201 rect.p0.x = 1;
202 rect.p0.y = 2;
203 rect.p1.x = 3;
204 rect.p1.y = 4;
205
206 ui_file_list_set_rect(flist, &rect);
207 PCUT_ASSERT_INT_EQUALS(rect.p0.x, flist->list->rect.p0.x);
208 PCUT_ASSERT_INT_EQUALS(rect.p0.y, flist->list->rect.p0.y);
209 PCUT_ASSERT_INT_EQUALS(rect.p1.x, flist->list->rect.p1.x);
210 PCUT_ASSERT_INT_EQUALS(rect.p1.y, flist->list->rect.p1.y);
211
212 ui_file_list_destroy(flist);
213 ui_window_destroy(window);
214 ui_destroy(ui);
215}
216
217/** ui_file_list_is_active() returns file list activity state */
218PCUT_TEST(is_active)
219{
220 ui_t *ui;
221 ui_window_t *window;
222 ui_wnd_params_t params;
223 ui_file_list_t *flist;
224 errno_t rc;
225
226 rc = ui_create_disp(NULL, &ui);
227 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
228
229 ui_wnd_params_init(&params);
230 params.caption = "Test";
231
232 rc = ui_window_create(ui, &params, &window);
233 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
234
235 rc = ui_file_list_create(window, true, &flist);
236 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
237 PCUT_ASSERT_TRUE(ui_file_list_is_active(flist));
238 ui_file_list_destroy(flist);
239
240 rc = ui_file_list_create(window, false, &flist);
241 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
242 PCUT_ASSERT_FALSE(ui_file_list_is_active(flist));
243 ui_file_list_destroy(flist);
244 ui_window_destroy(window);
245 ui_destroy(ui);
246}
247
248/** ui_file_list_activate() activates file list */
249PCUT_TEST(activate)
250{
251 ui_t *ui;
252 ui_window_t *window;
253 ui_wnd_params_t params;
254 ui_file_list_t *flist;
255 errno_t rc;
256
257 rc = ui_create_disp(NULL, &ui);
258 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
259
260 ui_wnd_params_init(&params);
261 params.caption = "Test";
262
263 rc = ui_window_create(ui, &params, &window);
264 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
265
266 rc = ui_file_list_create(window, false, &flist);
267 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
268
269 PCUT_ASSERT_FALSE(ui_file_list_is_active(flist));
270 rc = ui_file_list_activate(flist);
271 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
272 PCUT_ASSERT_TRUE(ui_file_list_is_active(flist));
273
274 ui_file_list_destroy(flist);
275 ui_window_destroy(window);
276 ui_destroy(ui);
277}
278
279/** ui_file_list_deactivate() deactivates file list */
280PCUT_TEST(deactivate)
281{
282 ui_t *ui;
283 ui_window_t *window;
284 ui_wnd_params_t params;
285 ui_file_list_t *flist;
286 errno_t rc;
287
288 rc = ui_create_disp(NULL, &ui);
289 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
290
291 ui_wnd_params_init(&params);
292 params.caption = "Test";
293
294 rc = ui_window_create(ui, &params, &window);
295 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
296
297 rc = ui_file_list_create(window, true, &flist);
298 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
299
300 PCUT_ASSERT_TRUE(ui_file_list_is_active(flist));
301 ui_file_list_deactivate(flist);
302 PCUT_ASSERT_FALSE(ui_file_list_is_active(flist));
303
304 ui_file_list_destroy(flist);
305 ui_window_destroy(window);
306 ui_destroy(ui);
307}
308
309/** ui_file_list_entry_append() appends new entry */
310PCUT_TEST(entry_append)
311{
312 ui_t *ui;
313 ui_window_t *window;
314 ui_wnd_params_t params;
315 ui_file_list_t *flist;
316 ui_file_list_entry_attr_t attr;
317 errno_t rc;
318
319 rc = ui_create_disp(NULL, &ui);
320 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
321
322 ui_wnd_params_init(&params);
323 params.caption = "Test";
324
325 rc = ui_window_create(ui, &params, &window);
326 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
327
328 rc = ui_file_list_create(window, true, &flist);
329 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
330
331 ui_file_list_entry_attr_init(&attr);
332
333 attr.name = "a";
334 attr.size = 1;
335 rc = ui_file_list_entry_append(flist, &attr);
336 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
337
338 PCUT_ASSERT_INT_EQUALS(1, ui_list_entries_cnt(flist->list));
339
340 attr.name = "b";
341 attr.size = 2;
342 rc = ui_file_list_entry_append(flist, &attr);
343 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
344
345 PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
346
347 ui_file_list_destroy(flist);
348 ui_window_destroy(window);
349 ui_destroy(ui);
350}
351
352/** ui_file_list_entry_destroy() destroys entry */
353PCUT_TEST(entry_destroy)
354{
355 ui_t *ui;
356 ui_window_t *window;
357 ui_wnd_params_t params;
358 ui_file_list_t *flist;
359 ui_file_list_entry_t *entry;
360 ui_file_list_entry_attr_t attr;
361 errno_t rc;
362
363 rc = ui_create_disp(NULL, &ui);
364 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
365
366 ui_wnd_params_init(&params);
367 params.caption = "Test";
368
369 rc = ui_window_create(ui, &params, &window);
370 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
371
372 rc = ui_file_list_create(window, true, &flist);
373 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
374
375 attr.name = "a";
376 attr.size = 1;
377 rc = ui_file_list_entry_append(flist, &attr);
378 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
379
380 attr.name = "b";
381 attr.size = 2;
382 rc = ui_file_list_entry_append(flist, &attr);
383 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
384
385 PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
386
387 entry = ui_file_list_first(flist);
388 ui_file_list_entry_destroy(entry);
389
390 PCUT_ASSERT_INT_EQUALS(1, ui_list_entries_cnt(flist->list));
391
392 entry = ui_file_list_first(flist);
393 ui_file_list_entry_destroy(entry);
394
395 PCUT_ASSERT_INT_EQUALS(0, ui_list_entries_cnt(flist->list));
396
397 ui_file_list_destroy(flist);
398 ui_window_destroy(window);
399 ui_destroy(ui);
400}
401
402/** ui_file_list_clear_entries() removes all entries from file list */
403PCUT_TEST(clear_entries)
404{
405 ui_t *ui;
406 ui_window_t *window;
407 ui_wnd_params_t params;
408 ui_file_list_t *flist;
409 ui_file_list_entry_attr_t attr;
410 errno_t rc;
411
412 rc = ui_create_disp(NULL, &ui);
413 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
414
415 ui_wnd_params_init(&params);
416 params.caption = "Test";
417
418 rc = ui_window_create(ui, &params, &window);
419 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
420
421 rc = ui_file_list_create(window, true, &flist);
422 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
423
424 ui_file_list_entry_attr_init(&attr);
425 attr.name = "a";
426 attr.size = 1;
427 rc = ui_file_list_entry_append(flist, &attr);
428 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
429
430 attr.name = "a";
431 attr.size = 2;
432 rc = ui_file_list_entry_append(flist, &attr);
433 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
434
435 PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
436
437 ui_file_list_clear_entries(flist);
438 PCUT_ASSERT_INT_EQUALS(0, ui_list_entries_cnt(flist->list));
439
440 ui_file_list_destroy(flist);
441 ui_window_destroy(window);
442 ui_destroy(ui);
443}
444
445/** ui_file_list_read_dir() reads the contents of a directory */
446PCUT_TEST(read_dir)
447{
448 ui_t *ui;
449 ui_window_t *window;
450 ui_wnd_params_t params;
451 ui_file_list_t *flist;
452 ui_file_list_entry_t *entry;
453 char buf[L_tmpnam];
454 char *fname;
455 char *p;
456 errno_t rc;
457 FILE *f;
458 int rv;
459
460 /* Create name for temporary directory */
461 p = tmpnam(buf);
462 PCUT_ASSERT_NOT_NULL(p);
463
464 /* Create temporary directory */
465 rc = vfs_link_path(p, KIND_DIRECTORY, NULL);
466 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
467
468 rv = asprintf(&fname, "%s/%s", p, "a");
469 PCUT_ASSERT_TRUE(rv >= 0);
470
471 f = fopen(fname, "wb");
472 PCUT_ASSERT_NOT_NULL(f);
473
474 rv = fprintf(f, "X");
475 PCUT_ASSERT_TRUE(rv >= 0);
476
477 rv = fclose(f);
478 PCUT_ASSERT_INT_EQUALS(0, rv);
479
480 rc = ui_create_disp(NULL, &ui);
481 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
482
483 ui_wnd_params_init(&params);
484 params.caption = "Test";
485
486 rc = ui_window_create(ui, &params, &window);
487 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
488
489 rc = ui_file_list_create(window, true, &flist);
490 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
491
492 rc = ui_file_list_read_dir(flist, p);
493 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
494
495 PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
496
497 entry = ui_file_list_first(flist);
498 PCUT_ASSERT_NOT_NULL(entry);
499 PCUT_ASSERT_STR_EQUALS("..", entry->name);
500
501 entry = ui_file_list_next(entry);
502 PCUT_ASSERT_NOT_NULL(entry);
503 PCUT_ASSERT_STR_EQUALS("a", entry->name);
504 PCUT_ASSERT_INT_EQUALS(1, entry->size);
505
506 ui_file_list_destroy(flist);
507
508 rv = remove(fname);
509 PCUT_ASSERT_INT_EQUALS(0, rv);
510
511 rv = remove(p);
512 PCUT_ASSERT_INT_EQUALS(0, rv);
513
514 free(fname);
515 ui_window_destroy(window);
516 ui_destroy(ui);
517}
518
519/** When moving to parent directory from a subdir, we seek to the
520 * coresponding entry
521 */
522PCUT_TEST(read_dir_up)
523{
524 ui_t *ui;
525 ui_window_t *window;
526 ui_wnd_params_t params;
527 ui_file_list_t *flist;
528 char buf[L_tmpnam];
529 char *subdir_a;
530 char *subdir_b;
531 char *subdir_c;
532 char *p;
533 errno_t rc;
534 int rv;
535
536 /* Create name for temporary directory */
537 p = tmpnam(buf);
538 PCUT_ASSERT_NOT_NULL(p);
539
540 /* Create temporary directory */
541 rc = vfs_link_path(p, KIND_DIRECTORY, NULL);
542 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
543
544 /* Create some subdirectories */
545
546 rv = asprintf(&subdir_a, "%s/%s", p, "a");
547 PCUT_ASSERT_TRUE(rv >= 0);
548 rc = vfs_link_path(subdir_a, KIND_DIRECTORY, NULL);
549 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
550
551 rv = asprintf(&subdir_b, "%s/%s", p, "b");
552 PCUT_ASSERT_TRUE(rv >= 0);
553 rc = vfs_link_path(subdir_b, KIND_DIRECTORY, NULL);
554 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
555
556 rv = asprintf(&subdir_c, "%s/%s", p, "c");
557 PCUT_ASSERT_TRUE(rv >= 0);
558 rc = vfs_link_path(subdir_c, KIND_DIRECTORY, NULL);
559 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
560
561 rc = ui_create_disp(NULL, &ui);
562 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
563
564 ui_wnd_params_init(&params);
565 params.caption = "Test";
566
567 rc = ui_window_create(ui, &params, &window);
568 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
569
570 rc = ui_file_list_create(window, true, &flist);
571 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
572
573 /* Start in subdirectory "b" */
574 rc = ui_file_list_read_dir(flist, subdir_b);
575 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
576
577 /* Now go up (into p) */
578
579 rc = ui_file_list_read_dir(flist, "..");
580 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
581
582 PCUT_ASSERT_NOT_NULL(ui_file_list_get_cursor(flist));
583 PCUT_ASSERT_STR_EQUALS("b", ui_file_list_get_cursor(flist)->name);
584
585 ui_file_list_destroy(flist);
586
587 rv = remove(subdir_a);
588 PCUT_ASSERT_INT_EQUALS(0, rv);
589
590 rv = remove(subdir_b);
591 PCUT_ASSERT_INT_EQUALS(0, rv);
592
593 rv = remove(subdir_c);
594 PCUT_ASSERT_INT_EQUALS(0, rv);
595
596 rv = remove(p);
597 PCUT_ASSERT_INT_EQUALS(0, rv);
598
599 free(subdir_a);
600 free(subdir_b);
601 free(subdir_c);
602
603 ui_window_destroy(window);
604 ui_destroy(ui);
605}
606
607/** ui_file_list_sort() sorts file list entries */
608PCUT_TEST(sort)
609{
610 ui_t *ui;
611 ui_window_t *window;
612 ui_wnd_params_t params;
613 ui_file_list_t *flist;
614 ui_file_list_entry_t *entry;
615 ui_file_list_entry_attr_t attr;
616 errno_t rc;
617
618 rc = ui_create_disp(NULL, &ui);
619 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
620
621 ui_wnd_params_init(&params);
622 params.caption = "Test";
623
624 rc = ui_window_create(ui, &params, &window);
625 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
626
627 rc = ui_file_list_create(window, true, &flist);
628 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
629
630 ui_file_list_entry_attr_init(&attr);
631
632 attr.name = "b";
633 attr.size = 1;
634 rc = ui_file_list_entry_append(flist, &attr);
635 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
636
637 attr.name = "c";
638 attr.size = 3;
639 rc = ui_file_list_entry_append(flist, &attr);
640 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
641
642 attr.name = "a";
643 attr.size = 2;
644 rc = ui_file_list_entry_append(flist, &attr);
645 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
646
647 rc = ui_file_list_sort(flist);
648 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
649
650 entry = ui_file_list_first(flist);
651 PCUT_ASSERT_STR_EQUALS("a", entry->name);
652 PCUT_ASSERT_INT_EQUALS(2, entry->size);
653
654 entry = ui_file_list_next(entry);
655 PCUT_ASSERT_STR_EQUALS("b", entry->name);
656 PCUT_ASSERT_INT_EQUALS(1, entry->size);
657
658 entry = ui_file_list_next(entry);
659 PCUT_ASSERT_STR_EQUALS("c", entry->name);
660 PCUT_ASSERT_INT_EQUALS(3, entry->size);
661
662 ui_file_list_destroy(flist);
663 ui_window_destroy(window);
664 ui_destroy(ui);
665}
666
667/** ui_file_list_refresh() */
668PCUT_TEST(refresh)
669{
670 ui_t *ui;
671 ui_window_t *window;
672 ui_wnd_params_t params;
673 ui_file_list_t *flist;
674 ui_file_list_entry_t *entry;
675 char buf[L_tmpnam];
676 char *fname;
677 char *p;
678 errno_t rc;
679 FILE *f;
680 int rv;
681
682 /* Create name for temporary directory */
683 p = tmpnam(buf);
684 PCUT_ASSERT_NOT_NULL(p);
685
686 /* Create temporary directory */
687 rc = vfs_link_path(p, KIND_DIRECTORY, NULL);
688 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
689
690 rv = asprintf(&fname, "%s/%s", p, "a");
691 PCUT_ASSERT_TRUE(rv >= 0);
692
693 f = fopen(fname, "wb");
694 PCUT_ASSERT_NOT_NULL(f);
695
696 rv = fprintf(f, "X");
697 PCUT_ASSERT_TRUE(rv >= 0);
698
699 rv = fclose(f);
700 PCUT_ASSERT_INT_EQUALS(0, rv);
701
702 rc = ui_create_disp(NULL, &ui);
703 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
704
705 ui_wnd_params_init(&params);
706 params.caption = "Test";
707
708 rc = ui_window_create(ui, &params, &window);
709 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
710
711 rc = ui_file_list_create(window, true, &flist);
712 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
713
714 rc = ui_file_list_read_dir(flist, p);
715 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
716
717 PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
718
719 entry = ui_file_list_first(flist);
720 PCUT_ASSERT_NOT_NULL(entry);
721 PCUT_ASSERT_STR_EQUALS("..", entry->name);
722
723 entry = ui_file_list_next(entry);
724 PCUT_ASSERT_NOT_NULL(entry);
725 PCUT_ASSERT_STR_EQUALS("a", entry->name);
726 PCUT_ASSERT_INT_EQUALS(1, entry->size);
727
728 rv = remove(fname);
729 PCUT_ASSERT_INT_EQUALS(0, rv);
730 free(fname);
731
732 rv = asprintf(&fname, "%s/%s", p, "b");
733 PCUT_ASSERT_TRUE(rv >= 0);
734
735 f = fopen(fname, "wb");
736 PCUT_ASSERT_NOT_NULL(f);
737
738 rv = fprintf(f, "X");
739 PCUT_ASSERT_TRUE(rv >= 0);
740
741 rv = fclose(f);
742 PCUT_ASSERT_INT_EQUALS(0, rv);
743
744 rc = ui_file_list_refresh(flist);
745 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
746
747 entry = ui_file_list_first(flist);
748 PCUT_ASSERT_NOT_NULL(entry);
749 PCUT_ASSERT_STR_EQUALS("..", entry->name);
750
751 entry = ui_file_list_next(entry);
752 PCUT_ASSERT_NOT_NULL(entry);
753 PCUT_ASSERT_STR_EQUALS("b", entry->name);
754 PCUT_ASSERT_INT_EQUALS(1, entry->size);
755
756 rv = remove(fname);
757 PCUT_ASSERT_INT_EQUALS(0, rv);
758 free(fname);
759
760 rv = remove(p);
761 PCUT_ASSERT_INT_EQUALS(0, rv);
762
763 ui_file_list_destroy(flist);
764
765 ui_window_destroy(window);
766 ui_destroy(ui);
767}
768
769/** ui_file_list_list_compare compares two file list entries */
770PCUT_TEST(list_compare)
771{
772 ui_t *ui;
773 ui_window_t *window;
774 ui_wnd_params_t params;
775 ui_file_list_t *flist;
776 ui_file_list_entry_t *a, *b;
777 ui_file_list_entry_attr_t attr;
778 int rel;
779 errno_t rc;
780
781 rc = ui_create_disp(NULL, &ui);
782 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
783
784 ui_wnd_params_init(&params);
785 params.caption = "Test";
786
787 rc = ui_window_create(ui, &params, &window);
788 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
789
790 rc = ui_file_list_create(window, true, &flist);
791 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
792
793 ui_file_list_entry_attr_init(&attr);
794
795 attr.name = "a";
796 attr.size = 2;
797 rc = ui_file_list_entry_append(flist, &attr);
798 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
799
800 attr.name = "b";
801 attr.size = 1;
802 rc = ui_file_list_entry_append(flist, &attr);
803 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
804
805 a = ui_file_list_first(flist);
806 PCUT_ASSERT_NOT_NULL(a);
807 b = ui_file_list_next(a);
808 PCUT_ASSERT_NOT_NULL(b);
809
810 /* a < b */
811 rel = ui_file_list_list_compare(a->entry, b->entry);
812 PCUT_ASSERT_TRUE(rel < 0);
813
814 /* b > a */
815 rel = ui_file_list_list_compare(b->entry, a->entry);
816 PCUT_ASSERT_TRUE(rel > 0);
817
818 /* a == a */
819 rel = ui_file_list_list_compare(a->entry, a->entry);
820 PCUT_ASSERT_INT_EQUALS(0, rel);
821
822 ui_file_list_destroy(flist);
823 ui_window_destroy(window);
824 ui_destroy(ui);
825}
826
827/** ui_file_list_entry_attr_init() initializes file list attribute structure */
828PCUT_TEST(entry_attr_init)
829{
830 ui_file_list_entry_attr_t attr;
831
832 ui_file_list_entry_attr_init(&attr);
833 PCUT_ASSERT_NULL(attr.name);
834 PCUT_ASSERT_INT_EQUALS(0, attr.size);
835 PCUT_ASSERT_EQUALS(false, attr.isdir);
836 PCUT_ASSERT_INT_EQUALS(0, attr.svc);
837}
838
839/** ui_file_list_first() returns valid entry or @c NULL as appropriate */
840PCUT_TEST(first)
841{
842 ui_t *ui;
843 ui_window_t *window;
844 ui_wnd_params_t params;
845 ui_file_list_t *flist;
846 ui_file_list_entry_t *entry;
847 ui_file_list_entry_attr_t attr;
848 errno_t rc;
849
850 rc = ui_create_disp(NULL, &ui);
851 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
852
853 ui_wnd_params_init(&params);
854 params.caption = "Test";
855
856 rc = ui_window_create(ui, &params, &window);
857 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
858
859 rc = ui_file_list_create(window, true, &flist);
860 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
861
862 ui_file_list_entry_attr_init(&attr);
863
864 entry = ui_file_list_first(flist);
865 PCUT_ASSERT_NULL(entry);
866
867 /* Add one entry */
868 attr.name = "a";
869 attr.size = 1;
870 rc = ui_file_list_entry_append(flist, &attr);
871 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
872
873 /* Now try getting it */
874 entry = ui_file_list_first(flist);
875 PCUT_ASSERT_NOT_NULL(entry);
876 PCUT_ASSERT_STR_EQUALS("a", entry->name);
877 PCUT_ASSERT_INT_EQUALS(1, entry->size);
878
879 /* Add another entry */
880 attr.name = "b";
881 attr.size = 2;
882 rc = ui_file_list_entry_append(flist, &attr);
883 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
884
885 /* We should still get the first entry */
886 entry = ui_file_list_first(flist);
887 PCUT_ASSERT_NOT_NULL(entry);
888 PCUT_ASSERT_STR_EQUALS("a", entry->name);
889 PCUT_ASSERT_INT_EQUALS(1, entry->size);
890
891 ui_file_list_destroy(flist);
892 ui_window_destroy(window);
893 ui_destroy(ui);
894}
895
896/** ui_file_list_last() returns valid entry or @c NULL as appropriate */
897PCUT_TEST(last)
898{
899 ui_t *ui;
900 ui_window_t *window;
901 ui_wnd_params_t params;
902 ui_file_list_t *flist;
903 ui_file_list_entry_t *entry;
904 ui_file_list_entry_attr_t attr;
905 errno_t rc;
906
907 rc = ui_create_disp(NULL, &ui);
908 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
909
910 ui_wnd_params_init(&params);
911 params.caption = "Test";
912
913 rc = ui_window_create(ui, &params, &window);
914 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
915
916 rc = ui_file_list_create(window, true, &flist);
917 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
918
919 ui_file_list_entry_attr_init(&attr);
920
921 entry = ui_file_list_last(flist);
922 PCUT_ASSERT_NULL(entry);
923
924 /* Add one entry */
925 attr.name = "a";
926 attr.size = 1;
927 rc = ui_file_list_entry_append(flist, &attr);
928 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
929
930 /* Now try getting it */
931 entry = ui_file_list_last(flist);
932 PCUT_ASSERT_NOT_NULL(entry);
933 PCUT_ASSERT_STR_EQUALS("a", entry->name);
934 PCUT_ASSERT_INT_EQUALS(1, entry->size);
935
936 /* Add another entry */
937 attr.name = "b";
938 attr.size = 2;
939 rc = ui_file_list_entry_append(flist, &attr);
940 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
941
942 /* We should get new entry now */
943 entry = ui_file_list_last(flist);
944 PCUT_ASSERT_NOT_NULL(entry);
945 attr.name = "b";
946 attr.size = 2;
947 PCUT_ASSERT_STR_EQUALS("b", entry->name);
948 PCUT_ASSERT_INT_EQUALS(2, entry->size);
949
950 ui_file_list_destroy(flist);
951 ui_window_destroy(window);
952 ui_destroy(ui);
953}
954
955/** ui_file_list_next() returns the next entry or @c NULL as appropriate */
956PCUT_TEST(next)
957{
958 ui_t *ui;
959 ui_window_t *window;
960 ui_wnd_params_t params;
961 ui_file_list_t *flist;
962 ui_file_list_entry_t *entry;
963 ui_file_list_entry_attr_t attr;
964 errno_t rc;
965
966 rc = ui_create_disp(NULL, &ui);
967 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
968
969 ui_wnd_params_init(&params);
970 params.caption = "Test";
971
972 rc = ui_window_create(ui, &params, &window);
973 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
974
975 rc = ui_file_list_create(window, true, &flist);
976 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
977
978 ui_file_list_entry_attr_init(&attr);
979
980 /* Add one entry */
981 attr.name = "a";
982 attr.size = 1;
983 rc = ui_file_list_entry_append(flist, &attr);
984 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
985
986 /* Now try getting its successor */
987 entry = ui_file_list_first(flist);
988 PCUT_ASSERT_NOT_NULL(entry);
989
990 entry = ui_file_list_next(entry);
991 PCUT_ASSERT_NULL(entry);
992
993 /* Add another entry */
994 attr.name = "b";
995 attr.size = 2;
996 rc = ui_file_list_entry_append(flist, &attr);
997 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
998
999 /* Try getting the successor of first entry again */
1000 entry = ui_file_list_first(flist);
1001 PCUT_ASSERT_NOT_NULL(entry);
1002
1003 entry = ui_file_list_next(entry);
1004 PCUT_ASSERT_NOT_NULL(entry);
1005 PCUT_ASSERT_STR_EQUALS("b", entry->name);
1006 PCUT_ASSERT_INT_EQUALS(2, entry->size);
1007
1008 ui_file_list_destroy(flist);
1009 ui_window_destroy(window);
1010 ui_destroy(ui);
1011}
1012
1013/** ui_file_list_prev() returns the previous entry or @c NULL as appropriate */
1014PCUT_TEST(prev)
1015{
1016 ui_t *ui;
1017 ui_window_t *window;
1018 ui_wnd_params_t params;
1019 ui_file_list_t *flist;
1020 ui_file_list_entry_t *entry;
1021 ui_file_list_entry_attr_t attr;
1022 errno_t rc;
1023
1024 rc = ui_create_disp(NULL, &ui);
1025 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1026
1027 ui_wnd_params_init(&params);
1028 params.caption = "Test";
1029
1030 rc = ui_window_create(ui, &params, &window);
1031 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1032
1033 rc = ui_file_list_create(window, true, &flist);
1034 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1035
1036 ui_file_list_entry_attr_init(&attr);
1037
1038 /* Add one entry */
1039 attr.name = "a";
1040 attr.size = 1;
1041 rc = ui_file_list_entry_append(flist, &attr);
1042 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1043
1044 /* Now try getting its predecessor */
1045 entry = ui_file_list_last(flist);
1046 PCUT_ASSERT_NOT_NULL(entry);
1047
1048 entry = ui_file_list_prev(entry);
1049 PCUT_ASSERT_NULL(entry);
1050
1051 /* Add another entry */
1052 attr.name = "b";
1053 attr.size = 2;
1054 rc = ui_file_list_entry_append(flist, &attr);
1055 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1056
1057 /* Try getting the predecessor of the new entry */
1058 entry = ui_file_list_last(flist);
1059 PCUT_ASSERT_NOT_NULL(entry);
1060
1061 entry = ui_file_list_prev(entry);
1062 PCUT_ASSERT_NOT_NULL(entry);
1063 PCUT_ASSERT_STR_EQUALS("a", entry->name);
1064 PCUT_ASSERT_INT_EQUALS(1, entry->size);
1065
1066 ui_file_list_destroy(flist);
1067 ui_window_destroy(window);
1068 ui_destroy(ui);
1069}
1070
1071/** ui_file_list_open_dir() opens a directory entry */
1072PCUT_TEST(open_dir)
1073{
1074 ui_t *ui;
1075 ui_window_t *window;
1076 ui_wnd_params_t params;
1077 ui_file_list_t *flist;
1078 ui_file_list_entry_t *entry;
1079 char buf[L_tmpnam];
1080 char *sdname;
1081 char *p;
1082 errno_t rc;
1083 int rv;
1084
1085 rc = ui_create_disp(NULL, &ui);
1086 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1087
1088 ui_wnd_params_init(&params);
1089 params.caption = "Test";
1090
1091 rc = ui_window_create(ui, &params, &window);
1092 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1093
1094 /* Create name for temporary directory */
1095 p = tmpnam(buf);
1096 PCUT_ASSERT_NOT_NULL(p);
1097
1098 /* Create temporary directory */
1099 rc = vfs_link_path(p, KIND_DIRECTORY, NULL);
1100 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1101
1102 rv = asprintf(&sdname, "%s/%s", p, "a");
1103 PCUT_ASSERT_TRUE(rv >= 0);
1104
1105 /* Create sub-directory */
1106 rc = vfs_link_path(sdname, KIND_DIRECTORY, NULL);
1107 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1108
1109 rc = ui_file_list_create(window, true, &flist);
1110 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1111
1112 rc = ui_file_list_read_dir(flist, p);
1113 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1114 PCUT_ASSERT_STR_EQUALS(p, flist->dir);
1115
1116 PCUT_ASSERT_INT_EQUALS(2, ui_list_entries_cnt(flist->list));
1117
1118 entry = ui_file_list_first(flist);
1119 PCUT_ASSERT_NOT_NULL(entry);
1120 PCUT_ASSERT_STR_EQUALS("..", entry->name);
1121
1122 entry = ui_file_list_next(entry);
1123 PCUT_ASSERT_NOT_NULL(entry);
1124 PCUT_ASSERT_STR_EQUALS("a", entry->name);
1125 PCUT_ASSERT_TRUE(entry->isdir);
1126
1127 rc = ui_file_list_open_dir(flist, entry);
1128 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1129
1130 PCUT_ASSERT_STR_EQUALS(sdname, flist->dir);
1131
1132 ui_file_list_destroy(flist);
1133 ui_window_destroy(window);
1134 ui_destroy(ui);
1135
1136 rv = remove(sdname);
1137 PCUT_ASSERT_INT_EQUALS(0, rv);
1138
1139 rv = remove(p);
1140 PCUT_ASSERT_INT_EQUALS(0, rv);
1141
1142 free(sdname);
1143}
1144
1145/** ui_file_list_open_file() runs selected callback */
1146PCUT_TEST(open_file)
1147{
1148 ui_t *ui;
1149 ui_window_t *window;
1150 ui_wnd_params_t params;
1151 ui_file_list_t *flist;
1152 ui_file_list_entry_attr_t attr;
1153 errno_t rc;
1154 test_resp_t resp;
1155
1156 rc = ui_create_disp(NULL, &ui);
1157 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1158
1159 ui_wnd_params_init(&params);
1160 params.caption = "Test";
1161
1162 rc = ui_window_create(ui, &params, &window);
1163 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1164
1165 rc = ui_file_list_create(window, true, &flist);
1166 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1167
1168 ui_file_list_set_cb(flist, &test_cb, &resp);
1169
1170 attr.name = "hello.txt";
1171 attr.size = 1;
1172 rc = ui_file_list_entry_append(flist, &attr);
1173 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1174
1175 resp.selected = false;
1176 resp.selected_file_list = NULL;
1177 resp.selected_fname = NULL;
1178
1179 ui_file_list_open_file(flist, ui_file_list_first(flist));
1180 PCUT_ASSERT_TRUE(resp.selected);
1181 PCUT_ASSERT_EQUALS(flist, resp.selected_file_list);
1182 PCUT_ASSERT_STR_EQUALS("hello.txt", resp.selected_fname);
1183
1184 ui_file_list_destroy(flist);
1185 ui_window_destroy(window);
1186 ui_destroy(ui);
1187}
1188
1189/** ui_file_list_activate_req() sends activation request */
1190PCUT_TEST(activate_req)
1191{
1192 ui_t *ui;
1193 ui_window_t *window;
1194 ui_wnd_params_t params;
1195 ui_file_list_t *flist;
1196 errno_t rc;
1197 test_resp_t resp;
1198
1199 rc = ui_create_disp(NULL, &ui);
1200 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1201
1202 ui_wnd_params_init(&params);
1203 params.caption = "Test";
1204
1205 rc = ui_window_create(ui, &params, &window);
1206 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1207
1208 rc = ui_file_list_create(window, true, &flist);
1209 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1210
1211 ui_file_list_set_cb(flist, &test_cb, &resp);
1212
1213 resp.activate_req = false;
1214 resp.activate_req_file_list = NULL;
1215
1216 ui_file_list_activate_req(flist);
1217 PCUT_ASSERT_TRUE(resp.activate_req);
1218 PCUT_ASSERT_EQUALS(flist, resp.activate_req_file_list);
1219
1220 ui_file_list_destroy(flist);
1221 ui_window_destroy(window);
1222 ui_destroy(ui);
1223}
1224
1225/** ui_file_list_selected() runs selected callback */
1226PCUT_TEST(selected)
1227{
1228 ui_t *ui;
1229 ui_window_t *window;
1230 ui_wnd_params_t params;
1231 ui_file_list_t *flist;
1232 errno_t rc;
1233 test_resp_t resp;
1234
1235 rc = ui_create_disp(NULL, &ui);
1236 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1237
1238 ui_wnd_params_init(&params);
1239 params.caption = "Test";
1240
1241 rc = ui_window_create(ui, &params, &window);
1242 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1243
1244 rc = ui_file_list_create(window, true, &flist);
1245 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1246
1247 ui_file_list_set_cb(flist, &test_cb, &resp);
1248
1249 resp.selected = false;
1250 resp.selected_file_list = NULL;
1251 resp.selected_fname = NULL;
1252
1253 ui_file_list_selected(flist, "hello.txt");
1254 PCUT_ASSERT_TRUE(resp.selected);
1255 PCUT_ASSERT_EQUALS(flist, resp.selected_file_list);
1256 PCUT_ASSERT_STR_EQUALS("hello.txt", resp.selected_fname);
1257
1258 ui_file_list_destroy(flist);
1259 ui_window_destroy(window);
1260 ui_destroy(ui);
1261}
1262
1263/** ui_file_list_get_cursor() returns the current cursor position */
1264PCUT_TEST(get_cursor)
1265{
1266 ui_t *ui;
1267 ui_window_t *window;
1268 ui_wnd_params_t params;
1269 ui_file_list_t *flist;
1270 ui_file_list_entry_attr_t attr;
1271 ui_file_list_entry_t *entry;
1272 ui_file_list_entry_t *cursor;
1273 errno_t rc;
1274
1275 rc = ui_create_disp(NULL, &ui);
1276 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1277
1278 ui_wnd_params_init(&params);
1279 params.caption = "Test";
1280
1281 rc = ui_window_create(ui, &params, &window);
1282 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1283
1284 rc = ui_file_list_create(window, true, &flist);
1285 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1286
1287 ui_file_list_entry_attr_init(&attr);
1288
1289 /* Append entry */
1290 attr.name = "a";
1291 attr.size = 1;
1292 rc = ui_file_list_entry_append(flist, &attr);
1293 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1294
1295 entry = ui_file_list_first(flist);
1296 PCUT_ASSERT_NOT_NULL(entry);
1297
1298 /* Cursor should be at the only entry */
1299 cursor = ui_file_list_get_cursor(flist);
1300 PCUT_ASSERT_EQUALS(entry, cursor);
1301
1302 ui_file_list_destroy(flist);
1303 ui_window_destroy(window);
1304 ui_destroy(ui);
1305}
1306
1307static void test_file_list_activate_req(ui_file_list_t *flist, void *arg)
1308{
1309 test_resp_t *resp = (test_resp_t *)arg;
1310
1311 resp->activate_req = true;
1312 resp->activate_req_file_list = flist;
1313}
1314
1315static void test_file_list_selected(ui_file_list_t *flist, void *arg,
1316 const char *fname)
1317{
1318 test_resp_t *resp = (test_resp_t *)arg;
1319
1320 resp->selected = true;
1321 resp->selected_file_list = flist;
1322 resp->selected_fname = fname;
1323}
1324
1325PCUT_EXPORT(file_list);
Note: See TracBrowser for help on using the repository browser.