Changeset a35b458 in mainline for uspace/app/tester


Ignore:
Timestamp:
2018-03-02T20:10:49Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
uspace/app/tester
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/tester/console/console1.c

    r3061bc1 ra35b458  
    5151        if (!test_quiet) {
    5252                console_ctrl_t *console = console_init(stdin, stdout);
    53                
     53
    5454                printf("Style test: ");
    5555                console_flush(console);
    … …  
    6868                console_set_style(console, STYLE_NORMAL);
    6969                printf("\n");
    70                
     70
    7171                unsigned int i;
    7272                unsigned int j;
    73                
     73
    7474                printf("\nForeground color test:\n");
    7575                for (j = 0; j < 2; j++) {
    … …  
    8484                        putchar('\n');
    8585                }
    86                
     86
    8787                printf("\nBackground color test:\n");
    8888                for (j = 0; j < 2; j++) {
    … …  
    9797                        putchar('\n');
    9898                }
    99                
     99
    100100                printf("\nRGB colors test:\n");
    101                
     101
    102102                for (i = 0; i < 255; i += 16) {
    103103                        console_flush(console);
    … …  
    108108                console_set_color(console, COLOR_WHITE, COLOR_BLACK, 0);
    109109                putchar('\n');
    110                
     110
    111111                for (i = 0; i < 255; i += 16) {
    112112                        console_flush(console);
    … …  
    117117                console_set_color(console, COLOR_WHITE, COLOR_BLACK, 0);
    118118                putchar('\n');
    119                
     119
    120120                for (i = 0; i < 255; i += 16) {
    121121                        console_flush(console);
    … …  
    127127                putchar('\n');
    128128        }
    129        
     129
    130130        return NULL;
    131131}

  • uspace/app/tester/fault/fault1.c

    r3061bc1 ra35b458  
    3333{
    3434        ((int *)(0))[1] = 0;
    35        
     35
    3636        return "Survived write to NULL";
    3737}

  • uspace/app/tester/fault/fault2.c

    r3061bc1 ra35b458  
    3838        volatile int var1 = *((aliasing_int *) (((char *) (&var)) + 1));
    3939        printf("Read %d\n", var1);
    40        
     40
    4141        return "Survived unaligned read";
    4242}

  • uspace/app/tester/float/float1.c

    r3061bc1 ra35b458  
    5252                double e = 0;
    5353                double f = 1;
    54                
     54
    5555                for (double d = 1; e != le; d *= f, f += 1) {
    5656                        le = e;
    5757                        e = e + 1 / d;
    5858                }
    59                
     59
    6060                if ((uint32_t) (e * PRECISION) != E_10E8) {
    6161                        atomic_inc(&threads_fault);
    … …  
    6363                }
    6464        }
    65        
     65
    6666        atomic_inc(&threads_finished);
    6767}
    … …  
    7070{
    7171        atomic_count_t total = 0;
    72        
     72
    7373        atomic_set(&threads_finished, 0);
    7474        atomic_set(&threads_fault, 0);
    75        
     75
    7676        TPRINTF("Creating threads");
    7777        for (unsigned int i = 0; i < THREADS; i++) {
    … …  
    8080                        break;
    8181                }
    82                
     82
    8383                TPRINTF(".");
    8484                total++;
    8585        }
    86        
     86
    8787        TPRINTF("\n");
    88        
     88
    8989        while (atomic_get(&threads_finished) < total) {
    9090                TPRINTF("Threads left: %" PRIua "\n",
    … …  
    9292                thread_sleep(1);
    9393        }
    94        
     94
    9595        if (atomic_get(&threads_fault) == 0)
    9696                return NULL;
    97        
     97
    9898        return "Test failed";
    9999}

  • uspace/app/tester/float/softfloat1.c

    r3061bc1 ra35b458  
    100100        if (a < b)
    101101                return -1;
    102        
     102
    103103        if (a > b)
    104104                return 1;
    105        
     105
    106106        return 0;
    107107}
    … …  
    111111        if (a < b)
    112112                return -1;
    113        
     113
    114114        if (a > b)
    115115                return 1;
    116        
     116
    117117        return 0;
    118118}
    … …  
    122122{
    123123        uint_to_double_op_t op = (uint_to_double_op_t) f;
    124        
     124
    125125        double c;
    126126        double sc;
    127127        op(uop_a[i], &c, &sc);
    128        
     128
    129129        *pic = (cmptype_t) (c * PRECISION);
    130130        *pisc = (cmptype_t) (sc * PRECISION);
    … …  
    135135{
    136136        double_to_uint_op_t op = (double_to_uint_op_t) f;
    137        
     137
    138138        unsigned int c;
    139139        unsigned int sc;
    140140        op(dop_a[i], &c, &sc);
    141        
     141
    142142        *pic = (cmptype_t) c;
    143143        *pisc = (cmptype_t) sc;
    … …  
    148148{
    149149        float_binary_op_t op = (float_binary_op_t) f;
    150        
     150
    151151        float c;
    152152        float sc;
    153153        op(fop_a[i], fop_a[j], &c, &sc);
    154        
     154
    155155        *pic = (cmptype_t) (c * PRECISION);
    156156        *pisc = (cmptype_t) (sc * PRECISION);
    … …  
    161161{
    162162        float_cmp_op_t op = (float_cmp_op_t) f;
    163        
     163
    164164        op(dop_a[i], dop_a[j], pis, piss);
    165165}
    … …  
    169169{
    170170        double_binary_op_t op = (double_binary_op_t) f;
    171        
     171
    172172        double c;
    173173        double sc;
    174174        op(dop_a[i], dop_a[j], &c, &sc);
    175        
     175
    176176        *pic = (cmptype_t) (c * PRECISION);
    177177        *pisc = (cmptype_t) (sc * PRECISION);
    … …  
    182182{
    183183        double_cmp_op_t op = (double_cmp_op_t) f;
    184        
     184
    185185        op(dop_a[i], dop_a[j], pis, piss);
    186186}
    … …  
    189189{
    190190        bool correct = true;
    191        
     191
    192192        for (unsigned int i = 0; i < OPERANDS; i++) {
    193193                cmptype_t ic;
    194194                cmptype_t isc;
    195                
     195
    196196                template(f, i, &ic, &isc);
    197197                cmptype_t diff = ic - isc;
    198                
     198
    199199                if (diff != 0) {
    200200                        TPRINTF("i=%u ic=%" PRIdCMPTYPE " isc=%" PRIdCMPTYPE "\n",
    … …  
    203203                }
    204204        }
    205        
     205
    206206        return correct;
    207207}
    … …  
    210210{
    211211        bool correct = true;
    212        
     212
    213213        for (unsigned int i = 0; i < OPERANDS; i++) {
    214214                for (unsigned int j = 0; j < OPERANDS; j++) {
    215215                        cmptype_t ic;
    216216                        cmptype_t isc;
    217                        
     217
    218218                        template(f, i, j, &ic, &isc);
    219219                        cmptype_t diff = ic - isc;
    220                        
     220
    221221                        if (diff != 0) {
    222222                                TPRINTF("i=%u, j=%u ic=%" PRIdCMPTYPE
    … …  
    226226                }
    227227        }
    228        
     228
    229229        return correct;
    230230}
    … …  
    275275                return;
    276276        }
    277        
     277
    278278        *pc = a / b;
    279279        *psc = div_float(a, b);
    … …  
    284284{
    285285        *pis = fcmp(a, b);
    286        
     286
    287287        if (is_float_lt(a, b) == -1)
    288288                *piss = -1;
    … …  
    320320                return;
    321321        }
    322        
     322
    323323        *pc = a / b;
    324324        *psc = div_double(a, b);
    … …  
    329329{
    330330        *pis = dcmp(a, b);
    331        
     331
    332332        if (is_double_lt(a, b) == -1)
    333333                *piss = -1;
    … …  
    343343{
    344344        bool err = false;
    345        
     345
    346346        if (!test_template_binary(float_template_binary, float_add_operator)) {
    347347                err = true;
    348348                TPRINTF("%s\n", "Float addition failed");
    349349        }
    350        
     350
    351351        if (!test_template_binary(float_template_binary, float_sub_operator)) {
    352352                err = true;
    353353                TPRINTF("%s\n", "Float addition failed");
    354354        }
    355        
     355
    356356        if (!test_template_binary(float_template_binary, float_mul_operator)) {
    357357                err = true;
    358358                TPRINTF("%s\n", "Float multiplication failed");
    359359        }
    360        
     360
    361361        if (!test_template_binary(float_template_binary, float_div_operator)) {
    362362                err = true;
    363363                TPRINTF("%s\n", "Float division failed");
    364364        }
    365        
     365
    366366        if (!test_template_binary(float_compare_template, float_cmp_operator)) {
    367367                err = true;
    368368                TPRINTF("%s\n", "Float comparison failed");
    369369        }
    370        
     370
    371371        if (!test_template_binary(double_template_binary, double_add_operator)) {
    372372                err = true;
    373373                TPRINTF("%s\n", "Double addition failed");
    374374        }
    375        
     375
    376376        if (!test_template_binary(double_template_binary, double_sub_operator)) {
    377377                err = true;
    378378                TPRINTF("%s\n", "Double addition failed");
    379379        }
    380        
     380
    381381        if (!test_template_binary(double_template_binary, double_mul_operator)) {
    382382                err = true;
    383383                TPRINTF("%s\n", "Double multiplication failed");
    384384        }
    385        
     385
    386386        if (!test_template_binary(double_template_binary, double_div_operator)) {
    387387                err = true;
    388388                TPRINTF("%s\n", "Double division failed");
    389389        }
    390        
     390
    391391        if (!test_template_binary(double_compare_template, double_cmp_operator)) {
    392392                err = true;
    393393                TPRINTF("%s\n", "Double comparison failed");
    394394        }
    395        
     395
    396396        if (!test_template_unary(uint_to_double_template,
    397397            uint_to_double_operator)) {
    … …  
    399399                TPRINTF("%s\n", "Conversion from unsigned int to double failed");
    400400        }
    401        
     401
    402402        if (!test_template_unary(double_to_uint_template,
    403403            double_to_uint_operator)) {
    … …  
    405405                TPRINTF("%s\n", "Conversion from double to unsigned int failed");
    406406        }
    407        
     407
    408408        if (!test_template_unary(double_to_uint_template,
    409409            double_to_int_operator)) {
    … …  
    411411                TPRINTF("%s\n", "Conversion from double to signed int failed");
    412412        }
    413        
     413
    414414        if (err)
    415415                return "Software floating point imprecision";
    416        
     416
    417417        return NULL;
    418418}

  • uspace/app/tester/hw/serial/serial1.c

    r3061bc1 ra35b458  
    5959        size_t nread;
    6060        size_t nwritten;
    61        
     61
    6262        if (test_argc < 1)
    6363                cnt = DEFAULT_COUNT;
    … …  
    7373                        return "Unexpected argument error";
    7474                }
    75        
     75
    7676        service_id_t svc_id;
    7777        errno_t res = loc_service_get_id("devices/\\hw\\pci0\\00:01.0\\com1\\a",
    … …  
    7979        if (res != EOK)
    8080                return "Failed getting serial port service ID";
    81        
     81
    8282        async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
    8383            IPC_FLAG_BLOCKING);
    8484        if (sess == NULL)
    8585                return "Failed connecting to serial device";
    86        
     86
    8787        res = chardev_open(sess, &chardev);
    8888        if (res != EOK) {
    … …  
    9090                return "Failed opening serial port";
    9191        }
    92        
     92
    9393        res = serial_open(sess, &serial);
    9494        if (res != EOK) {
    … …  
    9797                return "Failed opening serial port";
    9898        }
    99        
     99
    100100        char *buf = (char *) malloc(cnt + 1);
    101101        if (buf == NULL) {
    … …  
    105105                return "Failed allocating input buffer";
    106106        }
    107        
     107
    108108        unsigned old_baud;
    109109        serial_parity_t old_par;
    110110        unsigned old_stop;
    111111        unsigned old_word_size;
    112        
     112
    113113        res = serial_get_comm_props(serial, &old_baud, &old_par,
    114114            &old_word_size, &old_stop);
    … …  
    120120                return "Failed to get old serial communication parameters";
    121121        }
    122        
     122
    123123        res = serial_set_comm_props(serial, 1200, SERIAL_NO_PARITY, 8, 1);
    124124        if (EOK != res) {
    … …  
    129129                return "Failed setting serial communication parameters";
    130130        }
    131        
     131
    132132        TPRINTF("Trying reading %zu characters from serial device "
    133133            "(svc_id=%" PRIun ")\n", cnt, svc_id);
    134        
     134
    135135        size_t total = 0;
    136136        while (total < cnt) {
    137                
     137
    138138                rc = chardev_read(chardev, buf, cnt - total, &nread);
    139139                if (rc != EOK) {
    140140                        (void) serial_set_comm_props(serial, old_baud,
    141141                            old_par, old_word_size, old_stop);
    142                        
     142
    143143                        free(buf);
    144144                        chardev_close(chardev);
    … …  
    147147                        return "Failed reading from serial device";
    148148                }
    149                
     149
    150150                if (nread > cnt - total) {
    151151                        (void) serial_set_comm_props(serial, old_baud,
    152152                            old_par, old_word_size, old_stop);
    153                        
     153
    154154                        free(buf);
    155155                        chardev_close(chardev);
    … …  
    158158                        return "Read more data than expected";
    159159                }
    160                
     160
    161161                TPRINTF("Read %zd bytes\n", nread);
    162                
     162
    163163                buf[nread] = 0;
    164                
     164
    165165                /*
    166166                 * Write data back to the device to test the opposite
    … …  
    171171                        (void) serial_set_comm_props(serial, old_baud,
    172172                            old_par, old_word_size, old_stop);
    173                        
     173
    174174                        free(buf);
    175175                        chardev_close(chardev);
    … …  
    178178                        return "Failed writing to serial device";
    179179                }
    180                
     180
    181181                if (nwritten != nread) {
    182182                        (void) serial_set_comm_props(serial, old_baud,
    183183                            old_par, old_word_size, old_stop);
    184                        
     184
    185185                        free(buf);
    186186                        chardev_close(chardev);
    … …  
    189189                        return "Written less data than read from serial device";
    190190                }
    191                
     191
    192192                TPRINTF("Written %zd bytes\n", nwritten);
    193                
     193
    194194                total += nread;
    195195        }
    196        
     196
    197197        TPRINTF("Trying to write EOT banner to the serial device\n");
    198        
     198
    199199        size_t eot_size = str_size(EOT);
    200200        rc = chardev_write(chardev, (void *) EOT, eot_size, &nwritten);
    201        
     201
    202202        (void) serial_set_comm_props(serial, old_baud, old_par, old_word_size,
    203203            old_stop);
    204        
     204
    205205        free(buf);
    206206        chardev_close(chardev);
    207207        serial_close(serial);
    208208        async_hangup(sess);
    209        
     209
    210210        if (rc != EOK)
    211211                return "Failed to write EOT banner to serial device";
    212        
     212
    213213        if (nwritten != eot_size)
    214214                return "Written less data than the size of the EOT banner "
    215215                    "to serial device";
    216        
     216
    217217        return NULL;
    218218}

  • uspace/app/tester/ipc/ping_pong.c

    r3061bc1 ra35b458  
    4141{
    4242        TPRINTF("Pinging ns server for %d seconds...", DURATION_SECS);
    43        
     43
    4444        struct timeval start;
    4545        gettimeofday(&start, NULL);
    46        
     46
    4747        uint64_t count = 0;
    4848        while (true) {
    4949                struct timeval now;
    5050                gettimeofday(&now, NULL);
    51                
     51
    5252                if (tv_sub_diff(&now, &start) >= DURATION_SECS * 1000000L)
    5353                        break;
    54                
     54
    5555                size_t i;
    5656                for (i = 0; i < COUNT_GRANULARITY; i++) {
    5757                        errno_t retval = ns_ping();
    58                        
     58
    5959                        if (retval != EOK) {
    6060                                TPRINTF("\n");
    … …  
    6262                        }
    6363                }
    64                
     64
    6565                count += COUNT_GRANULARITY;
    6666        }
    67        
     67
    6868        TPRINTF("OK\nCompleted %" PRIu64 " round trips in %u seconds, %" PRIu64 " rt/s.\n",
    6969            count, DURATION_SECS, count / DURATION_SECS);
    70        
     70
    7171        return NULL;
    7272}

  • uspace/app/tester/ipc/starve.c

    r3061bc1 ra35b458  
    4242        if (console == NULL)
    4343                return "Failed to init connection with console.";
    44        
     44
    4545        struct timeval start;
    4646        gettimeofday(&start, NULL);
    47        
     47
    4848        TPRINTF("Intensive computation shall be imagined (for %ds)...\n", DURATION_SECS);
    4949        TPRINTF("Press a key to terminate prematurely...\n");
    … …  
    5151                struct timeval now;
    5252                gettimeofday(&now, NULL);
    53                
     53
    5454                if (tv_sub_diff(&now, &start) >= DURATION_SECS * 1000000L)
    5555                        break;
    56                
     56
    5757                cons_event_t ev;
    5858                suseconds_t timeout = 0;
    … …  
    6363                }
    6464        }
    65        
     65
    6666        // FIXME - unless a key was pressed, the answer leaked as no one
    6767        // will wait for it.
    6868        // We cannot use async_forget() directly, though. Something like
    6969        // console_forget_pending_kbd_event() shall come here.
    70        
     70
    7171        TPRINTF("Terminating...\n");
    72        
     72
    7373        console_done(console);
    74        
     74
    7575        return err;
    7676}

  • uspace/app/tester/loop/loop1.c

    r3061bc1 ra35b458  
    3636        while (true);
    3737        TPRINTF("\n");
    38        
     38
    3939        return "Survived endless loop";
    4040}

  • uspace/app/tester/mm/common.c

    r3061bc1 ra35b458  
    7272{
    7373        link_t *link;
    74        
     74
    7575        while ((link = list_first(&mem_blocks)) != NULL) {
    7676                mem_block_t *block = list_get_instance(link, mem_block_t, link);
    7777                free_block(block);
    7878        }
    79        
     79
    8080        while ((link = list_first(&mem_areas)) != NULL) {
    8181                mem_area_t *area = list_get_instance(link, mem_area_t, link);
    … …  
    8989        uint8_t *mbeg = (uint8_t *) block;
    9090        uint8_t *mend = (uint8_t *) block + sizeof(mem_block_t);
    91        
     91
    9292        /* Entry block memory <bbeg, bend) */
    9393        uint8_t *bbeg = (uint8_t *) block->addr;
    9494        uint8_t *bend = (uint8_t *) block->addr + block->size;
    95        
     95
    9696        /* Data block <dbeg, dend) */
    9797        uint8_t *dbeg = (uint8_t *) addr;
    9898        uint8_t *dend = (uint8_t *) addr + size;
    99        
     99
    100100        /* Check for overlaps */
    101101        if (((mbeg >= dbeg) && (mbeg < dend)) ||
    … …  
    104104            ((bend > dbeg) && (bend <= dend)))
    105105                return true;
    106        
     106
    107107        return false;
    108108}
    … …  
    122122{
    123123        bool fnd = false;
    124        
     124
    125125        list_foreach(mem_blocks, link, mem_block_t, block) {
    126126                if (overlap_match(block, addr, size)) {
    … …  
    129129                }
    130130        }
    131        
     131
    132132        return fnd;
    133133}
    … …  
    160160{
    161161        void *data;
    162        
     162
    163163        /* Allocate the chunk of memory */
    164164        data = malloc(size);
    … …  
    166166        if (data == NULL)
    167167                return NULL;
    168        
     168
    169169        /* Check for overlaps with other chunks */
    170170        if (test_overlap(data, size)) {
    … …  
    174174                error_flag = true;
    175175        }
    176        
     176
    177177        return data;
    178178}
    … …  
    197197        if (mem_allocated >= MAX_ALLOC)
    198198                return NULL;
    199        
     199
    200200        /* Allocate the block holder */
    201201        mem_block_t *block =
    … …  
    203203        if (block == NULL)
    204204                return NULL;
    205        
     205
    206206        link_initialize(&block->link);
    207        
     207
    208208        /* Allocate the block memory */
    209209        block->addr = checked_malloc(size);
    … …  
    213213                return NULL;
    214214        }
    215        
     215
    216216        block->size = size;
    217        
     217
    218218        /* Register the allocated block */
    219219        list_append(&block->link, &mem_blocks);
    220220        mem_allocated += size + sizeof(mem_block_t);
    221221        mem_blocks_count++;
    222        
     222
    223223        return block;
    224224}
    … …  
    238238        mem_allocated -= block->size + sizeof(mem_block_t);
    239239        mem_blocks_count--;
    240        
     240
    241241        /* Free the memory */
    242242        free(block->addr);
    … …  
    272272            pos < end; pos++)
    273273                *pos = block_expected_value(block, pos);
    274        
     274
    275275        check_consistency("fill_block");
    276276}
    … …  
    308308        if (mem_blocks_count == 0)
    309309                return NULL;
    310        
     310
    311311        unsigned long idx = rand() % mem_blocks_count;
    312312        link_t *entry = list_nth(&mem_blocks, idx);
    313        
     313
    314314        if (entry == NULL) {
    315315                TPRINTF("\nError: Corrupted list of allocated memory blocks.\n");
    … …  
    317317                error_flag = true;
    318318        }
    319        
     319
    320320        return list_get_instance(entry, mem_block_t, link);
    321321}
    … …  
    337337        if (area == NULL)
    338338                return NULL;
    339        
     339
    340340        link_initialize(&area->link);
    341        
     341
    342342        area->addr = as_area_create(AS_AREA_ANY, size,
    343343            AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE,
    … …  
    348348                return NULL;
    349349        }
    350        
     350
    351351        area->size = size;
    352        
     352
    353353        /* Register the allocated area */
    354354        list_append(&area->link, &mem_areas);
    355        
     355
    356356        return area;
    357357}
    … …  
    369369        /* Unregister the area */
    370370        list_remove(&area->link);
    371        
     371
    372372        /* Free the memory */
    373373        errno_t ret = as_area_destroy(area->addr);
    374374        if (ret != EOK)
    375375                error_flag = true;
    376        
     376
    377377        free(area);
    378378        check_consistency("unmap_area");
    … …  
    405405            pos < end; pos++)
    406406                *pos = area_expected_value(area, pos);
    407        
     407
    408408        check_consistency("fill_area");
    409409}

  • uspace/app/tester/mm/common.h

    r3061bc1 ra35b458  
    4848        /* Address of the start of the block */
    4949        void *addr;
    50        
     50
    5151        /* Size of the memory block */
    5252        size_t size;
    53        
     53
    5454        /* Link to other blocks */
    5555        link_t link;
    … …  
    5959        /* Address of the start of the area */
    6060        void *addr;
    61        
     61
    6262        /* Size of the memory area */
    6363        size_t size;

  • uspace/app/tester/mm/malloc1.c

    r3061bc1 ra35b458  
    208208{
    209209        for (unsigned int cycles = 0; /* always */; cycles++) {
    210                
     210
    211211                if ((subphase->cond.max_cycles) &&
    212212                    (cycles >= subphase->cond.max_cycles)) {
    … …  
    217217                        break;
    218218                }
    219                
     219
    220220                /*
    221221                 * Decide whether we alloc or free memory in this step.
    … …  
    229229                        int alloc = phase->alloc.min_block_size +
    230230                            (rand() % (phase->alloc.max_block_size - phase->alloc.min_block_size + 1));
    231                        
     231
    232232                        mem_block_t *blk = alloc_block(alloc);
    233233                        RETURN_IF_ERROR;
    234                        
     234
    235235                        if (blk == NULL) {
    236236                                TPRINTF("F(A)");
    … …  
    244244                                RETURN_IF_ERROR;
    245245                        }
    246                        
     246
    247247                } else if (rnd < subphase->prob.free) {
    248248                        mem_block_t *blk = get_random_block();
    … …  
    257257                                check_block(blk);
    258258                                RETURN_IF_ERROR;
    259                                
     259
    260260                                free_block(blk);
    261261                                RETURN_IF_ERROR;
    … …  
    263263                }
    264264        }
    265        
     265
    266266        TPRINTF("\n..  finished.\n");
    267267}
    … …  
    271271        for (unsigned int subno = 0; subno < 3; subno++) {
    272272                subphase_t *subphase = &phase->subphases[subno];
    273                
     273
    274274                TPRINTF(".. Sub-phase %u (%s)\n", subno + 1, subphase->name);
    275275                do_subphase(phase, subphase);
    … …  
    281281{
    282282        init_mem();
    283        
     283
    284284        for (unsigned int phaseno = 0; phaseno < sizeof_array(phases);
    285285            phaseno++) {
    286286                phase_t *phase = &phases[phaseno];
    287                
     287
    288288                TPRINTF("Entering phase %u (%s)\n", phaseno + 1, phase->name);
    289                
     289
    290290                do_phase(phase);
    291291                if (error_flag)
    292292                        break;
    293                
     293
    294294                TPRINTF("Phase finished.\n");
    295295        }
    296        
     296
    297297        TPRINTF("Cleaning up.\n");
    298298        done_mem();
    299299        if (error_flag)
    300300                return "Test failed";
    301        
     301
    302302        return NULL;
    303303}

  • uspace/app/tester/mm/malloc3.c

    r3061bc1 ra35b458  
    200200{
    201201        for (unsigned int cycles = 0; /* always */; cycles++) {
    202                
     202
    203203                if ((subphase->cond.max_cycles) &&
    204204                    (cycles >= subphase->cond.max_cycles)) {
    … …  
    209209                        break;
    210210                }
    211                
     211
    212212                /*
    213213                 * Decide whether we alloc or free memory in this step.
    … …  
    221221                        int alloc = phase->alloc.min_block_size +
    222222                            (rand() % (phase->alloc.max_block_size - phase->alloc.min_block_size + 1));
    223                        
     223
    224224                        mem_block_t *blk = alloc_block(alloc);
    225225                        RETURN_IF_ERROR;
    226                        
     226
    227227                        if (blk == NULL) {
    228228                                TPRINTF("F(A)");
    … …  
    235235                                fill_block(blk);
    236236                                RETURN_IF_ERROR;
    237                                
     237
    238238                                if ((mem_blocks_count % AREA_GRANULARITY) == 0) {
    239239                                        mem_area_t *area = map_area(AREA_SIZE);
    240240                                        RETURN_IF_ERROR;
    241                                        
     241
    242242                                        if (area != NULL) {
    243243                                                TPRINTF("*");
    … …  
    248248                                }
    249249                        }
    250                        
     250
    251251                } else if (rnd < subphase->prob.free) {
    252252                        mem_block_t *blk = get_random_block();
    … …  
    261261                                check_block(blk);
    262262                                RETURN_IF_ERROR;
    263                                
     263
    264264                                free_block(blk);
    265265                                RETURN_IF_ERROR;
    … …  
    267267                }
    268268        }
    269        
     269
    270270        TPRINTF("\n..  finished.\n");
    271271}
    … …  
    275275        for (unsigned int subno = 0; subno < 3; subno++) {
    276276                subphase_t *subphase = &phase->subphases[subno];
    277                
     277
    278278                TPRINTF(".. Sub-phase %u (%s)\n", subno + 1, subphase->name);
    279279                do_subphase(phase, subphase);
    … …  
    285285{
    286286        init_mem();
    287        
     287
    288288        for (unsigned int phaseno = 0; phaseno < sizeof_array(phases);
    289289            phaseno++) {
    290290                phase_t *phase = &phases[phaseno];
    291                
     291
    292292                TPRINTF("Entering phase %u (%s)\n", phaseno + 1, phase->name);
    293                
     293
    294294                do_phase(phase);
    295295                if (error_flag)
    296296                        break;
    297                
     297
    298298                TPRINTF("Phase finished.\n");
    299299        }
    300        
     300
    301301        TPRINTF("Cleaning up.\n");
    302302        done_mem();
    303303        if (error_flag)
    304304                return "Test failed";
    305        
     305
    306306        return NULL;
    307307}

  • uspace/app/tester/mm/mapping1.c

    r3061bc1 ra35b458  
    4141{
    4242        TPRINTF("Creating AS area...\n");
    43        
     43
    4444        void *result = as_area_create(AS_AREA_ANY, size,
    4545            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE, AS_AREA_UNPAGED);
    4646        if (result == AS_MAP_FAILED)
    4747                return NULL;
    48        
     48
    4949        return result;
    5050}
    … …  
    5353{
    5454        TPRINTF("Touching (faulting-in) AS area...\n");
    55        
     55
    5656        char *ptr = (char *)area;
    57        
     57
    5858        while (size > 0) {
    5959                *ptr = 0;
    … …  
    8686{
    8787        errno_t rc;
    88        
     88
    8989        size_t buffer1_len = BUFFER1_PAGES * PAGE_SIZE;
    9090        size_t buffer2_len = BUFFER2_PAGES * PAGE_SIZE;
    … …  
    9494                return "Cannot allocate memory";
    9595        }
    96        
     96
    9797        touch_area(buffer1, buffer1_len);
    9898        touch_area(buffer2, buffer2_len);
    99        
     99
    100100        /* Now verify that mapping to physical frames exist. */
    101101        if (!VERIFY_MAPPING(buffer1, BUFFER1_PAGES, EOK)) {
    … …  
    105105                return "Failed to find mapping (buffer2)";
    106106        }
    107        
     107
    108108        /* Let's destroy the buffer1 area and access it again. */
    109109        rc = as_area_destroy(buffer1);
    … …  
    114114                return "Mapping of destroyed area still exists";
    115115        }
    116        
     116
    117117        /* clean-up */
    118118        rc = as_area_destroy(buffer2);
    … …  
    120120                return "Failed to destroy AS area";
    121121        }
    122        
     122
    123123        return NULL;
    124124}

  • uspace/app/tester/mm/pager1.c

    r3061bc1 ra35b458  
    7171                return NULL;
    7272        }
    73        
     73
    7474        TPRINTF("Creating AS area...\n");
    75        
     75
    7676        void *result = async_as_area_create(AS_AREA_ANY, size,
    7777            AS_AREA_READ | AS_AREA_CACHEABLE, vfs_pager_sess, fd, 0, 0);
    … …  
    8080                return NULL;
    8181        }
    82        
     82
    8383        return result;
    8484}
    … …  
    8787{
    8888        TPRINTF("Touching (faulting-in) AS area...\n");
    89        
     89
    9090        volatile char *ptr = (char *) area;
    91        
     91
    9292        char ch;
    9393        while ((ch = *ptr++))
    … …  
    101101        if (!buffer)
    102102                return "Cannot allocate memory";
    103        
     103
    104104        touch_area(buffer, buffer_len);
    105105
    106106        as_area_destroy(buffer);
    107107        vfs_put(fd);
    108        
     108
    109109        return NULL;
    110110}

  • uspace/app/tester/print/print1.c

    r3061bc1 ra35b458  
    3636        TPRINTF("Expected output: \"  tex\"\n");
    3737        TPRINTF("Real output:     \"%*.*s\"\n\n", 5, 3, "text");
    38        
     38
    3939        TPRINTF("Testing printf(\"%%10.8s\", \"very long text\"):\n");
    4040        TPRINTF("Expected output: \"  very lon\"\n");
    4141        TPRINTF("Real output:     \"%10.8s\"\n\n", "very long text");
    42        
     42
    4343        TPRINTF("Testing printf(\"%%8.10s\", \"text\"):\n");
    4444        TPRINTF("Expected output: \"    text\"\n");
    4545        TPRINTF("Real output:     \"%8.10s\"\n\n", "text");
    46        
     46
    4747        TPRINTF("Testing printf(\"%%8.10s\", \"very long text\"):\n");
    4848        TPRINTF("Expected output: \"very long \"\n");
    4949        TPRINTF("Real output:     \"%8.10s\"\n\n", "very long text");
    50        
     50
    5151        TPRINTF("Testing printf(\"%%-*.*s\", 7, 7, \"text\"):\n");
    5252        TPRINTF("Expected output: \"text   \"\n");
    5353        TPRINTF("Real output:     \"%-*.*s\"\n\n", 7, 7, "text");
    54        
     54
    5555        return NULL;
    5656}

  • uspace/app/tester/print/print2.c

    r3061bc1 ra35b458  
    3636        TPRINTF("Expected output: [a]\n");
    3737        TPRINTF("Real output:     [%c]\n\n", 'a');
    38        
     38
    3939        TPRINTF("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", 1, 2, 3, 4, 5):\n");
    4040        TPRINTF("Expected output: [1] [ 02] [03 ] [004] [005]\n");
    4141        TPRINTF("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", 1, 2, 3, 4, 5);
    42        
     42
    4343        TPRINTF("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", -1, -2, -3, -4, -5):\n");
    4444        TPRINTF("Expected output: [-1] [-02] [-03] [-004] [-005]\n");
    4545        TPRINTF("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", -1, -2, -3, -4, -5);
    46        
     46
    4747        TPRINTF("Testing printf(\"%%lld %%3.2lld %%-3.2lld %%2.3lld %%-2.3lld\", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5):\n");
    4848        TPRINTF("Expected output: [-1] [-02] [-03] [-004] [-005]\n");
    4949        TPRINTF("Real output:     [%lld] [%3.2lld] [%-3.2lld] [%2.3lld] [%-2.3lld]\n\n", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5);
    50        
     50
    5151        TPRINTF("Testing printf(\"%%#x %%5.3#x %%-5.3#x %%3.5#x %%-3.5#x\", 17, 18, 19, 20, 21):\n");
    5252        TPRINTF("Expected output: [0x11] [0x012] [0x013] [0x00014] [0x00015]\n");
    5353        TPRINTF("Real output:     [%#x] [%#5.3x] [%#-5.3x] [%#3.5x] [%#-3.5x]\n\n", 17, 18, 19, 20, 21);
    54        
     54
    5555        char ch[12];
    5656        ptrdiff_t d, neg_d;
    57        
     57
    5858        d = &ch[0] - &ch[12];
    5959        neg_d = (unsigned)(-d);
    … …  
    6161        TPRINTF("Expected output: [-12] [12] [c] [-12] [14]\n");
    6262        TPRINTF("Real output:     [%td] [%tu] [%tx] [%ti] [%to]\n\n", d, neg_d, neg_d, d, neg_d);
    63        
     63
    6464        return NULL;
    6565}

  • uspace/app/tester/print/print3.c

    r3061bc1 ra35b458  
    3838        char buffer[BUFFER_SIZE];
    3939        int retval;
    40        
     40
    4141        TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short text without parameters.\"):\n");
    4242        TPRINTF("Expected result: retval=30 buffer=\"Short text without parameters.\"\n");
    4343        retval = snprintf(buffer, BUFFER_SIZE, "Short text without parameters.");
    4444        TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
    45        
     45
    4646        TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very very very long text without parameters.\"):\n");
    4747        TPRINTF("Expected result: retval=44 buffer=\"Very very very long text withou\"\n");
    4848        retval = snprintf(buffer, BUFFER_SIZE, "Very very very long text without parameters.");
    4949        TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
    50        
     50
    5151        TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short %%s.\", \"text\"):\n");
    5252        TPRINTF("Expected result: retval=11 buffer=\"Short text.\"\n");
    5353        retval = snprintf(buffer, BUFFER_SIZE, "Short %s.", "text");
    5454        TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
    55        
     55
    5656        TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very long %%s. This text's length is more than %%d. We are interested in the result.\", \"text\", " STRING(BUFFER_SIZE) "):\n");
    5757        TPRINTF("Expected result: retval=84 buffer=\"Very long text. This text's len\"\n");
    5858        retval = snprintf(buffer, BUFFER_SIZE, "Very long %s. This text's length is more than %d. We are interested in the result.", "text", BUFFER_SIZE);
    5959        TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
    60        
     60
    6161        return NULL;
    6262}

  • uspace/app/tester/print/print4.c

    r3061bc1 ra35b458  
    3535{
    3636        TPRINTF("ASCII printable characters (32 - 127) using printf(\"%%c\") and printf(\"%%lc\"):\n");
    37        
     37
    3838        uint8_t group;
    3939        for (group = 1; group < 4; group++) {
    4040                TPRINTF("%#x: ", group << 5);
    41                
     41
    4242                uint8_t index;
    4343                for (index = 0; index < 32; index++)
    4444                        TPRINTF("%c", (char) ((group << 5) + index));
    45                
     45
    4646                TPRINTF("  ");
    4747                for (index = 0; index < 32; index++)
    4848                        TPRINTF("%lc", (wint_t) ((group << 5) + index));
    49                
     49
    5050                TPRINTF("\n");
    5151        }
    52        
     52
    5353        TPRINTF("\nExtended ASCII characters (128 - 255) using printf(\"%%lc\"):\n");
    54        
     54
    5555        for (group = 4; group < 8; group++) {
    5656                TPRINTF("%#x: ", group << 5);
    57                
     57
    5858                uint8_t index;
    5959                for (index = 0; index < 32; index++)
    6060                        TPRINTF("%lc", (wint_t) ((group << 5) + index));
    61                
     61
    6262                TPRINTF("\n");
    6363        }
    64        
     64
    6565        TPRINTF("\nUTF-8 strings using printf(\"%%s\"):\n");
    6666        TPRINTF("English:  %s\n", "Quick brown fox jumps over the lazy dog");
    … …  
    7171        TPRINTF("Russian:  %s\n", "Леннон познакомился с художницей-авангардисткой");
    7272        TPRINTF("Armenian: %s\n", "Սկսեց հրատարակվել Երուսաղեմի հայկական");
    73        
     73
    7474        TPRINTF("\nUTF-32 strings using printf(\"%%ls\"):\n");
    7575        TPRINTF("English:  %ls\n", L"Quick brown fox jumps over the lazy dog");
    … …  
    8080        TPRINTF("Russian:  %ls\n", L"Леннон познакомился с художницей-авангардисткой");
    8181        TPRINTF("Armenian: %ls\n", L"Սկսեց հրատարակվել Երուսաղեմի հայկական");
    82        
     82
    8383        return NULL;
    8484}

  • uspace/app/tester/print/print5.c

    r3061bc1 ra35b458  
    4848        TPRINTF("Expected output: \"(NULL)\"\n");
    4949        TPRINTF("Real output:     \"%s\"\n\n", (char *) NULL);
    50        
     50
    5151        TPRINTF("Testing printf(\"%%c %%3.2c %%-3.2c %%2.3c %%-2.3c\", 'a', 'b', 'c', 'd', 'e'):\n");
    5252        TPRINTF("Expected output: [a] [  b] [c  ] [ d] [e ]\n");
    5353        TPRINTF("Real output:     [%c] [%3.2c] [%-3.2c] [%2.3c] [%-2.3c]\n\n", 'a', 'b', 'c', 'd', 'e');
    54        
     54
    5555        return NULL;
    5656}

  • uspace/app/tester/print/print6.c

    r3061bc1 ra35b458  
    126126                /* __PRINTF_FLAG_DECIMALPT */
    127127                { -1.23450067995e+231, "%#10.10e",  "-1.2345006800e+231", 0 },
    128                        
     128
    129129                /* special */
    130130
    … …  
    139139                 * Fixed
    140140                 */
    141                  
     141
    142142                /* padding */
    143143
    … …  
    181181        const int buf_size = 256;
    182182        char buf[256 + 1] = { 0 };
    183        
     183
    184184        TPRINTF("Test printing of floating point numbers via "
    185185            "printf(\"%%f\"):\n");
    186        
     186
    187187        for (int i = 0; i < patterns_len; ++i) {
    188                
     188
    189189                snprintf(buf, buf_size, pat[i].fmt, pat[i].val);
    190                
     190
    191191                if (!str_cmp(buf, pat[i].exp_str)) {
    192192                        TPRINTF("ok:  %s |%s| == |%s|\n",
    … …  
    203203                }
    204204        }
    205        
     205
    206206        if (failed) {
    207207                return "Unexpectedly misprinted floating point numbers.";

  • uspace/app/tester/stdio/stdio1.c

    r3061bc1 ra35b458  
    4242        FILE *file;
    4343        const char *file_name = "/textdemo";
    44        
     44
    4545        TPRINTF("Open file \"%s\"...", file_name);
    4646        errno = 0;
    … …  
    5151        } else
    5252                TPRINTF("OK\n");
    53        
     53
    5454        TPRINTF("Read file...");
    5555        size_t cnt = fread(buf, 1, BUF_SIZE, file);
    … …  
    6060        } else
    6161                TPRINTF("OK\n");
    62        
     62
    6363        buf[cnt] = '\0';
    6464        TPRINTF("Read %zu bytes, string \"%s\"\n", cnt, buf);
    65        
     65
    6666        TPRINTF("Seek to beginning...");
    6767        if (fseek(file, 0, SEEK_SET) != 0) {
    … …  
    7171        } else
    7272                TPRINTF("OK\n");
    73        
     73
    7474        TPRINTF("Read using fgetc()...");
    7575        while (true) {
    … …  
    7777                if (c == EOF)
    7878                        break;
    79                
     79
    8080                TPRINTF(".");
    8181        }
    8282        TPRINTF("[EOF]\n");
    83        
     83
    8484        TPRINTF("Close...");
    8585        if (fclose(file) != 0) {
    … …  
    8888        } else
    8989                TPRINTF("OK\n");
    90        
     90
    9191        return NULL;
    9292}

  • uspace/app/tester/stdio/stdio2.c

    r3061bc1 ra35b458  
    3838        FILE *file;
    3939        const char *file_name = "/test";
    40        
     40
    4141        TPRINTF("Open file \"%s\" for writing...", file_name);
    4242        errno = 0;
    … …  
    4747        } else
    4848                TPRINTF("OK\n");
    49        
     49
    5050        TPRINTF("Write to file...");
    5151        fprintf(file, "integer: %u, string: \"%s\"", 42, "Hello!");
    5252        TPRINTF("OK\n");
    53        
     53
    5454        TPRINTF("Close...");
    5555        if (fclose(file) != 0) {
    … …  
    5858        } else
    5959                TPRINTF("OK\n");
    60        
     60
    6161        TPRINTF("Open file \"%s\" for reading...", file_name);
    6262        file = fopen(file_name, "rt");
    … …  
    6666        } else
    6767                TPRINTF("OK\n");
    68        
     68
    6969        TPRINTF("File contains:\n");
    7070        while (true) {
    … …  
    7474                TPRINTF("%c", c);
    7575        }
    76        
     76
    7777        TPRINTF("\nClose...");
    7878        if (fclose(file) != 0) {
    … …  
    8181        } else
    8282                TPRINTF("OK\n");
    83        
     83
    8484        return NULL;
    8585}

  • uspace/app/tester/tester.c

    r3061bc1 ra35b458  
    8484        /* Execute the test */
    8585        const char *ret = test->entry();
    86        
     86
    8787        if (ret == NULL) {
    8888                printf("\nTest passed\n");
    8989                return true;
    9090        }
    91        
     91
    9292        printf("\n%s\n", ret);
    9393        return false;
    … …  
    9999        unsigned int i = 0;
    100100        unsigned int n = 0;
    101        
     101
    102102        printf("\n*** Running all safe tests ***\n\n");
    103        
     103
    104104        for (test = tests; test->name != NULL; test++) {
    105105                if (test->safe) {
    … …  
    111111                }
    112112        }
    113        
     113
    114114        printf("\nCompleted, %u tests run, %u passed.\n", i + n, i);
    115115}
    … …  
    123123                        len = str_length(test->name);
    124124        }
    125        
     125
    126126        unsigned int _len = (unsigned int) len;
    127127        if ((_len != len) || (((int) _len) < 0)) {
    … …  
    129129                return;
    130130        }
    131        
     131
    132132        for (test = tests; test->name != NULL; test++)
    133133                printf("%-*s %s%s\n", _len, test->name, test->desc,
    134134                    (test->safe ? "" : " (unsafe)"));
    135        
     135
    136136        printf("%-*s Run all safe tests\n", _len, "*");
    137137}
    … …  
    145145                return 0;
    146146        }
    147        
     147
    148148        log_init("tester");
    149149
    … …  
    151151        test_argc = argc - 2;
    152152        test_argv = argv + 2;
    153        
     153
    154154        if (str_cmp(argv[1], "*") == 0) {
    155155                run_safe_tests();
    156156                return 0;
    157157        }
    158        
     158
    159159        test_t *test;
    160160        for (test = tests; test->name != NULL; test++) {
    … …  
    163163                }
    164164        }
    165        
     165
    166166        printf("Unknown test \"%s\"\n", argv[1]);
    167167        return -2;

  • uspace/app/tester/thread/setjmp1.c

    r3061bc1 ra35b458  
    6464{
    6565        counter = 0;
    66        
     66
    6767        const char *err_msg = test_it();
    68        
     68
    6969        return err_msg;
    7070}

  • uspace/app/tester/thread/thread1.c

    r3061bc1 ra35b458  
    4545{
    4646        thread_detach(thread_get_id());
    47        
     47
    4848        while (atomic_get(&finish))
    4949                thread_usleep(100000);
    50        
     50
    5151        atomic_inc(&threads_finished);
    5252}
    … …  
    5656        unsigned int i;
    5757        atomic_count_t total = 0;
    58        
     58
    5959        atomic_set(&finish, 1);
    6060        atomic_set(&threads_finished, 0);
    61        
     61
    6262        TPRINTF("Creating threads");
    6363        for (i = 0; i < THREADS; i++) {
    … …  
    6969                total++;
    7070        }
    71        
     71
    7272        TPRINTF("\nRunning threads for %u seconds...", DELAY);
    7373        thread_sleep(DELAY);
    7474        TPRINTF("\n");
    75        
     75
    7676        atomic_set(&finish, 0);
    7777        while (atomic_get(&threads_finished) < total) {
    … …  
    8080                thread_sleep(1);
    8181        }
    82        
     82
    8383        return NULL;
    8484}

  • uspace/app/tester/vfs/vfs1.c

    r3061bc1 ra35b458  
    5050{
    5151        TPRINTF("Opening the root directory...");
    52        
     52
    5353        DIR *dirp = opendir("/");
    5454        if (!dirp) {
    … …  
    5757        } else
    5858                TPRINTF("OK\n");
    59        
     59
    6060        struct dirent *dp;
    6161        while ((dp = readdir(dirp)))
    6262                TPRINTF(" node \"%s\"\n", dp->d_name);
    6363        closedir(dirp);
    64        
     64
    6565        return NULL;
    6666}
    … …  
    7777        }
    7878        TPRINTF("Created directory %s\n", TEST_DIRECTORY);
    79        
     79
    8080        int fd0;
    8181        rc = vfs_lookup_open(TEST_FILE, WALK_REGULAR | WALK_MAY_CREATE,
    … …  
    8484                return "vfs_lookup_open() failed";
    8585        TPRINTF("Created file %s (fd=%d)\n", TEST_FILE, fd0);
    86        
     86
    8787        size_t size = sizeof(text);
    8888        size_t cnt;
    … …  
    9393
    9494        pos = 0;
    95        
     95
    9696        char buf[BUF_SIZE];
    9797        TPRINTF("read..\n");
    … …  
    100100                if (rc != EOK)
    101101                        return "read() failed";
    102                
     102
    103103                int icnt = (int) cnt;
    104104                if ((size_t) icnt != cnt) {
    … …  
    109109                }
    110110        }
    111        
     111
    112112        vfs_put(fd0);
    113        
     113
    114114        const char *rv = read_root();
    115115        if (rv != NULL)
    116116                return rv;
    117        
     117
    118118        if (vfs_rename_path(TEST_FILE, TEST_FILE2) != EOK)
    119119                return "vfs_rename_path() failed";
    120120        TPRINTF("Renamed %s to %s\n", TEST_FILE, TEST_FILE2);
    121        
     121
    122122        if (vfs_unlink_path(TEST_FILE2) != EOK)
    123123                return "vfs_unlink_path() failed";
    124124        TPRINTF("Unlinked %s\n", TEST_FILE2);
    125        
     125
    126126        if (vfs_unlink_path(TEST_DIRECTORY) != EOK)
    127127                return "vfs_unlink_path() failed";
    128128        TPRINTF("Removed directory %s\n", TEST_DIRECTORY);
    129        
     129
    130130        rv = read_root();
    131131        if (rv != NULL)
    132132                return rv;
    133        
     133
    134134        return NULL;
    135135}
Note: See TracChangeset for help on using the changeset viewer.