1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/test/array_tests.c Thu Jul 04 20:07:31 2019 +0200
1.3 @@ -0,0 +1,448 @@
1.4 +/*
1.5 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
1.6 + *
1.7 + * Copyright 2019 Mike Becker, Olaf Wintermann All rights reserved.
1.8 + *
1.9 + * Redistribution and use in source and binary forms, with or without
1.10 + * modification, are permitted provided that the following conditions are met:
1.11 + *
1.12 + * 1. Redistributions of source code must retain the above copyright
1.13 + * notice, this list of conditions and the following disclaimer.
1.14 + *
1.15 + * 2. Redistributions in binary form must reproduce the above copyright
1.16 + * notice, this list of conditions and the following disclaimer in the
1.17 + * documentation and/or other materials provided with the distribution.
1.18 + *
1.19 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1.20 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1.21 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1.22 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
1.23 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
1.24 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
1.25 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1.26 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
1.27 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
1.28 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
1.29 + * POSSIBILITY OF SUCH DAMAGE.
1.30 + */
1.31 +
1.32 +#include "array_tests.h"
1.33 +#include <ucx/utils.h>
1.34 +
1.35 +UCX_TEST(test_ucx_array_free) {
1.36 + UcxArray array = ucx_array_new(16, sizeof(int));
1.37 +
1.38 + UCX_TEST_BEGIN
1.39 + ucx_array_free(&array);
1.40 + UCX_TEST_ASSERT(array.data == NULL, "data pointer not NULL after free");
1.41 + UCX_TEST_ASSERT(array.size == 0, "size not zero after free");
1.42 + UCX_TEST_ASSERT(array.capacity == 0, "capacity not zero after free");
1.43 + UCX_TEST_ASSERT(array.allocator == ucx_default_allocator(),
1.44 + "allocator corrupted during free");
1.45 + UCX_TEST_END
1.46 +}
1.47 +
1.48 +UCX_TEST(test_ucx_array_new) {
1.49 + UcxArray array = ucx_array_new(16, 47);
1.50 +
1.51 + UCX_TEST_BEGIN
1.52 + UCX_TEST_ASSERT(array.data, "no memory allocated");
1.53 + UCX_TEST_ASSERT(array.size == 0, "size not initially zero");
1.54 + UCX_TEST_ASSERT(array.capacity == 16, "capacity not as requested");
1.55 + UCX_TEST_ASSERT(array.elemsize == 47, "element size not as requested");
1.56 + UCX_TEST_ASSERT(array.allocator == ucx_default_allocator(),
1.57 + "array not using the default allocator");
1.58 + UCX_TEST_END
1.59 + ucx_array_free(&array);
1.60 +}
1.61 +
1.62 +UCX_TEST(test_ucx_array_append) {
1.63 + UcxArray array = ucx_array_new(16, sizeof(int));
1.64 +
1.65 + int x = 42;
1.66 + ucx_array_append(&array, &x);
1.67 + UCX_TEST_BEGIN
1.68 +
1.69 + UCX_TEST_ASSERT(ucx_array_at_int(array, 0) == 42, "failed");
1.70 +
1.71 + x = 13;
1.72 + ucx_array_append(&array, &x);
1.73 +
1.74 + UCX_TEST_ASSERT(array.size == 2, "incorrect size after append");
1.75 + UCX_TEST_ASSERT(ucx_array_at_int(array, 1) == 13, "failed");
1.76 + UCX_TEST_ASSERT(ucx_array_at_int(array, 0) == 42,
1.77 + "append corrupted previously inserted data");
1.78 +
1.79 + ucx_array_append(&array, NULL);
1.80 +
1.81 + UCX_TEST_ASSERT(array.size == 3, "incorrect size after NULL append");
1.82 + UCX_TEST_ASSERT(ucx_array_at_int(array, 2) == 0, "element is not zeroed");
1.83 + UCX_TEST_ASSERT(ucx_array_at_int(array, 0) == 42,
1.84 + "NULL append corrupted previously inserted data");
1.85 + UCX_TEST_ASSERT(ucx_array_at_int(array, 1) == 13,
1.86 + "NULL append corrupted previously inserted data");
1.87 +
1.88 + UCX_TEST_END
1.89 +
1.90 + ucx_array_free(&array);
1.91 +}
1.92 +
1.93 +UCX_TEST(test_ucx_array_prepend) {
1.94 + UcxArray array = ucx_array_new(16, sizeof(int));
1.95 +
1.96 + int x = 42;
1.97 + ucx_array_prepend(&array, &x);
1.98 + UCX_TEST_BEGIN
1.99 +
1.100 + UCX_TEST_ASSERT(ucx_array_at_int(array, 0) == 42, "failed");
1.101 +
1.102 + x = 13;
1.103 + ucx_array_prepend(&array, &x);
1.104 +
1.105 + UCX_TEST_ASSERT(array.size == 2, "incorrect size after prepend");
1.106 + UCX_TEST_ASSERT(ucx_array_at_int(array, 0) == 13, "failed");
1.107 + UCX_TEST_ASSERT(ucx_array_at_int(array, 1) == 42,
1.108 + "prepend corrupted previously inserted data");
1.109 +
1.110 + ucx_array_prepend(&array, NULL);
1.111 +
1.112 + UCX_TEST_ASSERT(array.size == 3, "incorrect size after NULL prepend");
1.113 + UCX_TEST_ASSERT(ucx_array_at_int(array, 0) == 0, "element is not zeroed");
1.114 + UCX_TEST_ASSERT(ucx_array_at_int(array, 1) == 13,
1.115 + "NULL prepend corrupted previously inserted data");
1.116 + UCX_TEST_ASSERT(ucx_array_at_int(array, 2) == 42,
1.117 + "NULL prepend corrupted previously inserted data");
1.118 +
1.119 + UCX_TEST_END
1.120 +
1.121 + ucx_array_free(&array);
1.122 +}
1.123 +
1.124 +UCX_TEST(test_ucx_array_equals) {
1.125 + UcxArray a1 = ucx_array_new(16, sizeof(int));
1.126 + UcxArray a2 = ucx_array_new(16, sizeof(int));
1.127 + UcxArray a3 = ucx_array_new(16, sizeof(long int));
1.128 + UcxArray a4 = ucx_array_new(16, sizeof(int));
1.129 +
1.130 + a1.size = 5;
1.131 + ucx_array_at_int(a1, 0) = 47;
1.132 + ucx_array_at_int(a1, 1) = 11;
1.133 + ucx_array_at_int(a1, 2) = 0;
1.134 + ucx_array_at_int(a1, 3) = 8;
1.135 + ucx_array_at_int(a1, 4) = 15;
1.136 + a2.size = 5;
1.137 + ucx_array_at_int(a2, 0) = 47;
1.138 + ucx_array_at_int(a2, 1) = 11;
1.139 + ucx_array_at_int(a2, 2) = 0;
1.140 + ucx_array_at_int(a2, 3) = 8;
1.141 + ucx_array_at_int(a2, 4) = 15;
1.142 + a3.size = 5;
1.143 + ucx_array_at_longint(a3, 0) = 47;
1.144 + ucx_array_at_longint(a3, 1) = 11;
1.145 + ucx_array_at_longint(a3, 2) = 0;
1.146 + ucx_array_at_longint(a3, 3) = 8;
1.147 + ucx_array_at_longint(a3, 4) = 15;
1.148 + a4.size = 5;
1.149 + ucx_array_at_int(a4, 0) = 47;
1.150 + ucx_array_at_int(a4, 1) = 11;
1.151 + ucx_array_at_int(a4, 2) = -6;
1.152 + ucx_array_at_int(a4, 3) = 8;
1.153 + ucx_array_at_int(a4, 4) = 15;
1.154 +
1.155 + UCX_TEST_BEGIN
1.156 +
1.157 + UCX_TEST_ASSERT(ucx_array_equals(a1, a2, ucx_cmp_int, NULL) == 0, "failed");
1.158 + UCX_TEST_ASSERT(ucx_array_equals(a1, a4, ucx_cmp_int, NULL) > 0, "failed");
1.159 + UCX_TEST_ASSERT(ucx_array_equals(a4, a1, ucx_cmp_int, NULL) < 0, "failed");
1.160 + UCX_TEST_ASSERT(ucx_array_equals(a1, a3, ucx_cmp_int, NULL) < 0,
1.161 + "comparing arrays of different element size failed");
1.162 + UCX_TEST_ASSERT(ucx_array_equals(a3, a1, ucx_cmp_int, NULL) > 0,
1.163 + "comparing arrays of different element size failed");
1.164 +
1.165 + UCX_TEST_ASSERT(ucx_array_equals(a1, a2, NULL, NULL) == 0,
1.166 + "compare using memcmp() failed");
1.167 + UCX_TEST_ASSERT(ucx_array_equals(a1, a4, NULL, NULL) > 0,
1.168 + "compare using memcmp() failed");
1.169 + UCX_TEST_ASSERT(ucx_array_equals(a4, a1, NULL, NULL) < 0,
1.170 + "compare using memcmp() failed");
1.171 +
1.172 + UCX_TEST_END
1.173 + ucx_array_free(&a1);
1.174 + ucx_array_free(&a2);
1.175 + ucx_array_free(&a3);
1.176 + ucx_array_free(&a4);
1.177 +}
1.178 +
1.179 +UCX_TEST(test_ucx_array_concat) {
1.180 + UcxArray a1 = ucx_array_new(16, sizeof(int));
1.181 + UcxArray a2 = ucx_array_new(16, sizeof(int));
1.182 +
1.183 + a1.size = 2;
1.184 + ucx_array_at_int(a1, 0) = 47;
1.185 + ucx_array_at_int(a1, 1) = 11;
1.186 + a2.size = 3;
1.187 + ucx_array_at_int(a2, 0) = 0;
1.188 + ucx_array_at_int(a2, 1) = 8;
1.189 + ucx_array_at_int(a2, 2) = 15;
1.190 +
1.191 + UCX_TEST_BEGIN
1.192 +
1.193 + UCX_TEST_ASSERT(!ucx_array_concat(&a1, &a2), "failed");
1.194 + UCX_TEST_ASSERT(a1.size == 5, "failed");
1.195 + UCX_TEST_ASSERT(ucx_array_at_int(a1, 0) == 47, "failed");
1.196 + UCX_TEST_ASSERT(ucx_array_at_int(a1, 1) == 11, "failed");
1.197 + UCX_TEST_ASSERT(ucx_array_at_int(a1, 2) == 0, "failed");
1.198 + UCX_TEST_ASSERT(ucx_array_at_int(a1, 3) == 8, "failed");
1.199 + UCX_TEST_ASSERT(ucx_array_at_int(a1, 4) == 15, "failed");
1.200 +
1.201 + a1.elemsize *= 2;
1.202 + UCX_TEST_ASSERT(ucx_array_concat(&a1, &a2),
1.203 + "arrays of different element size must not be concatenated");
1.204 + UCX_TEST_ASSERT(a1.size == 5,
1.205 + "arrays of different element size must not be concatenated");
1.206 +
1.207 + UCX_TEST_END
1.208 + ucx_array_free(&a1);
1.209 + ucx_array_free(&a2);
1.210 +}
1.211 +
1.212 +UCX_TEST(test_ucx_array_at) {
1.213 + UcxArray array = ucx_array_new(16, sizeof(int));
1.214 +
1.215 + int x = 42;
1.216 + ucx_array_append(&array, &x);
1.217 + x = 13;
1.218 + ucx_array_append(&array, &x);
1.219 + x = 5;
1.220 + ucx_array_append(&array, &x);
1.221 +
1.222 + UCX_TEST_BEGIN
1.223 +
1.224 + UCX_TEST_ASSERT(ucx_array_at_int(array, 1) == 13, "failed");
1.225 + ucx_array_at_int(array, 1) = 80;
1.226 + UCX_TEST_ASSERT(ucx_array_at_int(array, 1) == 80, "assignment failed");
1.227 +
1.228 +
1.229 + UCX_TEST_ASSERT(ucx_array_at_int(array, 0) == 42, "corrupted data");
1.230 + UCX_TEST_ASSERT(ucx_array_at_int(array, 2) == 5, "corrupted data");
1.231 +
1.232 + UCX_TEST_END
1.233 +
1.234 + ucx_array_free(&array);
1.235 +}
1.236 +
1.237 +UCX_TEST(test_ucx_array_find) {
1.238 + UcxArray array = ucx_array_new(16, sizeof(int));
1.239 +
1.240 + array.size = 5;
1.241 + ucx_array_at_int(array, 0) = 47;
1.242 + ucx_array_at_int(array, 1) = 11;
1.243 + ucx_array_at_int(array, 2) = 0;
1.244 + ucx_array_at_int(array, 3) = 8;
1.245 + ucx_array_at_int(array, 4) = 15;
1.246 +
1.247 + int x = 8;
1.248 + int y = 90;
1.249 +
1.250 + UCX_TEST_BEGIN
1.251 +
1.252 + UCX_TEST_ASSERT(ucx_array_find(array,(void*)&x,ucx_cmp_int,NULL) == 3,
1.253 + "doesn't find element");
1.254 + UCX_TEST_ASSERT(ucx_array_find(array,(void*)&y,ucx_cmp_int,NULL) == 5,
1.255 + "finds non-existing element");
1.256 +
1.257 + UCX_TEST_ASSERT(ucx_array_find(array,(void*)&x,NULL,NULL) == 3,
1.258 + "failed using memcmp()");
1.259 + UCX_TEST_ASSERT(ucx_array_find(array,(void*)&y,NULL,NULL) == 5,
1.260 + "failed using memcmp()");
1.261 +
1.262 + UCX_TEST_END
1.263 + ucx_array_free(&array);
1.264 +}
1.265 +
1.266 +UCX_TEST(test_ucx_array_contains) {
1.267 + UcxArray array = ucx_array_new(16, sizeof(int));
1.268 +
1.269 + array.size = 5;
1.270 + ucx_array_at_int(array, 0) = 47;
1.271 + ucx_array_at_int(array, 1) = 11;
1.272 + ucx_array_at_int(array, 2) = 0;
1.273 + ucx_array_at_int(array, 3) = 8;
1.274 + ucx_array_at_int(array, 4) = 15;
1.275 +
1.276 + int x = 8;
1.277 + int y = 90;
1.278 +
1.279 + UCX_TEST_BEGIN
1.280 +
1.281 + UCX_TEST_ASSERT(ucx_array_contains(array,(void*)&x,ucx_cmp_int,NULL),
1.282 + "false negative");
1.283 + UCX_TEST_ASSERT(!ucx_array_contains(array,(void*)&y,ucx_cmp_int,NULL),
1.284 + "false positive");
1.285 +
1.286 + UCX_TEST_ASSERT(ucx_array_contains(array,(void*)&x,NULL,NULL),
1.287 + "false negative using memcmp()");
1.288 + UCX_TEST_ASSERT(!ucx_array_contains(array,(void*)&y,NULL,NULL),
1.289 + "false positive using memcmp()");
1.290 +
1.291 + UCX_TEST_END
1.292 + ucx_array_free(&array);
1.293 +}
1.294 +
1.295 +UCX_TEST(test_ucx_array_remove) {
1.296 + UcxArray array = ucx_array_new(16, sizeof(int));
1.297 +
1.298 + array.size = 5;
1.299 + ucx_array_at_int(array, 0) = 47;
1.300 + ucx_array_at_int(array, 1) = 11;
1.301 + ucx_array_at_int(array, 2) = 0;
1.302 + ucx_array_at_int(array, 3) = 8;
1.303 + ucx_array_at_int(array, 4) = 15;
1.304 +
1.305 + UCX_TEST_BEGIN
1.306 +
1.307 + ucx_array_remove(&array, 2);
1.308 + UCX_TEST_ASSERT(
1.309 + ucx_array_at_int(array, 0) == 47 &&
1.310 + ucx_array_at_int(array, 1) == 11 &&
1.311 + ucx_array_at_int(array, 2) == 8 &&
1.312 + ucx_array_at_int(array, 3) == 15,
1.313 + "wrong contents after remove");
1.314 + UCX_TEST_ASSERT(array.size == 4, "wrong size after remove");
1.315 +
1.316 + ucx_array_remove_fast(&array, 1);
1.317 + UCX_TEST_ASSERT(
1.318 + ucx_array_at_int(array, 0) == 47 &&
1.319 + ucx_array_at_int(array, 1) == 15 &&
1.320 + ucx_array_at_int(array, 2) == 8,
1.321 + "wrong contents after fast remove");
1.322 + UCX_TEST_ASSERT(array.size == 3, "wrong size after fast remove");
1.323 +
1.324 + UCX_TEST_END
1.325 + ucx_array_free(&array);
1.326 +}
1.327 +
1.328 +UCX_TEST(test_ucx_array_clone) {
1.329 +
1.330 + UcxArray array = ucx_array_new(16, sizeof(int));
1.331 +
1.332 + array.size = 5;
1.333 + ucx_array_at_int(array, 0) = 47;
1.334 + ucx_array_at_int(array, 1) = 11;
1.335 + ucx_array_at_int(array, 2) = 0;
1.336 + ucx_array_at_int(array, 3) = 8;
1.337 + ucx_array_at_int(array, 4) = 15;
1.338 +
1.339 + UcxArray copy = ucx_array_clone(array);
1.340 + UCX_TEST_BEGIN
1.341 +
1.342 + UCX_TEST_ASSERT(array.data != copy.data, "no true copy");
1.343 + UCX_TEST_ASSERT(ucx_array_equals(array, copy, ucx_cmp_int, NULL), "failed");
1.344 + UCX_TEST_ASSERT(array.size == copy.size, "size mismatch");
1.345 + UCX_TEST_ASSERT(array.capacity == copy.capacity, "capacity mismatch");
1.346 + UCX_TEST_ASSERT(array.elemsize == copy.elemsize, "element size mismatch");
1.347 + UCX_TEST_ASSERT(array.allocator == copy.allocator, "allocator mismatch");
1.348 +
1.349 + UCX_TEST_END
1.350 +
1.351 + ucx_array_free(&array);
1.352 + ucx_array_free(©);
1.353 +}
1.354 +
1.355 +UCX_TEST(test_ucx_array_sort) {
1.356 + UcxArray array = ucx_array_new(16, sizeof(int));
1.357 + array.size = 5;
1.358 + ucx_array_at_int(array, 0) = 47;
1.359 + ucx_array_at_int(array, 1) = 11;
1.360 + ucx_array_at_int(array, 2) = 0;
1.361 + ucx_array_at_int(array, 3) = 8;
1.362 + ucx_array_at_int(array, 4) = 15;
1.363 +
1.364 + UcxArray expected = ucx_array_new(16, sizeof(int));
1.365 + expected.size = 5;
1.366 + ucx_array_at_int(expected, 0) = 0;
1.367 + ucx_array_at_int(expected, 1) = 8;
1.368 + ucx_array_at_int(expected, 2) = 11;
1.369 + ucx_array_at_int(expected, 3) = 15;
1.370 + ucx_array_at_int(expected, 4) = 47;
1.371 +
1.372 +
1.373 + UCX_TEST_BEGIN
1.374 + void* original_ptr = array.data;
1.375 + UCX_TEST_ASSERT(!ucx_array_sort(array, ucx_cmp_int, NULL), "failed");
1.376 + UCX_TEST_ASSERT(!ucx_array_equals(array, expected, NULL, NULL), "failed");
1.377 + UCX_TEST_ASSERT(array.size == 5, "size corrupted");
1.378 + UCX_TEST_ASSERT(array.data == original_ptr, "shall not reallocate");
1.379 + UCX_TEST_END
1.380 +
1.381 + ucx_array_free(&expected);
1.382 + ucx_array_free(&array);
1.383 +}
1.384 +
1.385 +UCX_TEST(test_ucx_array_autogrow) {
1.386 + UcxArray array = ucx_array_new(4, sizeof(int));
1.387 + array.size = 3;
1.388 + ucx_array_at_int(array, 0) = 47;
1.389 + ucx_array_at_int(array, 1) = 11;
1.390 + int x = 5;
1.391 +
1.392 + UCX_TEST_BEGIN
1.393 +
1.394 + void* oldptr = array.data;
1.395 +
1.396 + ucx_array_append(&array, &x);
1.397 + UCX_TEST_ASSERT(array.capacity == 4 && array.data == oldptr,
1.398 + "array should not grow too early");
1.399 + ucx_array_append(&array, &x);
1.400 + UCX_TEST_ASSERT(array.capacity == 8, "array did not grow");
1.401 + UCX_TEST_ASSERT(array.size == 5, "incorrect size after grow");
1.402 + UCX_TEST_ASSERT(ucx_array_at_int(array, 3) == 5 &&
1.403 + ucx_array_at_int(array, 3) == 5, "corrupt data");
1.404 +
1.405 + UCX_TEST_END
1.406 + ucx_array_free(&array);
1.407 +}
1.408 +
1.409 +UCX_TEST(test_ucx_array_shrink) {
1.410 + UcxArray array = ucx_array_new(16, sizeof(int));
1.411 + array.size = 4;
1.412 +
1.413 + UCX_TEST_BEGIN
1.414 + UCX_TEST_ASSERT(!ucx_array_shrink(&array), "failed");
1.415 + UCX_TEST_ASSERT(array.capacity == 4, "incorrect capacity after shrink");
1.416 + UCX_TEST_END
1.417 + ucx_array_free(&array);
1.418 +}
1.419 +
1.420 +UCX_TEST(test_ucx_array_resize) {
1.421 + UcxArray array = ucx_array_new(16, sizeof(int));
1.422 + array.size = 8;
1.423 +
1.424 + UCX_TEST_BEGIN
1.425 +
1.426 + UCX_TEST_ASSERT(!ucx_array_resize(&array, 32), "failed");
1.427 + UCX_TEST_ASSERT(array.capacity == 32, "incorrect capacity after resize");
1.428 + UCX_TEST_ASSERT(array.size == 8, "incorrect size after resize");
1.429 +
1.430 + UCX_TEST_ASSERT(!ucx_array_resize(&array, 4), "failed");
1.431 + UCX_TEST_ASSERT(array.capacity == 4, "incorrect capacity after resize");
1.432 + UCX_TEST_ASSERT(array.size == 4, "incorrect size after resize");
1.433 +
1.434 + UCX_TEST_END
1.435 + ucx_array_free(&array);
1.436 +}
1.437 +
1.438 +UCX_TEST(test_ucx_array_reserve) {
1.439 + UcxArray array = ucx_array_new(16, sizeof(int));
1.440 +
1.441 + UCX_TEST_BEGIN
1.442 +
1.443 + UCX_TEST_ASSERT(!ucx_array_reserve(&array, 4), "failed");
1.444 + UCX_TEST_ASSERT(array.capacity == 16, "reserve shall not shrink");
1.445 +
1.446 + UCX_TEST_ASSERT(!ucx_array_resize(&array, 32), "failed");
1.447 + UCX_TEST_ASSERT(array.capacity == 32, "incorrect capacity after reserve");
1.448 +
1.449 + UCX_TEST_END
1.450 + ucx_array_free(&array);
1.451 +}
