#include "test/helpers.h"
 #include "test/lut.h"
 
-void t_buffertop_clear() //FTEST
+void t_buffertop_clear()
 {
        BufferTop* bt = buffertop_new(int, 10, MIN_T, 2);
 
        buffertop_destroy(bt);
 }
 
-void t_buffertop_size() //FTEST
+void t_buffertop_size()
 {
        BufferTop* bt = buffertop_new(double, 10, MAX_T, 3);
 
        buffertop_destroy(bt);
 }
 
-void t_buffertop_push_pop_basic() //FTEST
+void t_buffertop_push_pop_basic()
 {
        BufferTop* bt = buffertop_new(int, 5, MIN_T, 3);
 
        buffertop_destroy(bt);
 }
 
-void t_buffertop_push_pop_evolved() //FTEST
+void t_buffertop_push_pop_evolved()
 {
        int n = 10;
 
        buffertop_destroy(bt);
 }
 
-void t_buffertop_copy() //FTEST
+void t_buffertop_copy()
 {
        int n = 10;
 
 
 #include "test/helpers.h"
 #include "test/lut.h"
 
-void t_heap_clear() //FTEST
+void t_heap_clear()
 {
        Heap* h = heap_new(int, MIN_T, 2);
 
        heap_destroy(h);
 }
 
-void t_heap_size() //FTEST
+void t_heap_size()
 {
        Heap* h = heap_new(double, MAX_T, 3);
 
        heap_destroy(h);
 }
 
-void t_heap_push_pop_basic() //FTEST
+void t_heap_push_pop_basic()
 {
        Heap* h = heap_new(int, MIN_T, 3);
 
        heap_destroy(h);
 }
 
-void t_heap_push_pop_evolved() //FTEST
+void t_heap_push_pop_evolved()
 {
        int n = 10;
 
        heap_destroy(h);
 }
 
-void t_heap_copy() //FTEST
+void t_heap_copy()
 {
        int n = 10;
 
 
 #include "test/helpers.h"
 #include "test/lut.h"
 
-void t_list_clear() //FTEST
+void t_list_clear()
 {
        List* L = list_new(int);
 
        list_destroy(L);
 }
 
-void t_list_size() //FTEST
+void t_list_size()
 {
        List* L = list_new(double);
 
        list_destroy(L);
 }
 
-void t_list_push_pop_basic() //FTEST
+void t_list_push_pop_basic()
 {
        int n = 10;
 
        listI_destroy(li);
 }
 
-void t_list_push_pop_evolved() //FTEST
+void t_list_push_pop_evolved()
 {
        int n = 10;
 
        list_destroy(L);
 }
 
-void t_list_copy() //FTEST
+void t_list_copy()
 {
        int n = 10;
 
 
 #include "test/helpers.h"
 #include "test/lut.h"
 
-void t_priorityqueue_clear() //FTEST
+void t_priorityqueue_clear()
 {
        PriorityQueue* pq = priorityqueue_new(int, MIN_T, 2);
 
        priorityqueue_destroy(pq);
 }
 
-void t_priorityqueue_size() //FTEST
+void t_priorityqueue_size()
 {
        PriorityQueue* pq = priorityqueue_new(double, MAX_T, 3);
 
        priorityqueue_destroy(pq);
 }
 
-void t_priorityqueue_push_pop_basic() //FTEST
+void t_priorityqueue_push_pop_basic()
 {
        PriorityQueue* pq = priorityqueue_new(int, MIN_T, 3);
 
        priorityqueue_destroy(pq);
 }
 
-void t_priorityqueue_push_pop_evolved() //FTEST
+void t_priorityqueue_push_pop_evolved()
 {
        int n = 10;
 
        priorityqueue_destroy(pq);
 }
 
-void t_priorityqueue_copy() //FTEST
+void t_priorityqueue_copy()
 {
        int n = 10;
 
 
 #include "test/helpers.h"
 #include "test/lut.h"
 
-void t_queue_clear() //FTEST
+void t_queue_clear()
 {
        Queue* q = queue_new(int);
 
        queue_destroy(q);
 }
 
-void t_queue_size() //FTEST
+void t_queue_size()
 {
        Queue* q = queue_new(int);
 
        queue_destroy(q);
 }
 
-void t_queue_push_pop_basic() //FTEST
+void t_queue_push_pop_basic()
 {
        int n = 10;
 
        queue_destroy(q);
 }
 
-void t_queue_push_pop_evolved() //FTEST
+void t_queue_push_pop_evolved()
 {
        int n = 10;
 
        queue_destroy(q);
 }
 
-void t_queue_copy() //FTEST
+void t_queue_copy()
 {
        int n = 10;
 
 
 #include "test/helpers.h"
 #include "test/lut.h"
 
-void t_stack_clear() //FTEST
+void t_stack_clear()
 {
        Stack* s = stack_new(int);
 
        stack_destroy(s);
 }
 
-void t_stack_size() //FTEST
+void t_stack_size()
 {
        Stack* s = stack_new(int);
 
        stack_destroy(s);
 }
 
-void t_stack_push_pop_basic() //FTEST
+void t_stack_push_pop_basic()
 {
 
        int n = 10;
        stack_destroy(s);
 }
 
-void t_stack_push_pop_evolved() //FTEST
+void t_stack_push_pop_evolved()
 {
        Stack* s = stack_new(StructTest1);
 
        stack_destroy(s);
 }
 
-void t_stack_copy() //FTEST
+void t_stack_copy()
 {
        int n = 10;
 
 
 #include "test/helpers.h"
 #include "test/lut.h"
 
-void t_tree_clear() //FTEST
+void t_tree_clear()
 {
        Tree* t = tree_new(int);
 
        tree_destroy(t);
 }
 
-void t_tree_size() //FTEST
+void t_tree_size()
 {
        Tree* t = tree_new(int);
 
        tree_destroy(t);
 }
 
-void t_tree_add_remove() //FTEST
+void t_tree_add_remove()
 {
        Tree* t = tree_new(int);
 
        tree_destroy(t);
 }
 
-void t_tree_iterate() //FTEST
+void t_tree_iterate()
 {
        Tree* t = tree_new(int);
 
        tree_destroy(t);
 }
 
-void t_tree_copy() //FTEST
+void t_tree_copy()
 {
        Tree* t = tree_new(int);
 
 
 #include "test/helpers.h"
 #include "test/lut.h"
 
-void t_vector_clear() //FTEST
+void t_vector_clear()
 {
        Vector* v = vector_new(int);
        lu_assert(vector_empty(v));
        vector_destroy(v);
 }
 
-void t_vector_size() //FTEST
+void t_vector_size()
 {
        Vector* v = vector_new(int);
        lu_assert(vector_empty(v));
        vector_destroy(v);
 }
 
-void t_vector_push_pop_basic() //FTEST
+void t_vector_push_pop_basic()
 {
        int n = 10;
 
        vectorI_destroy(vi);
 }
 
-void t_vector_push_pop_evolved() //FTEST
+void t_vector_push_pop_evolved()
 {
        int n = 10;
 
        vector_destroy(v);
 }
 
-void t_vector_copy() //FTEST
+void t_vector_copy()
 {
        int n = 10;