Index: uspace/lib/c/Makefile =================================================================== --- uspace/lib/c/Makefile (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ uspace/lib/c/Makefile (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -145,7 +145,7 @@ generic/loader.c \ generic/getopt.c \ + generic/adt/array.c \ generic/adt/checksum.c \ generic/adt/circ_buf.c \ - generic/adt/dyn_array.c \ generic/adt/list.c \ generic/adt/hash_table.c \ @@ -193,6 +193,6 @@ TEST_SOURCES = \ + test/adt/array.c \ test/adt/circ_buf.c \ - test/adt/dyn_array.c \ test/adt/odict.c \ test/cap.c \ Index: uspace/lib/c/generic/adt/array.c =================================================================== --- uspace/lib/c/generic/adt/array.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) +++ uspace/lib/c/generic/adt/array.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + * + * Implementation of dynamic array that grows or shrinks based upon no. of + * items it contains. Non-negligible part of implementation is in @ref + * array.h because of type genericity. + */ + +#include +#include +#include +#include +#include +#include + +static errno_t array_realloc(array_t *da, size_t capacity) +{ + if (capacity == da->capacity) { + return EOK; + } + + void *new_data = realloc(da->_data, da->_item_size * capacity); + if (new_data) { + da->_data = new_data; + da->capacity = capacity; + } + return (new_data == NULL) ? ENOMEM : EOK; +} + +void array_destroy(array_t *da) +{ + array_clear(da); + free(da->_data); + da->capacity = 0; +} + +/** Remove item at given position, shift rest of array */ +void array_remove(array_t *da, size_t index) +{ + assert(index < da->size); + _array_unshift(da, index, 1); + errno_t rc = array_reserve(da, da->size); + assert(rc == EOK); +} + +/** Clear dynamic array (empty) */ +void array_clear(array_t *da) +{ + da->size = 0; +} + +/** Clear subsequence of array + * + * @param[in/out] da + * @param[in] begin index of first item to remove + * @param[in] end index behind last item to remove + */ +void array_clear_range(array_t *da, size_t begin, size_t end) +{ + assert(begin < da->size); + assert(end <= da->size); + + _array_unshift(da, begin, end - begin); + errno_t rc = array_reserve(da, da->size); + assert(rc == EOK); +} + +/** Concatenate two arrays + * + * @param[in/out] da1 first array and concatenated output + * @param[in] da2 second array, it is untouched + * + * @return EOK on success + * @return ENOMEM when allocation fails + */ +errno_t array_concat(array_t *da1, array_t *da2) +{ + assert(da1->_item_size == da2->_item_size); + + errno_t rc = array_reserve(da1, da1->size + da2->size); + if (rc != EOK) { + return rc; + } + void *dst = da1->_data + da1->size * da1->_item_size; + void *src = da2->_data; + size_t size = da1->_item_size * da2->size; + memcpy(dst, src, size); + da1->size += da2->size; + + return EOK; +} + +/** Grows/shrinks array so that it effeciently stores desired capacity + * + * @param da + * @param[in] desired capacity of array (items) + * + * @return EOK + * @return ENOMEM + */ +errno_t array_reserve(array_t *da, size_t capacity) +{ + const size_t factor = 2; + size_t new_capacity; + if (capacity > da->capacity) { + new_capacity = max(da->capacity * factor, capacity); + } else if (capacity < da->capacity / factor) { + new_capacity = min(da->capacity / factor, capacity); + } else { + new_capacity = capacity; + } + + return array_realloc(da, new_capacity); +} + +void _array_initialize(array_t *da, size_t item_size) +{ + da->_item_size = item_size; + da->_data = NULL; + + da->capacity = 0; + da->size = 0; +} + +/** Shift block of array + * + * Extends size of dynamic array, assumes sufficient capacity. + * + * @param da + * @param[in] index first item shifted + * @param[in] offset shift in no. of items + */ +void _array_shift(array_t *da, size_t index, size_t offset) +{ + assert(da->capacity >= da->size + offset); + + void *src = da->_data + index * da->_item_size; + void *dst = da->_data + (index + offset) * da->_item_size; + size_t size = (da->size - index) * da->_item_size; + memmove(dst, src, size); + da->size += offset; +} + +/** Unshift block of array + * + * Reduce size of dynamic array + * + * @param da + * @param[in] index first item unshifted (removed) + * @param[in] offset shift in no. of items + */ +void _array_unshift(array_t *da, size_t index, size_t offset) +{ + void *src = da->_data + (index + offset) * da->_item_size; + void *dst = da->_data + index * da->_item_size; + size_t size = (da->size - index - offset) * da->_item_size; + memmove(dst, src, size); + da->size -= offset; +} + +/** @} + */ Index: uspace/lib/c/generic/adt/dyn_array.c =================================================================== --- uspace/lib/c/generic/adt/dyn_array.c (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ (revision ) @@ -1,192 +1,0 @@ -/* - * Copyright (c) 2015 Michal Koutny - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libc - * @{ - */ -/** @file - * - * Implementation of dynamic array that grows or shrinks based upon no. of - * items it contains. Non-negligible part of implementation is in @ref - * dyn_array.h because of type genericity. - */ - -#include -#include -#include -#include -#include -#include - -static errno_t dyn_array_realloc(dyn_array_t *da, size_t capacity) -{ - if (capacity == da->capacity) { - return EOK; - } - - void *new_data = realloc(da->_data, da->_item_size * capacity); - if (new_data) { - da->_data = new_data; - da->capacity = capacity; - } - return (new_data == NULL) ? ENOMEM : EOK; -} - -void dyn_array_destroy(dyn_array_t *da) -{ - dyn_array_clear(da); - free(da->_data); - da->capacity = 0; -} - -/** Remove item at given position, shift rest of array */ -void dyn_array_remove(dyn_array_t *da, size_t index) -{ - assert(index < da->size); - _dyn_array_unshift(da, index, 1); - errno_t rc = dyn_array_reserve(da, da->size); - assert(rc == EOK); -} - -/** Clear dynamic array (empty) */ -void dyn_array_clear(dyn_array_t *da) -{ - da->size = 0; -} - -/** Clear subsequence of array - * - * @param[in/out] da - * @param[in] begin index of first item to remove - * @param[in] end index behind last item to remove - */ -void dyn_array_clear_range(dyn_array_t *da, size_t begin, size_t end) -{ - assert(begin < da->size); - assert(end <= da->size); - - _dyn_array_unshift(da, begin, end - begin); - errno_t rc = dyn_array_reserve(da, da->size); - assert(rc == EOK); -} - -/** Concatenate two arrays - * - * @param[in/out] da1 first array and concatenated output - * @param[in] da2 second array, it is untouched - * - * @return EOK on success - * @return ENOMEM when allocation fails - */ -errno_t dyn_array_concat(dyn_array_t *da1, dyn_array_t *da2) -{ - assert(da1->_item_size == da2->_item_size); - - errno_t rc = dyn_array_reserve(da1, da1->size + da2->size); - if (rc != EOK) { - return rc; - } - void *dst = da1->_data + da1->size * da1->_item_size; - void *src = da2->_data; - size_t size = da1->_item_size * da2->size; - memcpy(dst, src, size); - da1->size += da2->size; - - return EOK; -} - -/** Grows/shrinks array so that it effeciently stores desired capacity - * - * @param da - * @param[in] desired capacity of array (items) - * - * @return EOK - * @return ENOMEM - */ -errno_t dyn_array_reserve(dyn_array_t *da, size_t capacity) -{ - const size_t factor = 2; - size_t new_capacity; - if (capacity > da->capacity) { - new_capacity = max(da->capacity * factor, capacity); - } else if (capacity < da->capacity / factor) { - new_capacity = min(da->capacity / factor, capacity); - } else { - new_capacity = capacity; - } - - return dyn_array_realloc(da, new_capacity); -} - -void _dyn_array_initialize(dyn_array_t *da, size_t item_size) -{ - da->_item_size = item_size; - da->_data = NULL; - - da->capacity = 0; - da->size = 0; -} - -/** Shift block of array - * - * Extends size of dynamic array, assumes sufficient capacity. - * - * @param da - * @param[in] index first item shifted - * @param[in] offset shift in no. of items - */ -void _dyn_array_shift(dyn_array_t *da, size_t index, size_t offset) -{ - assert(da->capacity >= da->size + offset); - - void *src = da->_data + index * da->_item_size; - void *dst = da->_data + (index + offset) * da->_item_size; - size_t size = (da->size - index) * da->_item_size; - memmove(dst, src, size); - da->size += offset; -} - -/** Unshift block of array - * - * Reduce size of dynamic array - * - * @param da - * @param[in] index first item unshifted (removed) - * @param[in] offset shift in no. of items - */ -void _dyn_array_unshift(dyn_array_t *da, size_t index, size_t offset) -{ - void *src = da->_data + (index + offset) * da->_item_size; - void *dst = da->_data + index * da->_item_size; - size_t size = (da->size - index - offset) * da->_item_size; - memmove(dst, src, size); - da->size -= offset; -} - -/** @} - */ Index: uspace/lib/c/include/adt/array.h =================================================================== --- uspace/lib/c/include/adt/array.h (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) +++ uspace/lib/c/include/adt/array.h (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_ARRAY_H_ +#define LIBC_ARRAY_H_ + +#include +#include +#include + +typedef struct { + /** Data buffer of array */ + void *_data; + /** Size on bytes of a single item */ + size_t _item_size; + + /** Allocated space (in items) of the array */ + size_t capacity; + /** No. of items in the array */ + size_t size; +} array_t; + +/** Initialize dynamic array + * + * @param[in] capacity initial capacity of array + * + * @return void + */ +#define array_initialize(array, type) \ + _array_initialize((array), sizeof(type)) + +/** Dynamic array accessor + * + * @return lvalue for the given item + */ +#define array_at(array, type, index) \ + (*((type *) (array)->_data + index)) + +/** Access last element + * + * @return lvalue for the last item + */ +#define array_last(array, type) \ + (*((type *) (array)->_data + ((array)->size - 1))) + +/** Insert item at given position, shift rest of array + * + * @return EOK on success + * @return ENOMEM on failure + */ +#define array_insert(array, type, index, value) \ +({ \ + size_t _index = (index); \ + array_t *_da = (array); \ + errno_t rc = array_reserve(_da, _da->size + 1); \ + if (!rc) { \ + _array_shift(_da, _index, 1); \ + array_at(_da, type, _index) = (value); \ + } \ + rc; \ +}) + +/** Insert item at the end of array + * + * @return EOK on success + * @return ENOMEM on failure + */ +#define array_append(array, type, value) \ + array_insert(array, type, (array)->size, (value)) + +/** Dynamic array iteration + * + * @param[in] array array_t (not pointer) + * @param[in] it name of variable used as iterator, it's pointer + * to @p type + */ +#define array_foreach(array, type, it) \ + for (type *it = NULL; it == NULL; it = (type *)1) \ + for (type *_it = (type *)(array)._data; \ + it = _it, _it != ((type *)(array)._data + (array).size); \ + ++_it) + +/** Find first occurence of value + * + * @param[in] array array_t * + * @param[in] value value to search for + * + * @return index of found value or size of array when no found + */ +#define array_find(array, type, value) \ +({ \ + size_t _result = (array)->size; \ + array_foreach(*(array), type, _it) { \ + if (*_it == value) { \ + _result = _it - (type *)(array)->_data; \ + break; \ + } \ + } \ + _result; \ +}) + +extern void array_destroy(array_t *); +extern void array_remove(array_t *, size_t); +void array_clear(array_t *); +void array_clear_range(array_t *, size_t, size_t); +extern errno_t array_concat(array_t *, array_t *); +extern errno_t array_reserve(array_t *, size_t); + +extern void _array_initialize(array_t *, size_t); +extern void _array_shift(array_t *, size_t, size_t); +extern void _array_unshift(array_t *, size_t, size_t); + +#endif + +/** @} + */ Index: uspace/lib/c/include/adt/dyn_array.h =================================================================== --- uspace/lib/c/include/adt/dyn_array.h (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ (revision ) @@ -1,147 +1,0 @@ -/* - * Copyright (c) 2015 Michal Koutny - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libc - * @{ - */ -/** @file - */ - -#ifndef LIBC_DYN_ARRAY_H_ -#define LIBC_DYN_ARRAY_H_ - -#include -#include -#include - -typedef struct { - /** Data buffer of array */ - void *_data; - /** Size on bytes of a single item */ - size_t _item_size; - - /** Allocated space (in items) of the array */ - size_t capacity; - /** No. of items in the array */ - size_t size; -} dyn_array_t; - -/** Initialize dynamic array - * - * @param[in] capacity initial capacity of array - * - * @return void - */ -#define dyn_array_initialize(dyn_array, type) \ - _dyn_array_initialize((dyn_array), sizeof(type)) - -/** Dynamic array accessor - * - * @return lvalue for the given item - */ -#define dyn_array_at(dyn_array, type, index) \ - (*((type *) (dyn_array)->_data + index)) - -/** Access last element - * - * @return lvalue for the last item - */ -#define dyn_array_last(dyn_array, type) \ - (*((type *) (dyn_array)->_data + ((dyn_array)->size - 1))) - -/** Insert item at given position, shift rest of array - * - * @return EOK on success - * @return ENOMEM on failure - */ -#define dyn_array_insert(dyn_array, type, index, value) \ -({ \ - size_t _index = (index); \ - dyn_array_t *_da = (dyn_array); \ - errno_t rc = dyn_array_reserve(_da, _da->size + 1); \ - if (!rc) { \ - _dyn_array_shift(_da, _index, 1); \ - dyn_array_at(_da, type, _index) = (value); \ - } \ - rc; \ -}) - -/** Insert item at the end of array - * - * @return EOK on success - * @return ENOMEM on failure - */ -#define dyn_array_append(dyn_array, type, value) \ - dyn_array_insert(dyn_array, type, (dyn_array)->size, (value)) - -/** Dynamic array iteration - * - * @param[in] dyn_array dyn_array_t (not pointer) - * @param[in] it name of variable used as iterator, it's pointer - * to @p type - */ -#define dyn_array_foreach(dyn_array, type, it) \ - for (type *it = NULL; it == NULL; it = (type *)1) \ - for (type *_it = (type *)(dyn_array)._data; \ - it = _it, _it != ((type *)(dyn_array)._data + (dyn_array).size); \ - ++_it) - -/** Find first occurence of value - * - * @param[in] dyn_array dyn_array_t * - * @param[in] value value to search for - * - * @return index of found value or size of array when no found - */ -#define dyn_array_find(dyn_array, type, value) \ -({ \ - size_t _result = (dyn_array)->size; \ - dyn_array_foreach(*(dyn_array), type, _it) { \ - if (*_it == value) { \ - _result = _it - (type *)(dyn_array)->_data; \ - break; \ - } \ - } \ - _result; \ -}) - -extern void dyn_array_destroy(dyn_array_t *); -extern void dyn_array_remove(dyn_array_t *, size_t); -void dyn_array_clear(dyn_array_t *); -void dyn_array_clear_range(dyn_array_t *, size_t, size_t); -extern errno_t dyn_array_concat(dyn_array_t *, dyn_array_t *); -extern errno_t dyn_array_reserve(dyn_array_t *, size_t); - -extern void _dyn_array_initialize(dyn_array_t *, size_t); -extern void _dyn_array_shift(dyn_array_t *, size_t, size_t); -extern void _dyn_array_unshift(dyn_array_t *, size_t, size_t); - -#endif - -/** @} - */ Index: uspace/lib/c/test/adt/array.c =================================================================== --- uspace/lib/c/test/adt/array.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) +++ uspace/lib/c/test/adt/array.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -0,0 +1,235 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include + +PCUT_INIT + +PCUT_TEST_SUITE(array); + +typedef int data_t; +static array_t da; + +PCUT_TEST_BEFORE +{ + array_initialize(&da, data_t); + errno_t rc = array_reserve(&da, 3); + assert(rc == EOK); +} + +PCUT_TEST_AFTER +{ + array_destroy(&da); +} + +PCUT_TEST(initialization) +{ + PCUT_ASSERT_INT_EQUALS(da.capacity, 3); + PCUT_ASSERT_INT_EQUALS(da.size, 0); +} + +PCUT_TEST(append) +{ + array_append(&da, data_t, 42); + array_append(&da, data_t, 666); + + PCUT_ASSERT_INT_EQUALS(2, da.size); + PCUT_ASSERT_INT_EQUALS(42, array_at(&da, data_t, 0)); + PCUT_ASSERT_INT_EQUALS(666, array_at(&da, data_t, 1)); +} + +PCUT_TEST(assign) +{ + array_append(&da, data_t, 42); + array_at(&da, data_t, 0) = 112; + + PCUT_ASSERT_INT_EQUALS(112, array_at(&da, data_t, 0)); +} + +PCUT_TEST(remove) +{ + array_append(&da, data_t, 10); + array_append(&da, data_t, 11); + + array_remove(&da, 0); + + PCUT_ASSERT_INT_EQUALS(1, da.size); + PCUT_ASSERT_INT_EQUALS(11, array_at(&da, data_t, 0)); +} + +PCUT_TEST(insert) +{ + array_append(&da, data_t, 10); + array_append(&da, data_t, 11); + array_append(&da, data_t, 12); + array_insert(&da, data_t, 1, 99); + + PCUT_ASSERT_INT_EQUALS(4, da.size); + PCUT_ASSERT_INT_EQUALS(10, array_at(&da, data_t, 0)); + PCUT_ASSERT_INT_EQUALS(99, array_at(&da, data_t, 1)); + PCUT_ASSERT_INT_EQUALS(11, array_at(&da, data_t, 2)); + PCUT_ASSERT_INT_EQUALS(12, array_at(&da, data_t, 3)); +} + +PCUT_TEST(capacity_grow) +{ + array_append(&da, data_t, 42); + array_append(&da, data_t, 666); + array_append(&da, data_t, 42); + array_append(&da, data_t, 666); + + PCUT_ASSERT_TRUE(da.capacity > 3); +} + +PCUT_TEST(capacity_shrink) +{ + array_append(&da, data_t, 42); + array_append(&da, data_t, 666); + array_append(&da, data_t, 42); + + array_remove(&da, 0); + array_remove(&da, 0); + array_remove(&da, 0); + + PCUT_ASSERT_TRUE(da.capacity < 3); +} + +PCUT_TEST(iterator) +{ + for (int i = 0; i < 10; ++i) { + array_append(&da, data_t, i * i); + } + + int i = 0; + array_foreach(da, data_t, it) { + PCUT_ASSERT_INT_EQUALS(i * i, *it); + ++i; + } +} + +PCUT_TEST(find) +{ + array_append(&da, data_t, 10); + array_append(&da, data_t, 11); + array_append(&da, data_t, 12); + array_append(&da, data_t, 99); + + PCUT_ASSERT_INT_EQUALS(0, array_find(&da, data_t, 10)); + PCUT_ASSERT_INT_EQUALS(3, array_find(&da, data_t, 99)); + PCUT_ASSERT_INT_EQUALS(4, array_find(&da, data_t, 666)); +} + +PCUT_TEST(clear_range_middle) +{ + array_append(&da, data_t, 10); + array_append(&da, data_t, 11); + array_append(&da, data_t, 12); + array_append(&da, data_t, 99); + + array_clear_range(&da, 1, 3); + PCUT_ASSERT_INT_EQUALS(2, da.size); + PCUT_ASSERT_INT_EQUALS(10, array_at(&da, data_t, 0)); + PCUT_ASSERT_INT_EQUALS(99, array_at(&da, data_t, 1)); +} + +PCUT_TEST(clear_range_begin) +{ + array_append(&da, data_t, 10); + array_append(&da, data_t, 11); + array_append(&da, data_t, 12); + array_append(&da, data_t, 99); + + array_clear_range(&da, 0, 2); + PCUT_ASSERT_INT_EQUALS(2, da.size); + PCUT_ASSERT_INT_EQUALS(12, array_at(&da, data_t, 0)); + PCUT_ASSERT_INT_EQUALS(99, array_at(&da, data_t, 1)); +} + +PCUT_TEST(clear_range_end) +{ + array_append(&da, data_t, 10); + array_append(&da, data_t, 11); + array_append(&da, data_t, 12); + array_append(&da, data_t, 99); + + array_clear_range(&da, 2, 4); + PCUT_ASSERT_INT_EQUALS(2, da.size); + PCUT_ASSERT_INT_EQUALS(10, array_at(&da, data_t, 0)); + PCUT_ASSERT_INT_EQUALS(11, array_at(&da, data_t, 1)); +} + +PCUT_TEST(clear_range_empty) +{ + array_append(&da, data_t, 10); + array_append(&da, data_t, 99); + + array_clear_range(&da, 0, 0); + PCUT_ASSERT_INT_EQUALS(2, da.size); + PCUT_ASSERT_INT_EQUALS(10, array_at(&da, data_t, 0)); + PCUT_ASSERT_INT_EQUALS(99, array_at(&da, data_t, 1)); +} + +PCUT_TEST(concat_simple) +{ + array_append(&da, data_t, 10); + array_append(&da, data_t, 99); + + array_t da2; + array_initialize(&da2, data_t); + array_append(&da2, data_t, 30); + array_append(&da2, data_t, 31); + + array_concat(&da, &da2); + PCUT_ASSERT_INT_EQUALS(4, da.size); + PCUT_ASSERT_INT_EQUALS(2, da2.size); + + PCUT_ASSERT_INT_EQUALS(10, array_at(&da, data_t, 0)); + PCUT_ASSERT_INT_EQUALS(99, array_at(&da, data_t, 1)); + PCUT_ASSERT_INT_EQUALS(30, array_at(&da, data_t, 2)); + PCUT_ASSERT_INT_EQUALS(31, array_at(&da, data_t, 3)); + + array_destroy(&da2); +} + +PCUT_TEST(concat_self) +{ + array_append(&da, data_t, 10); + array_append(&da, data_t, 99); + + array_concat(&da, &da); + PCUT_ASSERT_INT_EQUALS(4, da.size); + + PCUT_ASSERT_INT_EQUALS(10, array_at(&da, data_t, 0)); + PCUT_ASSERT_INT_EQUALS(99, array_at(&da, data_t, 1)); + PCUT_ASSERT_INT_EQUALS(10, array_at(&da, data_t, 2)); + PCUT_ASSERT_INT_EQUALS(99, array_at(&da, data_t, 3)); +} + +PCUT_EXPORT(array); Index: uspace/lib/c/test/adt/dyn_array.c =================================================================== --- uspace/lib/c/test/adt/dyn_array.c (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ (revision ) @@ -1,235 +1,0 @@ -/* - * Copyright (c) 2015 Michal Koutny - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include -#include -#include - -PCUT_INIT - -PCUT_TEST_SUITE(dyn_array); - -typedef int data_t; -static dyn_array_t da; - -PCUT_TEST_BEFORE -{ - dyn_array_initialize(&da, data_t); - errno_t rc = dyn_array_reserve(&da, 3); - assert(rc == EOK); -} - -PCUT_TEST_AFTER -{ - dyn_array_destroy(&da); -} - -PCUT_TEST(initialization) -{ - PCUT_ASSERT_INT_EQUALS(da.capacity, 3); - PCUT_ASSERT_INT_EQUALS(da.size, 0); -} - -PCUT_TEST(append) -{ - dyn_array_append(&da, data_t, 42); - dyn_array_append(&da, data_t, 666); - - PCUT_ASSERT_INT_EQUALS(2, da.size); - PCUT_ASSERT_INT_EQUALS(42, dyn_array_at(&da, data_t, 0)); - PCUT_ASSERT_INT_EQUALS(666, dyn_array_at(&da, data_t, 1)); -} - -PCUT_TEST(assign) -{ - dyn_array_append(&da, data_t, 42); - dyn_array_at(&da, data_t, 0) = 112; - - PCUT_ASSERT_INT_EQUALS(112, dyn_array_at(&da, data_t, 0)); -} - -PCUT_TEST(remove) -{ - dyn_array_append(&da, data_t, 10); - dyn_array_append(&da, data_t, 11); - - dyn_array_remove(&da, 0); - - PCUT_ASSERT_INT_EQUALS(1, da.size); - PCUT_ASSERT_INT_EQUALS(11, dyn_array_at(&da, data_t, 0)); -} - -PCUT_TEST(insert) -{ - dyn_array_append(&da, data_t, 10); - dyn_array_append(&da, data_t, 11); - dyn_array_append(&da, data_t, 12); - dyn_array_insert(&da, data_t, 1, 99); - - PCUT_ASSERT_INT_EQUALS(4, da.size); - PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0)); - PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1)); - PCUT_ASSERT_INT_EQUALS(11, dyn_array_at(&da, data_t, 2)); - PCUT_ASSERT_INT_EQUALS(12, dyn_array_at(&da, data_t, 3)); -} - -PCUT_TEST(capacity_grow) -{ - dyn_array_append(&da, data_t, 42); - dyn_array_append(&da, data_t, 666); - dyn_array_append(&da, data_t, 42); - dyn_array_append(&da, data_t, 666); - - PCUT_ASSERT_TRUE(da.capacity > 3); -} - -PCUT_TEST(capacity_shrink) -{ - dyn_array_append(&da, data_t, 42); - dyn_array_append(&da, data_t, 666); - dyn_array_append(&da, data_t, 42); - - dyn_array_remove(&da, 0); - dyn_array_remove(&da, 0); - dyn_array_remove(&da, 0); - - PCUT_ASSERT_TRUE(da.capacity < 3); -} - -PCUT_TEST(iterator) -{ - for (int i = 0; i < 10; ++i) { - dyn_array_append(&da, data_t, i * i); - } - - int i = 0; - dyn_array_foreach(da, data_t, it) { - PCUT_ASSERT_INT_EQUALS(i * i, *it); - ++i; - } -} - -PCUT_TEST(find) -{ - dyn_array_append(&da, data_t, 10); - dyn_array_append(&da, data_t, 11); - dyn_array_append(&da, data_t, 12); - dyn_array_append(&da, data_t, 99); - - PCUT_ASSERT_INT_EQUALS(0, dyn_array_find(&da, data_t, 10)); - PCUT_ASSERT_INT_EQUALS(3, dyn_array_find(&da, data_t, 99)); - PCUT_ASSERT_INT_EQUALS(4, dyn_array_find(&da, data_t, 666)); -} - -PCUT_TEST(clear_range_middle) -{ - dyn_array_append(&da, data_t, 10); - dyn_array_append(&da, data_t, 11); - dyn_array_append(&da, data_t, 12); - dyn_array_append(&da, data_t, 99); - - dyn_array_clear_range(&da, 1, 3); - PCUT_ASSERT_INT_EQUALS(2, da.size); - PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0)); - PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1)); -} - -PCUT_TEST(clear_range_begin) -{ - dyn_array_append(&da, data_t, 10); - dyn_array_append(&da, data_t, 11); - dyn_array_append(&da, data_t, 12); - dyn_array_append(&da, data_t, 99); - - dyn_array_clear_range(&da, 0, 2); - PCUT_ASSERT_INT_EQUALS(2, da.size); - PCUT_ASSERT_INT_EQUALS(12, dyn_array_at(&da, data_t, 0)); - PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1)); -} - -PCUT_TEST(clear_range_end) -{ - dyn_array_append(&da, data_t, 10); - dyn_array_append(&da, data_t, 11); - dyn_array_append(&da, data_t, 12); - dyn_array_append(&da, data_t, 99); - - dyn_array_clear_range(&da, 2, 4); - PCUT_ASSERT_INT_EQUALS(2, da.size); - PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0)); - PCUT_ASSERT_INT_EQUALS(11, dyn_array_at(&da, data_t, 1)); -} - -PCUT_TEST(clear_range_empty) -{ - dyn_array_append(&da, data_t, 10); - dyn_array_append(&da, data_t, 99); - - dyn_array_clear_range(&da, 0, 0); - PCUT_ASSERT_INT_EQUALS(2, da.size); - PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0)); - PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1)); -} - -PCUT_TEST(concat_simple) -{ - dyn_array_append(&da, data_t, 10); - dyn_array_append(&da, data_t, 99); - - dyn_array_t da2; - dyn_array_initialize(&da2, data_t); - dyn_array_append(&da2, data_t, 30); - dyn_array_append(&da2, data_t, 31); - - dyn_array_concat(&da, &da2); - PCUT_ASSERT_INT_EQUALS(4, da.size); - PCUT_ASSERT_INT_EQUALS(2, da2.size); - - PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0)); - PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1)); - PCUT_ASSERT_INT_EQUALS(30, dyn_array_at(&da, data_t, 2)); - PCUT_ASSERT_INT_EQUALS(31, dyn_array_at(&da, data_t, 3)); - - dyn_array_destroy(&da2); -} - -PCUT_TEST(concat_self) -{ - dyn_array_append(&da, data_t, 10); - dyn_array_append(&da, data_t, 99); - - dyn_array_concat(&da, &da); - PCUT_ASSERT_INT_EQUALS(4, da.size); - - PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0)); - PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1)); - PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 2)); - PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 3)); -} - -PCUT_EXPORT(dyn_array); Index: uspace/lib/c/test/main.c =================================================================== --- uspace/lib/c/test/main.c (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ uspace/lib/c/test/main.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -32,9 +32,9 @@ PCUT_INIT; +PCUT_IMPORT(array); PCUT_IMPORT(cap); PCUT_IMPORT(casting); PCUT_IMPORT(circ_buf); PCUT_IMPORT(double_to_str); -PCUT_IMPORT(dyn_array); PCUT_IMPORT(fibril_timer); PCUT_IMPORT(getopt); Index: uspace/srv/sysman/job.c =================================================================== --- uspace/srv/sysman/job.c (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ uspace/srv/sysman/job.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -70,5 +70,5 @@ job->unit = u; - dyn_array_initialize(&job->blocked_jobs, job_t *); + array_initialize(&job->blocked_jobs, job_t *); job->blocking_jobs = 0; job->blocking_job_failed = false; @@ -120,8 +120,8 @@ assert(!link_used(&job->job_queue)); - dyn_array_foreach(job->blocked_jobs, job_t *, job_it) { + array_foreach(job->blocked_jobs, job_t *, job_it) { job_del_ref(&(*job_it)); } - dyn_array_destroy(&job->blocked_jobs); + array_destroy(&job->blocked_jobs); free(job); @@ -257,8 +257,8 @@ /* First remove references, then clear the array */ assert(job->blocked_jobs.size == job->blocked_jobs_count); - dyn_array_foreach(job->blocked_jobs, job_t *, job_it) { + array_foreach(job->blocked_jobs, job_t *, job_it) { job_unblock(*job_it, job); } - dyn_array_clear(&job->blocked_jobs); + array_clear(&job->blocked_jobs); /* Add reference for event handler */ Index: uspace/srv/sysman/job.h =================================================================== --- uspace/srv/sysman/job.h (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ uspace/srv/sysman/job.h (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -30,5 +30,5 @@ #define SYSMAN_JOB_H -#include +#include #include #include @@ -64,5 +64,5 @@ /** Jobs that this job is preventing from running */ - dyn_array_t blocked_jobs; + array_t blocked_jobs; /** * No. of jobs that the job is actually blocking (may differ from size Index: uspace/srv/sysman/job_closure.c =================================================================== --- uspace/srv/sysman/job_closure.c (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ uspace/srv/sysman/job_closure.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -66,5 +66,5 @@ blocking_job->blocked_jobs_count); - errno_t rc = dyn_array_append(&blocking_job->blocked_jobs, job_t *, + errno_t rc = array_append(&blocking_job->blocked_jobs, job_t *, blocked_job); if (rc != EOK) { @@ -97,5 +97,5 @@ goto finish; } - job_t *first_job = dyn_array_last(closure, job_t *); + job_t *first_job = array_last(closure, job_t *); job_add_ref(first_job); @@ -119,5 +119,5 @@ /* Pass job reference to closure and add one for unit */ - rc = dyn_array_append(closure, job_t *, created_job); + rc = array_append(closure, job_t *, created_job); if (rc != EOK) { goto finish; @@ -165,5 +165,5 @@ /* Pass job reference to closure and add one for unit */ - rc = dyn_array_append(closure, job_t *, created_job); + rc = array_append(closure, job_t *, created_job); if (rc != EOK) { goto finish; @@ -308,5 +308,5 @@ } - errno_t rc = dyn_array_append(job_closure, job_t *, main_job); + errno_t rc = array_append(job_closure, job_t *, main_job); if (rc != EOK) { return rc; @@ -343,5 +343,5 @@ if (rc == EOK) { - dyn_array_foreach(*job_closure, job_t *, job_it) { + array_foreach(*job_closure, job_t *, job_it) { sysman_log(LVL_DEBUG2, "%s\t%s, refs: %u", __func__, unit_name((*job_it)->unit), atomic_load(&(*job_it)->refcnt)); @@ -350,5 +350,5 @@ /* Clean after ourselves (BFS tag jobs) */ - dyn_array_foreach(*job_closure, job_t *, job_it) { + array_foreach(*job_closure, job_t *, job_it) { job_t *j = (*job_it)->unit->bfs_data; assert(*job_it == j); Index: uspace/srv/sysman/job_closure.h =================================================================== --- uspace/srv/sysman/job_closure.h (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ uspace/srv/sysman/job_closure.h (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -30,5 +30,5 @@ #define SYSMAN_JOB_CLOSURE_H -#include +#include #include "job.h" @@ -36,5 +36,5 @@ #define CLOSURE_ISOLATE 0x1 -typedef dyn_array_t job_closure_t; +typedef array_t job_closure_t; extern errno_t job_create_closure(job_t *, job_closure_t *, int); Index: uspace/srv/sysman/job_queue.c =================================================================== --- uspace/srv/sysman/job_queue.c (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ uspace/srv/sysman/job_queue.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -110,9 +110,9 @@ assert(other->merged_into == NULL); - errno_t rc = dyn_array_concat(&trunk->blocked_jobs, &other->blocked_jobs); + errno_t rc = array_concat(&trunk->blocked_jobs, &other->blocked_jobs); if (rc != EOK) { return rc; } - dyn_array_clear(&other->blocked_jobs); + array_clear(&other->blocked_jobs); // TODO allocate observed object @@ -145,5 +145,5 @@ { assert(trunk->blocked_jobs.size >= trunk->blocked_jobs_count); - dyn_array_clear_range(&trunk->blocked_jobs, + array_clear_range(&trunk->blocked_jobs, trunk->blocked_jobs_count, trunk->blocked_jobs.size); } @@ -172,5 +172,5 @@ /* Check consistency with existing jobs. */ - dyn_array_foreach(*closure, job_t *, job_it) { + array_foreach(*closure, job_t *, job_it) { job_t *job = *job_it; job_t *other_job = job->unit->job; @@ -214,5 +214,5 @@ /* Aggregate merged jobs, or rollback any changes in existing jobs */ bool finish_merge = (rc == EOK) && !has_error; - dyn_array_foreach(*closure, job_t *, job_it) { + array_foreach(*closure, job_t *, job_it) { if ((*job_it)->merged_into == NULL) { continue; @@ -236,5 +236,5 @@ * in their blocked_jobs array. */ - dyn_array_foreach(*closure, job_t *, job_it) { + array_foreach(*closure, job_t *, job_it) { job_t *job = (*job_it); if (job->merged_into != NULL) { @@ -255,5 +255,5 @@ /* We've stolen references from the closure, so erase it */ - dyn_array_clear(closure); + array_clear(closure); return EOK; Index: uspace/srv/sysman/sysman.c =================================================================== --- uspace/srv/sysman/sysman.c (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ uspace/srv/sysman/sysman.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -366,6 +366,6 @@ job_t *job = job_args->job; int flags = job_args->flags; - dyn_array_t job_closure; - dyn_array_initialize(&job_closure, job_t *); + array_t job_closure; + array_initialize(&job_closure, job_t *); if (job_args->callback != NULL) { @@ -402,8 +402,8 @@ job_del_ref(&job); - dyn_array_foreach(job_closure, job_t *, closure_job) { + array_foreach(job_closure, job_t *, closure_job) { job_del_ref(&(*closure_job)); } - dyn_array_destroy(&job_closure); + array_destroy(&job_closure); } Index: uspace/srv/sysman/test/job_closure.c =================================================================== --- uspace/srv/sysman/test/job_closure.c (revision 9559cf8aeef623550ee498ff9ef6fd5e1432349f) +++ uspace/srv/sysman/test/job_closure.c (revision 03daabd16d88c5efb885074dee56d30ea08f1b56) @@ -40,6 +40,6 @@ PCUT_TEST_SUITE(job_closure); -static dyn_array_t exp_closure; -static dyn_array_t act_closure; +static array_t exp_closure; +static array_t act_closure; static bool same_job(job_t *expected, job_t *actual) @@ -49,5 +49,5 @@ } -static bool same_jobs(dyn_array_t *expected, dyn_array_t *actual) +static bool same_jobs(array_t *expected, array_t *actual) { if (expected->size != actual->size) { @@ -58,7 +58,7 @@ /* Verify expected \subseteq actual (we've compared sizes) */ - dyn_array_foreach(*expected, job_t *, it_exp) { + array_foreach(*expected, job_t *, it_exp) { bool found = false; - dyn_array_foreach(*actual, job_t *, it_act) { + array_foreach(*actual, job_t *, it_act) { if (same_job(*it_exp, *it_act)) { found = true; @@ -79,5 +79,5 @@ { bool found = false; - dyn_array_foreach(blocking_job->blocked_jobs, job_t *, it) { + array_foreach(blocking_job->blocked_jobs, job_t *, it) { if (*it == blocked_job) { found = true; @@ -94,14 +94,14 @@ } -static void dummy_add_closure(dyn_array_t *closure) -{ - dyn_array_foreach(*closure, job_t *, it) { +static void dummy_add_closure(array_t *closure) +{ + array_foreach(*closure, job_t *, it) { (*it)->unit->job = *it; } } -static void destroy_job_closure(dyn_array_t *closure) -{ - dyn_array_foreach(*closure, job_t *, it) { +static void destroy_job_closure(array_t *closure) +{ + array_foreach(*closure, job_t *, it) { job_del_ref(&(*it)); } @@ -113,10 +113,10 @@ mock_set_units_state(STATE_STOPPED); - dyn_array_initialize(&exp_closure, job_t *); - errno_t rc = dyn_array_reserve(&exp_closure, MAX_TYPES * MAX_UNITS); + array_initialize(&exp_closure, job_t *); + errno_t rc = array_reserve(&exp_closure, MAX_TYPES * MAX_UNITS); assert(rc == EOK); - dyn_array_initialize(&act_closure, job_t *); - rc = dyn_array_reserve(&act_closure, MAX_TYPES * MAX_UNITS); + array_initialize(&act_closure, job_t *); + rc = array_reserve(&act_closure, MAX_TYPES * MAX_UNITS); assert(rc == EOK); @@ -127,8 +127,8 @@ { destroy_job_closure(&act_closure); - dyn_array_destroy(&act_closure); + array_destroy(&act_closure); destroy_job_closure(&exp_closure); - dyn_array_destroy(&exp_closure); + array_destroy(&exp_closure); mock_destroy_units(); @@ -156,7 +156,7 @@ PCUT_ASSERT_INT_EQUALS(EOK, rc); - dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED)); dummy_add_closure(&act_closure); @@ -188,7 +188,7 @@ PCUT_ASSERT_INT_EQUALS(EOK, rc); - dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED)); dummy_add_closure(&act_closure); @@ -222,7 +222,7 @@ PCUT_ASSERT_INT_EQUALS(EOK, rc); - dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED)); dummy_add_closure(&act_closure); @@ -269,11 +269,11 @@ PCUT_ASSERT_INT_EQUALS(EOK, rc); - dyn_array_append(&exp_closure, job_t *, dummy_job(u0, STATE_STOPPED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STOPPED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u4, STATE_STOPPED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u5, STATE_STOPPED)); - dyn_array_append(&exp_closure, job_t *, dummy_job(u6, STATE_STOPPED)); + array_append(&exp_closure, job_t *, dummy_job(u0, STATE_STOPPED)); + array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED)); + array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STOPPED)); + array_append(&exp_closure, job_t *, dummy_job(u4, STATE_STOPPED)); + array_append(&exp_closure, job_t *, dummy_job(u5, STATE_STOPPED)); + array_append(&exp_closure, job_t *, dummy_job(u6, STATE_STOPPED)); dummy_add_closure(&act_closure);