void TestHash()
{
Thing key = Word(7);
Thing item = Word(11);
Thing X, Y;
CommentLine("Testing Hashtable");
Hash H = NewHash(NULL);
HashIns(H, key, item);
//BAD CODE: if (IntWord(HashGet(H, key)) != 11)
//{ printf("no match!\n"); }
//HashGet can return NULL!
X = HashGet(H, key);
assert(X);
assert(SameThing(X, item));
if (ThingCmp(X, item) != EQ) printf("error in retr hash");
Y = HashRm(H, key);
assert(SameThing(Y, item));
assert(SameThing(X, Y));
DelThing(X);
X = HashRm(H, key);
assert(X == NULL);
DelHash(H);
//asm("int3");
DelThing(Y); // this calls the dtor on item
DelThing(key);
printf("Basic insert/retrieve in hash table done.\n");
}
extern bool IndexOverlaps( instruction *ins, int i ) {
/********************************************************/
if( ins->operands[i]->n.class != N_INDEXED ) return( false );
if( SameThing( ins->operands[i]->i.index, ins->result ) ) return( true );
return( false );
}
static bool OpsCollide( name *op_87, name *op_86 ) {
/****************************************************/
if( op_87->n.class == N_INDEXED ) {
if( op_86 == NULL ) return( FALSE );
if( op_86->n.class == N_INDEXED ) {
if( op_87->i.base == NULL ) return( TRUE );
if( op_86->i.base == NULL ) return( TRUE );
return( SameThing( op_87->i.base, op_86->i.base ) );
}
if( op_86->n.class != N_MEMORY && op_86->n.class != N_TEMP ) {
return( FALSE );
}
if( op_86->v.usage & ( NEEDS_MEMORY | USE_ADDRESS ) ) {
if( op_87->i.base != NULL ) {
return( SameThing( op_87->i.base, op_86 ) );
}
return( TRUE );
}
} else if( SameThing( op_87, op_86 ) ) {
static void TestList()
{
uint i, a;
Thing S, T, U, W, X;
Thing things[MAXCOUNT];
List L;
a=-93;
W = Word(a);
CommentLine("Test List");
L = NewList(); /* insert and empty list */
DelList(L); /* delete an empty list */
/* insert into a list, delete a list make sure thing is ok */
L = NewList();
ListIns(L, W);
DelList(L);
assert(a == IntWord(W));
L = NewList();
for (i=0; i<MAXCOUNT; i++)
{
T = Word(i);
things[i]=T;
//printf("made: >>%s<<\n", ThingToString(T));
ListIns(L, T);
}
//asm("int3");
String s1, s2;
for (i=0; i<MAXCOUNT; i++)
{
// seperate assignments are NECESSARY because if i assign
// inline with strcmp(ThingToString ... ) they will never
// get deleted and it will be a memory leak!!
s1 = ThingToString(things[i]);
s2 = ThingToString(ListGet(L, things[i]));
assert(strcmp(s1, s2)==0);
/*
if (strcmp(s1, s2) != 0)
{
printf("*** no match\n");
printf("%s ",ThingToString(things[i]));
printf("!= %s\n", ThingToString(ListGet(L, things[i])));
}
*/
DelStr(s1); // sigh, there is no real way around this.
DelStr(s2);
}
DelList(L);
fflush(stdout);
/* S, T, X are unused */
L = NewList();
S = Word(-64);
U = Word(64);
ListIns(L, S); // memory leak but these are just tests.
T = Word(-64);
assert(SameThing(S, T));
assert(SameThing(S, U) == false);
X = ListRm(L, T);
DelList(L);
/* X is unused */
L = NewList();
for (i = 0; i < MAXCOUNT; i++)
{
W = Word(i);
ListIns(L, W);
}
assert(GetListSize(L) == MAXCOUNT);
a = GetListSize(L);
for (i = 0; i < MAXCOUNT; i++)
{
a -= 1;
W = Word(i);
assert(i == IntWord(ListRm(L, W)));
assert(GetListSize(L) == a);
//printf("a: %d, size: %d\n", a, GetListSize(L));
}
DelList(L);
L = NewList();
assert(SameThing(S, W) == false);
ListIns(L, T);
i = GetListSize(L);
X = ListRm(L, T);
assert(GetListSize(L) == (i - 1));
assert(SameThing(X, T) == true);
/* check to make sure it's not in there anymore */
assert(ListRm(L, T) == NULL);
for (i = 0; i < MAXCOUNT; i++) { ListIns(L, T); }
assert(GetListSize(L) == MAXCOUNT);
for (i = 0; i < MAXCOUNT; i++)
{
X = ListRm (L, T);
assert(X != NULL);
}
assert(GetListSize(L) == 0);
assert(ListRm(L, T) == NULL);
DelList(L);
/* these are the only ones we actually made new */
/* W is a, S is -64, T= -64 */
DelThing(S);
DelThing(T);
DelThing(U);
DelThing(W);
printf("Done TestList()\n");
}
