[Dev] Add better error handling and tests for that

Author: Nikola Yurukov

fibheap/fibheap.go

@@ -172,7 +172,7 @@ func (heap *fibHeap) Size() uint {
 
 func (heap *fibHeap) DequeueMin() (*Entry, error) {
 	if heap.IsEmpty() {
-		return nil, fmt.Errorf("Heap is empty")
+		return nil, fmt.Errorf("Cannot dequeue minimum of empty heap")
 	}
 
 	heap.size--
@@ -275,8 +275,17 @@ func (heap *fibHeap) DequeueMin() (*Entry, error) {
 
 func (heap *fibHeap) DecreaseKey(node *Entry, newPriority float64) (*Entry, error) {
 
-	if newPriority > node.Priority {
-		return nil, fmt.Errorf("The given new priority is larger than the old")
+	if heap.IsEmpty() {
+		return nil, fmt.Errorf("Cannot decrease key in an empty heap")
+	}
+
+	if node == nil {
+		return nil, fmt.Errorf("Cannot decrease key: given node is nil")
+	}
+
+	if newPriority >= node.Priority {
+		return nil, fmt.Errorf("The given new priority: %v, is larger than or equal to the old: %v",
+			newPriority, node.Priority)
 	}
 
 	decreaseKeyUnchecked(heap, node, newPriority)
@@ -285,6 +294,14 @@ func (heap *fibHeap) DecreaseKey(node *Entry, newPriority float64) (*Entry, erro
 
 func (heap *fibHeap) Delete(node *Entry) error {
 
+	if heap.IsEmpty() {
+		return fmt.Errorf("Cannot delete element from an empty heap")
+	}
+
+	if node == nil {
+		return fmt.Errorf("Cannot delete node: given node is nil")
+	}
+
 	decreaseKeyUnchecked(heap, node, -math.MaxFloat64)
 	heap.DequeueMin()
 	return nil
@@ -299,10 +316,15 @@ func (heap *fibHeap) Delete(node *Entry) error {
  */
 func (heap *fibHeap) Merge(other FloatingFibonacciHeap) (FloatingFibonacciHeap, error) {
 
+	if heap == nil || other == nil {
+		return nil, fmt.Errorf("One of the heaps to merge is nil. Cannot merge")
+	}
+
 	otherHeap, ok := other.(*fibHeap)
 	if !ok {
 		// throw an error
-		return nil, fmt.Errorf("The passed object is of type %T, not of internal type *fibHeap. Please provide your own implementation of merge", other)
+		return nil, fmt.Errorf("The passed object is of type %T, not of internal type *fibHeap. "+
+			"Please provide your own implementation of merge", other)
 	}
 
 	resultSize := heap.size + otherHeap.size

fibheap/fibheap_test.go

@@ -148,6 +148,39 @@ func TestEnqueueDequeueMin(t *testing.T) {
 	}
 }
 
+func TestFibHeap_Enqueue_Min(t *testing.T) {
+	heap := NewFloatFibHeap()
+	for i := 0; i < len(NumberSequence1); i++ {
+		heap.Enqueue(NumberSequence1[i])
+	}
+
+	min, err := heap.Min()
+	assert.NoError(t, err)
+	assert.Equal(t, Seq1FirstMinimum, min.Priority)
+}
+
+func TestFibHeap_Min_EmptyHeap(t *testing.T) {
+	heap := NewFloatFibHeap()
+
+	heap.Enqueue(0)
+	heap.DequeueMin()
+
+	// Heap should be empty at this point
+
+	min, err := heap.Min()
+
+	assert.EqualError(t, err, "Trying to get minimum element of empty heap")
+	assert.Nil(t, min)
+}
+
+func TestFibHeap_DequeueMin_EmptyHeap(t *testing.T) {
+	heap := NewFloatFibHeap()
+	min, err := heap.DequeueMin()
+
+	assert.EqualError(t, err, "Cannot dequeue minimum of empty heap")
+	assert.Nil(t, min)
+}
+
 func TestEnqueueDecreaseKey(t *testing.T) {
 	heap := NewFloatFibHeap()
 	var e1, e2, e3 *Entry
@@ -180,6 +213,37 @@ func TestEnqueueDecreaseKey(t *testing.T) {
 	}
 }
 
+func TestFibHeap_DecreaseKey_EmptyHeap(t *testing.T) {
+	heap := NewFloatFibHeap()
+
+	elem := heap.Enqueue(15)
+	heap.DequeueMin()
+
+	// Heap should be empty at this point
+	min, err := heap.DecreaseKey(elem, 0)
+
+	assert.EqualError(t, err, "Cannot decrease key in an empty heap")
+	assert.Nil(t, min)
+}
+
+func TestFibHeap_DecreaseKey_NilNode(t *testing.T) {
+	heap := NewFloatFibHeap()
+	heap.Enqueue(1)
+	min, err := heap.DecreaseKey(nil, 0)
+
+	assert.EqualError(t, err, "Cannot decrease key: given node is nil")
+	assert.Nil(t, min)
+}
+
+func TestFibHeap_DecreaseKey_LargerNewPriority(t *testing.T) {
+	heap := NewFloatFibHeap()
+	node := heap.Enqueue(1)
+	min, err := heap.DecreaseKey(node, 20)
+
+	assert.EqualError(t, err, "The given new priority: 20, is larger than or equal to the old: 1")
+	assert.Nil(t, min)
+}
+
 func TestEnqueueDelete(t *testing.T) {
 	heap := NewFloatFibHeap()
 	var e1, e2, e3 *Entry
@@ -213,6 +277,24 @@ func TestEnqueueDelete(t *testing.T) {
 	}
 }
 
+func TestFibHeap_Delete_EmptyHeap(t *testing.T) {
+	heap := NewFloatFibHeap()
+
+	elem := heap.Enqueue(15)
+	heap.DequeueMin()
+
+	// Heap should be empty at this point
+	err := heap.Delete(elem)
+	assert.EqualError(t, err, "Cannot delete element from an empty heap")
+}
+
+func TestFibHeap_Delete_NilNode(t *testing.T) {
+	heap := NewFloatFibHeap()
+	heap.Enqueue(1)
+	err := heap.Delete(nil)
+	assert.EqualError(t, err, "Cannot delete node: given node is nil")
+}
+
 func TestMerge(t *testing.T) {
 	heap1 := NewFloatFibHeap()
 	for i := 0; i < len(NumberSequence3); i++ {
@@ -235,6 +317,14 @@ func TestMerge(t *testing.T) {
 	}
 }
 
+func TestFibHeap_Merge_NilHeap(t *testing.T) {
+	var heap FloatingFibonacciHeap
+	heap = NewFloatFibHeap()
+	newHeap, err := heap.Merge(nil)
+	assert.EqualError(t, err, "One of the heaps to merge is nil. Cannot merge")
+	assert.Nil(t, newHeap)
+}
+
 // ***************
 // BENCHMARK TESTS
 // ***************