cleanup and add tests

Author: jxsl13

Makefile

@@ -3,4 +3,8 @@ test:
 	go test -v -race -count=1 ./...
 
 fuzz_write:
-	go test -v -race -count=1 -fuzz=FuzzWrite -fuzztime 120s ./...
+	go test -v -race -count=1 -fuzz=FuzzWriterWrite -fuzztime 120s .
+
+
+fuzz_compress_decompress:
+	go test -fuzz=FuzzHuffmannCompressDecompress -fuzztime 120s .

huffmann_test.go

@@ -1,6 +1,7 @@
 package huffman
 
 import (
+	"bytes"
 	"reflect"
 	"testing"
 )
@@ -151,7 +152,47 @@ func TestCompressEmpty(t *testing.T) {
 	huff := NewHuffman()
 
 	_, err := huff.Compress([]byte{})
-	if err == nil {
-		t.Errorf("Expected error on empty input")
+	if err != nil {
+		t.Errorf("Expected error no error on empty input: %v", err)
+	}
+}
+
+func TestDecompressEmpty(t *testing.T) {
+	huff := NewHuffman()
+
+	_, err := huff.Decompress([]byte{})
+	if err != nil {
+		t.Errorf("Expected error no error on empty input: %v", err)
 	}
 }
+
+func FuzzHuffmannCompressDecompress(f *testing.F) {
+	f.Add([]byte("hello"))
+	f.Add([]byte("1234567890"))
+	f.Add([]byte("1234567890abcdef"))
+	f.Add([]byte("1234567890abcdef1234567890abcdef"))
+	f.Add([]byte("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"))
+	f.Add([]byte("cfgvlhböjnhavUBÖObv)öob"))
+
+	f.Fuzz(func(t *testing.T, data []byte) {
+		if len(data) == 0 {
+			return
+		}
+
+		huff := NewHuffman()
+
+		compressed, err := huff.Compress(data)
+		if err != nil {
+			t.Fatalf("Unexpected compression error: %v", err)
+		}
+
+		decompressed, err := huff.Decompress(compressed)
+		if err != nil {
+			t.Fatalf("Unexpected decompression error: %v", err)
+		}
+
+		if !bytes.Equal(decompressed, data) {
+			t.Fatalf("wanted %v, got %v", data, decompressed)
+		}
+	})
+}

writer_test.go

@@ -7,9 +7,7 @@ import (
 	"testing"
 )
 
-func FuzzWrite(f *testing.F) {
-	refHuffman := NewHuffman()
-
+func FuzzWriterWrite(f *testing.F) {
 	f.Add([]byte{})
 	f.Add([]byte("hello"))
 	f.Add([]byte("1234567890"))
@@ -96,35 +94,37 @@ func FuzzWrite(f *testing.F) {
 		0x03, 0x22, 0x02, 0x00, 0x00, 0x17,
 	})
 
-	dict := NewDictionary()
-
 	f.Fuzz(func(t *testing.T, data []byte) {
-		// TODO: except for the case where no data is passed, Compress and Write should do the same.
-		if len(data) == 0 {
-			return
-		}
-		inputStream := bytes.NewReader(data)
-		compressedStream := bytes.NewBuffer(make([]byte, 0, len(data)))
+		testWriteAndCompareWithCompress(t, data)
+	})
+}
 
-		w := NewWriterDict(dict, compressedStream)
-		n, err := io.CopyBuffer(w, inputStream, make([]byte, 2)) // we want to test with a small buffer explicitly
-		if err != nil {
-			t.Fatalf("error writing: %v", err)
-		}
+func testWriteAndCompareWithCompress(t *testing.T, data []byte) {
 
-		if n != int64(len(data)) {
-			t.Fatalf("expected to write %d bytes, wrote %d", len(data), n)
-		}
+	var (
+		huff             = NewHuffman()
+		inputStream      = bytes.NewReader(data)
+		compressedStream = bytes.NewBuffer(make([]byte, 0, len(data)))
+		w                = NewWriter(compressedStream)
+	)
 
-		compressed, err := refHuffman.Compress(data)
-		if err != nil {
-			t.Fatalf("error compressing: %v", err)
-		}
+	n, err := io.CopyBuffer(w, inputStream, make([]byte, 1)) // we want to test with a small buffer explicitly
+	if err != nil {
+		t.Fatalf("error writing: %v", err)
+	}
 
-		if !bytes.Equal(compressed, compressedStream.Bytes()) {
-			t.Fatalf("expected %v(%s), got %v(%s)", compressed, string(compressed), compressedStream.Bytes(), string(compressedStream.Bytes()))
-		}
-	})
+	if n != int64(len(data)) {
+		t.Fatalf("expected to write %d bytes, wrote %d", len(data), n)
+	}
+
+	compressed, err := huff.Compress(data)
+	if err != nil {
+		t.Fatalf("error compressing: %v", err)
+	}
+
+	if !bytes.Equal(compressed, compressedStream.Bytes()) {
+		t.Fatalf("expected %v(%s), got %v(%s)", compressed, string(compressed), compressedStream.Bytes(), compressedStream.String())
+	}
 }
 
 func BenchmarkCompression(b *testing.B) {