context/_reports/st/st_list.li

/*
 * @progname       st_list.li
 * @version        1.16 (2007-05-06)
 * @author         Perry Rapp
 * @category       self-test
 * @output         none
 * @description    validate list functions
*/

char_encoding("ASCII")

require("lifelines-reports.version:1.3")
option("explicitvars") /* Disallow use of undefined variables */
include("st_aux")

/* entry point in case not invoked via st_all.ll */
proc main()
{
	call testLists()
}

/*
 test some list functions
  */
proc testLists()
{
	call initSubsection()

	list(li)
	if (not(empty(li))) {
		call reportfail("empty FAILED")
	}
	else { incr(testok) }
	if (inlist(li,4)) {
		call reportfail("inlist(empty) FAILED")
	}
	else { incr(testok) }
	enqueue(li, 1)
	if (empty(li)) {
		call reportfail("not empty FAILED")
	}
	else { incr(testok) }
	if (not(inlist(li,1))) {
		call reportfail("inlist(1) in list with 1 FAILED")
	}
	else { incr(testok) }
	if (inlist(li,4)) {
		call reportfail("inlist(4) in list without 4 FAILED")
	}
	else { incr(testok) }
	set(te, dequeue(li))
	if (ne(te, 1)) {
		call reportfail("dequeue(1) FAILED")
	}
	else { incr(testok) }
/* enqueue & dequeue */
	enqueue(li, 100)
	enqueue(li, 200)
	set(te, dequeue(li))
	if (ne(te, 100)) {
		call reportfail("dequeue(100) FAILED")
	}
	else { incr(testok) }
	set(te, dequeue(li))
	if (ne(te, 200)) {
		call reportfail("dequeue(200) FAILED")
	}
	else { incr(testok) }
	if (not(empty(li))) {
		call reportfail("empty (enqueue & dequeue) FAILED")
	}
	else { incr(testok) }
/* requeue */
	enqueue(li, 10)
	enqueue(li, 20)
	set(te, dequeue(li))
	if (ne(te, 10)) {
		call reportfail("dequeue(10) FAILED")
	}
	else { incr(testok) }
	requeue(li, 8)
	set(te, dequeue(li))
	if (ne(te, 8)) {
		call reportfail("dequeue(8) FAILED")
	}
	else { incr(testok) }
	dequeue(li)
	if (not(empty(li))) {
		call reportfail("empty (requeue) FAILED")
	}
	else { incr(testok) }
/* push & pop */
	push(li, 1)
	push(li, 2)
	set(te, pop(li))
	if (ne(te, 2)) {
		call reportfail("pop(2) FAILED")
	}
	else { incr(testok) }
	set(te, pop(li))
	if (ne(te, 1)) {
		call reportfail("pop(1) FAILED")
	}
	else { incr(testok) }
	if (not(empty(li))) {
		call reportfail("empty (push&pop) FAILED")
	}
	else { incr(testok) }
/* getel & setel */
	enqueue(li, 1)
	enqueue(li, 2)
	set(te, getel(li, 2))
	if (ne(te, 2)) {
		call reportfail("getel(,2)==2 FAILED")
	}
	else { incr(testok) }
	setel(li, 4, 4) /* put a 4th element (3rd will be zero-filled) */
/* forlist & length */
	set(te2,0)
	set(te3,0)
	set(te4,0)
	forlist(li, te, n) {
		set(te1, te2)
 		set(te2, te3)
		set(te3, te4)
		set(te4, te)
		set(max, n)
	}
	if(ne(max,length(li))) {call reportfail("length FAILED")}
	else {incr(testok)}
	if(ne(te1,1)) {call reportfail("forlist#1 FAILED")} else {incr(testok)}
	if(ne(te2,2)) {call reportfail("forlist#2 FAILED")} else {incr(testok)}
	if(ne(te3,0)) {call reportfail("forlist#3 FAILED")} else {incr(testok)}
	if(ne(te4,4)) {call reportfail("forlist#4 FAILED")} else {incr(testok)}
/* continue getel & setel */
	set(te, dequeue(li))
	if (ne(te, 1)) {
		call reportfail("dequeue(1) from setel FAILED")
	}
	else { incr(testok) }
	set(te, dequeue(li))
	if (ne(te, 2)) {
		call reportfail("dequeue(2) from setel FAILED")
	}
	else { incr(testok) }
	set(te, dequeue(li))
	if (ne(te, 0)) {
		/* the 3rd was uninitialized created by setel */
		call reportfail("dequeue(3) from setel FAILED")
	}
	else { incr(testok) }
	set(te, dequeue(li))
	if (ne(te, 4)) {
		call reportfail("dequeue(4) from setel FAILED")
	}
	else { incr(testok) }
	if (not(empty(li))) {
		call reportfail("empty (getel & setel) FAILED")
	}
	else { incr(testok) }
	enqueue(li, "harry")
	enqueue(li, 3)
	call testFreeList(li)
/* sort & rsort */
	list(li)
	push(li, "aardvark")
	push(li, "coon")
	push(li, "bear")
	push(li, "eel")
	push(li, "dog")
	/* sort on li */
	/* so we expect words to come out in order */
	sort(li)
	if (or(
		ne(getel(li, 1), "aardvark")
		,ne(getel(li, 2), "bear")
		,ne(getel(li, 3), "coon")
		,ne(getel(li, 4), "dog")
		,ne(getel(li, 5), "eel")
		)) {
		call reportfail("sort FAILED")
	} else { incr(testok) }
	/* rsort on li */
	/* so we expect words to come out in reverse order */
	rsort(li)
	if (or(
		ne(getel(li, 1), "eel")
		,ne(getel(li, 2), "dog")
		,ne(getel(li, 3), "coon")
		,ne(getel(li, 4), "bear")
		,ne(getel(li, 5), "aardvark")
		)) {
		call reportfail("rsort FAILED")
	} else { incr(testok) }

	/* test sorting on 2nd argument */
	list(li)
	list(li2)
	push(li, "bush")
	push(li2, "hsub")
	push(li, "grass")
	push(li2, "ssarg")
	push(li, "shrub")
	push(li2, "burhs")
	push(li, "tree")
	push(li2, "eert")
	push(li, "marsh")
	push(li2, "hsram")
	push(li, "benz")
	push(li2, "zneb")
	/* sort on li2, which is words backwards */
	/* so we expect words to come out in order of each word backwards */
	/* eg, shrub is first because it ends with b */
	sort(li,li2)
	if (or(
		ne(getel(li, 1), "shrub")
		,ne(getel(li, 2), "tree")
		,ne(getel(li, 3), "marsh")
		,ne(getel(li, 4), "bush")
		,ne(getel(li, 5), "grass")
		,ne(getel(li, 6), "benz")
		)) {
		call reportfail("sort on 2 args FAILED")
	} else { incr(testok) }
	/* rsort on li2, which is words backwards */
	/* so we expect words to come out in reverse order of each word backwards */
	/* eg, benz is first because it ends with z */
	rsort(li, li2)
	if (or(
		ne(getel(li, 1), "benz")
		,ne(getel(li, 2), "grass")
		,ne(getel(li, 3), "bush")
		,ne(getel(li, 4), "marsh")
		,ne(getel(li, 5), "tree")
		,ne(getel(li, 6), "shrub")
		)) {
		call reportfail("rsort on 2 args FAILED")
	} else { incr(testok) }

	call reportSubsection("list tests")
}

proc testFreeList(li)
{
	free(li)
	if (ne(li, 0)) {
		call reportfail("free list FAILED")
	}
	else { incr(testok) }
}