diff --git a/src/heap/vieter_heap.c b/src/heap/vieter_heap.c
index f6d3eab..f660077 100644
--- a/src/heap/vieter_heap.c
+++ b/src/heap/vieter_heap.c
@@ -56,7 +56,7 @@ vieter_heap_error vieter_heap_pop(void **out, vieter_heap *heap) {
     return vieter_heap_empty;
   }
 
-  if (heap->tree->order == 0 && heap->tree->ptr.next_tree == NULL) {
+  if (heap->tree->order == 0) {
     *out = heap->tree->data;
     vieter_heap_tree_free(heap->tree);
     heap->tree = NULL;
diff --git a/src/heap/vieter_heap_tree.c b/src/heap/vieter_heap_tree.c
index 56907a8..ce9c0e8 100644
--- a/src/heap/vieter_heap_tree.c
+++ b/src/heap/vieter_heap_tree.c
@@ -162,7 +162,7 @@ vieter_heap_node *vieter_heap_tree_pop(void **out, vieter_heap_node *tree) {
   *out = tree_to_pop->data;
 
   if (tree_to_pop->order == 0) {
-    vieter_heap_tree_free(tree_to_pop);
+    vieter_heap_tree_free(tree);
 
     return original_root;
   }
@@ -183,10 +183,5 @@ vieter_heap_node *vieter_heap_tree_pop(void **out, vieter_heap_node *tree) {
     tree = next_tree;
   }
 
-  // original_root is zero if the heap only contained a single tree.
-  if (original_root != NULL) {
-    return vieter_heap_tree_merge(original_root, previous_tree);
-  } else {
-    return previous_tree;
-  }
+  return vieter_heap_tree_merge(original_root, previous_tree);
 }
diff --git a/src/heap/vieter_heap_tree.h b/src/heap/vieter_heap_tree.h
index c3bc55d..b7597f6 100644
--- a/src/heap/vieter_heap_tree.h
+++ b/src/heap/vieter_heap_tree.h
@@ -9,45 +9,28 @@ typedef struct vieter_heap_node {
     void *data;
     struct vieter_heap_node *largest_order;
     union {
-      // Roots point to next tree in the heap, other nodes point to their first
-      // neighbour.
-      struct vieter_heap_node *next_tree;
-      struct vieter_heap_node *next_largest_order;
+        struct vieter_heap_node *next_tree;
+        struct vieter_heap_node *next_largest_order;
     } ptr;
     uint8_t order;
 } vieter_heap_node;
 
-/*
- * Allocate an initialize a heap node object.
- */
 vieter_heap_node *vieter_heap_node_init();
 
-/*
- * Deallocate a node object.
- */
 void vieter_heap_node_free(vieter_heap_node *node);
 
+/* vieter_heap_tree *vieter_heap_tree_init(vieter_heap_node *root, vieter_heap_tree *next, uint8_t order); */
+
 /*
- * Deallocate a node's entire structure.
+ * Deallocate a tree object, along with its underlying tree structure.
  */
 void vieter_heap_tree_free(vieter_heap_node *root);
 
-/*
- * Given the roots of the smallest trees in two heaps, merge them into a single
- * large heap.
- */
 vieter_heap_node *vieter_heap_tree_merge(vieter_heap_node *root_a, vieter_heap_node *root_b);
 
-/*
- * Given the roots of two trees of the same order, merge them into a heap of one
- * order larger.
- */
 vieter_heap_node *vieter_heap_tree_merge_same_order(vieter_heap_node *root_a,
                                                     vieter_heap_node *root_b);
 
-/*
- * Remove the smallest element from the given heap.
- */
 vieter_heap_node *vieter_heap_tree_pop(void **out, vieter_heap_node *root);
 
 #endif
diff --git a/test/heap/test_heap.c b/test/heap/test_heap.c
index e136d87..74736a3 100644
--- a/test/heap/test_heap.c
+++ b/test/heap/test_heap.c
@@ -1,7 +1,6 @@
 #include "acutest.h"
 #include "vieter_heap.h"
 #include "vieter_heap_tree.h"
-#include <stdlib.h>
 
 #define TEST_SIZE(heap, size) \
     TEST_CHECK(vieter_heap_size(heap) == size); \
@@ -77,57 +76,10 @@ void test_pop() {
     vieter_heap_free(heap);
 }
 
-int uint64_t_compare(const void *a, const void *b) {
-    if ((*(uint64_t *)a) < (*(uint64_t *)b)) {
-        return -1;
-    } else if ((*(uint64_t *)a) < (*(uint64_t *)b)) {
-        return 1;
-    } else {
-        return 0;
-    }
-}
-
-void test_pop_random() {
-    srand(0);
-
-    vieter_heap *heap = vieter_heap_init();
-
-    uint64_t *numbers = malloc(500 * sizeof(uint64_t));
-    uint64_t num;
-
-    for (uint64_t i = 0; i < 500; i++) {
-        num = rand();
-        vieter_heap_insert(heap, num, (void *)num);
-        TEST_SIZE(heap, i + 1);
-
-        numbers[i] = num;
-    }
-
-
-    qsort(numbers, 500, sizeof(uint64_t), uint64_t_compare);
-
-    void *data = NULL;
-
-    for (uint64_t i = 0; i < 500; i++) {
-        TEST_CHECK(vieter_heap_peek(&data, heap) == vieter_heap_ok);
-        TEST_CHECK(data == (void *)numbers[i]);
-
-        data = NULL;
-
-        TEST_CHECK(vieter_heap_pop(&data, heap) == vieter_heap_ok);
-        TEST_CHECK(data == (void *)numbers[i]);
-        TEST_SIZE(heap, (uint64_t)500 - i - 1);
-    }
-
-    vieter_heap_free(heap);
-    free(numbers);
-}
-
 TEST_LIST = {
     {"init", test_init},
     {"merge same order", test_merge_same_order},
     {"insert", test_insert},
     {"pop", test_pop},
-    {"pop random", test_pop_random},
     {NULL, NULL}
 };