Changeset aefdccd in mainline for uspace/lib


Ignore:
Timestamp:
2025-10-20T06:14:54Z (2 months ago)
Author:
GitHub <noreply@…>
Parents:
adbd7e1 (diff), 3e41cc4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
boba-buba <120932204+boba-buba@…> (2025-10-20 06:14:54)
git-committer:
GitHub <noreply@…> (2025-10-20 06:14:54)
Message:

Merge branch 'HelenOS:master' into ticket/packet-capture

Location:
uspace/lib
Files:
15 added
29 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/arch/mips32/meson.build

    radbd7e1 raefdccd  
    3030
    3131arch_src += files(
     32        'src/atomic.c',
    3233        'src/entryjmp.S',
    3334        'src/thread_entry.S',

  • uspace/lib/c/arch/ppc32/meson.build

    radbd7e1 raefdccd  
    3030
    3131arch_src += files(
     32        'src/atomic.c',
    3233        'src/entryjmp.S',
    3334        'src/thread_entry.S',

  • uspace/lib/c/generic/capa.c

    radbd7e1 raefdccd  
    11/*
    2  * Copyright (c) 2015 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    199199}
    200200
     201/** Format capacity as string into a newly allocated buffer.
     202 *
     203 * @param capa Capacity
     204 * @param rstr Place to store pointer to newly allocated string
     205 * @return EOK on success or an error code
     206 */
    201207errno_t capa_format(capa_spec_t *capa, char **rstr)
    202208{
    … …  
    233239}
    234240
     241/** Format capacity as string into an existing buffer.
     242 *
     243 * @param capa Capacity
     244 * @param buf Buffer for storing string
     245 * @param bufsize Size of buffer in bytes
     246 * @return EOK on success or an error code
     247 */
     248errno_t capa_format_buf(capa_spec_t *capa, char *buf, size_t bufsize)
     249{
     250        errno_t rc;
     251        const char *sunit;
     252        uint64_t ipart;
     253        uint64_t fpart;
     254        uint64_t div;
     255
     256        sunit = NULL;
     257
     258        assert(capa->cunit < CU_LIMIT);
     259
     260        rc = ipow10_u64(capa->dp, &div);
     261        if (rc != EOK)
     262                return rc;
     263
     264        ipart = capa->m / div;
     265        fpart = capa->m % div;
     266
     267        sunit = cu_str[capa->cunit];
     268        if (capa->dp > 0) {
     269                snprintf(buf, bufsize, "%" PRIu64 ".%0*" PRIu64 " %s", ipart,
     270                    (int)capa->dp, fpart, sunit);
     271        } else {
     272                snprintf(buf, bufsize, "%" PRIu64 " %s", ipart, sunit);
     273        }
     274
     275        return EOK;
     276}
     277
     278/** Format capacity of n blocks as string into a newly allocated buffer.
     279 *
     280 * This computes the total capacity of the blocks, simplifies it
     281 * and formats it as string.
     282 *
     283 * @param nblocks Number of blocks
     284 * @param block_size Size of each block in bytes
     285 * @param rstr Place to store pointer to newly allocated string
     286 * @return EOK on success or an error code
     287 */
     288errno_t capa_blocks_format(uint64_t nblocks, size_t block_size,
     289    char **rptr)
     290{
     291        capa_spec_t capa;
     292
     293        capa_from_blocks(nblocks, block_size, &capa);
     294        capa_simplify(&capa);
     295        return capa_format(&capa, rptr);
     296}
     297
     298/** Format capacity of n blocks as string into an existing buffer.
     299 *
     300 * This computes the total capacity of the blocks, simplifies it
     301 * and formats it as string.
     302 *
     303 * This function does not return error. If the buffer is too small,
     304 * the string will be truncated. To make sure it is not truncated,
     305 * bufsize should be at least CAPA_BLOCKS_BUFSIZE.
     306 *
     307 * @param nblocks Number of blocks
     308 * @param block_size Size of each block in bytes
     309 * @param buf Buffer for storing string
     310 * @param bufsize Size of buffer in bytes
     311 */
     312void capa_blocks_format_buf(uint64_t nblocks, size_t block_size,
     313    char *buf, size_t bufsize)
     314{
     315        capa_spec_t capa;
     316        errno_t rc;
     317
     318        capa_from_blocks(nblocks, block_size, &capa);
     319        capa_simplify(&capa);
     320
     321        /* Should not get range error because of nblocks * block_size limits */
     322        rc = capa_format_buf(&capa, buf, bufsize);
     323        assert(rc == EOK);
     324        (void)rc;
     325}
     326
    235327static errno_t capa_digit_val(char c, int *val)
    236328{
    … …  
    273365}
    274366
     367/** Parse string as capacity specification.
     368 *
     369 * @param str String (e.g. "100 kB")
     370 * @param capa Place to store capacity
     371 * @return EOK on success or an error code
     372 */
    275373errno_t capa_parse(const char *str, capa_spec_t *capa)
    276374{

  • uspace/lib/c/include/capa.h

    radbd7e1 raefdccd  
    11/*
    2  * Copyright (c) 2015 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    8787} capa_spec_t;
    8888
     89/** Size of buffer large enough for capa_blocks_format_buf */
     90#define CAPA_BLOCKS_BUFSIZE 16
     91
    8992extern errno_t capa_format(capa_spec_t *, char **);
     93extern errno_t capa_format_buf(capa_spec_t *, char *, size_t);
     94extern errno_t capa_blocks_format(uint64_t, size_t, char **);
     95extern void capa_blocks_format_buf(uint64_t, size_t, char *, size_t);
    9096extern errno_t capa_parse(const char *, capa_spec_t *);
    9197extern void capa_simplify(capa_spec_t *);

  • uspace/lib/c/include/math.h

    radbd7e1 raefdccd  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2018 CZ.NIC, z.s.p.o.
    34 * All rights reserved.
    … …  
    3031#define _MATH_H
    3132
     33#include <_bits/decls.h>
    3234#include <limits.h>
    3335#include <stddef.h>
    3436#include <float.h>
     37
     38__C_DECLS_BEGIN;
    3539
    3640#if defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE) || defined(_HELENOS_SOURCE)
    … …  
    322326#endif
    323327
     328__C_DECLS_END;
     329
    324330#endif /* _MATH_H */

  • uspace/lib/c/test/capa.c

    radbd7e1 raefdccd  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2019 Matthieu Riolo
    34 * All rights reserved.
    … …  
    285286}
    286287
     288PCUT_TEST(capa_blocks_format)
     289{
     290        errno_t rc;
     291        char *str;
     292
     293        rc = capa_blocks_format(42, 1, &str);
     294        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     295        PCUT_ASSERT_STR_EQUALS("42 B", str);
     296        free(str);
     297}
     298
     299PCUT_TEST(capa_blocks_format_buf)
     300{
     301        char str[CAPA_BLOCKS_BUFSIZE];
     302
     303        capa_blocks_format_buf(42, 1, str, sizeof(str));
     304        PCUT_ASSERT_STR_EQUALS("42 B", str);
     305}
     306
    287307PCUT_EXPORT(capa);

  • uspace/lib/cpp/include/__bits/adt/bitset.hpp

    radbd7e1 raefdccd  
    4242    class bitset
    4343    {
     44        private:
     45            /**
     46             * While this might be a bit more wasteful
     47             * than using unsigned or unsigned long,
     48             * it will make parts of out code easier
     49             * to read.
     50             */
     51            using data_type = unsigned long long;
     52
    4453        public:
    4554            class reference
    … …  
    365374
    366375        private:
    367             /**
    368              * While this might be a bit more wasteful
    369              * than using unsigned or unsigned long,
    370              * it will make parts of out code easier
    371              * to read.
    372              */
    373             using data_type = unsigned long long;
    374 
    375376            static constexpr size_t bits_in_data_type_ = sizeof(data_type) * 8;
    376377            static constexpr size_t data_size_ = N / bits_in_data_type_ + 1;

  • uspace/lib/cpp/include/__bits/adt/list.hpp

    radbd7e1 raefdccd  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2019 Jaroslav Jindrak
    34 * All rights reserved.
    … …  
    8081                }
    8182
     83                pointer operator->() const
     84                {
     85                    return &current_->value;
     86                }
     87
    8288                list_const_iterator& operator++()
    8389                {
    … …  
    209215                    return current_->value;
    210216                }
     217
     218                pointer operator->() const
     219                {
     220                    return &current_->value;
     221                }
    211222
    212223                list_iterator& operator++()

  • uspace/lib/cpp/include/__bits/adt/list_node.hpp

    radbd7e1 raefdccd  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2018 Jaroslav Jindrak
    34 * All rights reserved.
    … …  
    2930#ifndef LIBCPP_BITS_ADT_LIST_NODE
    3031#define LIBCPP_BITS_ADT_LIST_NODE
     32
     33#include <utility>
    3134
    3235namespace std::aux

  • uspace/lib/cpp/include/__bits/insert_iterator.hpp

    radbd7e1 raefdccd  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2018 Jaroslav Jindrak
    34 * All rights reserved.
    … …  
    3334{
    3435    struct forward_iterator_tag;
     36    struct input_iterator_tag;
    3537}
    3638

  • uspace/lib/device/src/bd_srv.c

    radbd7e1 raefdccd  
    7777        rc = srv->srvs->ops->read_blocks(srv, ba, cnt, buf, size);
    7878        if (rc != EOK) {
    79                 async_answer_0(&rcall, ENOMEM);
    80                 async_answer_0(call, ENOMEM);
     79                async_answer_0(&rcall, rc);
     80                async_answer_0(call, rc);
    8181                free(buf);
    8282                return;
    … …  
    121121        rc = srv->srvs->ops->read_toc(srv, session, buf, size);
    122122        if (rc != EOK) {
    123                 async_answer_0(&rcall, ENOMEM);
    124                 async_answer_0(call, ENOMEM);
     123                async_answer_0(&rcall, rc);
     124                async_answer_0(call, rc);
    125125                free(buf);
    126126                return;

  • uspace/lib/math/meson.build

    radbd7e1 raefdccd  
    11#
     2# Copyright (c) 2025 Jiri Svoboda
    23# Copyright (c) 2013 Vojtech Horky
    34# All rights reserved.
    … …  
    3334        'generic/__fpclassify.c',
    3435        'generic/__signbit.c',
     36        'generic/atan2.c',
    3537        'generic/cos.c',
    3638        'generic/fabs.c',
     39        'generic/floor.c',
    3740        'generic/fmod.c',
    3841        'generic/fmodf.c',
    3942        'generic/nearbyint.c',
     43        'generic/pow.c',
     44        'generic/log.c',
     45        'generic/sqrt.c',
    4046        'generic/round.c',
     47        'generic/tan.c',
    4148        'generic/trig.c',
    4249        'generic/sin.c',

  • uspace/lib/meson.build

    radbd7e1 raefdccd  
    7272        'fbfont',
    7373        'fdisk',
     74        'fmgt',
    7475        'fmtutil',
    7576        'fs',
    … …  
    261262                                install_files += [[ 'lib', _shared_lib.full_path(), _libname ]]
    262263                                install_deps += [ _shared_lib ]
     264                                exported_devel_files += [ 'sharedlib', _shared_lib, _libname ]
    263265                        endif
    264266
    … …  
    289291                                dependencies: _shared_deps,
    290292                        )
    291                         exported_devel_files += [ 'sharedlib', _shared_lib, _libname ]
    292293                endif
    293294

  • uspace/lib/output/include/io/chargrid.h

    radbd7e1 raefdccd  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2011 Martin Decky
    34 * All rights reserved.
    … …  
    8182extern sysarg_t chargrid_putuchar(chargrid_t *, char32_t, bool);
    8283extern sysarg_t chargrid_newline(chargrid_t *);
     84extern sysarg_t chargrid_cr(chargrid_t *);
    8385extern sysarg_t chargrid_tabstop(chargrid_t *, sysarg_t);
    8486extern sysarg_t chargrid_backspace(chargrid_t *);

  • uspace/lib/output/src/chargrid.c

    radbd7e1 raefdccd  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2006 Josef Cejka
    34 * All rights reserved.
    … …  
    180181}
    181182
     183/** Return cursor to the beginning of the line.
     184 *
     185 * @param scrbuf Chargrid.
     186 *
     187 * @return Number of rows which have been affected. In usual
     188 *         situations this is 1.
     189 *
     190 */
     191sysarg_t chargrid_cr(chargrid_t *scrbuf)
     192{
     193        assert(scrbuf->col < scrbuf->cols);
     194        assert(scrbuf->row < scrbuf->rows);
     195
     196        scrbuf->col = 0;
     197        return 1;
     198}
     199
    182200/** Jump to a new row in chargrid.
    183201 *

  • uspace/lib/posix/include/posix/unistd.h

    radbd7e1 raefdccd  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2011 Jiri Zarevucky
    34 * Copyright (c) 2011 Petr Koupy
    … …  
    164165extern int execv(const char *path, char *const argv[]);
    165166extern int execvp(const char *file, char *const argv[]);
     167extern int execlp(const char *file, const char *arg, ...);
    166168
    167169/* Creating a Pipe */

  • uspace/lib/posix/src/unistd.c

    radbd7e1 raefdccd  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2011 Jiri Zarevucky
    34 * Copyright (c) 2011 Petr Koupy
    … …  
    530531/**
    531532 *
     533 * @param file
     534 * @param argv
     535 * @return
     536 */
     537int execlp(const char *file, const char *arg, ...)
     538{
     539        // TODO: low priority, just a compile-time dependency of dosbox
     540        not_implemented();
     541        return -1;
     542}
     543
     544/**
     545 *
    532546 * @param fildes
    533547 * @return

  • uspace/lib/ui/include/types/ui/list.h

    radbd7e1 raefdccd  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3838
    3939#include <gfx/color.h>
     40#include <stddef.h>
    4041
    4142struct ui_list;
    … …  
    6768} ui_list_cb_t;
    6869
     70/** Saved list position. */
     71typedef struct {
     72        /** Page index */
     73        size_t page_idx;
     74        /** Cursor index */
     75        size_t cursor_idx;
     76} ui_list_pos_t;
     77
    6978#endif
    7079

  • uspace/lib/ui/include/ui/filelist.h

    radbd7e1 raefdccd  
    5151extern errno_t ui_file_list_read_dir(ui_file_list_t *, const char *);
    5252extern errno_t ui_file_list_activate(ui_file_list_t *);
     53extern errno_t ui_file_list_refresh(ui_file_list_t *);
    5354extern void ui_file_list_deactivate(ui_file_list_t *);
    5455extern errno_t ui_file_list_open(ui_file_list_t *, ui_file_list_entry_t *);

  • uspace/lib/ui/include/ui/list.h

    radbd7e1 raefdccd  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    7171extern ui_list_entry_t *ui_list_prev(ui_list_entry_t *);
    7272extern bool ui_list_is_active(ui_list_t *);
     73extern void ui_list_save_pos(ui_list_t *, ui_list_pos_t *);
     74extern void ui_list_restore_pos(ui_list_t *, ui_list_pos_t *);
    7375
    7476#endif

  • uspace/lib/ui/include/ui/window.h

    radbd7e1 raefdccd  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    5656extern void ui_window_add(ui_window_t *, ui_control_t *);
    5757extern void ui_window_remove(ui_window_t *, ui_control_t *);
    58 extern ui_window_t *ui_window_get_active(ui_t *);
    5958extern errno_t ui_window_resize(ui_window_t *, gfx_rect_t *);
    6059extern ui_t *ui_window_get_ui(ui_window_t *);

  • uspace/lib/ui/private/window.h

    radbd7e1 raefdccd  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    136136extern errno_t ui_window_size_change(ui_window_t *, gfx_rect_t *,
    137137    ui_wnd_sc_op_t);
     138extern ui_window_t *ui_window_get_active(ui_t *);
     139extern ui_window_t *ui_window_first(ui_t *);
     140extern ui_window_t *ui_window_next(ui_window_t *);
    138141
    139142#endif

  • uspace/lib/ui/src/filelist.c

    radbd7e1 raefdccd  
    349349                goto error;
    350350        }
     351
     352        ui_file_list_clear_entries(flist);
    351353
    352354        if (str_cmp(ndir, "/") != 0) {
    … …  
    422424}
    423425
     426/** Re-read file list from directory.
     427 *
     428 * @param flist File list
     429 * @return EOK on success or an error code
     430 */
     431errno_t ui_file_list_refresh(ui_file_list_t *flist)
     432{
     433        errno_t rc;
     434        ui_list_pos_t pos;
     435
     436        ui_list_save_pos(flist->list, &pos);
     437        rc = ui_file_list_read_dir(flist, flist->dir);
     438        if (rc != EOK)
     439                return rc;
     440        ui_list_restore_pos(flist->list, &pos);
     441        return EOK;
     442}
     443
    424444/** Sort file list entries.
    425445 *
    … …  
    593613                return ENOMEM;
    594614
    595         ui_file_list_clear_entries(flist);
    596 
    597615        rc = ui_file_list_read_dir(flist, dirname);
    598616        if (rc != EOK) {

  • uspace/lib/ui/src/list.c

    radbd7e1 raefdccd  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    16521652}
    16531653
     1654/** Save list position for later.
     1655 *
     1656 * The position will be valid even if the list is cleaned and re-populated
     1657 * (it just counts position from the top.)
     1658 *
     1659 * @param list UI list
     1660 * @param pos Place to store position
     1661 */
     1662void ui_list_save_pos(ui_list_t *list, ui_list_pos_t *pos)
     1663{
     1664        pos->page_idx = list->page_idx;
     1665        pos->cursor_idx = list->cursor_idx;
     1666}
     1667
     1668/** Restore saved list position.
     1669 *
     1670 * The position will be valid even if the list is cleaned and re-populated
     1671 * (it just counts position from the top.)
     1672 *
     1673 * @param list UI list
     1674 * @param pos Saved list position
     1675 */
     1676void ui_list_restore_pos(ui_list_t *list, ui_list_pos_t *pos)
     1677{
     1678        size_t idx, i;
     1679        ui_list_entry_t *entry, *next;
     1680
     1681        idx = 0;
     1682        entry = ui_list_first(list);
     1683
     1684        for (i = 0; i < pos->cursor_idx; i++) {
     1685                next = ui_list_next(entry);
     1686                if (next != NULL) {
     1687                        entry = next;
     1688                        ++idx;
     1689                }
     1690        }
     1691
     1692        list->cursor = entry;
     1693        list->cursor_idx = idx;
     1694
     1695        idx = 0;
     1696        entry = ui_list_first(list);
     1697
     1698        for (i = 0; i < pos->page_idx; i++) {
     1699                next = ui_list_next(entry);
     1700                if (next != NULL) {
     1701                        entry = next;
     1702                        ++idx;
     1703                }
     1704        }
     1705
     1706        list->page = entry;
     1707        list->page_idx = idx;
     1708}
     1709
    16541710/** @}
    16551711 */

  • uspace/lib/ui/src/msgdialog.c

    radbd7e1 raefdccd  
    285285        if (dialog->cb != NULL && dialog->cb->close != NULL)
    286286                dialog->cb->close(dialog, dialog->arg);
     287        else
     288                ui_msg_dialog_destroy(dialog);
    287289}
    288290
    … …  
    310312                                dialog->cb->button(dialog, dialog->arg, 0);
    311313                                return;
     314                        } else {
     315                                ui_msg_dialog_destroy(dialog);
    312316                        }
    313317                } else if (event->key == KC_ESCAPE) {
    … …  
    316320                                dialog->cb->close(dialog, dialog->arg);
    317321                                return;
     322                        } else {
     323                                ui_msg_dialog_destroy(dialog);
    318324                        }
    319325                }
    … …  
    337343                                dialog->cb->button(dialog, dialog->arg, i);
    338344                }
     345        } else {
     346                ui_msg_dialog_destroy(dialog);
    339347        }
    340348}

  • uspace/lib/ui/src/ui.c

    radbd7e1 raefdccd  
    412412        errno_t rc;
    413413        gfx_context_t *gc;
    414         ui_window_t *awnd;
     414        ui_window_t *wnd;
    415415        gfx_color_t *color = NULL;
    416416
    … …  
    439439        gfx_color_delete(color);
    440440
    441         /* XXX Should repaint all windows */
    442         awnd = ui_window_get_active(ui);
    443         if (awnd == NULL)
    444                 return EOK;
    445 
    446         rc = ui_wdecor_paint(awnd->wdecor);
    447         if (rc != EOK)
    448                 return rc;
    449 
    450         return ui_window_paint(awnd);
     441        /* Repaint all windows */
     442        wnd = ui_window_first(ui);
     443        while (wnd != NULL) {
     444                rc = ui_wdecor_paint(wnd->wdecor);
     445                if (rc != EOK)
     446                        return rc;
     447
     448                rc = ui_window_paint(wnd);
     449                if (rc != EOK)
     450                        return rc;
     451
     452                wnd = ui_window_next(wnd);
     453        }
     454
     455        return EOK;
    451456}
    452457

  • uspace/lib/ui/src/window.c

    radbd7e1 raefdccd  
    617617}
    618618
     619/** Get first (lowermost) window (only valid in fullscreen mode).
     620 *
     621 * @param ui User interface
     622 * @return First window
     623 */
     624ui_window_t *ui_window_first(ui_t *ui)
     625{
     626        link_t *link;
     627
     628        link = list_first(&ui->windows);
     629        if (link == NULL)
     630                return NULL;
     631
     632        return list_get_instance(link, ui_window_t, lwindows);
     633}
     634
     635/** Get next window (only valid in fullscreen mode).
     636 *
     637 * @param cur Current window
     638 * @return First window
     639 */
     640ui_window_t *ui_window_next(ui_window_t *cur)
     641{
     642        link_t *link;
     643
     644        link = list_next(&cur->lwindows, &cur->ui->windows);
     645        if (link == NULL)
     646                return NULL;
     647
     648        return list_get_instance(link, ui_window_t, lwindows);
     649}
     650
    619651/** Get active window (only valid in fullscreen mode).
    620652 *

  • uspace/lib/ui/test/filelist.c

    radbd7e1 raefdccd  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    665665}
    666666
     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
    667769/** ui_file_list_list_compare compares two file list entries */
    668770PCUT_TEST(list_compare)

  • uspace/lib/ui/test/list.c

    radbd7e1 raefdccd  
    11/*
    2  * Copyright (c) 2024 Jiri Svoboda
     2 * Copyright (c) 2025 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    30643064}
    30653065
     3066/** ui_list_save_pos() / ui_list_restore_pos() saves/restores position */
     3067PCUT_TEST(save_pos_restore_pos)
     3068{
     3069        ui_t *ui;
     3070        ui_window_t *window;
     3071        ui_wnd_params_t params;
     3072        ui_list_t *list;
     3073        ui_list_entry_t *a, *b;
     3074        ui_list_entry_attr_t attr;
     3075        ui_list_pos_t pos;
     3076        test_resp_t resp;
     3077        errno_t rc;
     3078
     3079        rc = ui_create_disp(NULL, &ui);
     3080        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     3081
     3082        ui_wnd_params_init(&params);
     3083        params.caption = "Test";
     3084
     3085        rc = ui_window_create(ui, &params, &window);
     3086        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     3087
     3088        rc = ui_list_create(window, true, &list);
     3089        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     3090
     3091        ui_list_set_cb(list, &test_cb, &resp);
     3092
     3093        ui_list_entry_attr_init(&attr);
     3094
     3095        attr.caption = "a";
     3096        attr.arg = (void *)2;
     3097        rc = ui_list_entry_append(list, &attr, &a);
     3098        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     3099
     3100        attr.caption = "b";
     3101        attr.arg = (void *)1;
     3102        rc = ui_list_entry_append(list, &attr, &b);
     3103        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     3104
     3105        ui_list_set_cursor(list, b);
     3106
     3107        ui_list_save_pos(list, &pos);
     3108
     3109        /* Empty and re-build list. */
     3110
     3111        ui_list_entry_destroy(a);
     3112        ui_list_entry_destroy(b);
     3113
     3114        ui_list_entry_attr_init(&attr);
     3115
     3116        attr.caption = "a";
     3117        attr.arg = (void *)2;
     3118        rc = ui_list_entry_append(list, &attr, &a);
     3119        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     3120
     3121        attr.caption = "b";
     3122        attr.arg = (void *)1;
     3123        rc = ui_list_entry_append(list, &attr, &b);
     3124        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     3125
     3126        ui_list_restore_pos(list, &pos);
     3127
     3128        PCUT_ASSERT_STR_EQUALS("b", list->cursor->caption);
     3129
     3130        ui_list_destroy(list);
     3131        ui_window_destroy(window);
     3132        ui_destroy(ui);
     3133}
     3134
    30663135static void test_list_activate_req(ui_list_t *list, void *arg)
    30673136{
Note: See TracChangeset for help on using the changeset viewer.