@@ -1,10 +1,11 @@
 package predictor
 
 import (
 	diff "0dev.org/diff"
 	"bytes"
+	"fmt"
 	"io/ioutil"
 	"testing"
 )
 
 // Sample input from RFC1978 - PPP Predictor Compression Protocol
@@ -21,11 +22,11 @@
 	0x41, 0x41, 0x41, 0x41, 0x41, 0x0a, 0x6f, 0x41,
 	0x0a, 0x6f, 0x41, 0x0a, 0x41, 0x42, 0x41, 0x42,
 	0x41, 0x42, 0x0a, 0x60, 0x42, 0x41, 0x42, 0x41,
 	0x42, 0x0a, 0x60, 0x78, 0x78, 0x78, 0x78, 0x78, 0x0a}
 
-func TestCompressor(t *testing.T) {
+func TestCompressorSample(t *testing.T) {
 	var (
 		buf bytes.Buffer
 		err error
 	)
 
@@ -46,11 +47,11 @@
 	if len(delta.Added) > 0 || len(delta.Removed) > 0 {
 		t.Error("Unexpected compressed output", delta)
 	}
 }
 
-func TestDecompressor(t *testing.T) {
+func TestDecompressorSample(t *testing.T) {
 	in := Decompressor(bytes.NewReader(output))
 	result, err := ioutil.ReadAll(in)
 	if err != nil {
 		t.Error("Unexpected error while decompressing", err)
 	}
@@ -61,35 +62,84 @@
 	if len(delta.Added) > 0 || len(delta.Removed) > 0 {
 		t.Error("Unexpected decompressed output", delta)
 	}
 }
 
-func TestPartial(t *testing.T) {
-	var (
-		input []byte = []byte{0, 1, 2, 3, 4, 5, 6}
-		buf   bytes.Buffer
-		err   error
-	)
-
-	out := Compressor(&buf)
-	err = out(input)
-	if err != nil {
-		t.Error(err)
-	}
-
-	err = out(nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	compressed := buf.Bytes()
-	decompressed, err := ioutil.ReadAll(Decompressor(bytes.NewReader(compressed)))
-
+func TestEmptyCycle(t *testing.T) {
+	var input []byte = []byte{}
+
+	if err := cycle(input); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPartialCycle(t *testing.T) {
+	var input []byte = []byte{0, 1, 2, 3}
+
+	if err := cycle(input); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestBlockCycle(t *testing.T) {
+	var input []byte = []byte{0, 1, 2, 3, 4, 5, 6, 7}
+
+	if err := cycle(input); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestBlockPartialCycle(t *testing.T) {
+	var input []byte = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+
+	if err := cycle(input); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDualBlockCycle(t *testing.T) {
+	var input []byte = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+
+	if err := cycle(input); err != nil {
+		t.Error(err)
+	}
+}
+
+func cycle(input []byte) error {
+	var (
+		buf bytes.Buffer
+		err error
+	)
+
+	// Create a compressor and write the given data
+	compressor := Compressor(&buf)
+	err = compressor(input)
+	if err != nil {
+		return err
+	}
+
+	// Flush the compressor
+	err = compressor(nil)
+	if err != nil {
+		return err
+	}
+
+	// Attempt to decompress the data
+	compressed := buf.Bytes()
+	decompressed, err := ioutil.ReadAll(Decompressor(bytes.NewReader(compressed)))
+	if err != nil {
+		return err
+	}
+
+	// Diff the result against the initial input
 	delta := diff.Diff(diff.D{len(input), len(decompressed),
 		func(i, j int) bool { return input[i] == decompressed[j] }})
 
+	// Return a well-formated error if any differences are found
 	if len(delta.Added) > 0 || len(delta.Removed) > 0 {
-		t.Error("Unexpected decompressed output", delta)
-		t.Errorf("%#x", input)
-		t.Errorf("%#x", decompressed)
+		return fmt.Errorf("Unexpected decompressed output %v\ninput:  %#x\noutput: %#x\n",
+			delta, input, decompressed)
 	}
+
+	// All is good :)
+	return nil
 }