From f13b7ebaea8f263fd28b1288271fd0e25b028965 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Wed, 1 Apr 2015 12:31:32 -0400 Subject: [PATCH] Remove unused `tests` dir --- tests/queue.h | 543 --------------------------------------------- tests/swap.c | 224 ------------------- tests/test_table.c | 29 --- 3 files changed, 796 deletions(-) delete mode 100644 tests/queue.h delete mode 100644 tests/swap.c delete mode 100644 tests/test_table.c diff --git a/tests/queue.h b/tests/queue.h deleted file mode 100644 index 0b3a9c0b..00000000 --- a/tests/queue.h +++ /dev/null @@ -1,543 +0,0 @@ -/* $OpenBSD: queue.h,v 1.1 2007/10/26 03:14:08 niallo Exp $ */ -/* $NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $ */ - -/* - * Copyright (c) 1991, 1993 - * The Regents of the University of California. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. 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. - * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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. - * - * @(#)queue.h 8.5 (Berkeley) 8/20/94 - */ - -#pragma once - -/* - * This file defines five types of data structures: singly-linked lists, - * lists, simple queues, tail queues, and circular queues. - * - * - * A singly-linked list is headed by a single forward pointer. The elements - * are singly linked for minimum space and pointer manipulation overhead at - * the expense of O(n) removal for arbitrary elements. New elements can be - * added to the list after an existing element or at the head of the list. - * Elements being removed from the head of the list should use the explicit - * macro for this purpose for optimum efficiency. A singly-linked list may - * only be traversed in the forward direction. Singly-linked lists are ideal - * for applications with large datasets and few or no removals or for - * implementing a LIFO queue. - * - * A list is headed by a single forward pointer (or an array of forward - * pointers for a hash table header). The elements are doubly linked - * so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before - * or after an existing element or at the head of the list. A list - * may only be traversed in the forward direction. - * - * A simple queue is headed by a pair of pointers, one the head of the - * list and the other to the tail of the list. The elements are singly - * linked to save space, so elements can only be removed from the - * head of the list. New elements can be added to the list before or after - * an existing element, at the head of the list, or at the end of the - * list. A simple queue may only be traversed in the forward direction. - * - * A tail queue is headed by a pair of pointers, one to the head of the - * list and the other to the tail of the list. The elements are doubly - * linked so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before or - * after an existing element, at the head of the list, or at the end of - * the list. A tail queue may be traversed in either direction. - * - * A circle queue is headed by a pair of pointers, one to the head of the - * list and the other to the tail of the list. The elements are doubly - * linked so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before or after - * an existing element, at the head of the list, or at the end of the list. - * A circle queue may be traversed in either direction, but has a more - * complex end of list detection. - * - * For details on the use of these macros, see the queue(3) manual page. - */ - -#if defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC)) -#define _Q_INVALIDATE(a) (a) = ((void *)-1) -#else -#define _Q_INVALIDATE(a) -#endif - -/* - * Singly-linked List definitions. - */ -#define SLIST_HEAD(name, type) \ - struct name { \ - struct type *slh_first; /* first element */ \ - } - -#define SLIST_HEAD_INITIALIZER(head) \ - { NULL } - -#define SLIST_ENTRY(type) \ - struct { \ - struct type *sle_next; /* next element */ \ - } - -/* - * Singly-linked List access methods. - */ -#define SLIST_FIRST(head) ((head)->slh_first) -#define SLIST_END(head) NULL -#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head)) -#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) - -#define SLIST_FOREACH(var, head, field) \ - for ((var) = SLIST_FIRST(head); \ - (var) != SLIST_END(head); \ - (var) = SLIST_NEXT(var, field)) - -#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ - for ((varp) = &SLIST_FIRST((head)); \ - ((var) = *(varp)) != SLIST_END(head); \ - (varp) = &SLIST_NEXT((var), field)) - -/* - * Singly-linked List functions. - */ -#define SLIST_INIT(head) \ - { \ - SLIST_FIRST(head) = SLIST_END(head); \ - } - -#define SLIST_INSERT_AFTER(slistelm, elm, field) \ - do { \ - (elm)->field.sle_next = (slistelm)->field.sle_next; \ - (slistelm)->field.sle_next = (elm); \ - } while (0) - -#define SLIST_INSERT_HEAD(head, elm, field) \ - do { \ - (elm)->field.sle_next = (head)->slh_first; \ - (head)->slh_first = (elm); \ - } while (0) - -#define SLIST_REMOVE_NEXT(head, elm, field) \ - do { \ - (elm)->field.sle_next = (elm)->field.sle_next->field.sle_next; \ - } while (0) - -#define SLIST_REMOVE_HEAD(head, field) \ - do { \ - (head)->slh_first = (head)->slh_first->field.sle_next; \ - } while (0) - -#define SLIST_REMOVE(head, elm, type, field) \ - do { \ - if ((head)->slh_first == (elm)) { \ - SLIST_REMOVE_HEAD((head), field); \ - } else { \ - struct type *curelm = (head)->slh_first; \ - \ - while (curelm->field.sle_next != (elm)) \ - curelm = curelm->field.sle_next; \ - curelm->field.sle_next = curelm->field.sle_next->field.sle_next; \ - _Q_INVALIDATE((elm)->field.sle_next); \ - } \ - } while (0) - -/* - * List definitions. - */ -#define LIST_HEAD(name, type) \ - struct name { \ - struct type *lh_first; /* first element */ \ - } - -#define LIST_HEAD_INITIALIZER(head) \ - { NULL } - -#define LIST_ENTRY(type) \ - struct { \ - struct type *le_next; /* next element */ \ - struct type **le_prev; /* address of previous next element */ \ - } - -/* - * List access methods - */ -#define LIST_FIRST(head) ((head)->lh_first) -#define LIST_END(head) NULL -#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) -#define LIST_NEXT(elm, field) ((elm)->field.le_next) - -#define LIST_FOREACH(var, head, field) \ - for ((var) = LIST_FIRST(head); \ - (var) != LIST_END(head); \ - (var) = LIST_NEXT(var, field)) - -/* - * List functions. - */ -#define LIST_INIT(head) \ - do { \ - LIST_FIRST(head) = LIST_END(head); \ - } while (0) - -#define LIST_INSERT_AFTER(listelm, elm, field) \ - do { \ - if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \ - (listelm)->field.le_next->field.le_prev = &(elm)->field.le_next; \ - (listelm)->field.le_next = (elm); \ - (elm)->field.le_prev = &(listelm)->field.le_next; \ - } while (0) - -#define LIST_INSERT_BEFORE(listelm, elm, field) \ - do { \ - (elm)->field.le_prev = (listelm)->field.le_prev; \ - (elm)->field.le_next = (listelm); \ - *(listelm)->field.le_prev = (elm); \ - (listelm)->field.le_prev = &(elm)->field.le_next; \ - } while (0) - -#define LIST_INSERT_HEAD(head, elm, field) \ - do { \ - if (((elm)->field.le_next = (head)->lh_first) != NULL) \ - (head)->lh_first->field.le_prev = &(elm)->field.le_next; \ - (head)->lh_first = (elm); \ - (elm)->field.le_prev = &(head)->lh_first; \ - } while (0) - -#define LIST_REMOVE(elm, field) \ - do { \ - if ((elm)->field.le_next != NULL) \ - (elm)->field.le_next->field.le_prev = (elm)->field.le_prev; \ - *(elm)->field.le_prev = (elm)->field.le_next; \ - _Q_INVALIDATE((elm)->field.le_prev); \ - _Q_INVALIDATE((elm)->field.le_next); \ - } while (0) - -#define LIST_REPLACE(elm, elm2, field) \ - do { \ - if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \ - (elm2)->field.le_next->field.le_prev = &(elm2)->field.le_next; \ - (elm2)->field.le_prev = (elm)->field.le_prev; \ - *(elm2)->field.le_prev = (elm2); \ - _Q_INVALIDATE((elm)->field.le_prev); \ - _Q_INVALIDATE((elm)->field.le_next); \ - } while (0) - -/* - * Simple queue definitions. - */ -#define SIMPLEQ_HEAD(name, type) \ - struct name { \ - struct type *sqh_first; /* first element */ \ - struct type **sqh_last; /* addr of last next element */ \ - } - -#define SIMPLEQ_HEAD_INITIALIZER(head) \ - { NULL, &(head).sqh_first } - -#define SIMPLEQ_ENTRY(type) \ - struct { \ - struct type *sqe_next; /* next element */ \ - } - -/* - * Simple queue access methods. - */ -#define SIMPLEQ_FIRST(head) ((head)->sqh_first) -#define SIMPLEQ_END(head) NULL -#define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head)) -#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next) - -#define SIMPLEQ_FOREACH(var, head, field) \ - for ((var) = SIMPLEQ_FIRST(head); \ - (var) != SIMPLEQ_END(head); \ - (var) = SIMPLEQ_NEXT(var, field)) - -/* - * Simple queue functions. - */ -#define SIMPLEQ_INIT(head) \ - do { \ - (head)->sqh_first = NULL; \ - (head)->sqh_last = &(head)->sqh_first; \ - } while (0) - -#define SIMPLEQ_INSERT_HEAD(head, elm, field) \ - do { \ - if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \ - (head)->sqh_last = &(elm)->field.sqe_next; \ - (head)->sqh_first = (elm); \ - } while (0) - -#define SIMPLEQ_INSERT_TAIL(head, elm, field) \ - do { \ - (elm)->field.sqe_next = NULL; \ - *(head)->sqh_last = (elm); \ - (head)->sqh_last = &(elm)->field.sqe_next; \ - } while (0) - -#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) \ - do { \ - if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL) \ - (head)->sqh_last = &(elm)->field.sqe_next; \ - (listelm)->field.sqe_next = (elm); \ - } while (0) - -#define SIMPLEQ_REMOVE_HEAD(head, field) \ - do { \ - if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \ - (head)->sqh_last = &(head)->sqh_first; \ - } while (0) - -/* - * Tail queue definitions. - */ -#define TAILQ_HEAD(name, type) \ - struct name { \ - struct type *tqh_first; /* first element */ \ - struct type **tqh_last; /* addr of last next element */ \ - } - -#define TAILQ_HEAD_INITIALIZER(head) \ - { NULL, &(head).tqh_first } - -#define TAILQ_ENTRY(type) \ - struct { \ - struct type *tqe_next; /* next element */ \ - struct type **tqe_prev; /* address of previous next element */ \ - } - -/* - * tail queue access methods - */ -#define TAILQ_FIRST(head) ((head)->tqh_first) -#define TAILQ_END(head) NULL -#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) -#define TAILQ_LAST(head, headname) \ - (*(((struct headname *)((head)->tqh_last))->tqh_last)) -/* XXX */ -#define TAILQ_PREV(elm, headname, field) \ - (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) -#define TAILQ_EMPTY(head) \ - (TAILQ_FIRST(head) == TAILQ_END(head)) - -#define TAILQ_FOREACH(var, head, field) \ - for ((var) = TAILQ_FIRST(head); \ - (var) != TAILQ_END(head); \ - (var) = TAILQ_NEXT(var, field)) - -#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ - for ((var) = TAILQ_LAST(head, headname); \ - (var) != TAILQ_END(head); \ - (var) = TAILQ_PREV(var, headname, field)) - -/* - * Tail queue functions. - */ -#define TAILQ_INIT(head) \ - do { \ - (head)->tqh_first = NULL; \ - (head)->tqh_last = &(head)->tqh_first; \ - } while (0) - -#define TAILQ_INSERT_HEAD(head, elm, field) \ - do { \ - if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \ - (head)->tqh_first->field.tqe_prev = &(elm)->field.tqe_next; \ - else \ - (head)->tqh_last = &(elm)->field.tqe_next; \ - (head)->tqh_first = (elm); \ - (elm)->field.tqe_prev = &(head)->tqh_first; \ - } while (0) - -#define TAILQ_INSERT_TAIL(head, elm, field) \ - do { \ - (elm)->field.tqe_next = NULL; \ - (elm)->field.tqe_prev = (head)->tqh_last; \ - *(head)->tqh_last = (elm); \ - (head)->tqh_last = &(elm)->field.tqe_next; \ - } while (0) - -#define TAILQ_INSERT_AFTER(head, listelm, elm, field) \ - do { \ - if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL) \ - (elm)->field.tqe_next->field.tqe_prev = &(elm)->field.tqe_next; \ - else \ - (head)->tqh_last = &(elm)->field.tqe_next; \ - (listelm)->field.tqe_next = (elm); \ - (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ - } while (0) - -#define TAILQ_INSERT_BEFORE(listelm, elm, field) \ - do { \ - (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ - (elm)->field.tqe_next = (listelm); \ - *(listelm)->field.tqe_prev = (elm); \ - (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ - } while (0) - -#define TAILQ_REMOVE(head, elm, field) \ - do { \ - if (((elm)->field.tqe_next) != NULL) \ - (elm)->field.tqe_next->field.tqe_prev = (elm)->field.tqe_prev; \ - else \ - (head)->tqh_last = (elm)->field.tqe_prev; \ - *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ - _Q_INVALIDATE((elm)->field.tqe_prev); \ - _Q_INVALIDATE((elm)->field.tqe_next); \ - } while (0) - -#define TAILQ_REPLACE(head, elm, elm2, field) \ - do { \ - if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL) \ - (elm2)->field.tqe_next->field.tqe_prev = &(elm2)->field.tqe_next; \ - else \ - (head)->tqh_last = &(elm2)->field.tqe_next; \ - (elm2)->field.tqe_prev = (elm)->field.tqe_prev; \ - *(elm2)->field.tqe_prev = (elm2); \ - _Q_INVALIDATE((elm)->field.tqe_prev); \ - _Q_INVALIDATE((elm)->field.tqe_next); \ - } while (0) - -/* - * Circular queue definitions. - */ -#define CIRCLEQ_HEAD(name, type) \ - struct name { \ - struct type *cqh_first; /* first element */ \ - struct type *cqh_last; /* last element */ \ - } - -#define CIRCLEQ_HEAD_INITIALIZER(head) \ - { CIRCLEQ_END(&head), CIRCLEQ_END(&head) } - -#define CIRCLEQ_ENTRY(type) \ - struct { \ - struct type *cqe_next; /* next element */ \ - struct type *cqe_prev; /* previous element */ \ - } - -/* - * Circular queue access methods - */ -#define CIRCLEQ_FIRST(head) ((head)->cqh_first) -#define CIRCLEQ_LAST(head) ((head)->cqh_last) -#define CIRCLEQ_END(head) ((void *)(head)) -#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) -#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) -#define CIRCLEQ_EMPTY(head) \ - (CIRCLEQ_FIRST(head) == CIRCLEQ_END(head)) - -#define CIRCLEQ_FOREACH(var, head, field) \ - for ((var) = CIRCLEQ_FIRST(head); \ - (var) != CIRCLEQ_END(head); \ - (var) = CIRCLEQ_NEXT(var, field)) - -#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ - for ((var) = CIRCLEQ_LAST(head); \ - (var) != CIRCLEQ_END(head); \ - (var) = CIRCLEQ_PREV(var, field)) - -/* - * Circular queue functions. - */ -#define CIRCLEQ_INIT(head) \ - do { \ - (head)->cqh_first = CIRCLEQ_END(head); \ - (head)->cqh_last = CIRCLEQ_END(head); \ - } while (0) - -#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) \ - do { \ - (elm)->field.cqe_next = (listelm)->field.cqe_next; \ - (elm)->field.cqe_prev = (listelm); \ - if ((listelm)->field.cqe_next == CIRCLEQ_END(head)) \ - (head)->cqh_last = (elm); \ - else \ - (listelm)->field.cqe_next->field.cqe_prev = (elm); \ - (listelm)->field.cqe_next = (elm); \ - } while (0) - -#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) \ - do { \ - (elm)->field.cqe_next = (listelm); \ - (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ - if ((listelm)->field.cqe_prev == CIRCLEQ_END(head)) \ - (head)->cqh_first = (elm); \ - else \ - (listelm)->field.cqe_prev->field.cqe_next = (elm); \ - (listelm)->field.cqe_prev = (elm); \ - } while (0) - -#define CIRCLEQ_INSERT_HEAD(head, elm, field) \ - do { \ - (elm)->field.cqe_next = (head)->cqh_first; \ - (elm)->field.cqe_prev = CIRCLEQ_END(head); \ - if ((head)->cqh_last == CIRCLEQ_END(head)) \ - (head)->cqh_last = (elm); \ - else \ - (head)->cqh_first->field.cqe_prev = (elm); \ - (head)->cqh_first = (elm); \ - } while (0) - -#define CIRCLEQ_INSERT_TAIL(head, elm, field) \ - do { \ - (elm)->field.cqe_next = CIRCLEQ_END(head); \ - (elm)->field.cqe_prev = (head)->cqh_last; \ - if ((head)->cqh_first == CIRCLEQ_END(head)) \ - (head)->cqh_first = (elm); \ - else \ - (head)->cqh_last->field.cqe_next = (elm); \ - (head)->cqh_last = (elm); \ - } while (0) - -#define CIRCLEQ_REMOVE(head, elm, field) \ - do { \ - if ((elm)->field.cqe_next == CIRCLEQ_END(head)) \ - (head)->cqh_last = (elm)->field.cqe_prev; \ - else \ - (elm)->field.cqe_next->field.cqe_prev = (elm)->field.cqe_prev; \ - if ((elm)->field.cqe_prev == CIRCLEQ_END(head)) \ - (head)->cqh_first = (elm)->field.cqe_next; \ - else \ - (elm)->field.cqe_prev->field.cqe_next = (elm)->field.cqe_next; \ - _Q_INVALIDATE((elm)->field.cqe_prev); \ - _Q_INVALIDATE((elm)->field.cqe_next); \ - } while (0) - -#define CIRCLEQ_REPLACE(head, elm, elm2, field) \ - do { \ - if (((elm2)->field.cqe_next = (elm)->field.cqe_next) == CIRCLEQ_END(head)) \ - (head)->cqh_last = (elm2); \ - else \ - (elm2)->field.cqe_next->field.cqe_prev = (elm2); \ - if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) == CIRCLEQ_END(head)) \ - (head)->cqh_first = (elm2); \ - else \ - (elm2)->field.cqe_prev->field.cqe_next = (elm2); \ - _Q_INVALIDATE((elm)->field.cqe_prev); \ - _Q_INVALIDATE((elm)->field.cqe_next); \ - } while (0) diff --git a/tests/swap.c b/tests/swap.c deleted file mode 100644 index abc3b3b5..00000000 --- a/tests/swap.c +++ /dev/null @@ -1,224 +0,0 @@ -/* - * vim:ts=4:sw=4:expandtab - */ -#include -#include -#include -#include -#include -#include - -#include "queue.h" - -struct obj { - int abc; - TAILQ_ENTRY(obj) entry; -}; - -TAILQ_HEAD(objhead, obj) head; - -void dump() { - struct obj *e; - printf("dump:\n"); - e = TAILQ_FIRST(&head); - printf("first: %d\n", e->abc); - e = TAILQ_LAST(&head, objhead); - printf("last: %d\n", e->abc); - TAILQ_FOREACH(e, &head, entry) { - printf(" %d\n", e->abc); - } - printf("again, but reverse:\n"); - TAILQ_FOREACH_REVERSE(e, &head, objhead, entry) { - printf(" %d\n", e->abc); - } - printf("done\n\n"); -} - -#define TAILQ_SWAP(first, second, head, field) \ - do { \ - *((first)->field.tqe_prev) = (second); \ - (second)->field.tqe_prev = (first)->field.tqe_prev; \ - (first)->field.tqe_prev = &((second)->field.tqe_next); \ - (first)->field.tqe_next = (second)->field.tqe_next; \ - if ((second)->field.tqe_next) \ - (second)->field.tqe_next->field.tqe_prev = &((first)->field.tqe_next); \ - (second)->field.tqe_next = first; \ - if ((head)->tqh_last == &((second)->field.tqe_next)) \ - (head)->tqh_last = &((first)->field.tqe_next); \ - } while (0) - -void _TAILQ_SWAP(struct obj *first, struct obj *second, struct objhead *head) { - struct obj **tqe_prev = first->entry.tqe_prev; - *tqe_prev = second; - - second->entry.tqe_prev = first->entry.tqe_prev; - - first->entry.tqe_prev = &(second->entry.tqe_next); - - first->entry.tqe_next = second->entry.tqe_next; - - if (second->entry.tqe_next) { - struct obj *tqe_next = second->entry.tqe_next; - tqe_next->entry.tqe_prev = &(first->entry.tqe_next); - } - - second->entry.tqe_next = first; - - if (head->tqh_last == &(second->entry.tqe_next)) - head->tqh_last = &(first->entry.tqe_next); -} - -int main() { - printf("hello\n"); - - TAILQ_INIT(&head); - - struct obj first; - first.abc = 123; - - struct obj second; - second.abc = 456; - - struct obj third; - third.abc = 789; - - struct obj fourth; - fourth.abc = 999; - - struct obj fifth; - fifth.abc = 5555; - - /* - * ************************************************ - */ - printf("swapping first two elements:\n"); - - TAILQ_INSERT_TAIL(&head, &first, entry); - TAILQ_INSERT_TAIL(&head, &second, entry); - TAILQ_INSERT_TAIL(&head, &third, entry); - - dump(); - - TAILQ_SWAP(&first, &second, &head, entry); - - dump(); - - /* - * ************************************************ - */ - printf("swapping last two elements:\n"); - - TAILQ_INIT(&head); - - TAILQ_INSERT_TAIL(&head, &first, entry); - TAILQ_INSERT_TAIL(&head, &second, entry); - TAILQ_INSERT_TAIL(&head, &third, entry); - - dump(); - - TAILQ_SWAP(&second, &third, &head, entry); - - dump(); - - /* - * ************************************************ - */ - printf("longer list:\n"); - - TAILQ_INIT(&head); - - TAILQ_INSERT_TAIL(&head, &first, entry); - TAILQ_INSERT_TAIL(&head, &second, entry); - TAILQ_INSERT_TAIL(&head, &third, entry); - TAILQ_INSERT_TAIL(&head, &fourth, entry); - - dump(); - - TAILQ_SWAP(&first, &second, &head, entry); - - dump(); - - /* - * ************************************************ - */ - printf("longer list 2:\n"); - - TAILQ_INIT(&head); - - TAILQ_INSERT_TAIL(&head, &first, entry); - TAILQ_INSERT_TAIL(&head, &second, entry); - TAILQ_INSERT_TAIL(&head, &third, entry); - TAILQ_INSERT_TAIL(&head, &fourth, entry); - - dump(); - - TAILQ_SWAP(&second, &third, &head, entry); - - dump(); - - /* - * ************************************************ - */ - printf("longer list, swap, then insert:\n"); - - TAILQ_INIT(&head); - - TAILQ_INSERT_TAIL(&head, &first, entry); - TAILQ_INSERT_TAIL(&head, &second, entry); - TAILQ_INSERT_TAIL(&head, &third, entry); - TAILQ_INSERT_TAIL(&head, &fourth, entry); - - dump(); - - TAILQ_SWAP(&second, &third, &head, entry); - - dump(); - - TAILQ_INSERT_AFTER(&head, &third, &fifth, entry); - - dump(); - - /* - * ************************************************ - */ - printf("longer list, swap, then append:\n"); - - TAILQ_INIT(&head); - - TAILQ_INSERT_TAIL(&head, &first, entry); - TAILQ_INSERT_TAIL(&head, &second, entry); - TAILQ_INSERT_TAIL(&head, &third, entry); - TAILQ_INSERT_TAIL(&head, &fourth, entry); - - dump(); - - TAILQ_SWAP(&second, &third, &head, entry); - - dump(); - - TAILQ_INSERT_TAIL(&head, &fifth, entry); - - dump(); - - /* - * ************************************************ - */ - printf("longer list, swap, then remove:\n"); - - TAILQ_INIT(&head); - - TAILQ_INSERT_TAIL(&head, &first, entry); - TAILQ_INSERT_TAIL(&head, &second, entry); - TAILQ_INSERT_TAIL(&head, &third, entry); - TAILQ_INSERT_TAIL(&head, &fourth, entry); - - dump(); - - TAILQ_SWAP(&second, &third, &head, entry); - - dump(); - - TAILQ_REMOVE(&head, &second, entry); - - dump(); -} diff --git a/tests/test_table.c b/tests/test_table.c deleted file mode 100644 index 554be3e7..00000000 --- a/tests/test_table.c +++ /dev/null @@ -1,29 +0,0 @@ -#include -#include "table.h" - -void print_table() { - int r, c; - printf("printing table...\n"); - for (c = 0; c < table_dims.x; c++) - for (r = 0; r < table_dims.y; r++) - printf("table[%d][%d] = %p\n", c, r, table[c][r]); - printf("done\n"); -} - -int main() { - printf("table.c tests\n"); - printf("table_dimensions = %d, %d\n", table_dims.x, table_dims.y); - init_table(); - printf("table_dimensions = %d, %d\n", table_dims.x, table_dims.y); - print_table(); - - printf("expand_table_cols()\n"); - expand_table_cols(); - printf("table_dimensions = %d, %d\n", table_dims.x, table_dims.y); - print_table(); - - printf("expand_table_rows()\n"); - expand_table_rows(); - printf("table_dimensions = %d, %d\n", table_dims.x, table_dims.y); - print_table(); -}