Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 03daabd in mainline


Ignore:
Timestamp:
2019-10-06T19:47:36Z (13 months ago)
Author:
Matthieu Riolo <matthieu.riolo@…>
Children:
5be6361
Parents:
9559cf8
git-author:
Matthieu Riolo <matthieu.riolo@…> (2019-09-17 07:50:03)
git-committer:
Matthieu Riolo <matthieu.riolo@…> (2019-10-06 19:47:36)
Message:

Renaming dyn_array to array

The term dyn_array is redunant and has therefore been replaced
with the shorter term array

Location:
uspace
Files:
1 added
1 deleted
9 edited
2 moved

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/Makefile

    r9559cf8 r03daabd  
    145145        generic/loader.c \
    146146        generic/getopt.c \
     147        generic/adt/array.c \
    147148        generic/adt/checksum.c \
    148149        generic/adt/circ_buf.c \
    149         generic/adt/dyn_array.c \
    150150        generic/adt/list.c \
    151151        generic/adt/hash_table.c \
     
    193193
    194194TEST_SOURCES = \
     195        test/adt/array.c \
    195196        test/adt/circ_buf.c \
    196         test/adt/dyn_array.c \
    197197        test/adt/odict.c \
    198198        test/cap.c \
  • uspace/lib/c/generic/adt/array.c

    r9559cf8 r03daabd  
    3434 * Implementation of dynamic array that grows or shrinks based upon no. of
    3535 * items it contains. Non-negligible part of implementation is in @ref
    36  * dyn_array.h because of type genericity.
     36 * array.h because of type genericity.
    3737 */
    3838
    3939#include <assert.h>
    4040#include <errno.h>
    41 #include <adt/dyn_array.h>
     41#include <adt/array.h>
    4242#include <macros.h>
    4343#include <mem.h>
    4444#include <stdlib.h>
    4545
    46 static errno_t dyn_array_realloc(dyn_array_t *da, size_t capacity)
     46static errno_t array_realloc(array_t *da, size_t capacity)
    4747{
    4848        if (capacity == da->capacity) {
     
    5858}
    5959
    60 void dyn_array_destroy(dyn_array_t *da)
     60void array_destroy(array_t *da)
    6161{
    62         dyn_array_clear(da);
     62        array_clear(da);
    6363        free(da->_data);
    6464        da->capacity = 0;
     
    6666
    6767/** Remove item at given position, shift rest of array */
    68 void dyn_array_remove(dyn_array_t *da, size_t index)
     68void array_remove(array_t *da, size_t index)
    6969{
    7070        assert(index < da->size);
    71         _dyn_array_unshift(da, index, 1);
    72         errno_t rc = dyn_array_reserve(da, da->size);
     71        _array_unshift(da, index, 1);
     72        errno_t rc = array_reserve(da, da->size);
    7373        assert(rc == EOK);
    7474}
    7575
    7676/** Clear dynamic array (empty) */
    77 void dyn_array_clear(dyn_array_t *da)
     77void array_clear(array_t *da)
    7878{
    7979        da->size = 0;
     
    8686 * @param[in]      end    index behind last item to remove
    8787 */
    88 void dyn_array_clear_range(dyn_array_t *da, size_t begin, size_t end)
     88void array_clear_range(array_t *da, size_t begin, size_t end)
    8989{
    9090        assert(begin < da->size);
    9191        assert(end <= da->size);
    9292
    93         _dyn_array_unshift(da, begin, end - begin);
    94         errno_t rc = dyn_array_reserve(da, da->size);
     93        _array_unshift(da, begin, end - begin);
     94        errno_t rc = array_reserve(da, da->size);
    9595        assert(rc == EOK);
    9696}
     
    104104 * @return ENOMEM when allocation fails
    105105 */
    106 errno_t dyn_array_concat(dyn_array_t *da1, dyn_array_t *da2)
     106errno_t array_concat(array_t *da1, array_t *da2)
    107107{
    108108        assert(da1->_item_size == da2->_item_size);
    109109
    110         errno_t rc = dyn_array_reserve(da1, da1->size + da2->size);
     110        errno_t rc = array_reserve(da1, da1->size + da2->size);
    111111        if (rc != EOK) {
    112112                return rc;
     
    129129 * @return ENOMEM
    130130 */
    131 errno_t dyn_array_reserve(dyn_array_t *da, size_t capacity)
     131errno_t array_reserve(array_t *da, size_t capacity)
    132132{
    133133        const size_t factor = 2;
     
    141141        }
    142142
    143         return dyn_array_realloc(da, new_capacity);
     143        return array_realloc(da, new_capacity);
    144144}
    145145
    146 void _dyn_array_initialize(dyn_array_t *da, size_t item_size)
     146void _array_initialize(array_t *da, size_t item_size)
    147147{
    148148        da->_item_size = item_size;
     
    161161 * @param[in]  offset  shift in no. of items
    162162 */
    163 void _dyn_array_shift(dyn_array_t *da, size_t index, size_t offset)
     163void _array_shift(array_t *da, size_t index, size_t offset)
    164164{
    165165        assert(da->capacity >= da->size + offset);
     
    180180 * @param[in]  offset  shift in no. of items
    181181 */
    182 void _dyn_array_unshift(dyn_array_t *da, size_t index, size_t offset)
     182void _array_unshift(array_t *da, size_t index, size_t offset)
    183183{
    184184        void *src = da->_data + (index + offset) * da->_item_size;
  • uspace/lib/c/include/adt/array.h

    r9559cf8 r03daabd  
    3333 */
    3434
    35 #ifndef LIBC_DYN_ARRAY_H_
    36 #define LIBC_DYN_ARRAY_H_
     35#ifndef LIBC_ARRAY_H_
     36#define LIBC_ARRAY_H_
    3737
    3838#include <errno.h>
     
    5050        /** No. of items in the array */
    5151        size_t size;
    52 } dyn_array_t;
     52} array_t;
    5353
    5454/** Initialize dynamic array
     
    5858 * @return void
    5959 */
    60 #define dyn_array_initialize(dyn_array, type)                                  \
    61         _dyn_array_initialize((dyn_array), sizeof(type))
     60#define array_initialize(array, type)                                  \
     61        _array_initialize((array), sizeof(type))
    6262
    6363/** Dynamic array accessor
     
    6565 * @return lvalue for the given item
    6666 */
    67 #define dyn_array_at(dyn_array, type, index)                                   \
    68         (*((type *) (dyn_array)->_data + index))
     67#define array_at(array, type, index)                                   \
     68        (*((type *) (array)->_data + index))
    6969
    7070/** Access last element
     
    7272 * @return lvalue for the last item
    7373 */
    74 #define dyn_array_last(dyn_array, type)                                        \
    75         (*((type *) (dyn_array)->_data + ((dyn_array)->size - 1)))
     74#define array_last(array, type)                                        \
     75        (*((type *) (array)->_data + ((array)->size - 1)))
    7676
    7777/** Insert item at given position, shift rest of array
     
    8080 * @return ENOMEM on failure
    8181 */
    82 #define dyn_array_insert(dyn_array, type, index, value)                        \
    83 ({                                                                             \
    84         size_t _index = (index);                                               \
    85         dyn_array_t *_da = (dyn_array);                                        \
    86         errno_t rc = dyn_array_reserve(_da, _da->size + 1);                        \
    87         if (!rc) {                                                             \
    88                 _dyn_array_shift(_da, _index, 1);                              \
    89                 dyn_array_at(_da, type, _index) = (value);                     \
    90         }                                                                      \
    91         rc;                                                                    \
     82#define array_insert(array, type, index, value)                        \
     83({                                                                     \
     84        size_t _index = (index);                                           \
     85        array_t *_da = (array);                                            \
     86        errno_t rc = array_reserve(_da, _da->size + 1);                    \
     87        if (!rc) {                                                         \
     88                _array_shift(_da, _index, 1);                                  \
     89                array_at(_da, type, _index) = (value);                     \
     90        }                                                                  \
     91        rc;                                                                \
    9292})
    9393
     
    9797 * @return ENOMEM on failure
    9898 */
    99 #define dyn_array_append(dyn_array, type, value)                               \
    100         dyn_array_insert(dyn_array, type, (dyn_array)->size, (value))
     99#define array_append(array, type, value)                               \
     100        array_insert(array, type, (array)->size, (value))
    101101
    102102/** Dynamic array iteration
    103103 *
    104  * @param[in]  dyn_array   dyn_array_t (not pointer)
    105  * @param[in]  it          name of variable used as iterator, it's pointer
    106  *                         to @p type
     104 * @param[in]  array   array_t (not pointer)
     105 * @param[in]  it      name of variable used as iterator, it's pointer
     106 *                     to @p type
    107107 */
    108 #define dyn_array_foreach(dyn_array, type, it)                                 \
    109         for (type *it = NULL; it == NULL; it = (type *)1)                      \
    110             for (type *_it = (type *)(dyn_array)._data;                        \
    111             it = _it, _it != ((type *)(dyn_array)._data + (dyn_array).size);   \
     108#define array_foreach(array, type, it)                                 \
     109        for (type *it = NULL; it == NULL; it = (type *)1)                  \
     110            for (type *_it = (type *)(array)._data;                        \
     111            it = _it, _it != ((type *)(array)._data + (array).size);       \
    112112            ++_it)
    113113
    114114/** Find first occurence of value
    115115 *
    116  * @param[in]  dyn_array   dyn_array_t *
     116 * @param[in]  array   array_t *
    117117 * @param[in]  value       value to search for
    118118 *
    119119 * @return  index of found value or size of array when no found
    120120 */
    121 #define dyn_array_find(dyn_array, type, value)                                 \
    122 ({                                                                             \
    123         size_t _result = (dyn_array)->size;                                    \
    124         dyn_array_foreach(*(dyn_array), type, _it) {                           \
     121#define array_find(array, type, value)                                 \
     122({                                                                     \
     123        size_t _result = (array)->size;                                    \
     124        array_foreach(*(array), type, _it) {                               \
    125125                if (*_it == value) {                                           \
    126                         _result = _it - (type *)(dyn_array)->_data;            \
    127                         break;                                                 \
     126                        _result = _it - (type *)(array)->_data;                    \
     127                        break;                                                     \
    128128                }                                                              \
    129         }                                                                      \
    130         _result;                                                               \
     129        }                                                                  \
     130        _result;                                                           \
    131131})
    132132
    133 extern void dyn_array_destroy(dyn_array_t *);
    134 extern void dyn_array_remove(dyn_array_t *, size_t);
    135 void dyn_array_clear(dyn_array_t *);
    136 void dyn_array_clear_range(dyn_array_t *, size_t, size_t);
    137 extern errno_t dyn_array_concat(dyn_array_t *, dyn_array_t *);
    138 extern errno_t dyn_array_reserve(dyn_array_t *, size_t);
     133extern void array_destroy(array_t *);
     134extern void array_remove(array_t *, size_t);
     135void array_clear(array_t *);
     136void array_clear_range(array_t *, size_t, size_t);
     137extern errno_t array_concat(array_t *, array_t *);
     138extern errno_t array_reserve(array_t *, size_t);
    139139
    140 extern void _dyn_array_initialize(dyn_array_t *, size_t);
    141 extern void _dyn_array_shift(dyn_array_t *, size_t, size_t);
    142 extern void _dyn_array_unshift(dyn_array_t *, size_t, size_t);
     140extern void _array_initialize(array_t *, size_t);
     141extern void _array_shift(array_t *, size_t, size_t);
     142extern void _array_unshift(array_t *, size_t, size_t);
    143143
    144144#endif
  • uspace/lib/c/test/main.c

    r9559cf8 r03daabd  
    3232PCUT_INIT;
    3333
     34PCUT_IMPORT(array);
    3435PCUT_IMPORT(cap);
    3536PCUT_IMPORT(casting);
    3637PCUT_IMPORT(circ_buf);
    3738PCUT_IMPORT(double_to_str);
    38 PCUT_IMPORT(dyn_array);
    3939PCUT_IMPORT(fibril_timer);
    4040PCUT_IMPORT(getopt);
  • uspace/srv/sysman/job.c

    r9559cf8 r03daabd  
    7070        job->unit = u;
    7171
    72         dyn_array_initialize(&job->blocked_jobs, job_t *);
     72        array_initialize(&job->blocked_jobs, job_t *);
    7373        job->blocking_jobs = 0;
    7474        job->blocking_job_failed = false;
     
    120120        assert(!link_used(&job->job_queue));
    121121
    122         dyn_array_foreach(job->blocked_jobs, job_t *, job_it) {
     122        array_foreach(job->blocked_jobs, job_t *, job_it) {
    123123                job_del_ref(&(*job_it));
    124124        }
    125         dyn_array_destroy(&job->blocked_jobs);
     125        array_destroy(&job->blocked_jobs);
    126126
    127127        free(job);
     
    257257        /* First remove references, then clear the array */
    258258        assert(job->blocked_jobs.size == job->blocked_jobs_count);
    259         dyn_array_foreach(job->blocked_jobs, job_t *, job_it) {
     259        array_foreach(job->blocked_jobs, job_t *, job_it) {
    260260                job_unblock(*job_it, job);
    261261        }
    262         dyn_array_clear(&job->blocked_jobs);
     262        array_clear(&job->blocked_jobs);
    263263
    264264        /* Add reference for event handler */
  • uspace/srv/sysman/job.h

    r9559cf8 r03daabd  
    3030#define SYSMAN_JOB_H
    3131
    32 #include <adt/dyn_array.h>
     32#include <adt/array.h>
    3333#include <adt/list.h>
    3434#include <stdatomic.h>
     
    6464
    6565        /** Jobs that this job is preventing from running */
    66         dyn_array_t blocked_jobs;
     66        array_t blocked_jobs;
    6767        /**
    6868         * No. of jobs that the job is actually blocking (may differ from size
  • uspace/srv/sysman/job_closure.c

    r9559cf8 r03daabd  
    6666            blocking_job->blocked_jobs_count);
    6767
    68         errno_t rc = dyn_array_append(&blocking_job->blocked_jobs, job_t *,
     68        errno_t rc = array_append(&blocking_job->blocked_jobs, job_t *,
    6969            blocked_job);
    7070        if (rc != EOK) {
     
    9797                        goto finish;
    9898                }
    99                 job_t *first_job = dyn_array_last(closure, job_t *);
     99                job_t *first_job = array_last(closure, job_t *);
    100100
    101101                job_add_ref(first_job);
     
    119119
    120120                /* Pass job reference to closure and add one for unit */
    121                 rc = dyn_array_append(closure, job_t *, created_job);
     121                rc = array_append(closure, job_t *, created_job);
    122122                if (rc != EOK) {
    123123                        goto finish;
     
    165165
    166166                /* Pass job reference to closure and add one for unit */
    167                 rc = dyn_array_append(closure, job_t *, created_job);
     167                rc = array_append(closure, job_t *, created_job);
    168168                if (rc != EOK) {
    169169                        goto finish;
     
    308308        }
    309309
    310         errno_t rc = dyn_array_append(job_closure, job_t *, main_job);
     310        errno_t rc = array_append(job_closure, job_t *, main_job);
    311311        if (rc != EOK) {
    312312                return rc;
     
    343343
    344344        if (rc == EOK) {
    345                 dyn_array_foreach(*job_closure, job_t *, job_it) {
     345                array_foreach(*job_closure, job_t *, job_it) {
    346346                        sysman_log(LVL_DEBUG2, "%s\t%s, refs: %u", __func__,
    347347                            unit_name((*job_it)->unit), atomic_load(&(*job_it)->refcnt));
     
    350350
    351351        /* Clean after ourselves (BFS tag jobs) */
    352         dyn_array_foreach(*job_closure, job_t *, job_it) {
     352        array_foreach(*job_closure, job_t *, job_it) {
    353353                job_t *j = (*job_it)->unit->bfs_data;
    354354                assert(*job_it == j);
  • uspace/srv/sysman/job_closure.h

    r9559cf8 r03daabd  
    3030#define SYSMAN_JOB_CLOSURE_H
    3131
    32 #include <adt/dyn_array.h>
     32#include <adt/array.h>
    3333
    3434#include "job.h"
     
    3636#define CLOSURE_ISOLATE 0x1
    3737
    38 typedef dyn_array_t job_closure_t;
     38typedef array_t job_closure_t;
    3939
    4040extern errno_t job_create_closure(job_t *, job_closure_t *, int);
  • uspace/srv/sysman/job_queue.c

    r9559cf8 r03daabd  
    110110        assert(other->merged_into == NULL);
    111111
    112         errno_t rc = dyn_array_concat(&trunk->blocked_jobs, &other->blocked_jobs);
     112        errno_t rc = array_concat(&trunk->blocked_jobs, &other->blocked_jobs);
    113113        if (rc != EOK) {
    114114                return rc;
    115115        }
    116         dyn_array_clear(&other->blocked_jobs);
     116        array_clear(&other->blocked_jobs);
    117117
    118118        // TODO allocate observed object
     
    145145{
    146146        assert(trunk->blocked_jobs.size >= trunk->blocked_jobs_count);
    147         dyn_array_clear_range(&trunk->blocked_jobs,
     147        array_clear_range(&trunk->blocked_jobs,
    148148            trunk->blocked_jobs_count, trunk->blocked_jobs.size);
    149149}
     
    172172
    173173        /* Check consistency with existing jobs. */
    174         dyn_array_foreach(*closure, job_t *, job_it) {
     174        array_foreach(*closure, job_t *, job_it) {
    175175                job_t *job = *job_it;
    176176                job_t *other_job = job->unit->job;
     
    214214        /* Aggregate merged jobs, or rollback any changes in existing jobs */
    215215        bool finish_merge = (rc == EOK) && !has_error;
    216         dyn_array_foreach(*closure, job_t *, job_it) {
     216        array_foreach(*closure, job_t *, job_it) {
    217217                if ((*job_it)->merged_into == NULL) {
    218218                        continue;
     
    236236         *      in their blocked_jobs array.
    237237         */
    238         dyn_array_foreach(*closure, job_t *, job_it) {
     238        array_foreach(*closure, job_t *, job_it) {
    239239                job_t *job = (*job_it);
    240240                if (job->merged_into != NULL) {
     
    255255
    256256        /* We've stolen references from the closure, so erase it */
    257         dyn_array_clear(closure);
     257        array_clear(closure);
    258258
    259259        return EOK;
  • uspace/srv/sysman/sysman.c

    r9559cf8 r03daabd  
    366366        job_t *job = job_args->job;
    367367        int flags = job_args->flags;
    368         dyn_array_t job_closure;
    369         dyn_array_initialize(&job_closure, job_t *);
     368        array_t job_closure;
     369        array_initialize(&job_closure, job_t *);
    370370
    371371        if (job_args->callback != NULL) {
     
    402402        job_del_ref(&job);
    403403
    404         dyn_array_foreach(job_closure, job_t *, closure_job) {
     404        array_foreach(job_closure, job_t *, closure_job) {
    405405                job_del_ref(&(*closure_job));
    406406        }
    407         dyn_array_destroy(&job_closure);
     407        array_destroy(&job_closure);
    408408}
    409409
  • uspace/srv/sysman/test/job_closure.c

    r9559cf8 r03daabd  
    4040PCUT_TEST_SUITE(job_closure);
    4141
    42 static dyn_array_t exp_closure;
    43 static dyn_array_t act_closure;
     42static array_t exp_closure;
     43static array_t act_closure;
    4444
    4545static bool same_job(job_t *expected, job_t *actual)
     
    4949}
    5050
    51 static bool same_jobs(dyn_array_t *expected, dyn_array_t *actual)
     51static bool same_jobs(array_t *expected, array_t *actual)
    5252{
    5353        if (expected->size != actual->size) {
     
    5858
    5959        /* Verify expected \subseteq actual (we've compared sizes) */
    60         dyn_array_foreach(*expected, job_t *, it_exp) {
     60        array_foreach(*expected, job_t *, it_exp) {
    6161                bool found = false;
    62                 dyn_array_foreach(*actual, job_t *, it_act) {
     62                array_foreach(*actual, job_t *, it_act) {
    6363                        if (same_job(*it_exp, *it_act)) {
    6464                                found = true;
     
    7979{
    8080        bool found = false;
    81         dyn_array_foreach(blocking_job->blocked_jobs, job_t *, it) {
     81        array_foreach(blocking_job->blocked_jobs, job_t *, it) {
    8282                if (*it == blocked_job) {
    8383                        found = true;
     
    9494}
    9595
    96 static void dummy_add_closure(dyn_array_t *closure)
    97 {
    98         dyn_array_foreach(*closure, job_t *, it) {
     96static void dummy_add_closure(array_t *closure)
     97{
     98        array_foreach(*closure, job_t *, it) {
    9999                (*it)->unit->job = *it;
    100100        }
    101101}
    102102
    103 static void destroy_job_closure(dyn_array_t *closure)
    104 {
    105         dyn_array_foreach(*closure, job_t *, it) {
     103static void destroy_job_closure(array_t *closure)
     104{
     105        array_foreach(*closure, job_t *, it) {
    106106                job_del_ref(&(*it));
    107107        }
     
    113113        mock_set_units_state(STATE_STOPPED);
    114114
    115         dyn_array_initialize(&exp_closure, job_t *);
    116         errno_t rc = dyn_array_reserve(&exp_closure, MAX_TYPES * MAX_UNITS);
     115        array_initialize(&exp_closure, job_t *);
     116        errno_t rc = array_reserve(&exp_closure, MAX_TYPES * MAX_UNITS);
    117117        assert(rc == EOK);
    118118
    119         dyn_array_initialize(&act_closure, job_t *);
    120         rc = dyn_array_reserve(&act_closure, MAX_TYPES * MAX_UNITS);
     119        array_initialize(&act_closure, job_t *);
     120        rc = array_reserve(&act_closure, MAX_TYPES * MAX_UNITS);
    121121        assert(rc == EOK);
    122122
     
    127127{
    128128        destroy_job_closure(&act_closure);
    129         dyn_array_destroy(&act_closure);
     129        array_destroy(&act_closure);
    130130
    131131        destroy_job_closure(&exp_closure);
    132         dyn_array_destroy(&exp_closure);
     132        array_destroy(&exp_closure);
    133133
    134134        mock_destroy_units();
     
    156156        PCUT_ASSERT_INT_EQUALS(EOK, rc);
    157157
    158         dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
    159         dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
    160         dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
     158        array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
     159        array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
     160        array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
    161161
    162162        dummy_add_closure(&act_closure);
     
    188188        PCUT_ASSERT_INT_EQUALS(EOK, rc);
    189189
    190         dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
    191         dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
    192         dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
     190        array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
     191        array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
     192        array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
    193193
    194194        dummy_add_closure(&act_closure);
     
    222222        PCUT_ASSERT_INT_EQUALS(EOK, rc);
    223223
    224         dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
    225         dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
    226         dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
     224        array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
     225        array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
     226        array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
    227227
    228228        dummy_add_closure(&act_closure);
     
    269269        PCUT_ASSERT_INT_EQUALS(EOK, rc);
    270270
    271         dyn_array_append(&exp_closure, job_t *, dummy_job(u0, STATE_STOPPED));
    272         dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
    273         dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
    274         dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STOPPED));
    275         dyn_array_append(&exp_closure, job_t *, dummy_job(u4, STATE_STOPPED));
    276         dyn_array_append(&exp_closure, job_t *, dummy_job(u5, STATE_STOPPED));
    277         dyn_array_append(&exp_closure, job_t *, dummy_job(u6, STATE_STOPPED));
     271        array_append(&exp_closure, job_t *, dummy_job(u0, STATE_STOPPED));
     272        array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
     273        array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
     274        array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STOPPED));
     275        array_append(&exp_closure, job_t *, dummy_job(u4, STATE_STOPPED));
     276        array_append(&exp_closure, job_t *, dummy_job(u5, STATE_STOPPED));
     277        array_append(&exp_closure, job_t *, dummy_job(u6, STATE_STOPPED));
    278278
    279279        dummy_add_closure(&act_closure);
Note: See TracChangeset for help on using the changeset viewer.