tests: add testdata & golden tests

adjust_test.go

@@ -206,6 +206,26 @@ func TestAdjustContrast(t *testing.T) {
 	}
 }
 
+func TestAdjustContrastGolden(t *testing.T) {
+	src, err := Open("testdata/lena_128.png")
+	if err != nil {
+		t.Errorf("Open: %v", err)
+	}
+	for name, p := range map[string]float64{
+		"out_contrast_m10.png": -10,
+		"out_contrast_p10.png": 10,
+	} {
+		got := AdjustContrast(src, p)
+		want, err := Open("testdata/" + name)
+		if err != nil {
+			t.Errorf("Open: %v", err)
+		}
+		if !compareNRGBA(got, toNRGBA(want), 0) {
+			t.Errorf("resulting image differs from golden: %s", name)
+		}
+	}
+}
+
 func TestAdjustBrightness(t *testing.T) {
 	td := []struct {
 		desc string
@@ -333,6 +353,26 @@ func TestAdjustBrightness(t *testing.T) {
 	}
 }
 
+func TestAdjustBrightnessGolden(t *testing.T) {
+	src, err := Open("testdata/lena_128.png")
+	if err != nil {
+		t.Errorf("Open: %v", err)
+	}
+	for name, p := range map[string]float64{
+		"out_brightness_m10.png": -10,
+		"out_brightness_p10.png": 10,
+	} {
+		got := AdjustBrightness(src, p)
+		want, err := Open("testdata/" + name)
+		if err != nil {
+			t.Errorf("Open: %v", err)
+		}
+		if !compareNRGBA(got, toNRGBA(want), 0) {
+			t.Errorf("resulting image differs from golden: %s", name)
+		}
+	}
+}
+
 func TestAdjustGamma(t *testing.T) {
 	td := []struct {
 		desc string
@@ -416,6 +456,26 @@ func TestAdjustGamma(t *testing.T) {
 	}
 }
 
+func TestAdjustGammaGolden(t *testing.T) {
+	src, err := Open("testdata/lena_128.png")
+	if err != nil {
+		t.Errorf("Open: %v", err)
+	}
+	for name, g := range map[string]float64{
+		"out_gamma_0.75.png": 0.75,
+		"out_gamma_1.25.png": 1.25,
+	} {
+		got := AdjustGamma(src, g)
+		want, err := Open("testdata/" + name)
+		if err != nil {
+			t.Errorf("Open: %v", err)
+		}
+		if !compareNRGBA(got, toNRGBA(want), 0) {
+			t.Errorf("resulting image differs from golden: %s", name)
+		}
+	}
+}
+
 func TestAdjustSigmoid(t *testing.T) {
 	td := []struct {
 		desc string

convolution_test.go

@@ -2,7 +2,6 @@ package imaging
 
 import (
 	"image"
-	"image/color"
 	"testing"
 )
 
@@ -234,14 +233,12 @@ func TestConvolve5x5(t *testing.T) {
 }
 
 func BenchmarkConvolve3x3(b *testing.B) {
-	r := image.Rect(0, 0, 500, 500)
-	img := image.NewRGBA(r)
-	for x := r.Min.X; x < r.Max.X; x++ {
-		for y := r.Min.Y; y < r.Max.Y; y++ {
-			img.SetRGBA(x, y, color.RGBA{uint8(x % 255), uint8(y % 255), uint8((x + y) % 255), 255})
-		}
+	b.StopTimer()
+	img, err := Open("testdata/lena_512.png")
+	if err != nil {
+		b.Fatalf("Open: %v", err)
 	}
-	b.ResetTimer()
+	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		Convolve3x3(
 			img,
@@ -256,14 +253,12 @@ func BenchmarkConvolve3x3(b *testing.B) {
 }
 
 func BenchmarkConvolve5x5(b *testing.B) {
-	r := image.Rect(0, 0, 500, 500)
-	img := image.NewRGBA(r)
-	for x := r.Min.X; x < r.Max.X; x++ {
-		for y := r.Min.Y; y < r.Max.Y; y++ {
-			img.SetRGBA(x, y, color.RGBA{uint8(x % 255), uint8(y % 255), uint8((x + y) % 255), 255})
-		}
+	b.StopTimer()
+	img, err := Open("testdata/lena_512.png")
+	if err != nil {
+		b.Fatalf("Open: %v", err)
 	}
-	b.ResetTimer()
+	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		Convolve5x5(
 			img,

effects_test.go

@@ -88,6 +88,26 @@ func TestBlur(t *testing.T) {
 	}
 }
 
+func TestBlurGolden(t *testing.T) {
+	src, err := Open("testdata/lena_128.png")
+	if err != nil {
+		t.Errorf("Open: %v", err)
+	}
+	for name, sigma := range map[string]float64{
+		"out_blur_0.5.png": 0.5,
+		"out_blur_1.5.png": 1.5,
+	} {
+		got := Blur(src, sigma)
+		want, err := Open("testdata/" + name)
+		if err != nil {
+			t.Errorf("Open: %v", err)
+		}
+		if !compareNRGBA(got, toNRGBA(want), 0) {
+			t.Errorf("resulting image differs from golden: %s", name)
+		}
+	}
+}
+
 func TestSharpen(t *testing.T) {
 	td := []struct {
 		desc  string
@@ -188,3 +208,23 @@ func TestSharpen(t *testing.T) {
 		}
 	}
 }
+
+func TestSharpenGolden(t *testing.T) {
+	src, err := Open("testdata/lena_128.png")
+	if err != nil {
+		t.Errorf("Open: %v", err)
+	}
+	for name, sigma := range map[string]float64{
+		"out_sharpen_0.5.png": 0.5,
+		"out_sharpen_1.5.png": 1.5,
+	} {
+		got := Sharpen(src, sigma)
+		want, err := Open("testdata/" + name)
+		if err != nil {
+			t.Errorf("Open: %v", err)
+		}
+		if !compareNRGBA(got, toNRGBA(want), 0) {
+			t.Errorf("resulting image differs from golden: %s", name)
+		}
+	}
+}

resize_test.go

@@ -2,7 +2,6 @@ package imaging
 
 import (
 	"image"
-	"image/color"
 	"testing"
 )
 
@@ -159,7 +158,7 @@ func TestResize(t *testing.T) {
 	for _, d := range td {
 		got := Resize(d.src, d.w, d.h, d.f)
 		want := d.want
-		if !compareNRGBA(got, want, 1) {
+		if !compareNRGBA(got, want, 0) {
 			t.Errorf("test [%s] failed: %#v", d.desc, got)
 		}
 	}
@@ -202,6 +201,28 @@ func TestResize(t *testing.T) {
 	}
 }
 
+func TestResizeGolden(t *testing.T) {
+	src, err := Open("testdata/lena_512.png")
+	if err != nil {
+		t.Errorf("Open: %v", err)
+	}
+	for name, filter := range map[string]ResampleFilter{
+		"out_resize_nearest.png": NearestNeighbor,
+		"out_resize_linear.png":  Linear,
+		"out_resize_catrom.png":  CatmullRom,
+		"out_resize_lanczos.png": Lanczos,
+	} {
+		got := Resize(src, 128, 0, filter)
+		want, err := Open("testdata/" + name)
+		if err != nil {
+			t.Errorf("Open: %v", err)
+		}
+		if !compareNRGBA(got, toNRGBA(want), 0) {
+			t.Errorf("resulting image differs from golden: %s", name)
+		}
+	}
+}
+
 func TestFit(t *testing.T) {
 	td := []struct {
 		desc string
@@ -571,39 +592,37 @@ func TestThumbnail(t *testing.T) {
 }
 
 func BenchmarkResizeLanczosUp(b *testing.B) {
-	benchmarkResize(b, 50, 500, Lanczos)
+	benchmarkResize(b, "testdata/lena_128.png", 512, Lanczos)
 }
 
 func BenchmarkResizeLinearUp(b *testing.B) {
-	benchmarkResize(b, 50, 500, Linear)
+	benchmarkResize(b, "testdata/lena_128.png", 512, Linear)
 }
 
 func BenchmarkResizeNearestNeighborUp(b *testing.B) {
-	benchmarkResize(b, 50, 500, NearestNeighbor)
+	benchmarkResize(b, "testdata/lena_128.png", 512, NearestNeighbor)
 }
 
 func BenchmarkResizeLanczosDown(b *testing.B) {
-	benchmarkResize(b, 500, 50, Lanczos)
+	benchmarkResize(b, "testdata/lena_512.png", 128, Lanczos)
 }
 
 func BenchmarkResizeLinearDown(b *testing.B) {
-	benchmarkResize(b, 500, 50, Linear)
+	benchmarkResize(b, "testdata/lena_512.png", 128, Linear)
 }
 
 func BenchmarkResizeNearestNeighborDown(b *testing.B) {
-	benchmarkResize(b, 500, 50, NearestNeighbor)
+	benchmarkResize(b, "testdata/lena_512.png", 128, NearestNeighbor)
 }
 
-func benchmarkResize(b *testing.B, size1, size2 int, f ResampleFilter) {
-	r := image.Rect(0, 0, size1, size1)
-	img := image.NewRGBA(r)
-	for x := r.Min.X; x < r.Max.X; x++ {
-		for y := r.Min.Y; y < r.Max.Y; y++ {
-			img.SetRGBA(x, y, color.RGBA{uint8(x % 255), uint8(y % 255), uint8((x + y) % 255), 255})
-		}
+func benchmarkResize(b *testing.B, filename string, size int, f ResampleFilter) {
+	b.StopTimer()
+	img, err := Open(filename)
+	if err != nil {
+		b.Fatalf("Open: %v", err)
 	}
-	b.ResetTimer()
+	b.StartTimer()
 	for i := 0; i < b.N; i++ {
-		Resize(img, size2, size2, f)
+		Resize(img, size, size, f)
 	}
 }

tools_test.go

@@ -598,7 +598,7 @@ func TestOverlay(t *testing.T) {
 	for _, d := range td {
 		got := Overlay(d.src1, d.src2, d.p, d.a)
 		want := d.want
-		if !compareNRGBA(got, want, 1) {
+		if !compareNRGBA(got, want, 0) {
 			t.Errorf("test [%s] failed: %#v", d.desc, got)
 		}
 	}

utils_test.go

@@ -59,11 +59,3 @@ func TestClamp(t *testing.T) {
 		}
 	}
 }
-
-func BenchmarkClamp(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		for _, x := range []float64{0.49, 0.51, 254.1, 254.9, 128, -1, 256} {
-			clamp(x)
-		}
-	}
-}