TEST(Test03, RelationalTests)
{
{
Set s;
Set t;
createEmptySet(&s);
createEmptySet(&t);
for (int i = 0; i < NUM_TESTS; i++)
{
randomSet(&s);
reassignSet(&t, &s);
ASSERT_TRUE(isSubsetOf(&s, &t));
ASSERT_TRUE(isSubsetOf(&t, &s));
ASSERT_TRUE(isEqualToSet(&s, &t));
ASSERT_TRUE(isEqualToSet(&t, &s));
insertSet(&s, rand() % MAX_SET_SIZE + MAX_SET_SIZE);
ASSERT_TRUE(isSubsetOf(&t, &s));
ASSERT_FALSE(isSubsetOf(&s, &t));
}
destroySet(&s);
destroySet(&t);
}
}
void visualTests() {
Set s;
Set t;
int i;
createEmptySet(&s);
showOutput("The set constructed with the default constructor: ", &s);
for (i = 0; i < 10; i += 1) {
insertSet(&s, i);
}
showOutput("The set should be {0, ..., 9}: ", &s);
// test Insert() and Contains() with '<<'
for (i = 0; i < 10; i += 1) {
insertSet(&s, i);
}
showOutput("The set should be {0, ..., 9}: ", &s);
createCopySet(&t, &s);
showOutput("The copy of s constructed with the copy constructor = ", &t);
randomSet(&t);
showOutput("The random set generated equals = ", &t);
printf("The visual tests are over\n");
destroySet(&s);
destroySet(&t);
}
TEST(Test02, EqualityTests)
{
{
for (int i = 0; i < NUM_TESTS; i++)
{
Set s;
Set t;
createEmptySet(&s);
randomSet(&s);
createCopySet(&t, &s);
ASSERT_TRUE(isEqualToSet(&t, &s));
ASSERT_TRUE(isEqualToSet(&s, &t));
insertSet(&t, MAX_SET_SIZE);
ASSERT_FALSE(isEqualToSet(&s, &t));
ASSERT_FALSE(isEqualToSet(&t, &s));
randomSet(&t);
ASSERT_FALSE(isEqualToSet(&t, &s));
destroySet(&s);
destroySet(&t);
}
}
}
TEST(Test04, MembershipTests)
{
{
int x[100];
Set universal;
createEmptySet(&universal);
for (int i = 0; i < 100; i++)
{
insertSet(&universal, i);
x[i] = i;
}
Set s;
createCopySet(&s, &universal);
for (int i = 0; i < 50; i++)
{
/* choose a random element in array x */
int k = rand() % (100 - i);
int val = x[i];
/* remove that random value from x by copying the last element into position k */
x[k] = x[100 - i - 1];
ASSERT_TRUE(isMemberSet(&s, val));
removeSet(&s, val);
ASSERT_FALSE(isMemberSet(&s, val));
}
}
}
/*
* The structure of the output is:
*
* {} <default constructed set>
* {0,1,...,9} <insert 0-9>
* {0,1,...,9} <insert 0-9 (fail b/c repeat)>
* {0,1,...,9} <copy constructed>
* {0,2,3,...,95,99} <random set>
*/
TEST(Test01, VisualTests)
{
{
std::set<int> basic, random;
Set s;
Set t;
int i;
createEmptySet(&s);
assertSetsAreEqual(basic, &s);
for (i = 0; i < 10; i++)
{
insertSet(&s, i);
basic.insert(i);
}
assertSetsAreEqual(basic, &s);
for (i = 0; i < 10; i++)
{
insertSet(&s, i);
}
assertSetsAreEqual(basic, &s);
createCopySet(&t, &s);
assertSetsAreEqual(basic, &t);
Set temp;
int n = rand() % MAX_SET_SIZE + 1;
createEmptySet(&temp);
for (int i = 0; i < n; i++)
{
int val = rand() % MAX_SET_SIZE;
insertSet(&temp, val);
random.insert(val);
}
reassignSet(&t, &temp);
destroySet(&temp);
assertSetsAreEqual(random, &t);
destroySet(&s);
destroySet(&t);
}
}
set* computeFollowSets(int id, prodRuleNode** rulelist, set **firststs, set** followsts, int** rec_stack, int stack_size)
{
if(rulelist[id]->rhs_occ_cnt == 0)
{
set* st = createEmptySet();
st->val = TK_DOLLAR;
followsts[id] = st;
return st;
}
if(rulelist[id]->follow_set_flag == 2)
return followsts[id];
if(rulelist[id]->follow_set_flag == 1)
{
set* com_st = NULL;
int k;
int idx;
// to find the start of the cycle
for (idx = 0; idx < stack_size; ++idx)
if((*rec_stack)[idx] == id)
break;
for (k = idx; k < stack_size; ++k)
com_st = setUnion(com_st, followsts[(*rec_stack)[k]]);
for (k = idx; k < stack_size; ++k)
followsts[(*rec_stack)[k]] = com_st;
return followsts[id];
}
rulelist[id]->follow_set_flag = 1;
followsts[id] = NULL;
int rhs_cnt = rulelist[id]->rhs_occ_cnt;
int i;
for (i = 0; i < rhs_cnt; ++i)
{
rhsOcc temp = rulelist[id]->rhs_occs[i];
bool term_flag = false;
int j = temp.j + 1;
while(j < rulelist[temp.ntid]->rule_length[temp.i])
{
set* fst = computeFirstSets(rulelist[temp.ntid]->prod_rules[temp.i][j], rulelist, firststs);
followsts[id] = setUnion(followsts[id], fst);
if(!isPresent(TK_EPS, fst))
{
term_flag = true;
break;
}
j++;
}
if(term_flag)
continue;
(*rec_stack) = (int*) realloc((*rec_stack), sizeof(int) * (stack_size + 1));
(*rec_stack)[stack_size] = temp.ntid;
set* flst = computeFollowSets(temp.ntid, rulelist, firststs, followsts, rec_stack, stack_size + 1);
followsts[id] = setUnion(followsts[id], flst);
}
rulelist[id]->follow_set_flag = 2;
return followsts[id];
}
set* getFirstSet(int id, set** firststs)
{
// ensure that computeFirstSets has been called for that id earlier
if(isTerminal(id))
{
set* st = createEmptySet();
st->val = id;
return st;
}
return firststs[id];
}
void randomSet(Set* s) {
Set t;
int n = rand() % maximum_set_size + 1;
int i;
createEmptySet(&t);
for (i = 0; i < n; i += 1) {
insertSet(&t, rand() % maximum_set_size);
}
assignSet(s, &t);
destroySet(&t);
}
void relationalTests() {
Set s;
Set t;
int i;
createEmptySet(&s);
createEmptySet(&t);
for (i = 0; i < number_of_tests; i += 1) {
randomSet(&s);
assignSet(&t, &s);
assert(isSubsetOf(&s, &t));
assert(isSubsetOf(&t, &s));
assert(isEqualToSet(&s, &t));
assert(isEqualToSet(&t, &s));
insertSet(&s, rand() % maximum_set_size + maximum_set_size);
assert(isSubsetOf(&t, &s));
assert(! isSubsetOf(&s, &t));
}
printf("The relational tests have been passed\n");
destroySet(&s);
destroySet(&t);
}
void randomSet(Set *s)
{
Set t;
int n = rand() % MAX_SET_SIZE + 1;
createEmptySet(&t);
for (int i = 0; i < n; i++)
{
insertSet(&t, rand() % MAX_SET_SIZE);
}
reassignSet(s, &t);
destroySet(&t);
}
void equalityTests(void) {
int i;
for (i = 0; i < number_of_tests; i += 1) {
Set s;
Set t;
createEmptySet(&s);
randomSet(&s);
createCopySet(&t, &s);
assert(isEqualToSet(&t, &s));
assert(isEqualToSet(&s, &t));
insertSet(&t, maximum_set_size);
assert(! isEqualToSet(&s, &t));
assert(! isEqualToSet(&t, &s));
randomSet(&t);
assert(! isEqualToSet(&t, &s));
destroySet(&s);
destroySet(&t);
} // This test could fail with small probability
printf("The equality tests have been passed\n");
}
set* computeFirstSets(int id, prodRuleNode** rulelist, set** firststs)
{
if(isTerminal(id))
{
set* st = createEmptySet();
st->val = id;
return st;
}
if(firststs[id] != NULL)
return firststs[id];
set* st = NULL;
prodRuleNode* p = rulelist[id];
int i, j;
for (i = 0; i < p->prod_rule_cnt; ++i)
{
if(p->prod_rules[i][0] == TK_EPS)
{
st = setAdd(TK_EPS, st);
continue;
}
bool flag = false;
for (j = 0; j < p->rule_length[i]; ++j)
{
set* st2 = computeFirstSets(p->prod_rules[i][j], rulelist, firststs);
st = setUnion(st, st2);
if(!isPresent(TK_EPS, st2))
{
flag = true;
break;
}
}
if(!flag)
st = setAdd(TK_EPS, st);
}
firststs[id] = st;
return st;
}
/*
* create two sets with n random elements
* the sets should have 50% of the elements in common
*/
void createRandomSetN(int n, Set* a, Set* b) {
int x;
int last_size = 0;
createEmptySet(a);
while (a->len < n) {
if (a->len != last_size) {
last_size = a->len;
if (last_size % 1000 == 0) {
printf("%d..", last_size);
fflush(stdout);
}
}
x = 2 * (5 * n - (rand() % (10 * n)));
if (isMemberSet(a, x)) { continue; } // try another number
/* a will have only even elements */
insertSet(a, x);
if ((rand() % 2) == 0) {
insertSet(b, x);
} else {
insertSet(b, x + 1); // an odd value, can't be in a
}
}
assert(a->len == b->len);
}
/* remove all elements from self that are also elements of other */
void subtractFromSet(Set* self, const Set* other) {
if (isEmptySet(self)) { return; } //can't remove anything from empty set
if (isEmptySet(other)) { return; } //nothing to remove from self
if (isSubsetOf (self, other)) {
createEmptySet (self);
return;
}
/*code here*/ //have two sets (one a copy of self),
//might have to recreate remove code/subset code here
/*Set intersect_set;
createCopySet (&intersect_set, self);
intersect_set.capacity = intersect_set.len;
intersectFromSet (&intersect_set, other); //create temporary set with intersection of self and other
*/
Set copy_set;
createCopySet (©_set, self);
copy_set.capacity = copy_set.len;
destroySet (self);
self->elements = (int*) malloc (copy_set.capacity * sizeof (int)); //copy original set into copy_set and rebuild self
/*int intersect_index = 0;
int self_index = 0;
int copy_index = 0;
while (copy_index < copy_set.len) {
if (copy_set.elements[copy_index] == intersect_set.elements[intersect_index]) {
intersect_index += 1;
copy_index += 1;
}
else if (intersect_index >= intersect_set.len || copy_set.elements[copy_index] < intersect_set.elements[intersect_index]) {
self->elements[self_index] = copy_set.elements[copy_index];
copy_index += 1;
self_index += 1;
}
else if (copy_set.elements[copy_index] > intersect_set.elements[intersect_index]) {
intersect_index += 1;
}
}*/
int copy_index = 0;
int self_index = 0;
int other_index = 0;
while (copy_index < copy_set.len) {
if (other_index >= other->len || copy_set.elements[copy_index] < other->elements[other_index]) {
self->elements[self_index] = copy_set.elements[copy_index];
self_index += 1;
copy_index += 1;
}
else if (copy_set.elements[copy_index] > other->elements[other_index]) {
other_index += 1;
}
else {
copy_index += 1;
other_index += 1;
}
}
self->len = self_index;
self->capacity = copy_set.capacity;
destroySet (©_set);
/*destroySet (&intersect_set);*/
//assert (checkValidSet (self)); //test code, remove later
}
TEST(Test05, SpecialCaseTests)
{
{
Set empty;
Set universal;
Set s;
Set r;
int i;
createEmptySet(&empty);
createEmptySet(&universal);
createEmptySet(&r);
for (i = 0; i < MAX_SET_SIZE; i++)
{
insertSet(&universal, i);
}
ASSERT_TRUE(checkCaseNew(&subtractFromSet, &universal, &universal, &empty));
ASSERT_TRUE(checkCaseNew(&unionInSet, &universal, &universal, &universal));
ASSERT_TRUE(checkCaseNew(&intersectFromSet, &universal, &universal, &universal));
ASSERT_TRUE(checkCaseNew(&intersectFromSet, &universal, &empty, &empty));
ASSERT_TRUE(checkCaseNew(&intersectFromSet, &empty, &universal, &empty));
ASSERT_TRUE(checkCaseNew(&unionInSet, &universal, &empty, &universal));
ASSERT_TRUE(checkCaseNew(&unionInSet, &empty, &universal, &universal));
ASSERT_TRUE(checkCaseNew(&unionInSet, &empty, &empty, &empty));
ASSERT_TRUE(checkCaseNew(&subtractFromSet, &empty, &empty, &empty));
ASSERT_TRUE(checkCaseNew(&intersectFromSet, &empty, &empty, &empty));
createEmptySet(&s);
ASSERT_TRUE(isEmptySet(&s));
for (i = 0; i < 10; i++)
{
insertSet(&s, i);
}
ASSERT_TRUE(s.len == 10);
for (i = 0; i < 10; i++)
{
ASSERT_TRUE(isMemberSet(&s, i));
}
for (i = 0; i < 10; i++)
{
removeSet(&s, i);
removeSet(&s, i);
ASSERT_TRUE(s.len == 9 - i);
}
ASSERT_TRUE(isEmptySet(&s));
for (i = 0; i < NUM_TESTS; i++)
{
randomSet(&s);
ASSERT_TRUE(isSubsetOf(&empty, &s));
ASSERT_FALSE(isSubsetOf(&s, &empty));
ASSERT_TRUE(isSubsetOf(&s, &universal));
ASSERT_FALSE(isSubsetOf(&universal, &s));
ASSERT_TRUE(checkCaseNew(&intersectFromSet, &empty, &s, &empty));
ASSERT_TRUE(checkCaseNew(&intersectFromSet, &s, &empty, &empty));
ASSERT_TRUE(checkCaseNew(&intersectFromSet, &universal, &s, &s));
ASSERT_TRUE(checkCaseNew(&intersectFromSet, &s, &universal, &s));
ASSERT_TRUE(checkCaseNew(&unionInSet, &universal, &s, &universal));
ASSERT_TRUE(checkCaseNew(&unionInSet, &s, &universal, &universal));
ASSERT_TRUE(checkCaseNew(&subtractFromSet, &s, &empty, &s));
assignSet(&r, &universal);
subtractFromSet(&r, &s);
ASSERT_TRUE(checkCaseNew(&subtractFromSet, &universal, &r, &s));
ASSERT_TRUE(checkCaseNew(&unionInSet, &s, &r, &universal));
ASSERT_TRUE(checkCaseNew(&unionInSet, &r, &s, &universal));
}
destroySet(&empty);
destroySet(&universal);
destroySet(&s);
destroySet(&r);
}
}
TEST(Test07, AlgebraicTests)
{
{
Set empty;
Set universal;
Set r;
Set s;
Set t;
Set u;
Set v;
Set w;
int i;
createEmptySet(&empty);
createEmptySet(&universal);
for (i = 0; i < MAX_SET_SIZE; i++)
{
insertSet(&universal, i);
}
createEmptySet(&r);
createEmptySet(&s);
createEmptySet(&t);
createEmptySet(&u);
createEmptySet(&v);
createEmptySet(&w);
ASSERT_FALSE(isEqualToSet(&empty, &universal));
for (i = 0; i < NUM_TESTS; i++)
{
randomSet(&u);
randomSet(&v);
randomSet(&w);
/* w * (u - v) == w * u - w * v */
assignSet(&s, &u);
subtractFromSet(&s, &v);
assignSet(&r, &w);
intersectFromSet(&r, &s);
assignSet(&t, &w);
intersectFromSet(&t, &v);
assignSet(&s, &w);
intersectFromSet(&s, &u);
subtractFromSet(&s, &t);
ASSERT_TRUE(isEqualToSet(&r, &s));
/* u * (v + w) == (u * v) + (u * w) */
assignSet(&s, &v);
unionInSet(&s, &w);
assignSet(&r, &u);
intersectFromSet(&r, &s);
assignSet(&t, &u);
intersectFromSet(&t, &w);
assignSet(&s, &u);
intersectFromSet(&s, &v);
unionInSet(&s, &t);
ASSERT_TRUE(isEqualToSet(&r, &s));
/* universal - (u * v) == (universal - u) + (universal - v) */
assignSet(&s, &u);
intersectFromSet(&s, &v);
assignSet(&r, &universal);
subtractFromSet(&r, &s);
assignSet(&t, &universal);
subtractFromSet(&t, &v);
assignSet(&s, &universal);
subtractFromSet(&s, &u);
unionInSet(&s, &t);
ASSERT_TRUE(isEqualToSet(&r, &s));
/* universal - (u + v) == (universal - u) * (universal - v) */
assignSet(&s, &u);
unionInSet(&s, &v);
assignSet(&r, &universal);
subtractFromSet(&r, &s);
assignSet(&t, &universal);
subtractFromSet(&t, &v);
assignSet(&s, &universal);
subtractFromSet(&s, &u);
intersectFromSet(&s, &t);
ASSERT_TRUE(isEqualToSet(&r, &s));
}
destroySet(&empty);
destroySet(&universal);
destroySet(&r);
destroySet(&s);
destroySet(&t);
destroySet(&u);
destroySet(&v);
destroySet(&w);
}
}
void specialCaseTests(void) {
Set empty;
Set universal;
int i;
Set s;
Set r;
createEmptySet(&empty);
createEmptySet(&universal);
createEmptySet(&r);
for (i = 0; i < maximum_set_size; i += 1) {
insertSet(&universal, i);
}
checkCase(&subtractFromSet, &universal, &universal, &empty);
checkCase(&unionInSet, &universal, &universal, &universal);
checkCase(&intersectFromSet, &universal, &universal, &universal);
checkCase(&intersectFromSet, &universal, &empty, &empty);
checkCase(&intersectFromSet, &empty, &universal, &empty);
checkCase(&unionInSet, &universal, &empty, &universal);
checkCase(&unionInSet, &empty, &universal, &universal);
checkCase(&unionInSet, &empty, &empty, &empty);
checkCase(&subtractFromSet, &empty, &empty, &empty);
checkCase(&intersectFromSet, &empty, &empty, &empty);
createEmptySet(&s);
assert(isEmptySet(&s));
for (i = 0; i < 10; i += 1) {
insertSet(&s, i);
}
assert(s.len == 10);
for (i = 0; i < 10; i += 1) {
assert(isMemberSet(&s, i));
}
for (i = 0; i < 10; i += 1) {
removeSet(&s, i);
removeSet(&s, i);
assert(s.len == 9 - i);
}
assert(isEmptySet(&s));
for (i = 0; i < number_of_tests; i += 1) {
randomSet(&s);
assert(isSubsetOf(&empty, &s));
assert(!isSubsetOf(&s, &empty));
assert(isSubsetOf(&s, &universal));
assert(!isSubsetOf(&universal, &s));
checkCase(&intersectFromSet, &empty, &s, &empty);
checkCase(&intersectFromSet, &s, &empty, &empty);
checkCase(&intersectFromSet, &universal, &s, &s);
checkCase(&intersectFromSet, &s, &universal, &s);
checkCase(&unionInSet, &universal, &s, &universal);
checkCase(&unionInSet, &s, &universal, &universal);
checkCase(&subtractFromSet, &s, &empty, &s);
assignSet(&r, &universal);
subtractFromSet(&r, &s); // r = u - s;
checkCase(&subtractFromSet, &universal, &r, &s); // (u - (u - s) == s)
checkCase(&unionInSet, &s, &r, &universal); // s + (u - s) == u
checkCase(&unionInSet, &r, &s, &universal); // (u - s) + s == u
}
printf("The special case tests have been passed\n");
destroySet(&empty);
destroySet(&universal);
destroySet(&s);
destroySet(&r);
}
void algebraicTests(void) {
Set empty;
Set universal;
int i;
Set s;
Set t;
Set u;
Set v;
Set w;
createEmptySet(&empty);
createEmptySet(&universal);
for (i = 0; i < maximum_set_size; i += 1) {
insertSet(&universal, i);
}
createEmptySet(&s);
createEmptySet(&t);
createEmptySet(&u);
createEmptySet(&v);
createEmptySet(&w);
for (i = 0; i < number_of_tests; i += 1) {
randomSet(&u);
randomSet(&v);
randomSet(&w);
/* u + v == v + u */
assignSet(&s, &u);
unionInSet(&s, &v);
assignSet(&t, &v);
unionInSet(&t, &u);
assert(isEqualToSet(&s, &t));
/* u + (v + w) == (u + v) + w */
assignSet(&t, &v);
unionInSet(&t, &w);
assignSet(&s, &u);
unionInSet(&s, &t);
assignSet(&t, &u);
unionInSet(&t, &v);
unionInSet(&t, &w);
assert(isEqualToSet(&s, &t));
/* u * v == v * u */
assignSet(&s, &u);
intersectFromSet(&s, &v);
assignSet(&t, &v);
intersectFromSet(&t, &u);
assert(isEqualToSet(&s, &t));
/* u * (v * w) == (u * v) * w */
assignSet(&t, &v);
intersectFromSet(&t, &w);
assignSet(&s, &u);
intersectFromSet(&s, &t);
assignSet(&t, &u);
intersectFromSet(&t, &v);
intersectFromSet(&t, &w);
assert(isEqualToSet(&s, &t));
/* u - v == u - (u * v) */
assignSet(&s, &u);
intersectFromSet(&s, &v);
assignSet(&t, &u);
subtractFromSet(&t, &s);
assignSet(&s, &u);
subtractFromSet(&s, &v);
assert(isEqualToSet(&s, &t));
/* additional tests, not implemented
assert(w * (u - v) == w * u - w * v);
assert(u * (v + w) == (u * v) + (u * w));
assert(universal - (u * v) == (universal - u) + (universal - v));
assert(universal - (u + v) == (universal - u) * (universal - v));
*/
}
printf("The algebraic tests have been passed\n");
destroySet(&empty);
destroySet(&universal);
destroySet(&s);
destroySet(&t);
destroySet(&u);
destroySet(&v);
destroySet(&w);
}
