multi: add buffer.Write and pool.WriteBuffer, make GCQueue generic

pool/recycle_test.go

@@ -0,0 +1,193 @@
+package pool_test
+
+import (
+	"bytes"
+	"testing"
+	"time"
+
+	"github.com/lightningnetwork/lnd/buffer"
+	"github.com/lightningnetwork/lnd/pool"
+)
+
+type mockRecycler bool
+
+func (m *mockRecycler) Recycle() {
+	*m = false
+}
+
+// TestRecyclers verifies that known recyclable types properly return to their
+// zero-value after invoking Recycle.
+func TestRecyclers(t *testing.T) {
+	tests := []struct {
+		name    string
+		newItem func() interface{}
+	}{
+		{
+			"mock recycler",
+			func() interface{} { return new(mockRecycler) },
+		},
+		{
+			"write_buffer",
+			func() interface{} { return new(buffer.Write) },
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			// Initialize the Recycler to test.
+			r := test.newItem().(pool.Recycler)
+
+			// Dirty the item.
+			dirtyGeneric(t, r)
+
+			// Invoke Recycle to clear the item.
+			r.Recycle()
+
+			// Assert the item is now clean.
+			isCleanGeneric(t, r)
+		})
+	}
+}
+
+type recyclePoolTest struct {
+	name    string
+	newPool func() interface{}
+}
+
+// TestGenericRecyclePoolTests generically tests that pools derived from the
+// base Recycle pool properly are properly configured.
+func TestConcreteRecyclePoolTests(t *testing.T) {
+	const (
+		gcInterval     = time.Second
+		expiryInterval = 250 * time.Millisecond
+	)
+
+	tests := []recyclePoolTest{
+		{
+			name: "write buffer pool",
+			newPool: func() interface{} {
+				return pool.NewWriteBuffer(
+					gcInterval, expiryInterval,
+				)
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			testRecyclePool(t, test)
+		})
+	}
+}
+
+func testRecyclePool(t *testing.T, test recyclePoolTest) {
+	p := test.newPool()
+
+	// Take an item from the pool.
+	r1 := takeGeneric(t, p)
+
+	// Dirty the item.
+	dirtyGeneric(t, r1)
+
+	// Return the item to the pool.
+	returnGeneric(t, p, r1)
+
+	// Take items from the pool until we find the original. We expect at
+	// most two, in the event that a fresh item is populated after the
+	// first is taken.
+	for i := 0; i < 2; i++ {
+		// Wait a small duration to ensure the tests are reliable, and
+		// don't to active the non-blocking case unintentionally.
+		<-time.After(time.Millisecond)
+
+		r2 := takeGeneric(t, p)
+
+		// Take an item, skipping those whose pointer does not match the
+		// one we dirtied.
+		if r1 != r2 {
+			continue
+		}
+
+		// Finally, verify that the item has been properly cleaned.
+		isCleanGeneric(t, r2)
+
+		return
+	}
+
+	t.Fatalf("original item not found")
+}
+
+func takeGeneric(t *testing.T, p interface{}) pool.Recycler {
+	t.Helper()
+
+	switch pp := p.(type) {
+	case *pool.WriteBuffer:
+		return pp.Take()
+
+	default:
+		t.Fatalf("unknown pool type: %T", p)
+	}
+
+	return nil
+}
+
+func returnGeneric(t *testing.T, p, item interface{}) {
+	t.Helper()
+
+	switch pp := p.(type) {
+	case *pool.WriteBuffer:
+		pp.Return(item.(*buffer.Write))
+
+	default:
+		t.Fatalf("unknown pool type: %T", p)
+	}
+}
+
+func dirtyGeneric(t *testing.T, i interface{}) {
+	t.Helper()
+
+	switch item := i.(type) {
+	case *mockRecycler:
+		*item = true
+
+	case *buffer.Write:
+		dirtySlice(item[:])
+
+	default:
+		t.Fatalf("unknown item type: %T", i)
+	}
+
+}
+
+func dirtySlice(slice []byte) {
+	for i := range slice {
+		slice[i] = 0xff
+	}
+}
+
+func isCleanGeneric(t *testing.T, i interface{}) {
+	t.Helper()
+
+	switch item := i.(type) {
+	case *mockRecycler:
+		if isDirty := *item; isDirty {
+			t.Fatalf("mock recycler still diry")
+		}
+
+	case *buffer.Write:
+		isCleanSlice(t, item[:])
+
+	default:
+		t.Fatalf("unknown item type: %T", i)
+	}
+}
+
+func isCleanSlice(t *testing.T, slice []byte) {
+	t.Helper()
+
+	expSlice := make([]byte, len(slice))
+	if !bytes.Equal(expSlice, slice) {
+		t.Fatalf("slice not recycled, want: %v, got: %v",
+			expSlice, slice)
+	}
+}