int main(void) {
List *lst;
Entry *it;
lst = mk_list();
void *a_foo = mk_foo(2);
void *b_bar = mk_bar(3, 4);
insert(lst, a_foo);
insert(lst, b_bar);
insert(lst, mk_foo(5));
int c = 0;
for (it = lst->head; it != NULL; it = it->next) {
Foo *v = (Foo *)(it->data);
if (1 || is_bar(v)) {
Bar *b;
b = to_bar(v);
printf("bar: x=%d, y=%d\n", v->x, b->y);
}
if (++c > 3)
break;
}
return 0;
}
int main(int argc, char **argv)
{
struct ListNode *head;
int a[] = {1,2,3,4,5};
mk_list(&head, a, 5);
//head->next->next = head;
printf("%d\n", hasCycle(head));
printf("%d\n", detectCycle(head)->val);
return 0;
}
/* 式のリスト(空)を作る */
expr_list_t mk_expr_list()
{
return (expr_list_t)mk_list();
}
/* 関数定義のリスト関係 */
fun_def_list_t mk_fun_def_list()
{
return (fun_def_list_t)mk_list();
}
/* 文のリスト関係 */
stmt_list_t mk_stmt_list()
{
return (stmt_list_t)mk_list();
}
/* 変数宣言のリスト関係の関数. 意味は expr_listの場合と同じ */
var_decl_list_t mk_var_decl_list()
{
return (var_decl_list_t)mk_list();
}
/* Create a new list node with position information */
node * mk_pos_list(int key, node *list, unsigned int start, unsigned int stop) {
node *result = mk_list(key, list);
return result;
}
struct pnode *add_symbol_constant(struct pnode *parms, int value)
{
return mk_list(HEAD(parms), mk_list(mk_constant(value), NULL));
}
struct pnode *make_constant_list(int value1, int value2)
{
return mk_list(mk_constant(value1), mk_list(mk_constant(value2), NULL));
}
/*envを作る*/
env_list_t mk_env(void){
return (env_list_t)mk_list();
}
int main(int argc, char **argv)
{
if (argc > 1)
while (++argv, --argc) {
if (!strcmp("-c", argv[0]))
color_on = 1;
else if (!strcmp("-h", argv[0]))
printf("liblisp unit tests\n\tusage ./%s (-c)? (-h)?\n", argv[0]);
else
printf("unknown argument '%s'\n", argv[0]);
}
unit_test_start("liblisp");
{
print_note("util.c");
test(is_number("0xfAb"));
test(is_number("-01234567"));
test(is_number("+1000000000000000000000000000003"));
test(!is_number(""));
test(!is_number("+"));
test(!is_number("-"));
test(unbalanced("(((", '(', ')') > 0);
test(unbalanced("))", '(', ')') < 0);
test(unbalanced("", '(', ')') == 0);
test(unbalanced("\"(", '(', ')') == 0);
test(unbalanced("( \"))))(()()()(()\\\"())\")", '(', ')') == 0);
test(unbalanced("(a (b) c (d (e (f) \")\" g)))", '(', ')') == 0);
test(unbalanced("((a b) c", '(', ')') > 0);
test(!is_fnumber(""));
test(!is_fnumber("1e"));
test(!is_fnumber("-1e"));
test(!is_fnumber("1-e"));
test(is_fnumber("+0."));
test(is_fnumber("123")); /*this passes, see header */
test(is_fnumber("1e-3"));
test(is_fnumber("1.003e+34"));
test(is_fnumber("1e34"));
test(is_fnumber("93.04"));
test(match("", ""));
test(match("abc", "abc"));
test(!match("abC", "abc"));
test(match("aaa*", "aaaXX"));
test(!match("aaa*", "XXaaaXX"));
test(match(".bc", "abc"));
test(match("a.c", "aXc"));
test(!match("a\\.c", "aXc"));
test(match("a\\.c", "a.c"));
char *s = NULL;
state(s = vstrcatsep(",", "a", "b", "c", "", "foo", "bar", NULL));
test(!sstrcmp("a,b,c,,foo,bar", s));
free(s);
char *t = NULL, *s1 = "Hello,", *s2 = " World!";
state(t = calloc(16, 1));
state(strcpy(t, s1));
test(((size_t) (lstrcatend(t, s2) - t)) == (strlen(s1) + strlen(s2)));
free(t);
/*test tr, or translate, functionality */
size_t trinsz = 0;
uint8_t trout[128] = { 0 }, *trin = (uint8_t *) "aaabbbcdaacccdeeefxxxa";
tr_state_t *tr1;
state(tr1 = tr_new());
state(trinsz = strlen((char *)trin));
test(tr_init(tr1, "", (uint8_t *) "abc", (uint8_t *) "def") == TR_OK);
test(tr_block(tr1, trin, trout, trinsz) == trinsz);
test(!strcmp((char *)trout, "dddeeefdddfffdeeefxxxd"));
test(tr_init(tr1, "s", (uint8_t *) "abc", (uint8_t *) "def") == TR_OK);
state(memset(trout, 0, 128));
test(tr_block(tr1, trin, trout, trinsz) <= trinsz);
test(!strcmp((char *)trout, "defddfdeeefxxxd"));
state(tr_delete(tr1));
/*know collisions for the djb2 hash algorithm */
test(djb2("heliotropes", strlen("heliotropes")) ==
djb2("neurospora", strlen("neurospora")));
test(djb2("depravement", strlen("depravement")) ==
djb2("serafins", strlen("serafins")));
/*should not collide */
test(djb2("heliotropes", strlen("heliotropes")) !=
djb2("serafins", strlen("serafins")));
}
{ /*io.c test */
io_t *in, *out;
print_note("io.c");
/*string input */
static const char hello[] = "Hello\n";
/**@note io_sin currently duplicates "hello" internally*/
state(in = io_sin(hello, strlen(hello)));
test(io_is_in(in));
test(io_getc(in) == 'H');
test(io_getc(in) == 'e');
test(io_getc(in) == 'l');
test(io_getc(in) == 'l');
test(io_getc(in) == 'o');
test(io_getc(in) == '\n');
test(io_getc(in) == EOF);
test(io_getc(in) == EOF);
test(!io_error(in));
test(io_seek(in, 0, SEEK_SET) >= 0);
test(io_getc(in) == 'H');
test(io_seek(in, 3, SEEK_SET) >= 0);
test(io_getc(in) == 'l');
test(io_ungetc('x', in) == 'x');
test(io_getc(in) == 'x');
test(io_getc(in) == 'o');
state(io_close(in));
/*string output */
char *s = NULL;
static const char hello_world[] = "Hello,\n\tWorld!\n";
/**@note io_sin currently duplicates hello_world internally*/
state(in = io_sin(hello_world, strlen(hello_world)));
test(!strcmp(s = io_getline(in), "Hello,"));
s = (free(s), NULL);
test(!strcmp(s = io_getline(in), "\tWorld!"));
s = (free(s), NULL);
test(!io_getline(in));
test(io_seek(in, 0, SEEK_SET) >= 0);
test(!strcmp(s = io_getdelim(in, EOF), "Hello,\n\tWorld!\n"));
s = (free(s), NULL);
state(io_close(in));
state(out = io_sout(1));
test(io_puts("Hello, World", out) != EOF);
test(!strcmp("Hello, World", io_get_string(out)));
test(io_putc('\n', out) != EOF);
test(!strcmp("Hello, World\n", io_get_string(out)));
test(io_seek(out, -6, SEEK_CUR) >= 0);
test(io_puts("Mars\n", out) != EOF);
test(!strcmp("Hello, Mars\n\n", io_get_string(out)));
free(io_get_string(out));
state(io_close(out));
static const char block_in[16] = {1, 3, 4, 6};
static char block_out[16] = {0};
state((in = io_sin(block_in, 16)));
test(io_getc(in) == 1);
test(io_read(block_out, 15, in) == 15);
test(!memcmp(block_out, block_in+1, 15));
state(io_close(in));
}
{ /* hash.c hash table tests */
hash_table_t *h = NULL;
print_note("hash.c");
state(h = hash_create(1));
return_if(!h);
test(!hash_insert(h, "key1", "val1"));
test(!hash_insert(h, "key2", "val2"));
/* assuming the hash algorithm is djb2, then
* "heliotropes" collides with "neurospora"
* "depravement" collides with "serafins"
* "playwright" collides with "snush" (for djb2a)
* See:
* <https://programmers.stackexchange.com/questions/49550/which-hashing-algorithm-is-best-for-uniqueness-and-speed> */
test(!hash_insert(h, "heliotropes", "val3"));
test(!hash_insert(h, "neurospora", "val4"));
test(!hash_insert(h, "depravement", "val5"));
test(!hash_insert(h, "serafins", "val6"));
test(!hash_insert(h, "playwright", "val7"));
test(!hash_insert(h, "snush", "val8"));
test(!hash_insert(h, "", "val9"));
test(!hash_insert(h, "nil", ""));
test(!hash_insert(h, "a", "x"));
test(!hash_insert(h, "a", "y"));
test(!hash_insert(h, "a", "z"));
test(!sstrcmp("val1", hash_lookup(h, "key1")));
test(!sstrcmp("val2", hash_lookup(h, "key2")));
test(!sstrcmp("val3", hash_lookup(h, "heliotropes")));
test(!sstrcmp("val4", hash_lookup(h, "neurospora")));
test(!sstrcmp("val5", hash_lookup(h, "depravement")));
test(!sstrcmp("val6", hash_lookup(h, "serafins")));
test(!sstrcmp("val7", hash_lookup(h, "playwright")));
test(!sstrcmp("val8", hash_lookup(h, "snush")));
test(!sstrcmp("val9", hash_lookup(h, "")));
test(!sstrcmp("", hash_lookup(h, "nil")));
test(!sstrcmp("z", hash_lookup(h, "a")));
test(hash_get_load_factor(h) <= 0.75f);
state(hash_destroy(h));
}
{ /* lisp.c (and the lisp interpreter in general) */
lisp_t *l;
print_note("lisp.c");
/*while unit testing eschews state being held across tests it is makes
*little sense in this case*/
state(l = lisp_init());
state(io_close(lisp_get_logging(l)));
test(!lisp_set_logging(l, io_nout()));
return_if(!l);
test(!lisp_eval_string(l, ""));
test(is_int(lisp_eval_string(l, "2")));
test(get_int(lisp_eval_string(l, "(+ 2 2)")) == 4);
test(get_int(lisp_eval_string(l, "(* 3 2)")) == 6);
lisp_cell_t *x = NULL, *y = NULL, *z = NULL;
char *t = NULL;
state(x = lisp_intern(l, lstrdup_or_abort("foo")));
state(y = lisp_intern(l, t = lstrdup_or_abort("foo"))); /*this one needs freeing! */
state(z = lisp_intern(l, lstrdup_or_abort("bar")));
test(x == y && x != NULL);
test(x != z);
free(t); /*free the non-interned string */
test(is_proc(lisp_eval_string(l, "(define square (lambda (x) (* x x)))")));
test(get_int(lisp_eval_string(l, "(square 4)")) == 16);
test(!is_list(cons(l, gsym_tee(), gsym_tee())));
test(is_list(cons(l, gsym_tee(), gsym_nil())));
test(!is_list(cons(l, gsym_nil(), cons(l, gsym_tee(), gsym_tee()))));
test(is_list(mk_list(l, gsym_tee(), gsym_nil(), gsym_tee(), NULL)));
test(gsym_error() == lisp_eval_string(l, "(> 'a 1)"));
test(is_sym(x));
test(is_asciiz(x));
test(!is_str(x));
test(gsym_error() == lisp_eval_string(l, "(eval (cons quote 0))"));
char *serial = NULL;
test(!strcmp((serial = lisp_serialize(l, cons(l, gsym_tee(), gsym_error()))), "(t . error)"));
state(free(serial));
state(lisp_destroy(l));
}
return unit_test_end("liblisp"); /*should be zero! */
}
int main(int argc, char** argv) {
IntList* list1 = mk_list();
print_list(list1);
printf("is_empty(list1) = 1? %d\n", is_empty(list1));
printf("length(list1) = 0? %d\n", length(list1));
free_list(list1);
IntList* list2 = mk_list();
push_back(list2, 4);
push_back(list2, 5);
printf("is_empty(list2) = 0? %d\n", is_empty(list2));
printf("length(list2) = 2? %d\n", length(list2));
print_list(list2);
printf("sum(list2) = 9? %d\n", sum(list2));
int ret1, ret2, ret3;
printf("index_of(list2, 4, ret1) = true? %d\n", index_of(list2, 4, &ret1));
printf("index_of(list2, 5, ret2) = true? %d\n", index_of(list2, 5, &ret2));
printf("index_of(list2, 6, ret3) = false? %d\n", index_of(list2, 6, &ret3));
printf("index_of(list2, 4, ret1), ret1 = 0? %d\n", ret1);
printf("index_of(list2, 5, ret2), ret2 = 1? %d\n", ret2);
push_front(list2, 6);
print_list(list2);
printf("index_of(list2, 4, ret1) = true? %d\n", index_of(list2, 4, &ret1));
printf("index_of(list2, 5, ret2) = true? %d\n", index_of(list2, 5, &ret2));
printf("index_of(list2, 6, ret3) = true? %d\n", index_of(list2, 6, &ret3));
printf("index_of(list2, 4, ret1), ret1 = 1? %d\n", ret1);
printf("index_of(list2, 5, ret2), ret2 = 2? %d\n", ret2);
printf("index_of(list2, 6, ret3), ret2 = 0? %d\n", ret3);
insert(list2, 8, 0);
print_list(list2);
insert(list2, 9, 2);
print_list(list2);
insert(list2, 7, 4);
print_list(list2);
intersperse(list2, 3);
print_list(list2);
IntList* list3 = mk_list();
push_back(list3, 4);
push_back(list3, 5);
intersperse(list3, 2);
print_list(list3);
int pop;
pop_front(list3, &pop);
print_list(list3);
printf("pop = %d\n", pop);
pop_front(list3, &pop);
print_list(list3);
printf("pop = %d\n", pop);
pop_front(list3, &pop);
print_list(list3);
printf("pop = %d\n", pop);
printf("list3 = ");
print_list(list3);
printf("\nfree_list(list2)...\n");
free_list(list2);
printf("free_list(list3)...\n");
free_list(list3);
return 0;
}
