Add TestEmptyRing

sdk/log/batch_test.go

@@ -554,80 +554,74 @@ func TestQueue(t *testing.T) {
 	})
 }
 
-func TestRing(t *testing.T) {
-	verify := func(t *testing.T, r *ring, N int, sum int) {
-		// Len
-		n := r.Len()
-		if n != N {
-			t.Errorf("r.Len() == %d; expected %d", n, N)
-		}
-
-		// iteration
-		n = 0
-		s := 0
-		r.Do(func(v Record) {
-			n++
-			body := v.Body()
-			if body.Kind() != log.KindEmpty {
-				s += int(body.AsInt64())
-			}
-		})
-		if n != N {
-			t.Errorf("number of forward iterations == %d; expected %d", n, N)
-		}
-		if sum >= 0 && s != sum {
-			t.Errorf("forward ring sum = %d; expected %d", s, sum)
+func verifyRing(t *testing.T, r *ring, N int, sum int) {
+	// Length.
+	assert.Equal(t, N, r.Len(), "r.Len()")
+
+	// Iteration.
+	var n, s int
+	r.Do(func(v Record) {
+		n++
+		body := v.Body()
+		if body.Kind() != log.KindEmpty {
+			s += int(body.AsInt64())
 		}
+	})
+	assert.Equal(t, N, n, "number of forward iterations")
+	if sum >= 0 {
+		assert.Equal(t, sum, s, "forward ring sum")
+	}
 
-		if r == nil {
-			return
-		}
+	if r == nil {
+		return
+	}
 
-		// connections
-		if r.next != nil {
-			var p *ring // previous element
-			for q := r; p == nil || q != r; q = q.next {
-				if p != nil && p != q.prev {
-					t.Errorf("prev = %p, expected q.prev = %p\n", p, q.prev)
-				}
-				p = q
+	// Connections.
+	if r.next != nil {
+		var p *ring // previous element.
+		for q := r; p == nil || q != r; q = q.next {
+			if p != nil {
+				assert.Equalf(t, p, q.prev, "prev = %p, expected q.prev = %p", p, q.prev)
 			}
-			if p != r.prev {
-				t.Errorf("prev = %p, expected r.prev = %p\n", p, r.prev)
-			}
-		}
-
-		// Next, Prev
-		if r.Next() != r.next {
-			t.Errorf("r.Next() != r.next")
-		}
-		if r.Prev() != r.prev {
-			t.Errorf("r.Prev() != r.prev")
+			p = q
 		}
+		assert.Equalf(t, p, r.prev, "prev = %p, expected r.prev = %p", p, r.prev)
 	}
 
+	// Next, Prev.
+	assert.Equal(t, r.next, r.Next(), "r.Next() != r.next")
+	assert.Equal(t, r.prev, r.Prev(), "r.Prev() != r.prev")
+}
+
+func TestNewRing(t *testing.T) {
 	for i := 0; i < 10; i++ {
+		// Empty value.
 		r := newRing(i)
-		verify(t, r, i, -1)
+		verifyRing(t, r, i, -1)
 	}
 
-	makeN := func(n int) *ring {
+	for n := 0; n < 10; n++ {
 		r := newRing(n)
 		for i := 1; i <= n; i++ {
 			var rec Record
 			rec.SetBody(log.IntValue(i))
 			r.Value = rec
 			r = r.Next()
 		}
-		return r
+
+		sum := (n*n + n) / 2
+		verifyRing(t, r, n, sum)
 	}
+}
 
-	sumN := func(n int) int { return (n*n + n) / 2 }
+func TestEmptyRing(t *testing.T) {
+	var rNext, rPrev ring
+	verifyRing(t, rNext.Next(), 1, 0)
+	verifyRing(t, rPrev.Prev(), 1, 0)
 
-	for i := 0; i < 10; i++ {
-		r := makeN(i)
-		verify(t, r, i, sumN(i))
-	}
+	var rLen, rDo *ring
+	assert.Equal(t, rLen.Len(), 0, "Len()")
+	rDo.Do(func(Record) { assert.Fail(t, "Do func arg called") })
 }
 
 func BenchmarkBatchProcessorOnEmit(b *testing.B) {