Huge refactoring

main.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "Directory.h"
+#include "DirectoryRecord.h"
+
+void clear_buffer() {
+    int c;
+    while ((c = getchar()) != '\n' && c != EOF) {
+    }
+}
+
+void append_record(Directory *directory) {
+    char phone_number[PHONE_NUMBER_MAXLEN];
+    printf("Enter the phone number: ");
+    scanf("%10s", phone_number);
+    clear_buffer();
+
+    char name[NAME_MAXLEN];
+    printf("Enter the name: ");
+    scanf("%20s", name);
+    clear_buffer();
+
+    char surname[SURNAME_MAXLEN];
+    printf("Enter the surname: ");
+    scanf("%20s", surname);
+    clear_buffer();
+
+    int birth_date_year, birth_date_month, birth_date_day;
+    do {
+        printf("Enter the birth date (Y-m-d): ");
+    } while (scanf("%d-%d-%d", &birth_date_year, &birth_date_month, &birth_date_day) != 3);
+
+    clear_buffer();
+    printf("\nIs the information entered correct? (Y/n) ");
+
+    char choice = getchar();
+    if (choice != '\n') {
+        getchar();
+    }
+
+    if (choice == 'n') {
+        printf("\n===>The procedure has been cancelled.\n");
+    } else {
+        DirectoryRecord *record = DirectoryRecord_init(false, phone_number, name, surname, birth_date_year, birth_date_month, birth_date_day);
+
+        if (Directory_append(directory, record)) {
+            printf("\n===>The record has been saved in the directory.\n");
+        } else {
+            printf("\n===>This phone number is already associated with a record. The record has not been saved.\n");
+        }
+
+        DirectoryRecord_destroy(&record);
+    }
+}
+
+void search_record(Directory *directory) {
+    printf("Enter the phone number that corresponds to the record you are looking for: ");
+    char phone_number[PHONE_NUMBER_MAXLEN];
+    scanf("%10s", phone_number);
+    clear_buffer();
+    DirectoryRecord *record = Directory_search(directory, phone_number);
+    printf("\n");
+
+    if (record == NULL) {
+        printf("===>No records were found for this phone number.\n");
+    } else {
+        printf("========================\n");
+        DirectoryRecord_print(record);
+        DirectoryRecord_destroy(&record);
+        printf("========================\n");
+    }
+}
+
+void delete_record(Directory *directory) {
+    printf("Enter the phone number that corresponds to the record you wish to delete: ");
+
+    char phone_number[PHONE_NUMBER_MAXLEN];
+    scanf("%10s", phone_number);
+    clear_buffer();
+    DirectoryRecord *record = Directory_search(directory, phone_number);
+    printf("\n");
+
+    if (record == NULL) {
+        printf("===>No records were found for this phone number.\n");
+    } else {
+        printf("========================\n");
+        DirectoryRecord_print(record);
+        DirectoryRecord_destroy(&record);
+        printf("========================\n");
+
+        printf("\nAre you sure you want to delete this record? (Y/n) ");
+
+        char choice = getchar();
+        if (choice != '\n') {
+            getchar();
+        }
+
+        if (choice == 'n') {
+            printf("\n===>The procedure has been cancelled.\n");
+        } else {
+            Directory_delete(directory, phone_number);
+            printf("Delete done\n");
+        }
+    }
+}
+
+int main() {
+    Directory *directory = Directory_init("directory_database");
+
+    while (true) {
+        BPTree_print(directory->index, 0);
+
+        printf("Enter 1 to add a member.\n");
+        printf("Enter 2 to search for a member via their phone number.\n");
+        printf("Enter 3 to delete a member.\n");
+        printf("Enter 4 to display all members.\n");
+        printf("Enter 5 to exit the program.\n");
+        printf("What do you want to do? ");
+        int action;
+        scanf("%d", &action);
+        clear_buffer();
+
+        if (action < 1 || action > 5) {
+            system("clear");
+            continue;
+        }
+
+        if (action == 5) {
+            break;
+        }
+
+        printf("\n");
+
+        switch (action) {
+            case 1:
+                append_record(directory);
+                break;
+            case 2:
+                search_record(directory);
+                break;
+            case 3:
+                delete_record(directory);
+                break;
+            case 4:
+                Directory_print(directory);
+                break;
+        }
+
+        printf("\nPress enter to continue...");
+        getchar();
+        system("clear");
+    }
+
+    Directory_destroy(&directory);
+    return EXIT_SUCCESS;
+}

src/BPTree.c

@@ -7,34 +7,19 @@
 
 #include "Array.h"
 
-static bool has_maximum_keys(BPTreeNode *node);
-static BPTreeNode *find_leaf(BPTreeNode *root, uint64_t key, BPTreeNodeArray **parents);
-
-static bool has_maximum_keys(BPTreeNode *node) {
-    return node->keys->size == 2 * node->order;
-}
-
-static BPTreeNode *find_leaf(BPTreeNode *root, uint64_t key, BPTreeNodeArray **parents) {
-    BPTreeNode *current = root;
-    // CAUTION : 10 is not enough.
-    *parents = BPTreeNodeArray_init(10);
-
-    while (!current->is_leaf) {
-        BPTreeNodeArray_append(*parents, current);
-        int child_index = lower_bound(current->keys, key);
-
-        if (child_index < current->keys->size && current->keys->items[child_index] == key) {
-            child_index += 1;
-        }
-
-        current = current->children->items[child_index];
-    }
+// BPTreeNode
 
-    return current;
+static BPTreeNode *BPTreeNode_init(int order, bool is_leaf) {
+    BPTreeNode *root = (BPTreeNode *)malloc(sizeof(BPTreeNode));
+    root->order = order;
+    root->is_leaf = is_leaf;
+    root->keys = IntegerArray_init(2 * root->order);
+    root->data = IntegerArray_init(2 * root->order);
+    root->children = BPTreeNodeArray_init(2 * root->order + 1);
+    root->next = NULL;
+    return root;
 }
 
-// BPTreeNode
-
 static void BPTreeNode_destroy(BPTreeNode **node) {
     IntegerArray_destroy(&(*node)->keys);
     IntegerArray_destroy(&(*node)->data);
@@ -46,14 +31,7 @@ static void BPTreeNode_destroy(BPTreeNode **node) {
 // BPTree
 
 BPTreeNode *BPTree_init(int order) {
-    BPTreeNode *root = (BPTreeNode *)malloc(sizeof(BPTreeNode));
-    root->order = order;
-    root->is_leaf = true;
-    root->keys = IntegerArray_init(2 * root->order);
-    root->data = IntegerArray_init(2 * root->order);
-    root->children = BPTreeNodeArray_init(2 * root->order + 1);
-    root->next = NULL;
-    return root;
+    return BPTreeNode_init(order, true);
 }
 
 void BPTree_destroy(BPTreeNode **root) {
@@ -102,6 +80,18 @@ bool BPTree_search(BPTreeNode *root, uint64_t key, uint64_t *data) {
     return BPTree_search(root->children->items[child_index], key, data);
 }
 
+// "traverse" function for insertion and deletion.
+
+static BPTreeNode *traverse(BPTreeNode *node, uint64_t key) {
+    int virtual_insertion_index = lower_bound(node->keys, key);
+
+    if (virtual_insertion_index < node->keys->size && node->keys->items[virtual_insertion_index] == key) {
+        virtual_insertion_index += 1;
+    }
+
+    return node->children->items[virtual_insertion_index];
+}
+
 // BPTree : Insertion
 
 static void insert_non_full(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode *previous_split_right_node) {
@@ -119,47 +109,47 @@ static void insert_non_full(BPTreeNode *node, uint64_t key, uint64_t data, BPTre
 static void redistribute_keys(BPTreeNode *left_node, BPTreeNode *right_node, int left_index, int right_index) {
     for (int i = right_index; i < left_node->keys->size; i++) {
         IntegerArray_append(right_node->keys, left_node->keys->items[i]);
-
-        if (left_node->is_leaf) {
-            IntegerArray_append(right_node->data, left_node->data->items[i]);
-        }
     }
 
     left_node->keys->size = left_index;
 
-    if (left_node->is_leaf) {
+    for (int i = right_index; i < left_node->data->size; i++) {
+        IntegerArray_append(right_node->data, left_node->data->items[i]);
+    }
+
+    if (left_node->data->size > 0) {
         left_node->data->size = left_index;
     }
 }
 
-static uint64_t split_leaf(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode **right_node) {
+static uint64_t split_leaf(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode **split_right_node) {
     int virtual_insertion_index = lower_bound(node->keys, key);
     int median_index = node->keys->size / 2;
     uint64_t median_value;
-    *right_node = BPTree_init(node->order);
+    *split_right_node = BPTreeNode_init(node->order, true);
 
     if (virtual_insertion_index < median_index) {
         median_value = node->keys->items[median_index - 1];
-        redistribute_keys(node, *right_node, median_index - 1, median_index - 1);
+        redistribute_keys(node, *split_right_node, median_index - 1, median_index - 1);
         int insertion_index = IntegerArray_insert_sorted(node->keys, key);
         IntegerArray_insert_at_index(node->data, insertion_index, data);
     } else if (virtual_insertion_index > median_index) {
         median_value = node->keys->items[median_index];
-        redistribute_keys(node, *right_node, median_index, median_index);
-        int insertion_index = IntegerArray_insert_sorted((*right_node)->keys, key);
-        IntegerArray_insert_at_index((*right_node)->data, insertion_index, data);
+        redistribute_keys(node, *split_right_node, median_index, median_index);
+        int insertion_index = IntegerArray_insert_sorted((*split_right_node)->keys, key);
+        IntegerArray_insert_at_index((*split_right_node)->data, insertion_index, data);
     } else {
         median_value = key;
-        redistribute_keys(node, *right_node, median_index, median_index);
-        int insertion_index = IntegerArray_insert_sorted((*right_node)->keys, key);
-        IntegerArray_insert_at_index((*right_node)->data, insertion_index, data);
+        redistribute_keys(node, *split_right_node, median_index, median_index);
+        int insertion_index = IntegerArray_insert_sorted((*split_right_node)->keys, key);
+        IntegerArray_insert_at_index((*split_right_node)->data, insertion_index, data);
     }
 
     if (node->next != NULL) {
-        (*right_node)->next = node->next;
+        (*split_right_node)->next = node->next;
     }
 
-    node->next = *right_node;
+    node->next = *split_right_node;
     return median_value;
 }
 
@@ -171,108 +161,98 @@ static void redistribute_children(BPTreeNode *left_node, BPTreeNode *right_node,
     left_node->children->size = left_index;
 }
 
-static uint64_t split_internal(BPTreeNode *node, uint64_t key, BPTreeNode *right_child_node, BPTreeNode **right_node) {
+static uint64_t split_internal(BPTreeNode *node, uint64_t key, BPTreeNode *previous_split_right_node, BPTreeNode **split_right_node) {
     int virtual_insertion_index = lower_bound(node->keys, key);
     int median_index = node->keys->size / 2;
     uint64_t median_value;
-    *right_node = BPTree_init(node->order);
-    (*right_node)->is_leaf = false;
+    *split_right_node = BPTreeNode_init(node->order, false);
 
     if (virtual_insertion_index < median_index) {
         median_value = node->keys->items[median_index - 1];
-        redistribute_keys(node, *right_node, median_index - 1, median_index);
-        redistribute_children(node, *right_node, median_index, median_index);
+        redistribute_keys(node, *split_right_node, median_index - 1, median_index);
+        redistribute_children(node, *split_right_node, median_index, median_index);
         int insertion_index = IntegerArray_insert_sorted(node->keys, key);
-        BPTreeNodeArray_insert_at_index(node->children, insertion_index + 1, right_child_node);
+        BPTreeNodeArray_insert_at_index(node->children, insertion_index + 1, previous_split_right_node);
     } else if (virtual_insertion_index > median_index) {
         median_value = node->keys->items[median_index];
-        redistribute_keys(node, *right_node, median_index, median_index + 1);
-        redistribute_children(node, *right_node, median_index + 1, median_index + 1);
-        int insertion_index = IntegerArray_insert_sorted((*right_node)->keys, key);
-        BPTreeNodeArray_insert_at_index((*right_node)->children, insertion_index + 1, right_child_node);
+        redistribute_keys(node, *split_right_node, median_index, median_index + 1);
+        redistribute_children(node, *split_right_node, median_index + 1, median_index + 1);
+        int insertion_index = IntegerArray_insert_sorted((*split_right_node)->keys, key);
+        BPTreeNodeArray_insert_at_index((*split_right_node)->children, insertion_index + 1, previous_split_right_node);
     } else {
         median_value = key;
-        redistribute_keys(node, *right_node, median_index, median_index);
-        redistribute_children(node, *right_node, median_index + 1, median_index + 1);
-        BPTreeNodeArray_insert_at_index((*right_node)->children, 0, right_child_node);
+        redistribute_keys(node, *split_right_node, median_index, median_index);
+        redistribute_children(node, *split_right_node, median_index + 1, median_index + 1);
+        BPTreeNodeArray_insert_at_index((*split_right_node)->children, 0, previous_split_right_node);
     }
 
     return median_value;
 }
 
+static uint64_t insert_full(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode *previous_split_right_node, BPTreeNode **split_right_node) {
+    if (node->is_leaf) {
+        return split_leaf(node, key, data, split_right_node);
+    }
+
+    return split_internal(node, key, previous_split_right_node, split_right_node);
+}
+
 static void grow(BPTreeNode *root, uint64_t median_value, BPTreeNode *split_right_node) {
-    BPTreeNode *left_node = BPTree_init(root->order);
-    left_node->is_leaf = split_right_node->is_leaf;
+    BPTreeNode *left_node = BPTreeNode_init(root->order, split_right_node->is_leaf);
     root->is_leaf = false;
 
     IntegerArray_copy(root->keys, left_node->keys);
-    IntegerArray_clear(root->keys);
-    IntegerArray_append(root->keys, median_value);
-
     IntegerArray_copy(root->data, left_node->data);
-    IntegerArray_clear(root->data);
-
     BPTreeNodeArray_copy(root->children, left_node->children);
+
+    IntegerArray_clear(root->keys);
+    IntegerArray_clear(root->data);
     BPTreeNodeArray_clear(root->children);
+
+    IntegerArray_append(root->keys, median_value);
     BPTreeNodeArray_append(root->children, left_node);
     BPTreeNodeArray_append(root->children, split_right_node);
 }
 
-static void insert_full(BPTreeNode *root, BPTreeNodeArray *parents, BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode *previous_split_right_node) {
-    uint64_t median_value;
-    BPTreeNode *split_right_node;
+static bool _BPTree_insert(BPTreeNode *parent, BPTreeNode *root, uint64_t *key, uint64_t data, BPTreeNode **split_right_node) {
+    BPTreeNode *previous_split_right_node = NULL;
+    if (!root->is_leaf && !_BPTree_insert(root, traverse(root, *key), key, data, &previous_split_right_node)) {
+        return false;
+    }
 
-    if (node->is_leaf) {
-        median_value = split_leaf(node, key, data, &split_right_node);
-    } else {
-        median_value = split_internal(node, key, previous_split_right_node, &split_right_node);
+    int index;
+    bool is_found = IntegerArray_binary_search(root->keys, *key, &index);
+    if (root->is_leaf && is_found) {
+        return false;
     }
 
-    if (node == root) {
-        grow(root, median_value, split_right_node);
-    } else {
-        BPTreeNode *parent = BPTreeNodeArray_pop(parents);
+    if (!root->is_leaf && previous_split_right_node == NULL) {
+        *split_right_node = NULL;
+        return true;
+    }
 
-        if (has_maximum_keys(parent)) {
-            // 0 is passed instead of data because the recursion is necessarily done on an internal node.
-            insert_full(root, parents, parent, median_value, 0, split_right_node);
-        } else {
-            insert_non_full(parent, median_value, data, split_right_node);
-        }
+    if (root->keys->size < 2 * root->order) {
+        insert_non_full(root, *key, data, previous_split_right_node);
+        *split_right_node = NULL;
+        return true;
     }
-}
 
-void BPTree_insert(BPTreeNode *root, uint64_t key, uint64_t data) {
-    BPTreeNodeArray *parents;
-    BPTreeNode *leaf = find_leaf(root, key, &parents);
+    *key = insert_full(root, *key, data, previous_split_right_node, split_right_node);
 
-    int index;
-    if (IntegerArray_binary_search(leaf->keys, key, &index)) {
-        BPTreeNodeArray_destroy(&parents);
-        return;
+    if (parent == NULL) {
+        grow(root, *key, *split_right_node);
     }
 
-    if (has_maximum_keys(leaf)) {
-        insert_full(root, parents, leaf, key, data, NULL);
-    } else {
-        insert_non_full(leaf, key, data, NULL);
-    }
+    return true;
+}
 
-    BPTreeNodeArray_destroy(&parents);
+bool BPTree_insert(BPTreeNode *root, uint64_t key, uint64_t data) {
+    BPTreeNode *previous_split_right_node;
+    return _BPTree_insert(NULL, root, &key, data, &previous_split_right_node);
 }
 
 // BPTree : Deletion
 
-static BPTreeNode *traverse(BPTreeNode *node, uint64_t key) {
-    int virtual_insertion_index = lower_bound(node->keys, key);
-
-    if (virtual_insertion_index < node->keys->size && node->keys->items[virtual_insertion_index] == key) {
-        virtual_insertion_index += 1;
-    }
-
-    return node->children->items[virtual_insertion_index];
-}
-
 static uint64_t find_smallest_key(BPTreeNode *root) {
     if (root->is_leaf) {
         return root->keys->items[0];
@@ -390,7 +370,7 @@ static void steal_internal(BPTreeNode *parent, BPTreeNode *node, BPTreeNode *sib
     }
 }
 
-static void deletion_rebalance(BPTreeNode *node, BPTreeNode *parent) {
+static void deletion_rebalance(BPTreeNode *parent, BPTreeNode *node) {
     BPTreeNode *sibling = find_sibling(parent, node);
 
     if (sibling->keys->size == sibling->order) {
@@ -406,8 +386,8 @@ static void deletion_rebalance(BPTreeNode *node, BPTreeNode *parent) {
     }
 }
 
-static bool _BPTree_delete(BPTreeNode *root, uint64_t key, BPTreeNode *parent) {
-    if (!root->is_leaf && !_BPTree_delete(traverse(root, key), key, root)) {
+static bool _BPTree_delete(BPTreeNode *parent, BPTreeNode *root, uint64_t key) {
+    if (!root->is_leaf && !_BPTree_delete(root, traverse(root, key), key)) {
         return false;
     }
 
@@ -429,12 +409,12 @@ static bool _BPTree_delete(BPTreeNode *root, uint64_t key, BPTreeNode *parent) {
     }
 
     if (parent != NULL && root->keys->size < root->order) {
-        deletion_rebalance(root, parent);
+        deletion_rebalance(parent, root);
     }
 
     return true;
 }
 
 bool BPTree_delete(BPTreeNode *root, uint64_t key) {
-    return _BPTree_delete(root, key, NULL);
+    return _BPTree_delete(NULL, root, key);
 }

src/BPTree.h

@@ -20,7 +20,7 @@ void BPTree_destroy(BPTreeNode **root);
 
 void BPTree_print(BPTreeNode *root, int depth);
 bool BPTree_search(BPTreeNode *root, uint64_t key, uint64_t *data);
-void BPTree_insert(BPTreeNode *root, uint64_t key, uint64_t data);
+bool BPTree_insert(BPTreeNode *root, uint64_t key, uint64_t data);
 bool BPTree_delete(BPTreeNode *root, uint64_t key);
 
 #endif

src/main.c

-#include <stdio.h>
+#include <assert.h>
 #include <stdlib.h>
 
-#include "Directory.h"
-#include "DirectoryRecord.h"
+#include "Array.h"
+#include "BPTree.h"
 
-void clear_buffer() {
-    int c;
-    while ((c = getchar()) != '\n' && c != EOF) {
-    }
-}
-
-void append_record(Directory *directory) {
-    char phone_number[PHONE_NUMBER_MAXLEN];
-    printf("Enter the phone number: ");
-    scanf("%10s", phone_number);
-    clear_buffer();
-
-    char name[NAME_MAXLEN];
-    printf("Enter the name: ");
-    scanf("%20s", name);
-    clear_buffer();
-
-    char surname[SURNAME_MAXLEN];
-    printf("Enter the surname: ");
-    scanf("%20s", surname);
-    clear_buffer();
-
-    int birth_date_year, birth_date_month, birth_date_day;
-    do {
-        printf("Enter the birth date (Y-m-d): ");
-    } while (scanf("%d-%d-%d", &birth_date_year, &birth_date_month, &birth_date_day) != 3);
-
-    clear_buffer();
-    printf("\nIs the information entered correct? (Y/n) ");
-
-    char choice = getchar();
-    if (choice != '\n') {
-        getchar();
-    }
-
-    if (choice == 'n') {
-        printf("\n===>The procedure has been cancelled.\n");
-    } else {
-        DirectoryRecord *record = DirectoryRecord_init(false, phone_number, name, surname, birth_date_year, birth_date_month, birth_date_day);
-
-        if (Directory_append(directory, record)) {
-            printf("\n===>The record has been saved in the directory.\n");
-        } else {
-            printf("\n===>This phone number is already associated with a record. The record has not been saved.\n");
-        }
-
-        DirectoryRecord_destroy(&record);
-    }
-}
-
-void search_record(Directory *directory) {
-    printf("Enter the phone number that corresponds to the record you are looking for: ");
-    char phone_number[PHONE_NUMBER_MAXLEN];
-    scanf("%10s", phone_number);
-    clear_buffer();
-    DirectoryRecord *record = Directory_search(directory, phone_number);
-    printf("\n");
+int main() {
+    BPTreeNode *root = BPTree_init(2);
 
-    if (record == NULL) {
-        printf("===>No records were found for this phone number.\n");
-    } else {
-        printf("========================\n");
-        DirectoryRecord_print(record);
-        DirectoryRecord_destroy(&record);
-        printf("========================\n");
+    uint64_t input[] = {8, 12, 11, 47, 22, 95, 86, 40, 33, 78, 28, 5, 75, 88, 21, 56, 82, 51, 93, 66, 48, 70, 57, 65, 35, 4, 60, 41, 49, 55, 68, 72, 23, 31, 30, 42, 18, 87, 24, 58};
+    IntegerArray *keys = IntegerArray_init(40);
+    for (int i = 0; i < 30; i++) {
+        IntegerArray_append(keys, input[i]);
     }
-}
-
-void delete_record(Directory *directory) {
-    printf("Enter the phone number that corresponds to the record you wish to delete: ");
-
-    char phone_number[PHONE_NUMBER_MAXLEN];
-    scanf("%10s", phone_number);
-    clear_buffer();
-    DirectoryRecord *record = Directory_search(directory, phone_number);
-    printf("\n");
 
-    if (record == NULL) {
-        printf("===>No records were found for this phone number.\n");
-    } else {
-        printf("========================\n");
-        DirectoryRecord_print(record);
-        DirectoryRecord_destroy(&record);
-        printf("========================\n");
+    IntegerArray_print(keys);
 
-        printf("\nAre you sure you want to delete this record? (Y/n) ");
-
-        char choice = getchar();
-        if (choice != '\n') {
-            getchar();
-        }
-
-        if (choice == 'n') {
-            printf("\n===>The procedure has been cancelled.\n");
-        } else {
-            Directory_delete(directory, phone_number);
-            printf("Delete done\n");
-        }
+    for (int i = 0; i < keys->size; i++) {
+        BPTree_insert(root, keys->items[i], keys->items[i] * 1000);
     }
-}
-
-int main() {
-    Directory *directory = Directory_init("directory_database");
-
-    while (true) {
-        BPTree_print(directory->index, 0);
-
-        printf("Enter 1 to add a member.\n");
-        printf("Enter 2 to search for a member via their phone number.\n");
-        printf("Enter 3 to delete a member.\n");
-        printf("Enter 4 to display all members.\n");
-        printf("Enter 5 to exit the program.\n");
-        printf("What do you want to do? ");
-        int action;
-        scanf("%d", &action);
-        clear_buffer();
-
-        if (action < 1 || action > 5) {
-            system("clear");
-            continue;
-        }
-
-        if (action == 5) {
-            break;
-        }
-
-        printf("\n");
 
-        switch (action) {
-            case 1:
-                append_record(directory);
-                break;
-            case 2:
-                search_record(directory);
-                break;
-            case 3:
-                delete_record(directory);
-                break;
-            case 4:
-                Directory_print(directory);
-                break;
-        }
+    for (int i = 0; i < keys->size; i++) {
+        uint64_t data;
+        bool found = BPTree_search(root, keys->items[i], &data);
 
-        printf("\nPress enter to continue...");
-        getchar();
-        system("clear");
+        assert(found == true);
+        assert(data == keys->items[i] * 1000);
     }
 
-    Directory_destroy(&directory);
+    BPTree_delete(root, 65);
+    BPTree_delete(root, 57);
+    BPTree_delete(root, 47);
+    BPTree_delete(root, 28);
+    BPTree_delete(root, 51);
+    BPTree_insert(root, 100, 100 * 1000);
+    BPTree_delete(root, 48);
+    BPTree_delete(root, 41);
+    BPTree_delete(root, 60);
+    BPTree_delete(root, 5);
+    BPTree_delete(root, 8);
+    BPTree_delete(root, 21);
+
+    BPTree_delete(root, 86);
+    BPTree_delete(root, 100);
+    BPTree_delete(root, 88);
+    BPTree_delete(root, 95);
+    BPTree_delete(root, 49);
+    BPTree_delete(root, 56);
+    BPTree_delete(root, 55);
+
+    BPTree_print(root, 0);
+
+    IntegerArray_destroy(&keys);
+    BPTree_destroy(&root);
     return EXIT_SUCCESS;
 }

src/tests/BPTreeTests.c

+/**
+ * @file BPTreeTests.c
+ * @author Florian Burgener (florian.burgener@etu.hesge.ch)
+ * @brief Unit tests of the BPTree data structure.
+ * @version 1.0
+ * @date 2022-06-07
+ */
 #include <stdbool.h>
 #include <stdint.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 #include "../Array.h"
@@ -10,18 +16,13 @@
 #define RANDOM_MIN 0
 #define RANDOM_MAX 1000
 
-BPTreeNode *tree;
-
-void setUp(void) {
+void setUp() {
 }
 
-void tearDown(void) {
-    if (tree != NULL) {
-        BPTree_destroy(&tree);
-    }
+void tearDown() {
 }
 
-// BEGIN : Compliance with B+ Tree rules
+// BEGIN : Functions that check that a B+ Tree is compliant with the rules
 
 static BPTreeNode *find_first_leaf(BPTreeNode *root) {
     if (root->is_leaf) {
@@ -218,7 +219,7 @@ static bool check_BPTree_compliance(BPTreeNode *root) {
     return is_compliant;
 }
 
-// END : BPTree Compliance
+// END : Functions that check that a B+ Tree is compliant with the rules
 
 /**
  * @brief Performs a linear search for an item in an array.
@@ -271,7 +272,7 @@ static uint64_t transform_key_to_data(uint64_t key) {
 
 // **** BEGIN : test_BPTree_insert
 
-static void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(BPTreeNode **root, int order) {
+static void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(int order) {
     int size = 1;
 
     // Test 10 times, variable i being the seed.
@@ -282,16 +283,16 @@ static void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_g
         // will have the size of 1 then 2, 4, 8, 16, 32, ...
         for (int j = 0; j < 8; j++) {
             IntegerArray *keys = generate_random_numbers_array(size, RANDOM_MIN, RANDOM_MAX);
-            *root = BPTree_init(order);
+            BPTreeNode *root = BPTree_init(order);
 
             for (int i = 0; i < keys->size; i++) {
-                BPTree_insert(*root, keys->items[i], transform_key_to_data(keys->items[i]));
+                BPTree_insert(root, keys->items[i], transform_key_to_data(keys->items[i]));
                 // After each insertion is verified that the B+ Tree is compliant with the rules.
-                TEST_ASSERT(check_BPTree_compliance(*root));
+                TEST_ASSERT(check_BPTree_compliance(root));
             }
 
             IntegerArray_destroy(&keys);
-            BPTree_destroy(root);
+            BPTree_destroy(&root);
 
             size *= 2;
         }
@@ -301,34 +302,34 @@ static void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_g
 }
 
 void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_order_1() {
-    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 1);
+    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(1);
 }
 
 void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_order_2() {
-    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 2);
+    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(2);
 }
 
 void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_order_3() {
-    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 3);
+    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(3);
 }
 
 void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_order_4() {
-    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 4);
+    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(4);
 }
 
 void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_order_8() {
-    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 8);
+    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(8);
 }
 
 void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_order_16() {
-    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 16);
+    test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_given_order(16);
 }
 
 // **** END : test_BPTree_insert
 
 // **** BEGIN : test_BPTree_delete
 
-void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(BPTreeNode **root, int order) {
+void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(int order) {
     int size = 1;
 
     // Test 10 times, variable i being the seed.
@@ -339,20 +340,20 @@ void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_or
         // will have the size of 1 then 2, 4, 8, 16, 32, ...
         for (int j = 0; j < 8; j++) {
             IntegerArray *keys = generate_random_numbers_array(size, RANDOM_MIN, RANDOM_MAX);
-            *root = BPTree_init(order);
+            BPTreeNode *root = BPTree_init(order);
 
             for (int i = 0; i < keys->size; i++) {
-                BPTree_insert(*root, keys->items[i], transform_key_to_data(keys->items[i]));
+                BPTree_insert(root, keys->items[i], transform_key_to_data(keys->items[i]));
             }
 
             while (keys->size > 0) {
                 int index = rand() % keys->size;
-                BPTree_delete(*root, keys->items[index]);
+                BPTree_delete(root, keys->items[index]);
                 IntegerArray_delete_at_index(keys, index);
             }
 
             IntegerArray_destroy(&keys);
-            BPTree_destroy(root);
+            BPTree_destroy(&root);
 
             size *= 2;
         }
@@ -362,34 +363,34 @@ void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_or
 }
 
 void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_order_1() {
-    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 1);
+    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(1);
 }
 
 void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_order_2() {
-    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 2);
+    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(2);
 }
 
 void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_order_3() {
-    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 3);
+    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(3);
 }
 
 void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_order_4() {
-    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 4);
+    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(4);
 }
 
 void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_order_8() {
-    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 8);
+    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(8);
 }
 
 void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_order_16() {
-    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(&tree, 16);
+    test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_order(16);
 }
 
 // **** END : test_BPTree_delete
 
 // **** BEGIN : test_BPTree_search
 
-void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(BPTreeNode **root, int order) {
+void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(int order) {
     int size = 256;
 
     // Test 10 times, variable i being the seed.
@@ -397,47 +398,47 @@ void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTr
         srand(i);
 
         IntegerArray *keys = generate_random_numbers_array(size, RANDOM_MIN, RANDOM_MAX);
-        *root = BPTree_init(order);
+        BPTreeNode *root = BPTree_init(order);
 
         for (int i = 0; i < keys->size; i++) {
-            BPTree_insert(*root, keys->items[i], transform_key_to_data(keys->items[i]));
+            BPTree_insert(root, keys->items[i], transform_key_to_data(keys->items[i]));
         }
 
         for (int i = 0; i < keys->size; i++) {
             uint64_t data;
-            bool is_found = BPTree_search(*root, keys->items[i], &data);
+            bool is_found = BPTree_search(root, keys->items[i], &data);
 
             TEST_ASSERT(is_found);
             TEST_ASSERT_EQUAL_UINT64(transform_key_to_data(keys->items[i]), data);
         }
 
         IntegerArray_destroy(&keys);
-        BPTree_destroy(root);
+        BPTree_destroy(&root);
     }
 }
 
 void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_order_1() {
-    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(&tree, 1);
+    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(1);
 }
 
 void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_order_2() {
-    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(&tree, 2);
+    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(2);
 }
 
 void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_order_3() {
-    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(&tree, 3);
+    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(3);
 }
 
 void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_order_4() {
-    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(&tree, 4);
+    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(4);
 }
 
 void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_order_8() {
-    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(&tree, 8);
+    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(8);
 }
 
 void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_order_16() {
-    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(&tree, 16);
+    test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTree_of_given_order(16);
 }
 
 // **** END : test_BPTree_search