Initial Spring 2016 commit.

kern/test/threadlisttest.c

@@ -0,0 +1,343 @@
+/*
+ * Copyright (c) 2013
+ *	The President and Fellows of Harvard College.
+ *
+ * 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 UNIVERSITY 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 UNIVERSITY 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 <types.h>
+#include <lib.h>
+#include <thread.h>
+#include <threadlist.h>
+#include <test.h>
+
+#define NUMNAMES 7
+static const char *const names[NUMNAMES] = {
+	"Aillard",
+	"Aldaran",
+	"Alton",
+	"Ardais",
+	"Elhalyn",
+	"Hastur",
+	"Ridenow",
+};
+
+static struct thread *fakethreads[NUMNAMES];
+
+////////////////////////////////////////////////////////////
+// fakethread
+
+#define FAKE_MAGIC ((void *)0xbaabaa)
+
+/*
+ * Create a dummy struct thread that we can put on lists for testing.
+ */
+static
+struct thread *
+fakethread_create(const char *name)
+{
+	struct thread *t;
+
+	t = kmalloc(sizeof(*t));
+	if (t == NULL) {
+		panic("threadlisttest: Out of memory\n");
+	}
+	/* ignore most of the fields, zero everything for tidiness */
+	bzero(t, sizeof(*t));
+	t->t_name = kstrdup(name);
+	if (t->t_name == NULL) {
+		panic("threadlisttest: Out of memory\n");
+	}
+	t->t_stack = FAKE_MAGIC;
+	threadlistnode_init(&t->t_listnode, t);
+	return t;
+}
+
+/*
+ * Destroy a fake thread.
+ */
+static
+void
+fakethread_destroy(struct thread *t)
+{
+	KASSERT(t->t_stack == FAKE_MAGIC);
+	threadlistnode_cleanup(&t->t_listnode);
+	kfree(t->t_name);
+	kfree(t);
+}
+
+////////////////////////////////////////////////////////////
+// support stuff
+
+static
+void
+check_order(struct threadlist *tl, bool rev)
+{
+	const char string0[] = "...";
+	const char stringN[] = "~~~";
+
+	struct thread *t;
+	const char *first = rev ? stringN : string0;
+	const char *last = rev ? string0 : stringN;
+	const char *prev;
+	int cmp;
+
+	prev = first;
+	THREADLIST_FORALL(t, *tl) {
+		cmp = strcmp(prev, t->t_name);
+		KASSERT(rev ? (cmp > 0) : (cmp < 0));
+		prev = t->t_name;
+	}
+	cmp = strcmp(prev, last);
+	KASSERT(rev ? (cmp > 0) : (cmp < 0));
+}
+
+////////////////////////////////////////////////////////////
+// tests
+
+static
+void
+threadlisttest_a(void)
+{
+	struct threadlist tl;
+
+	threadlist_init(&tl);
+	KASSERT(threadlist_isempty(&tl));
+	threadlist_cleanup(&tl);
+}
+
+static
+void
+threadlisttest_b(void)
+{
+	struct threadlist tl;
+	struct thread *t;
+
+	threadlist_init(&tl);
+
+	threadlist_addhead(&tl, fakethreads[0]);
+	check_order(&tl, false);
+	check_order(&tl, true);
+	KASSERT(tl.tl_count == 1);
+	t = threadlist_remhead(&tl);
+	KASSERT(tl.tl_count == 0);
+	KASSERT(t == fakethreads[0]);
+
+	threadlist_addtail(&tl, fakethreads[0]);
+	check_order(&tl, false);
+	check_order(&tl, true);
+	KASSERT(tl.tl_count == 1);
+	t = threadlist_remtail(&tl);
+	KASSERT(tl.tl_count == 0);
+	KASSERT(t == fakethreads[0]);
+
+	threadlist_cleanup(&tl);
+}
+
+static
+void
+threadlisttest_c(void)
+{
+	struct threadlist tl;
+	struct thread *t;
+
+	threadlist_init(&tl);
+
+	threadlist_addhead(&tl, fakethreads[0]);
+	threadlist_addhead(&tl, fakethreads[1]);
+	KASSERT(tl.tl_count == 2);
+
+	check_order(&tl, true);
+
+	t = threadlist_remhead(&tl);
+	KASSERT(t == fakethreads[1]);
+	t = threadlist_remhead(&tl);
+	KASSERT(t == fakethreads[0]);
+	KASSERT(tl.tl_count == 0);
+
+	threadlist_addtail(&tl, fakethreads[0]);
+	threadlist_addtail(&tl, fakethreads[1]);
+	KASSERT(tl.tl_count == 2);
+
+	check_order(&tl, false);
+
+	t = threadlist_remtail(&tl);
+	KASSERT(t == fakethreads[1]);
+	t = threadlist_remtail(&tl);
+	KASSERT(t == fakethreads[0]);
+	KASSERT(tl.tl_count == 0);
+
+	threadlist_cleanup(&tl);
+}
+
+static
+void
+threadlisttest_d(void)
+{
+	struct threadlist tl;
+	struct thread *t;
+
+	threadlist_init(&tl);
+
+	threadlist_addhead(&tl, fakethreads[0]);
+	threadlist_addtail(&tl, fakethreads[1]);
+	KASSERT(tl.tl_count == 2);
+
+	check_order(&tl, false);
+
+	t = threadlist_remhead(&tl);
+	KASSERT(t == fakethreads[0]);
+	t = threadlist_remtail(&tl);
+	KASSERT(t == fakethreads[1]);
+	KASSERT(tl.tl_count == 0);
+
+	threadlist_addhead(&tl, fakethreads[0]);
+	threadlist_addtail(&tl, fakethreads[1]);
+	KASSERT(tl.tl_count == 2);
+
+	check_order(&tl, false);
+
+	t = threadlist_remtail(&tl);
+	KASSERT(t == fakethreads[1]);
+	t = threadlist_remtail(&tl);
+	KASSERT(t == fakethreads[0]);
+	KASSERT(tl.tl_count == 0);
+
+	threadlist_cleanup(&tl);
+}
+
+static
+void
+threadlisttest_e(void)
+{
+	struct threadlist tl;
+	struct thread *t;
+	unsigned i;
+
+	threadlist_init(&tl);
+
+	threadlist_addhead(&tl, fakethreads[1]);
+	threadlist_addtail(&tl, fakethreads[3]);
+	KASSERT(tl.tl_count == 2);
+	check_order(&tl, false);
+
+	threadlist_insertafter(&tl, fakethreads[3], fakethreads[4]);
+	KASSERT(tl.tl_count == 3);
+	check_order(&tl, false);
+
+	threadlist_insertbefore(&tl, fakethreads[0], fakethreads[1]);
+	KASSERT(tl.tl_count == 4);
+	check_order(&tl, false);
+
+	threadlist_insertafter(&tl, fakethreads[1], fakethreads[2]);
+	KASSERT(tl.tl_count == 5);
+	check_order(&tl, false);
+
+	KASSERT(fakethreads[4]->t_listnode.tln_prev->tln_self ==
+		fakethreads[3]);
+	KASSERT(fakethreads[3]->t_listnode.tln_prev->tln_self ==
+		fakethreads[2]);
+	KASSERT(fakethreads[2]->t_listnode.tln_prev->tln_self ==
+		fakethreads[1]);
+	KASSERT(fakethreads[1]->t_listnode.tln_prev->tln_self ==
+		fakethreads[0]);
+
+	for (i=0; i<5; i++) {
+		t = threadlist_remhead(&tl);
+		KASSERT(t == fakethreads[i]);
+	}
+	KASSERT(tl.tl_count == 0);
+
+	threadlist_cleanup(&tl);
+}
+
+static
+void
+threadlisttest_f(void)
+{
+	struct threadlist tl;
+	struct thread *t;
+	unsigned i;
+
+	threadlist_init(&tl);
+
+	for (i=0; i<NUMNAMES; i++) {
+		threadlist_addtail(&tl, fakethreads[i]);
+	}
+	KASSERT(tl.tl_count == NUMNAMES);
+
+	i=0;
+	THREADLIST_FORALL(t, tl) {
+		KASSERT(t == fakethreads[i]);
+		i++;
+	}
+	KASSERT(i == NUMNAMES);
+
+	i=0;
+	THREADLIST_FORALL_REV(t, tl) {
+		KASSERT(t == fakethreads[NUMNAMES - i - 1]);
+		i++;
+	}
+	KASSERT(i == NUMNAMES);
+
+	for (i=0; i<NUMNAMES; i++) {
+		t = threadlist_remhead(&tl);
+		KASSERT(t == fakethreads[i]);
+	}
+	KASSERT(tl.tl_count == 0);
+}
+
+////////////////////////////////////////////////////////////
+// external interface
+
+int
+threadlisttest(int nargs, char **args)
+{
+	unsigned i;
+
+	(void)nargs;
+	(void)args;
+
+	kprintf("Testing threadlists...\n");
+
+	for (i=0; i<NUMNAMES; i++) {
+		fakethreads[i] = fakethread_create(names[i]);
+	}
+
+	threadlisttest_a();
+	threadlisttest_b();
+	threadlisttest_c();
+	threadlisttest_d();
+	threadlisttest_e();
+	threadlisttest_f();
+
+	for (i=0; i<NUMNAMES; i++) {
+		fakethread_destroy(fakethreads[i]);
+		fakethreads[i] = NULL;
+	}
+
+	kprintf("Done.\n");
+	return 0;
+}