Merged in SimplifyRingBufferTesting (pull request #6)

SimplifyRingBufferTesting

Approved-by: Alan Noble <anoble@gmail.com>

ringbuffer/RingBuffer_test.go

@@ -29,28 +29,44 @@ LICENSE
 package ringbuffer
 
 import (
+	"fmt"
 	"testing"
 	"time"
 )
 
+// Parameters used over the testing
 const (
 	testBufferSize            = 10
 	testElementSize           = 1
-	testOverFlowSize          = 5
+	testOverFlowSize          = 2
 	testDataSize              = 1
 	testConcurrencyBufferSize = 1000
 )
 
+// Types of actions, assertions and test ends
+const (
+	testWrite       = 0
+	testDoneWriting = 1
+	testRead        = 2
+	testDoneReading = 3
+	testEnd         = 4
+	assertNoError   = 5
+	assertError     = 6
+)
+
+// Strings to help with test fail messages
+const (
+	noErrorFailMessage    = "Should have got error!"
+	falseErrorFailMessage = "Should not have got error: %v"
+	atMessage             = " Series: %v"
+)
+
+// Pointer to the ringbuffer we will be testing
 var rb *ringBuffer
 
-// Call when we get an error we shouldn't have
+// Call when the a test array has the wrong format
-func falseErrorFail(t *testing.T, err error) {
+func wrongFmt() {
-	t.Errorf("Should not have got error: %v", err)
+	fmt.Println("Test has wrong format!")
-}
-
-// Call when we should have got an error but didnt
-func noErrorFail(t *testing.T) {
-	t.Errorf("Should have got error!")
 }
 
 // Test that the Make method correctly allocates memory for arbitrary buffer
@@ -65,255 +81,67 @@ func TestMake(t *testing.T) {
 	}
 }
 
-// Test call to done writing when no writing has occured.
+// Format: { <size of uffer>, <type of check>, <action>, ..., <action>, <test end> }
-// We pass arbitrary clipSize.
+var tests = [][]int{
-func TestDoneWriting1(t *testing.T) {
+	{testBufferSize, assertError, testDoneWriting, testEnd},
-	if rb.DoneWriting(testDataSize) == nil {
+	{testBufferSize, assertNoError, testWrite, testDoneWriting, testEnd},
-		noErrorFail(t)
+	{testBufferSize, assertError, testDoneReading, testEnd},
-	}
+	{testBufferSize, assertError, testRead, testEnd},
+	{testBufferSize, assertError, testWrite, testWrite, testEnd},
+	{testBufferSize, assertNoError, testWrite, testDoneWriting, testRead,
+		testDoneReading, testEnd},
+	{testBufferSize, assertNoError, testWrite, testDoneWriting, testWrite,
+		testDoneWriting, testRead, testDoneReading, testRead, testDoneReading,
+		testEnd},
+	{testBufferSize, assertError, testWrite, testDoneWriting, testRead,
+		testDoneReading, testRead, testDoneReading, testEnd},
+	{testOverFlowSize, assertError, testWrite, testDoneWriting, testWrite, testDoneWriting,
+		testWrite, testDoneWriting, testEnd},
+	{testOverFlowSize, assertNoError, testWrite, testDoneWriting, testWrite, testDoneWriting,
+		testRead, testDoneReading, testWrite, testDoneWriting, testEnd},
+	{testOverFlowSize, assertError, testWrite, testDoneWriting, testWrite, testDoneWriting,
+		testRead, testDoneReading, testWrite, testDoneWriting, testWrite,
+		testDoneWriting, testEnd},
+	{testBufferSize, assertError, testWrite, testDoneWriting, testWrite,
+		testDoneWriting, testRead, testRead, testEnd},
 }
 
-// Test call to done writing when there has been some 'writing'
+// Tests series of actions performed by the ring buffer defined in array tests
-func TestDoneWriting2(t *testing.T) {
+func TestAllSorts(t *testing.T) {
-	if _, err := rb.Get(); err != nil {
+	for i := range tests {
-		falseErrorFail(t, err)
+		rb = NewRingBuffer(tests[i][0], testElementSize)
-	}
+		var err error
-	if err := rb.DoneWriting(testDataSize); err != nil {
+		for j := 2; tests[i][j] != testEnd; j++ {
-		falseErrorFail(t, err)
+			var newErr error
-	}
+			switch tests[i][j] {
-}
+			case testWrite:
-
+				_, newErr = rb.Get()
-// Test call to done reading when there hasn't been any reading
+			case testDoneWriting:
-func TestDoneReading1(t *testing.T) {
+				newErr = rb.DoneWriting(testDataSize)
-	rb = NewRingBuffer(testBufferSize, testElementSize)
+			case testRead:
-	if rb.DoneReading() == nil {
+				_, newErr = rb.Read()
-		noErrorFail(t)
+			case testDoneReading:
-	}
+				newErr = rb.DoneReading()
-}
+			default:
-
+				wrongFmt()
-// Test read when there hasn't been anything written to buffer
+			}
-func TestReadingWithoutWrite(t *testing.T) {
+			if err == nil {
-	rb = NewRingBuffer(testBufferSize, testElementSize)
+				err = newErr
-	_, err := rb.Read()
+			}
-	if err == nil {
-		noErrorFail(t)
-	}
-}
-
-// Try Writing twice without calling DoneWriting
-func TestWritingTwice(t *testing.T) {
-	rb = NewRingBuffer(testBufferSize, testElementSize)
-	_, err := rb.Get()
-	_, err = rb.Get()
-	if err == nil {
-		noErrorFail(t)
-	}
-}
-
-// Test call to done reading when there has been some reading
-func TestDoneReading2(t *testing.T) {
-	rb = NewRingBuffer(testBufferSize, testElementSize)
-	_, err := rb.Get()
-	rb.DoneWriting(testDataSize)
-	_, err = rb.Read()
-	if err != nil {
-		falseErrorFail(t, err)
-	}
-	rb.DoneReading()
-}
-
-// Testing writing then reading for single 'write' and single 'read' routines
-func TestWritingAndReading1(t *testing.T) {
-	rb = NewRingBuffer(testBufferSize, testElementSize)
-	if _, err := rb.Get(); err != nil {
-		falseErrorFail(t, err)
-	}
-	if err := rb.DoneWriting(testDataSize); err != nil {
-		falseErrorFail(t, err)
-	}
-	if _, err := rb.Read(); err != nil {
-		falseErrorFail(t, err)
-	}
-	if err := rb.DoneReading(); err != nil {
-		falseErrorFail(t, err)
-	}
-}
-
-// Testing two 'writes' and two 'reads'
-func TestWritingAndReading2(t *testing.T) {
-	rb = NewRingBuffer(testBufferSize, testElementSize)
-	for i := 0; i < 2; i++ {
-		if _, err := rb.Get(); err != nil {
-			falseErrorFail(t, err)
 		}
-		if err := rb.DoneWriting(testDataSize); err != nil {
+		switch tests[i][1] {
-			falseErrorFail(t, err)
+		case assertError:
+			if err == nil {
+				t.Errorf(noErrorFailMessage+atMessage, i)
+			}
+		case assertNoError:
+			if err != nil {
+				t.Errorf(falseErrorFailMessage+atMessage, err, i)
+			}
+		default:
+			wrongFmt()
 		}
 	}
-	for i := 0; i < 2; i++ {
-		if _, err := rb.Read(); err != nil {
-			falseErrorFail(t, err)
-		}
-		if err := rb.DoneReading(); err != nil {
-			falseErrorFail(t, err)
-		}
-	}
-}
-
-// Testing one 'write' and two 'reads'
-func TestWritingAndReading3(t *testing.T) {
-	rb = NewRingBuffer(testBufferSize, testElementSize)
-	if _, err := rb.Get(); err != nil {
-		falseErrorFail(t, err)
-	}
-	if err := rb.DoneWriting(testDataSize); err != nil {
-		falseErrorFail(t, err)
-	}
-	var err1 error
-	var err2 error
-	for i := 0; i < 2; i++ {
-		_, err1 = rb.Read()
-		err2 = rb.DoneReading()
-	}
-	if err1 == nil {
-		noErrorFail(t)
-	}
-	if err2 == nil {
-		noErrorFail(t)
-	}
-}
-
-// Test two 'writes' and one 'read'
-func TestWritingAndReading4(t *testing.T) {
-	rb = NewRingBuffer(testBufferSize, testElementSize)
-	for i := 0; i < 2; i++ {
-		if _, err := rb.Get(); err != nil {
-			falseErrorFail(t, err)
-		}
-		if err := rb.DoneWriting(testDataSize); err != nil {
-			falseErrorFail(t, err)
-		}
-	}
-	if _, err := rb.Read(); err != nil {
-		falseErrorFail(t, err)
-	}
-	if err := rb.DoneReading(); err != nil {
-		falseErrorFail(t, err)
-	}
-}
-
-// Test writing past capacity
-func TestWritingAndReading5(t *testing.T) {
-	rb = NewRingBuffer(testOverFlowSize, testElementSize)
-	var err1 error
-	var err2 error
-	for i := 0; i < testOverFlowSize+1; i++ {
-		_, err1 = rb.Get()
-		err2 = rb.DoneWriting(testDataSize)
-	}
-	if err1 == nil {
-		noErrorFail(t)
-	}
-	if err2 == nil {
-		noErrorFail(t)
-	}
-}
-
-// Test writing to size, then read some, then 'write' to test that we go back
-// to start of buffer
-func TestWritingAndReading6(t *testing.T) {
-	rb = NewRingBuffer(testOverFlowSize, testElementSize)
-	var err1 error
-	var err2 error
-	for i := 0; i < testOverFlowSize; i++ {
-		_, err1 = rb.Get()
-		err2 = rb.DoneWriting(testDataSize)
-	}
-	if err1 != nil {
-		falseErrorFail(t, err1)
-	}
-	if err2 != nil {
-		falseErrorFail(t, err2)
-	}
-	for i := 0; i < 2; i++ {
-		_, err1 = rb.Read()
-		err2 = rb.DoneReading()
-	}
-	if err1 != nil {
-		falseErrorFail(t, err1)
-	}
-	if err2 != nil {
-		falseErrorFail(t, err2)
-	}
-	_, err1 = rb.Get()
-	err2 = rb.DoneWriting(testDataSize)
-	if err1 != nil {
-		falseErrorFail(t, err1)
-	}
-	if err2 != nil {
-		falseErrorFail(t, err2)
-	}
-}
-
-// Now let's do the previous test again, but this time we will try to write
-// past capacity
-func TestWritingAndReading7(t *testing.T) {
-	rb = NewRingBuffer(testOverFlowSize, testElementSize)
-	var err1 error
-	var err2 error
-	for i := 0; i < testOverFlowSize; i++ {
-		_, err1 = rb.Get()
-		err2 = rb.DoneWriting(testDataSize)
-	}
-	if err1 != nil {
-		falseErrorFail(t, err1)
-	}
-	if err2 != nil {
-		falseErrorFail(t, err2)
-	}
-	for i := 0; i < 2; i++ {
-		_, err1 = rb.Read()
-		err2 = rb.DoneReading()
-	}
-	if err1 != nil {
-		falseErrorFail(t, err1)
-	}
-	if err2 != nil {
-		falseErrorFail(t, err2)
-	}
-	for i := 0; i < testOverFlowSize; i++ {
-		_, err1 = rb.Get()
-		err2 = rb.DoneWriting(testDataSize)
-	}
-	if err1 == nil {
-		noErrorFail(t)
-	}
-	if err2 == nil {
-		noErrorFail(t)
-	}
-}
-
-// Test reading twice without call to DoneReading
-func TestWritingAndReading8(t *testing.T) {
-	rb = NewRingBuffer(testBufferSize, 10)
-	var err1 error
-	var err2 error
-	for i := 0; i < 2; i++ {
-		_, err1 = rb.Get()
-		err2 = rb.DoneWriting(testDataSize)
-	}
-	if err1 != nil {
-		falseErrorFail(t, err1)
-	}
-	if err2 != nil {
-		falseErrorFail(t, err2)
-	}
-	for i := 0; i < 2; i++ {
-		_, err1 = rb.Read()
-	}
-	if err1 == nil {
-		noErrorFail(t)
-	}
 }
 
 // Let's see if we can do concurrency. (tip: run as: go test -race) to see
@@ -326,10 +154,10 @@ func TestConcurrency1(t *testing.T) {
 			if data, err1 := rb.Read(); data != nil {
 				err2 := rb.DoneReading()
 				if err1 != nil {
-					falseErrorFail(t, err1)
+					t.Errorf(falseErrorFailMessage, err1)
 				}
 				if err2 != nil {
-					falseErrorFail(t, err2)
+					t.Errorf(falseErrorFailMessage, err2)
 				}
 			}
 		}
@@ -339,10 +167,10 @@ func TestConcurrency1(t *testing.T) {
 			_, err1 := rb.Get()
 			err2 := rb.DoneWriting(testDataSize)
 			if err1 != nil {
-				falseErrorFail(t, err1)
+				t.Errorf(falseErrorFailMessage, err1)
 			}
 			if err2 != nil {
-				falseErrorFail(t, err2)
+				t.Errorf(falseErrorFailMessage, err2)
 			}
 		}
 	}()