summaryrefslogtreecommitdiffstats
path: root/tiler/utils_test.c
diff options
context:
space:
mode:
Diffstat (limited to 'tiler/utils_test.c')
-rw-r--r--tiler/utils_test.c489
1 files changed, 489 insertions, 0 deletions
diff --git a/tiler/utils_test.c b/tiler/utils_test.c
new file mode 100644
index 0000000..c152125
--- /dev/null
+++ b/tiler/utils_test.c
@@ -0,0 +1,489 @@
+/*
+ * utils_test.c
+ *
+ * Memory Allocator Utility tests.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * 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.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR
+ * CONTRIBUTORS 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define __DEBUG__
+#define __DEBUG_ASSERT__
+#define __DEBUG_ENTRY__
+
+#include <utils.h>
+#include <list_utils.h>
+#include <debug_utils.h>
+#include "testlib.h"
+
+#define TESTS\
+ T(test_new())\
+ T(test_list())\
+ T(test_ezlist())\
+ T(test_dzlist())\
+ T(test_plist())\
+ T(test_mlist())\
+ T(test_math())
+
+#define F() in = head.next;
+#define N(a) res |= NOT_P(in,!=,&head); \
+ res |= NOT_P(in->me,!=,NULL) || NOT_I(in->me->data,==,a); in = in->next;
+#define Z(a) res |= NOT_P(in,!=,&head); \
+ res |= NOT_I(in->data,==,a); in = in->next;
+#define L() res |= NOT_P(in,==,&head);
+
+int all_zero(int *p, int len)
+{
+ IN;
+ int ix = 0;
+ for (ix = 0; ix < len; ix ++)
+ {
+ if (p[ix])
+ {
+ P("[%d]=%d\n", ix, p[ix]);
+ return R_I(1);
+ }
+ }
+ return R_I(0);
+}
+
+int test_new() {
+ IN;
+ int *p;
+ p = NEW(int);
+ int res = NOT_I(all_zero(p, 1),==,0);
+ FREE(p);
+ res |= NOT_I(p,==,NULL);
+ p = NEWN(int, 8000);
+ res |= NOT_I(all_zero(p, 8000),==,0);
+ FREE(p);
+ p = NEWN(int, 1000000);
+ res |= NOT_I(all_zero(p, 1000000),==,0);
+ FREE(p);
+ return R_I(res);
+}
+
+int test_list() {
+ IN;
+
+ struct elem {
+ int data;
+ } *elA, *elB;
+ struct list {
+ struct elem *me;
+ struct list *last, *next;
+ } head, *inA, *inB, *in, *in_safe;
+
+ /* initialization */
+ DLIST_INIT(head);
+ int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ inA = NEW(struct list);
+ DLIST_ADD_AFTER(head, elA, *inA);
+ F()N(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ inB = NEW(struct list);
+ DLIST_ADD_AFTER(*inA, elB, *inB);
+ F()N(1)N(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ inB = NEW(struct list);
+ (DLIST_ADD_BEFORE(head, elB, *inB))->data = 3;
+ F()N(1)N(2)N(3)L();
+
+ /* move an element to another position or another list */
+ DLIST_MOVE_AFTER(head, *inB);
+ F()N(3)N(1)N(2)L();
+
+ DLIST_MOVE_BEFORE(head, *inB);
+ F()N(1)N(2)N(3)L();
+
+ /* works even if the position is the same */
+ DLIST_MOVE_BEFORE(head, *inB);
+ F()N(1)N(2)N(3)L();
+
+ res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+ DLIST_LOOP(head, in) {
+ P("%d", in->me->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DLIST_SAFE_LOOP(head, in, in_safe) {
+ if (in->me->data > 1)
+ {
+ DLIST_REMOVE(*in);
+ FREE(in->me);
+ FREE(in);
+ }
+ }
+ F()N(1)L();
+
+ /* delete list */
+ DLIST_SAFE_LOOP(head, in, in_safe) {
+ DLIST_REMOVE(*in);
+ FREE(in->me);
+ FREE(in);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_ezlist() {
+ IN;
+
+ struct elem {
+ int data;
+ struct elem *me, *last, *next;
+ } *elA, *elB, head, *el, *el_safe, *in;
+
+ /* initialization */
+ DLIST_INIT(head);
+ int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ DLIST_ADD_AFTER(head, elA, *elA);
+ F()N(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ DLIST_ADD_AFTER(*elA, elB, *elB);
+ F()N(1)N(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ (DLIST_ADD_BEFORE(head, elB, *elB))->data = 3;
+ F()N(1)N(2)N(3)L();
+
+ /* move an element to another position or another list */
+ DLIST_MOVE_AFTER(head, *elB);
+ F()N(3)N(1)N(2)L();
+
+ DLIST_MOVE_BEFORE(head, *elB);
+ F()N(1)N(2)N(3)L();
+
+ /* works even if the position is the same */
+ DLIST_MOVE_BEFORE(head, *elB);
+ F()N(1)N(2)N(3)L();
+
+ res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+ DLIST_LOOP(head, el) {
+ P("%d", el->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DLIST_SAFE_RLOOP(head, el, el_safe) {
+ if (el->me->data == 1)
+ {
+ DLIST_REMOVE(*el);
+ FREE(el);
+ }
+ }
+ F()N(2)N(3)L();
+
+ /* delete list */
+ DLIST_SAFE_LOOP(head, el, el_safe) {
+ DLIST_REMOVE(*el);
+ FREE(el);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_dzlist() {
+ IN;
+
+ struct elem {
+ int data;
+ struct elem *last, *next;
+ } *elA, *elB, head, *el, *el_safe, *in;
+
+ /* initialization */
+ DZLIST_INIT(head);
+ int res = NOT_I(DZLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ DZLIST_ADD_AFTER(head, *elA);
+ F()Z(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ DZLIST_ADD_AFTER(*elA, *elB);
+ F()Z(1)Z(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ (DZLIST_ADD_BEFORE(head, *elB))->data = 3;
+ F()Z(1)Z(2)Z(3)L();
+
+ /* move an element to another position or another list */
+ DZLIST_MOVE_AFTER(head, *elB);
+ F()Z(3)Z(1)Z(2)L();
+
+ DZLIST_MOVE_BEFORE(head, *elB);
+ F()Z(1)Z(2)Z(3)L();
+
+ /* works even if the position is the same */
+ DZLIST_MOVE_BEFORE(head, *elB);
+ F()Z(1)Z(2)Z(3)L();
+
+ res |= NOT_I(DZLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DZLIST_LAST(head)->data,==,3);
+
+ DZLIST_LOOP(head, el) {
+ P("%d", el->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DZLIST_SAFE_RLOOP(head, el, el_safe) {
+ if (el->data == 1)
+ {
+ DZLIST_REMOVE(*el);
+ FREE(el);
+ }
+ }
+ F()Z(2)Z(3)L();
+
+ /* delete list */
+ DZLIST_SAFE_LOOP(head, el, el_safe) {
+ DZLIST_REMOVE(*el);
+ FREE(el);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_plist() {
+ IN;
+
+ struct elem;
+ struct list {
+ struct elem *me;
+ struct list *last, *next;
+ } head, *inA, *inB, *in;
+ struct elem {
+ int data;
+ struct list *list_data;
+ } *elA, *elB, *el, *el_safe;
+
+ /* initialization */
+ DLIST_INIT(head);
+ int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ inA = NEW(struct list);
+ DLIST_PADD_AFTER(head, elA, inA, list_data);
+ F()N(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ inB = NEW(struct list);
+ DLIST_PADD_AFTER(*inA, elB, inB, list_data);
+ F()N(1)N(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ inB = NEW(struct list);
+ (DLIST_PADD_BEFORE(head, elB, inB, list_data))->data = 3;
+ F()N(1)N(2)N(3)L();
+
+ /* move an element to another position or another list */
+ DLIST_MOVE_AFTER(head, *inB);
+ F()N(3)N(1)N(2)L();
+
+ DLIST_MOVE_BEFORE(head, *inB);
+ F()N(1)N(2)N(3)L();
+
+ /* works even if the position is the same */
+ DLIST_MOVE_BEFORE(head, *inB);
+ F()N(1)N(2)N(3)L();
+
+ res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+ DLIST_LOOP(head, in) {
+ P("%d", in->me->data);
+ }
+ P(".");
+ DLIST_PLOOP(head, el, list_data) {
+ P("%d", el->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DLIST_SAFE_PLOOP(head, el, el_safe, list_data) {
+ if (el->data == 2)
+ {
+ DLIST_REMOVE(*el->list_data);
+ FREE(el->list_data);
+ FREE(el);
+ }
+ }
+ F()N(1)N(3)L();
+
+ /* delete list */
+ DLIST_SAFE_PLOOP(head, el, el_safe, list_data) {
+ DLIST_REMOVE(*el->list_data);
+ FREE(el->list_data);
+ FREE(el);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_mlist() {
+ IN;
+
+ struct elem {
+ int data;
+ struct list {
+ struct list *last, *next;
+ struct elem *me;
+ } list_data;
+ } *elA, *elB, *el, *el_safe;
+ struct list head, *in;
+
+ /* initialization */
+ DLIST_INIT(head);
+ int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ DLIST_MADD_AFTER(head, elA, list_data);
+ F()N(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ DLIST_MADD_AFTER(elA->list_data, elB, list_data);
+ F()N(1)N(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ (DLIST_MADD_BEFORE(head, elB, list_data))->data = 3;
+ F()N(1)N(2)N(3)L();
+
+ /* move an element to another position or another list */
+ DLIST_MOVE_AFTER(head, elB->list_data);
+ F()N(3)N(1)N(2)L();
+
+ DLIST_MOVE_BEFORE(head, elB->list_data);
+ F()N(1)N(2)N(3)L();
+
+ /* works even if the position is the same */
+ DLIST_MOVE_BEFORE(head, elB->list_data);
+ F()N(1)N(2)N(3)L();
+
+ res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+ DLIST_LOOP(head, in) {
+ P("%d", in->me->data);
+ }
+ P(".");
+ DLIST_MLOOP(head, el, list_data) {
+ P("%d", el->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DLIST_SAFE_MLOOP(head, el, el_safe, list_data) {
+ if (el->data != 2)
+ {
+ DLIST_REMOVE(el->list_data);
+ FREE(el);
+ }
+ }
+ F()N(2)L();
+
+ /* delete list */
+ DLIST_SAFE_MLOOP(head, el, el_safe, list_data) {
+ DLIST_REMOVE(el->list_data);
+ FREE(el);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_math()
+{
+ IN;
+ int res = 0;
+ res |= NOT_I(ROUND_UP_TO2POW(0, 4096),==,0);
+ res |= NOT_I(ROUND_UP_TO2POW(1, 4096),==,4096);
+ res |= NOT_I(ROUND_UP_TO2POW(4095, 4096),==,4096);
+ res |= NOT_I(ROUND_UP_TO2POW(4096, 4096),==,4096);
+ res |= NOT_I(ROUND_UP_TO2POW(4097, 4096),==,8192);
+ res |= NOT_I(ROUND_DOWN_TO2POW(0, 4096),==,0);
+ res |= NOT_I(ROUND_DOWN_TO2POW(1, 4096),==,0);
+ res |= NOT_I(ROUND_DOWN_TO2POW(4095, 4096),==,0);
+ res |= NOT_I(ROUND_DOWN_TO2POW(4096, 4096),==,4096);
+ res |= NOT_I(ROUND_DOWN_TO2POW(4097, 4096),==,4096);
+ return R_I(res);
+}
+
+DEFINE_TESTS(TESTS)
+
+int main(int argc, char **argv)
+{
+ return TestLib_Run(argc, argv, nullfn, nullfn, NULL);
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-18 18:38:57 +0000