shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-11-07 01:27:11 +03:00
Code
c1c80f6c37
systemd/src/test/test-bitmap.c

123 lines
3.5 KiB
C
Raw Normal View History

Add SPDX license identifiers to source files under the LGPL This follows what the kernel is doing, c.f. https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5fd54ace4721fc5ce2bb5aef6318fcf17f421460.
2017-11-18 19:09:20 +03:00
/* SPDX-License-Identifier: LGPL-2.1+ */
basic: add a Bitmap implementation For when a Hashmap is overkill.
2015-07-13 20:47:26 +03:00
/***
This file is part of systemd
Copyright 2015 Tom Gundersen
***/
#include "bitmap.h"
int main(int argc, const char *argv[]) {
bitmap: fix bitmap_equal on bitmaps with unset bits Given two bitmaps and the following code: Bitmap *a = bitmap_new(), *b = bitmap_new(); bitmap_set(a, 0); bitmap_unset(a, 0); These two bitmaps should now have the same bits set and they should be equal but bitmap_equal() will return false in this case because the bitmaps array in a is larger because of the bit which was previously set. Fix this by comparing only the bits which exists in both bitmaps and then check that the rest of the bits (if any) is all zero. This also adds test code for this issue.
2015-07-31 19:56:35 +03:00
_cleanup_bitmap_free_ Bitmap *b = NULL, *b2 = NULL;
bitmap: use external iterator Reuse the Iterator object from hashmap.h and expose a similar API. This allows us to do { Iterator i; unsigned n; BITMAP_FOREACH(n, b, i) { Iterator j; unsigned m; BITMAP_FOREACH(m, b, j) { ... } } } without getting confused. Requested by David.
2015-07-16 15:06:11 +03:00
Iterator it;
basic: add a Bitmap implementation For when a Hashmap is overkill.
2015-07-13 20:47:26 +03:00
unsigned n = (unsigned) -1, i = 0;
b = bitmap_new();
assert_se(b);
assert_se(bitmap_ensure_allocated(&b) == 0);
bitmap_free(b);
b = NULL;
assert_se(bitmap_ensure_allocated(&b) == 0);
assert_se(bitmap_isset(b, 0) == false);
assert_se(bitmap_isset(b, 1) == false);
assert_se(bitmap_isset(b, 256) == false);
assert_se(bitmap_isclear(b) == true);
assert_se(bitmap_set(b, 0) == 0);
assert_se(bitmap_isset(b, 0) == true);
assert_se(bitmap_isclear(b) == false);
bitmap_unset(b, 0);
assert_se(bitmap_isset(b, 0) == false);
assert_se(bitmap_isclear(b) == true);
assert_se(bitmap_set(b, 1) == 0);
assert_se(bitmap_isset(b, 1) == true);
assert_se(bitmap_isclear(b) == false);
bitmap_unset(b, 1);
assert_se(bitmap_isset(b, 1) == false);
assert_se(bitmap_isclear(b) == true);
assert_se(bitmap_set(b, 256) == 0);
assert_se(bitmap_isset(b, 256) == true);
assert_se(bitmap_isclear(b) == false);
bitmap_unset(b, 256);
assert_se(bitmap_isset(b, 256) == false);
assert_se(bitmap_isclear(b) == true);
basic: bitmap - complete fix for bitshift overflow The bug found by David existed in several places, fix them all. Also extend the tests to cover these cases.
2015-07-17 19:30:41 +03:00
assert_se(bitmap_set(b, 32) == 0);
bitmap_unset(b, 0);
assert_se(bitmap_isset(b, 32) == true);
bitmap_unset(b, 32);
BITMAP_FOREACH(n, NULL, it)
assert_not_reached("NULL bitmap");
basic: add a Bitmap implementation For when a Hashmap is overkill.
2015-07-13 20:47:26 +03:00
assert_se(bitmap_set(b, 0) == 0);
assert_se(bitmap_set(b, 1) == 0);
assert_se(bitmap_set(b, 256) == 0);
bitmap: use external iterator Reuse the Iterator object from hashmap.h and expose a similar API. This allows us to do { Iterator i; unsigned n; BITMAP_FOREACH(n, b, i) { Iterator j; unsigned m; BITMAP_FOREACH(m, b, j) { ... } } } without getting confused. Requested by David.
2015-07-16 15:06:11 +03:00
BITMAP_FOREACH(n, b, it) {
basic: add a Bitmap implementation For when a Hashmap is overkill.
2015-07-13 20:47:26 +03:00
assert_se(n == i);
if (i == 0)
i = 1;
else if (i == 1)
i = 256;
else if (i == 256)
i = (unsigned) -1;
}
assert_se(i == (unsigned) -1);
i = 0;
bitmap: use external iterator Reuse the Iterator object from hashmap.h and expose a similar API. This allows us to do { Iterator i; unsigned n; BITMAP_FOREACH(n, b, i) { Iterator j; unsigned m; BITMAP_FOREACH(m, b, j) { ... } } } without getting confused. Requested by David.
2015-07-16 15:06:11 +03:00
BITMAP_FOREACH(n, b, it) {
basic: add a Bitmap implementation For when a Hashmap is overkill.
2015-07-13 20:47:26 +03:00
assert_se(n == i);
if (i == 0)
i = 1;
else if (i == 1)
i = 256;
else if (i == 256)
i = (unsigned) -1;
}
assert_se(i == (unsigned) -1);
test-bitmap: add tests for bitmap_copy()
2017-11-28 12:19:04 +03:00
b2 = bitmap_copy(b);
assert_se(b2);
assert_se(bitmap_equal(b, b2) == true);
assert_se(bitmap_equal(b, b) == true);
assert_se(bitmap_equal(b, NULL) == false);
assert_se(bitmap_equal(NULL, b) == false);
assert_se(bitmap_equal(NULL, NULL) == true);
basic: add a Bitmap implementation For when a Hashmap is overkill.
2015-07-13 20:47:26 +03:00
bitmap_clear(b);
assert_se(bitmap_isclear(b) == true);
test-bitmap: add tests for bitmap_copy()
2017-11-28 12:19:04 +03:00
assert_se(bitmap_equal(b, b2) == false);
bitmap_free(b2);
b2 = NULL;
basic: add a Bitmap implementation For when a Hashmap is overkill.
2015-07-13 20:47:26 +03:00
assert_se(bitmap_set(b, (unsigned) -1) == -ERANGE);
bitmap: fix bitmap_equal on bitmaps with unset bits Given two bitmaps and the following code: Bitmap *a = bitmap_new(), *b = bitmap_new(); bitmap_set(a, 0); bitmap_unset(a, 0); These two bitmaps should now have the same bits set and they should be equal but bitmap_equal() will return false in this case because the bitmaps array in a is larger because of the bit which was previously set. Fix this by comparing only the bits which exists in both bitmaps and then check that the rest of the bits (if any) is all zero. This also adds test code for this issue.
2015-07-31 19:56:35 +03:00
bitmap_free(b);
b = NULL;
assert_se(bitmap_ensure_allocated(&b) == 0);
assert_se(bitmap_ensure_allocated(&b2) == 0);
assert_se(bitmap_equal(b, b2));
assert_se(bitmap_set(b, 0) == 0);
bitmap_unset(b, 0);
assert_se(bitmap_equal(b, b2));
bitmap: make bitmap_clear free the bitmap array Given two bitmaps and the following code: Bitmap *a = bitmap_new(), *b = bitmap_new(); bitmap_set(a, 1); bitmap_clear(a); bitmap_set(a, 0); bitmap_set(b, 0); These two bitmaps should now have the same bits set and they should be equal but bitmap_equal() will return false in this case because while bitmap_clear() resets the number of elements in the array it does not clear the array and bitmap_set() expects the array to be cleared. GREEDY_REALLOC0 looks at the allocated size and not the actual size so it does not clear any memory. Fix this by freeing the allocated memory and resetting the whole Bitmap to an initial state in bitmap_clear(). This also adds test code for this issue.
2015-07-31 20:01:34 +03:00
assert_se(bitmap_set(b, 1) == 0);
bitmap_clear(b);
assert_se(bitmap_equal(b, b2));
assert_se(bitmap_set(b, 0) == 0);
assert_se(bitmap_set(b2, 0) == 0);
assert_se(bitmap_equal(b, b2));
basic: add a Bitmap implementation For when a Hashmap is overkill.
2015-07-13 20:47:26 +03:00
return 0;
}
Copy Permalink