char *add_existing_tests()
{
tree *first = NULL;
int data[MAX_ELEMENT];
unsigned int result;
unsigned int element_in_tree = 0;
int i = 0;
unsigned long rand_seed = (unsigned long) time(NULL);
ILOG("Random seed: %lu", rand_seed);
srand(rand_seed);
for (i = 0; i < MAX_ELEMENT; i++) {
data[i] = rand();
}
// Try to allocate a new tree.
first = init_dictionnary(data_cmp, data_print, data_delete, NULL);
if (first == NULL) {
ELOG("Init dictionnary error");
return "Init dictionnary error";
}
verif_tree(first);
for (i = 0; i < MAX_ELEMENT; i++) {
if (!is_present(first, &(data[i]))) {
element_in_tree++;
}
result = insert_elmt(first, &(data[i]), sizeof(int));
if (result != element_in_tree) {
ELOG("Wrong result of inserted element");
return "Wrong result of inserted element";
}
verif_tree(first);
}
// Try to add existing data
for (i = 0; i < MAX_ELEMENT; i++) {
if (!is_present(first, &(data[i]))) {
ELOG("Element is not present, it said! F**k");
return "Element is not present";
}
result = insert_elmt(first, &(data[i]), sizeof(int));
if (result != element_in_tree) {
ELOG("Wrong result of inserted element");
return "Wrong result of inserted element";
}
verif_tree(first);
}
// Try to delete it
delete_tree(first);
return NULL;
}
char *alloc_tests()
{
tree *first = NULL;
// Try to allocate a new tree.
first = init_dictionnary(data_cmp, data_print, data_delete, NULL);
if (first == NULL) {
ELOG("Init dictionnary error");
return "Init dictionnary error";
}
if (sizeof(*first) != sizeof(tree)) {
ELOG("Wrong returned size");
return "Wrong returned size";
}
// Try to delete it
delete_tree(first);
// Try to delete a null tree
delete_tree(NULL);
return NULL;
}
char *get_data_tests()
{
tree *first = NULL;
struct _tree_data data[MAX_ELEMENT];
struct _tree_data tmp_elmnt;
struct _tree_data current_min;
unsigned int result;
unsigned int element_in_tree = 0;
int i = 0;
int j = 0;
unsigned long rand_seed = (unsigned long) time(NULL);
ILOG("Random seed: %lu", rand_seed);
srand(rand_seed);
for (i = 0; i < MAX_ELEMENT; i++) {
data[i].key = rand();
data[i].value = rand();
}
verif_tree(first);
// Try to allocate a new tree.
first = init_dictionnary(data_cmp, data_print, data_delete, NULL);
if (first == NULL) {
ELOG("Init dictionnary error");
return "Init dictionnary error";
}
// Add data
verif_tree(first);
for (i = 0; i < MAX_ELEMENT; i++) {
tmp_elmnt.key = data[i].key;
if (!is_present(first, &(tmp_elmnt))) {
element_in_tree++;
}
result = insert_elmt(first, &(data[i]), sizeof(struct _tree_data));
if (result != element_in_tree) {
ELOG("Wrong result of inserted element");
return "Wrong result of inserted element";
}
verif_tree(first);
}
current_min.key = (int) 0x80000000;
current_min.value = (int) 0x80000000;
for (i = 0; i < MAX_ELEMENT && element_in_tree != 0; i++) {
tmp_elmnt.key = (int) 0x7fffffff;
tmp_elmnt.value = (int) 0x7fffffff;
// Get minimum data
for (j = 0; j < MAX_ELEMENT; j++) {
if ( data[j].key < tmp_elmnt.key
&& data[j].key > current_min.key) {
tmp_elmnt.key = data[j].key;
tmp_elmnt.value = data[j].value;
}
}
current_min.key = tmp_elmnt.key;
current_min.value = tmp_elmnt.value;
if (!is_present(first, &tmp_elmnt)) {
ELOG("Minimum data not in tree");
return "Minimum data not in tree";
}
delete_node_min(first);
if (is_present(first, &tmp_elmnt)) {
ELOG("Minimum element deleted");
return "Minimum element deleted";
}
element_in_tree--;
verif_tree(first);
}
// Try to delete it
delete_tree(first);
return NULL;
}
char *explore_tests()
{
tree *first = NULL;
struct _tree_data data[MAX_ELEMENT];
struct _tree_data tmp_elmnt;
unsigned int result;
unsigned int element_in_tree = 0;
int i = 0;
unsigned int r = 0;
unsigned long rand_seed = (unsigned long) time(NULL);
ILOG("Random seed: %lu", rand_seed);
srand(rand_seed);
for (i = 0; i < MAX_ELEMENT; i++) {
data[i].key = rand();
data[i].value = 1;
}
// explore tree on a NULL tree
explore_tree(first, count_treat, &r);
if (r != 0) {
ELOG("Wrong result on NULL tree");
return "Wrong result on NULL tree";
}
// Try to allocate a new tree.
first = init_dictionnary(data_cmp, data_print, data_delete, data_copy);
if (first == NULL) {
ELOG("Init dictionnary error");
return "Init dictionnary error";
}
// explore tree on an empty tree
explore_tree(first, count_treat, &r);
if (r != 0) {
ELOG("Wrong result on empty tree");
return "Wrong result on empty tree";
}
// Add data
verif_tree(first);
for (i = 0; i < MAX_ELEMENT; i++) {
tmp_elmnt.key = data[i].key;
if (!is_present(first, &(tmp_elmnt))) {
element_in_tree++;
}
result = insert_elmt(first, &(data[i]), sizeof(struct _tree_data));
if (result != element_in_tree) {
ELOG("Wrong result of inserted element");
return "Wrong result of inserted element";
}
verif_tree(first);
}
explore_tree(first, count_treat, &r);
if (r != element_in_tree) {
ELOG("Wrong result on empty tree: %d != %d", r, element_in_tree);
return "Wrong result on empty tree";
}
// Try to delete it
delete_tree(first);
return NULL;
}
char *struct_tests()
{
tree *first = NULL;
struct _tree_data data[MAX_ELEMENT];
struct _tree_data look_for_data;
unsigned int result;
int bool_result;
unsigned int element_in_tree = 0;
int i = 0;
unsigned long rand_seed = (unsigned long) time(NULL);
ILOG("Random seed: %lu", rand_seed);
srand(rand_seed);
for (i = 0; i < MAX_ELEMENT; i++) {
data[i].key = rand();
data[i].value = rand();
}
verif_tree(first);
// Get data on non existing tree
for (i = MAX_ELEMENT - 1; i >= 0; i--) {
look_for_data.key = data[i].key;
bool_result = get_data(first, &(look_for_data), sizeof(struct _tree_data));
if (bool_result) {
ELOG("Data found");
return "Data found";
}
}
// Try to allocate a new tree.
first = init_dictionnary(data_cmp, data_print, data_delete, NULL);
if (first == NULL) {
ELOG("Init dictionnary error");
return "Init dictionnary error";
}
// Get data on empty tree
for (i = MAX_ELEMENT - 1; i >= 0; i--) {
look_for_data.key = data[i].key;
bool_result = get_data(first, &(look_for_data), sizeof(struct _tree_data));
if (bool_result) {
ELOG("Data found");
return "Data found";
}
}
// Add data
verif_tree(first);
for (i = 0; i < MAX_ELEMENT; i++) {
look_for_data.key = data[i].key;
if (!is_present(first, &(look_for_data))) {
element_in_tree++;
}
result = insert_elmt(first, &(data[i]), sizeof(struct _tree_data));
if (result != element_in_tree) {
ELOG("Wrong result of inserted element");
return "Wrong result of inserted element";
}
verif_tree(first);
}
// Get data
for (i = MAX_ELEMENT - 1; i >= 0; i--) {
look_for_data.key = data[i].key;
bool_result = get_data(first, &(look_for_data), sizeof(struct _tree_data));
if (!bool_result) {
ELOG("Data not found");
return "Data not found";
}
if ( look_for_data.key != data[i].key
&& look_for_data.value != data[i].value) {
ELOG("Not the good data retrieve.");
return "Not the good data retrieve.";
}
verif_tree(first);
}
// Try to delete it
delete_tree(first);
return NULL;
}
tree* initialize_signal_avl()
{
tree *signal_tree = NULL;
signal_tree = init_dictionnary(data_cmp_sig, data_print_sig, data_delete_sig, data_copy_sig);
return signal_tree;
}
