void test_rf_set_equal() {
char a[] = "a";
char b[] = "b";
char c[] = "c";
rf_SetElement *elems1[] = {
rf_set_element_new_string(a),
rf_set_element_new_string(b),
rf_set_element_new_string(c),
};
rf_Set *set1 = rf_set_new(3, elems1);
rf_SetElement *elems2[] = {
rf_set_element_new_string(c),
rf_set_element_new_string(b),
rf_set_element_new_string(a),
};
rf_Set *set2 = rf_set_new(3, elems2);
rf_SetElement *elems3[] = {
rf_set_element_new_string(a),
rf_set_element_new_string(b),
};
rf_Set *set3 = rf_set_new(2, elems3);
CU_ASSERT_TRUE(rf_set_equal(set1, set1)) //stupid case
CU_ASSERT_TRUE(rf_set_equal(set1, set2)) //tricky case, same set with switched order
CU_ASSERT_FALSE(rf_set_equal(set1, set3)) //false case
rf_set_free(set1);
rf_set_free(set2);
rf_set_free(set3);
}
void test_rf_set_new_intersection() {
char *a = "a";
char *b = "b";
char *c = "c";
rf_SetElement *elems1[3] = {
rf_set_element_new_string(a),
rf_set_element_new_string(b),
rf_set_element_new_string(c),
};
rf_SetElement *elems2[2] = {
rf_set_element_new_string(b),
rf_set_element_new_string(c),
};
rf_Set *set1 = rf_set_new(3, elems1);
rf_Set *set2 = rf_set_new(2, elems2);
rf_Set *result = rf_set_new_intersection(set1, set2);
CU_ASSERT_EQUAL(result->cardinality, 2);
CU_ASSERT_TRUE(rf_set_contains_element(result, elems2[0]));
CU_ASSERT_TRUE(rf_set_contains_element(result, elems2[1]));
rf_set_free(set1);
rf_set_free(set2);
rf_set_free(result);
}
void test_rf_set_is_subset() {
rf_Set *emptyset = rf_set_new(0, NULL);
rf_SetElement *elems1[] = {
rf_set_element_new_string("a"),
rf_set_element_new_string("b"),
rf_set_element_new_string("c"),
};
rf_SetElement *elems2[] = {
rf_set_element_new_string("a"),
rf_set_element_new_string("b"),
rf_set_element_new_string("c"),
};
rf_Set *set1 = rf_set_new(3, elems1);
rf_Set *set2 = rf_set_new(3, elems2);
CU_ASSERT_TRUE(rf_set_is_subset(emptyset, set1));
CU_ASSERT_TRUE(rf_set_is_subset(set1, set1));
CU_ASSERT_TRUE(rf_set_is_subset(set1, set2)); //sollte mMn gehen. //kann noch perversiert werden mit untersch. Sortierung.
rf_SetElement *elems3[] = {
rf_set_element_new_string("a"),
rf_set_element_new_string("d"),
};
rf_Set *set3 = rf_set_new(2, elems3);
CU_ASSERT_FALSE(rf_set_is_subset(set1, set3));
rf_set_free(emptyset);
rf_set_free(set1);
rf_set_free(set2);
rf_set_free(set3);
}
static
Value *
_set(const Ast *expr) {
Value *rval = value_new();
int n = 0;
for(Ast *c = expr->child; c != NULL; c = c->next)
n++;
int eidx = -1;
rf_SetElement *elems[n];
for(Ast *c = expr->child; c != NULL; c = c->next) {
Value *v;
switch(c->class) {
case N_STRING:
elems[++eidx] = rf_set_element_new_string(c->value);
break;
case N_SET:
v = _set(c);
elems[++eidx] = rf_set_element_new_set(v->as_Set);
value_free(v);
break;
}
}
value_set_set(rval, rf_set_new(n, elems));
return rval;
}
void test_rf_set_get_element_index() {
char a[] = "a";
char b[] = "b";
char c[] = "c";
char d[] = "d";
char a2[] = "a";
rf_SetElement *elems[] = {
rf_set_element_new_string(a),
rf_set_element_new_string(b),
rf_set_element_new_string(c),
};
rf_Set *set1 = rf_set_new(3, elems);
rf_SetElement *test1 = rf_set_element_new_string(d);
rf_SetElement *test2 = rf_set_element_new_string(a2);
for(int i = 0; i < 3; i++) {
CU_ASSERT_EQUAL(rf_set_get_element_index(set1, elems[i]), i);
}
CU_ASSERT_EQUAL(rf_set_get_element_index(set1, test1), -1);
CU_ASSERT_EQUAL(rf_set_get_element_index(set1, test2), 0);
rf_set_free(set1);
rf_set_element_free(test1);
rf_set_element_free(test2);
}
void test_rf_set_contains_element() {
rf_Set *emptyset = rf_set_new(0, NULL);
rf_SetElement *elem_x = rf_set_element_new_string("x");
CU_ASSERT_FALSE(rf_set_contains_element(emptyset, elem_x));
rf_SetElement *elems1[] = {
rf_set_element_new_string("a"),
rf_set_element_new_string("b"),
rf_set_element_new_string("c"),
};
rf_Set *set1 = rf_set_new(3, elems1);
for(int i = 0; i < 3; i++) {
CU_ASSERT_TRUE(rf_set_contains_element(set1, elems1[i]));
}
CU_ASSERT_FALSE(rf_set_contains_element(set1, elem_x));
rf_set_free(emptyset);
rf_set_free(set1);
rf_set_element_free(elem_x);
}
void test_rf_set_element_new_set() {
rf_SetElement *elems[3];
elems[0] = rf_set_element_new_string("a");
elems[1] = rf_set_element_new_string("b");
elems[2] = rf_set_element_new_string("c");
rf_Set *subset = rf_set_new(3, elems);
rf_SetElement *set_elem = rf_set_element_new_set(subset);
// CU_ASSERT_EQUAL(set_elem->type, RF_SET_ELEMENT_TYPE_SET);
// CU_ASSERT_TRUE(rf_set_equal(subset, set_elem->value.set));
rf_set_free(subset);
rf_set_element_free(set_elem);
}
void test_rf_set_clone() {
char a[] = "a";
char b[] = "b";
char c[] = "c";
rf_SetElement *elems1[] = {
rf_set_element_new_string(a),
rf_set_element_new_string(b),
rf_set_element_new_string(c),
};
rf_Set *set1 = rf_set_new(3, elems1);
rf_Set *result = rf_set_clone(set1);
CU_ASSERT_PTR_NOT_EQUAL(set1, result);
for(int i = 0; i < result->cardinality; i++) {
CU_ASSERT_PTR_NOT_EQUAL(set1->elements[i], result->elements[i]);
CU_ASSERT_EQUAL(*set1->elements[i]->value.string, *result->elements[i]->value.string);
}
rf_set_free(set1);
rf_set_free(result);
}
void test_rf_set_element_clone() {
//case, element is a char
rf_SetElement *src1 = rf_set_element_new_string("a");
rf_SetElement *dst1 = rf_set_element_clone(src1);
CU_ASSERT_PTR_NOT_EQUAL(dst1, src1);
CU_ASSERT_STRING_EQUAL(dst1->value.string, src1->value.string);
//case element is a subset
rf_SetElement *elems[] = {
rf_set_element_new_string("a"),
rf_set_element_new_string("b"),
rf_set_element_new_string("c"),
};
rf_Set *subset = rf_set_new(3, elems);
rf_SetElement *src2 = rf_set_element_new_set(subset);
rf_SetElement *dst2 = rf_set_element_clone(src2);
//Must not work on same elements by copying pointers
CU_ASSERT_PTR_NOT_EQUAL(src2->value.set, subset);
CU_ASSERT_PTR_NOT_EQUAL(dst2->value.set, subset);
CU_ASSERT_PTR_NOT_EQUAL(dst2, src2);
CU_ASSERT_TRUE(rf_set_element_equal(dst2, src2));
CU_ASSERT_STRING_EQUAL(dst2->value.set->elements[0]->value.string, src2->value.set->elements[0]->value.string);
CU_ASSERT_STRING_EQUAL(dst2->value.set->elements[1]->value.string, src2->value.set->elements[1]->value.string);
CU_ASSERT_STRING_EQUAL(dst2->value.set->elements[2]->value.string, src2->value.set->elements[2]->value.string);
rf_set_element_free(src1);
rf_set_element_free(dst1);
rf_set_free(subset);
rf_set_element_free(src2);
rf_set_element_free(dst2);
}
void test_rf_set_new() {
char a[] = "a";
char b[] = "b";
char c[] = "c";
rf_SetElement *elems[] = {
rf_set_element_new_string(a),
rf_set_element_new_string(b),
rf_set_element_new_string(c),
};
rf_Set *subset = rf_set_new(3, elems);
CU_ASSERT_STRING_EQUAL(subset->elements[0]->value.string, a);
CU_ASSERT_STRING_EQUAL(subset->elements[1]->value.string, b);
CU_ASSERT_STRING_EQUAL(subset->elements[2]->value.string, c);
//check for double elements
//uncommented cause assert fails here
//elems[2] = elems[0];
//subset = rf_set_new(3, elems);
rf_set_free(subset);
}
void test_rf_set_new_powerset() {
CU_FAIL_FATAL("not implemented");
char a[] = "a";
char b[] = "b";
char c[] = "c";
char *results[] = {
" ",
" ",
" ",
" ",
" ",
" ",
" ",
'\0'
};
char *expected[] = {
"a", "b", "c", "ab", "ac", "bc", "abc", '\0'
};
rf_SetElement *elems[] = {
rf_set_element_new_string(a),
rf_set_element_new_string(b),
rf_set_element_new_string(c),
};
rf_Set *set1 = rf_set_new(3, elems);
CU_ASSERT_TRUE(set1 != NULL);
rf_Set *powerset = rf_set_new_powerset(set1);
CU_ASSERT_EQUAL(powerset->cardinality, 8);
/*
for(int i = 0; i < 8; i++) {
for(int j = 0; j < 3; j++) {
results[i][j] = 0;
}
}
*/
for(int i = 0; i < powerset->cardinality; i++) {
rf_SetElement *tmp1 = powerset->elements[i];
for(int j = 0; j < tmp1->value.set->cardinality; j++) {
rf_SetElement *tmp2 = tmp1->value.set->elements[j];
if(tmp2 != NULL) {
results[i][j] = *tmp2->value.string;
}
}
// printf("### ^%s$\n", results[i]);
}
for(int i = 0; i < 8; i++) {
bool contains = false;
for(int j = 0; j < 3; j++) {
if(strcmp(results[i], expected[j]) == 0) {
printf("[%s|%s]\n", results[i], expected[i]);
contains = true;
}
}
CU_ASSERT_TRUE(contains);
}
rf_set_free(set1);
rf_set_free(powerset);
}
