[Test] Return typed errors for Fibonacci heap

Author: Nikola Yurukov

fibheap/fibheap.go

@@ -95,6 +95,22 @@ type Entry struct {
 	Priority float64
 }
 
+// EmptyHeapError fires when the heap is empty and an operation could
+// not be completed for that reason. Its string holds additional data.
+type EmptyHeapError string
+
+func (e EmptyHeapError) Error() string {
+	return string(e)
+}
+
+// NilError fires when a heap or entry is nil and an operation could
+// not be completed for that reason. Its string holds additional data.
+type NilError string
+
+func (e NilError) Error() string {
+	return string(e)
+}
+
 // NewFloatFibHeap creates a new, empty, Fibonacci heap object.
 func NewFloatFibHeap() FloatingFibonacciHeap { return FloatingFibonacciHeap{nil, 0} }
 
@@ -111,7 +127,7 @@ func (heap *FloatingFibonacciHeap) Enqueue(priority float64) *Entry {
 // Min returns the minimum element in the heap
 func (heap *FloatingFibonacciHeap) Min() (*Entry, error) {
 	if heap.IsEmpty() {
-		return nil, fmt.Errorf("Trying to get minimum element of empty heap")
+		return nil, EmptyHeapError("Trying to get minimum element of empty heap")
 	}
 	return heap.min, nil
 }
@@ -130,7 +146,7 @@ func (heap *FloatingFibonacciHeap) Size() uint {
 // minimal element in the heap
 func (heap *FloatingFibonacciHeap) DequeueMin() (*Entry, error) {
 	if heap.IsEmpty() {
-		return nil, fmt.Errorf("Cannot dequeue minimum of empty heap")
+		return nil, EmptyHeapError("Cannot dequeue minimum of empty heap")
 	}
 
 	heap.size--
@@ -227,22 +243,19 @@ func (heap *FloatingFibonacciHeap) DequeueMin() (*Entry, error) {
 		}
 	}
 
-	// All done. Return minimum element and no error
 	return min, nil
 }
 
-// DecreaseKey decreases the key of the
-// given element, sets it to the new
-// given priority and returns the node
-// if successfully set
+// DecreaseKey decreases the key of the given element, sets it to the new
+// given priority and returns the node if successfully set
 func (heap *FloatingFibonacciHeap) DecreaseKey(node *Entry, newPriority float64) (*Entry, error) {
 
 	if heap.IsEmpty() {
-		return nil, fmt.Errorf("Cannot decrease key in an empty heap")
+		return nil, EmptyHeapError("Cannot decrease key in an empty heap")
 	}
 
 	if node == nil {
-		return nil, fmt.Errorf("Cannot decrease key: given node is nil")
+		return nil, NilError("Cannot decrease key: given node is nil")
 	}
 
 	if newPriority >= node.Priority {
@@ -258,11 +271,11 @@ func (heap *FloatingFibonacciHeap) DecreaseKey(node *Entry, newPriority float64)
 func (heap *FloatingFibonacciHeap) Delete(node *Entry) error {
 
 	if heap.IsEmpty() {
-		return fmt.Errorf("Cannot delete element from an empty heap")
+		return EmptyHeapError("Cannot delete element from an empty heap")
 	}
 
 	if node == nil {
-		return fmt.Errorf("Cannot delete node: given node is nil")
+		return NilError("Cannot delete node: given node is nil")
 	}
 
 	decreaseKeyUnchecked(heap, node, -math.MaxFloat64)
@@ -278,7 +291,7 @@ func (heap *FloatingFibonacciHeap) Delete(node *Entry) error {
 func (heap *FloatingFibonacciHeap) Merge(other *FloatingFibonacciHeap) (FloatingFibonacciHeap, error) {
 
 	if heap == nil || other == nil {
-		return FloatingFibonacciHeap{}, fmt.Errorf("One of the heaps to merge is nil. Cannot merge")
+		return FloatingFibonacciHeap{}, NilError("One of the heaps to merge is nil. Cannot merge")
 	}
 
 	resultSize := heap.size + other.size

fibheap/fibheap_test.go

@@ -8,6 +8,7 @@ import (
 	"math/rand"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // Go does not have constant arrays.
@@ -132,7 +133,7 @@ func TestEnqueueDequeueMin(t *testing.T) {
 	var err error
 	for heap.Size() > 0 {
 		min, err = heap.DequeueMin()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if heap.Size() == 199 {
 			assert.Equal(t, Seq1FirstMinimum, min.Priority)
 		}
@@ -155,19 +156,20 @@ func TestFibHeap_Enqueue_Min(t *testing.T) {
 	}
 
 	min, err := heap.Min()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, Seq1FirstMinimum, min.Priority)
 }
 
 func TestFibHeap_Min_EmptyHeap(t *testing.T) {
 	heap := NewFloatFibHeap()
 
 	heap.Enqueue(0)
-	heap.DequeueMin()
+	min, err := heap.DequeueMin()
+	require.NoError(t, err)
 
 	// Heap should be empty at this point
 
-	min, err := heap.Min()
+	min, err = heap.Min()
 
 	assert.EqualError(t, err, "Trying to get minimum element of empty heap")
 	assert.Nil(t, min)
@@ -177,6 +179,7 @@ func TestFibHeap_DequeueMin_EmptyHeap(t *testing.T) {
 	heap := NewFloatFibHeap()
 	min, err := heap.DequeueMin()
 
+	assert.IsType(t, EmptyHeapError(""), err)
 	assert.EqualError(t, err, "Cannot dequeue minimum of empty heap")
 	assert.Nil(t, min)
 }
@@ -196,19 +199,21 @@ func TestEnqueueDecreaseKey(t *testing.T) {
 		}
 	}
 
-	assert.NotNil(t, e1)
-	assert.NotNil(t, e2)
-	assert.NotNil(t, e3)
+	require.NotNil(t, e1)
+	require.NotNil(t, e2)
+	require.NotNil(t, e3)
 
-	heap.DecreaseKey(e1, Seq2DecreaseKey1Trgt)
-	heap.DecreaseKey(e2, Seq2DecreaseKey2Trgt)
-	heap.DecreaseKey(e3, Seq2DecreaseKey3Trgt)
+	_, err := heap.DecreaseKey(e1, Seq2DecreaseKey1Trgt)
+	require.NoError(t, err)
+	_, err = heap.DecreaseKey(e2, Seq2DecreaseKey2Trgt)
+	require.NoError(t, err)
+	_, err = heap.DecreaseKey(e3, Seq2DecreaseKey3Trgt)
+	require.NoError(t, err)
 
 	var min *Entry
-	var err error
 	for i := 0; i < len(NumberSequence2Sorted); i++ {
 		min, err = heap.DequeueMin()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, NumberSequence2Sorted[i], min.Priority)
 	}
 }
@@ -222,6 +227,7 @@ func TestFibHeap_DecreaseKey_EmptyHeap(t *testing.T) {
 	// Heap should be empty at this point
 	min, err := heap.DecreaseKey(elem, 0)
 
+	assert.IsType(t, EmptyHeapError(""), err)
 	assert.EqualError(t, err, "Cannot decrease key in an empty heap")
 	assert.Nil(t, min)
 }
@@ -231,6 +237,7 @@ func TestFibHeap_DecreaseKey_NilNode(t *testing.T) {
 	heap.Enqueue(1)
 	min, err := heap.DecreaseKey(nil, 0)
 
+	assert.IsType(t, NilError(""), err)
 	assert.EqualError(t, err, "Cannot decrease key: given node is nil")
 	assert.Nil(t, min)
 }
@@ -266,13 +273,16 @@ func TestEnqueueDelete(t *testing.T) {
 	var err error
 
 	err = heap.Delete(e1)
+	require.NoError(t, err)
 	err = heap.Delete(e2)
+	require.NoError(t, err)
 	err = heap.Delete(e3)
+	require.NoError(t, err)
 
 	var min *Entry
 	for i := 0; i < len(NumberSequence2Deleted3ElemSorted); i++ {
 		min, err = heap.DequeueMin()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, NumberSequence2Deleted3ElemSorted[i], min.Priority)
 	}
 }
@@ -285,13 +295,15 @@ func TestFibHeap_Delete_EmptyHeap(t *testing.T) {
 
 	// Heap should be empty at this point
 	err := heap.Delete(elem)
+	assert.IsType(t, EmptyHeapError(""), err)
 	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.IsType(t, NilError(""), err)
 	assert.EqualError(t, err, "Cannot delete node: given node is nil")
 }
 
@@ -307,12 +319,12 @@ func TestMerge(t *testing.T) {
 	}
 
 	heap, err := heap1.Merge(&heap2)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var min *Entry
 	for i := 0; i < len(NumberSequenceMerged3And4Sorted); i++ {
 		min, err = heap.DequeueMin()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, NumberSequenceMerged3And4Sorted[i], min.Priority)
 	}
 }
@@ -321,6 +333,7 @@ func TestFibHeap_Merge_NilHeap(t *testing.T) {
 	var heap FloatingFibonacciHeap
 	heap = NewFloatFibHeap()
 	newHeap, err := heap.Merge(nil)
+	assert.IsType(t, NilError(""), err)
 	assert.EqualError(t, err, "One of the heaps to merge is nil. Cannot merge")
 	assert.Equal(t, newHeap, FloatingFibonacciHeap{})
 }