void test_create(){
DESCRIBE("CRIA ARVORE");
WHEN("Eu crio uma ARVORE");
IF("Uma chave");
THEN("Resultado deve ser ponteiro");
struct node_avl * p = avl_insert(NULL,1);
isNotNull(p);
THEN("Deve ter altura 1");
isEqual(avl_height(p),1);
avl_destroy(p);
}
void test_diverse(){
int i;
struct node_avl * p = NULL;
DESCRIBE("Teste de diferentes balanceamentos");
for(i=1; i<=8; i++){
struct node_avl * new_root = avl_insert(p,i);
isNotNull(new_root);
p = new_root;
}
THEN("Altura da árvore deve ser 3");
isEqual(avl_height(p),1);
DESCRIBE("Remove 5 e 1");
p = avl_delete(p,5);
p = avl_delete(p,1);
THEN("Altura deve ser 2");
isEqual(avl_height(p),1);
DESCRIBE("Remove 8 e 7");
p = avl_delete(p,8);
p = avl_delete(p,7);
THEN("Altura deve ser 2");
isEqual(avl_height(p),0);
DESCRIBE("Remove 3 (raiz)");
p = avl_delete(p,3);
THEN("Altura deve ser 1");
isEqual(avl_height(p),0);
DESCRIBE("Remove 2, 4 e 6");
p = avl_delete(p,2);
p = avl_delete(p,4);
p = avl_delete(p,6);
THEN("Altura deve ser 0");
isEqual(avl_height(p),0);
}
void test_insert(){
int i;
struct node_avl * p = NULL;
DESCRIBE("INSERE ELEMENTOS");
WHEN("Eu insiro elementos");
IF("Insiro um número razoável MAX");
THEN("Deve inserir todos");
for(i=1; i<=MAX; i++){
struct node_avl * new_root = avl_insert(p,i);
isNotNull(new_root);
p = new_root;
}
THEN("Deve não estar vazia");
isNotEqual(avl_height(p),0);
THEN("Deve encontrar todas as chaves inseridas");
for(i=1; i<=MAX; i++){
isNotNull(avl_search(p,i));
}
THEN("Alturas da subárvore direita e esquerda não podem ter diferença maior que 1");
if (p){
int left, right, diff;
left = avl_height(p->left);
right = avl_height(p->right);
diff = left>right?left-right:right-left;
diff = diff>1? 0:1;
isNotEqual(diff,0);
}
else isNotNull(NULL);
THEN("Consegue imprimir INFIX");
avl_print_infix(p);
avl_destroy(p);
}
void test_delete(){
int i;
struct node_avl * p = NULL;
DESCRIBE("Remove elementos");
for(i=1; i<=MAX; i++){
struct node_avl * new_root = avl_insert(p,i);
isNotNull(new_root);
p = new_root;
}
THEN("Remove todas as chaves");
for(i=1; i<=MAX; i++){
struct node_avl * new_root = avl_delete(p,i);
p = new_root;
}
isNull(p);
}
void finit(){
//push the address of the next open cell to the stack
COLON(here);
COMPPRIM(LIT);
enter(0);
COMPPRIM(PEEK);
COMPPRIM(EXIT);
//compile TOS
COLON(comptos);
enter(here);
COMPPRIM(POKE);
enter(here);
COMPPRIM(LIT);
enter(1);
COMPPRIM(PLUS);
COMPPRIM(LIT);
enter(0);
COMPPRIM(POKE);
COMPPRIM(EXIT);
//turn a nonzero value to -1, and keep zero values
COLON(logify);
COMPPRIM(LIT);
enter(0);
COMPPRIM(EQL);
COMPPRIM(NOT);
COMPPRIM(EXIT);
//branch if false
COLON(notbranch);
COMPPRIM(LIT); //I could have used logify and then not, but there's an extra 'not' in logify, so for efficiency I just implemented it inline.
enter(0);
COMPPRIM(EQL);
COMPPRIM(PUSNXT);
COMPPRIM(AND); //compute branch value depending on the boolean found on the stack.
COMPPRIM(FROMR);
COMPPRIM(PLUS);
COMPPRIM(TOR);
//add the branch value to the return value and store it back on the return stack, overwriting the old value.
COMPPRIM(EXIT);
//peek xt
COLON(peekxt);
COMPPRIM(LIT);
enter(127);
COMPPRIM(WORD);
COMPPRIM(DUP);
enter(comptos);
COMPPRIM(FIND);
enter(here);
COMPPRIM(LIT);
enter(1);
COMPPRIM(MINUS);
COMPPRIM(PEEK);
COMPPRIM(LIT);
enter(0);
COMPPRIM(POKE);
COMPPRIM(EXIT);
//execute xt
COLON(excut);
int extspace = *dict + 3;
COMPPRIM(LIT);
enter(extspace);
COMPPRIM(POKE);
enter(0);
COMPPRIM(EXIT);
//interpret
intern(DOCOL, -1);
COMPPRIM(FROMR);
COMPPRIM(FROMR);
COMPPRIM(FROMR);
COMPPRIM(PDROP);
COMPPRIM(PDROP);
COMPPRIM(PDROP);
enter(*dict+1);
enter(0);
int intloop = *dict-1;
enter(peekxt);
COMPPRIM(LIT);
enter(1);
COMPPRIM(EQL);
COMPPRIM(NOT);
IF(intfound);
enter(excut);
ELSE(intfound);
COMPPRIM(ATOI);
THEN(intfound);
COMPPRIM(LIT);
enter((int)'\n');
COMPPRIM(LIT);
enter((int)'k');
COMPPRIM(LIT);
enter((int)'o');
COMPPRIM(EMIT);
COMPPRIM(EMIT);
COMPPRIM(EMIT);
COMPPRIM(FROMR);
COMPPRIM(PDROP);
enter(intloop);
//compile
intern(DOCOL, 0);
COMPPRIM(FROMR);
COMPPRIM(FROMR);
COMPPRIM(FROMR);
COMPPRIM(PDROP);
COMPPRIM(PDROP);
COMPPRIM(PDROP);
enter(*dict+1);
enter(0);
int comploop = *dict-1;
enter(peekxt);
COMPPRIM(DUP);
COMPPRIM(LIT);
enter(1);
COMPPRIM(EQL);
COMPPRIM(NOT);
IF(compfound);
IF(compimm);
enter(excut);
ELSE(compimm);
enter(comptos);
ELSE(compfound);
COMPPRIM(PDROP);
COMPPRIM(LIT);
COMPPRIM(LIT);
enter(comptos);
COMPPRIM(ATOI);
enter(comptos);
THEN(compfound); THEN(compimm);
COMPPRIM(FROMR);
COMPPRIM(PDROP);
enter(comploop);
//colon compiler
COLON(colon);
enter(here);
COMPPRIM(LIT);
enter(3);
COMPPRIM(DUP);
COMPPRIM(PEEK);
enter(comptos);
COMPPRIM(POKE);
COMPPRIM(LIT);
enter(127);
COMPPRIM(WORD);
COMPPRIM(PDROP);
COMPPRIM(LIT);
enter(0);
COMPPRIM(DUP);
enter(comptos);
enter(comptos);
COMPPRIM(EXIT);
//cold start to setup interpreter
mputs("cs @ ");
puts(itoa(*dict));
int coldstart = *dict;
enter(DOCOL);
enter(intloop);
IP=coldstart;
cs=coldstart;
}
