148 lines
3.6 KiB
Go
148 lines
3.6 KiB
Go
package test
|
|
|
|
import (
|
|
"bytes"
|
|
"image"
|
|
"image/color"
|
|
"image/draw"
|
|
"image/gif"
|
|
"image/jpeg"
|
|
"image/png"
|
|
"math/rand"
|
|
"testing"
|
|
|
|
"golang.org/x/image/webp"
|
|
)
|
|
|
|
var (
|
|
variantRed = color.NRGBA{R: 255, A: 255}
|
|
variantGreen = color.NRGBA{G: 255, A: 255}
|
|
variantBlue = color.NRGBA{B: 255, A: 255}
|
|
)
|
|
|
|
func variantSolidImage(width int, height int, fill color.NRGBA) *image.NRGBA {
|
|
canvas := image.NewNRGBA(image.Rect(0, 0, width, height))
|
|
draw.Draw(canvas, canvas.Bounds(), image.NewUniform(fill), image.Point{}, draw.Src)
|
|
return canvas
|
|
}
|
|
|
|
func encodePNG(t *testing.T, source image.Image) []byte {
|
|
t.Helper()
|
|
var buffer bytes.Buffer
|
|
if err := png.Encode(&buffer, source); err != nil {
|
|
t.Fatalf("png encode failed: %v", err)
|
|
}
|
|
return buffer.Bytes()
|
|
}
|
|
|
|
func encodeJPEG(t *testing.T, source image.Image) []byte {
|
|
t.Helper()
|
|
var buffer bytes.Buffer
|
|
if err := jpeg.Encode(&buffer, source, &jpeg.Options{Quality: 90}); err != nil {
|
|
t.Fatalf("jpeg encode failed: %v", err)
|
|
}
|
|
return buffer.Bytes()
|
|
}
|
|
|
|
func solidPNG(t *testing.T, width int, height int) []byte {
|
|
t.Helper()
|
|
return encodePNG(t, variantSolidImage(width, height, variantRed))
|
|
}
|
|
|
|
func stripedImage(t *testing.T) *image.NRGBA {
|
|
t.Helper()
|
|
canvas := image.NewNRGBA(image.Rect(0, 0, 40, 20))
|
|
for x := 0; x < 40; x++ {
|
|
fill := variantGreen
|
|
if x < 10 {
|
|
fill = variantRed
|
|
}
|
|
if x >= 30 {
|
|
fill = variantBlue
|
|
}
|
|
for y := 0; y < 20; y++ {
|
|
canvas.SetNRGBA(x, y, fill)
|
|
}
|
|
}
|
|
return canvas
|
|
}
|
|
|
|
func noisyImage(width int, height int) *image.NRGBA {
|
|
generator := rand.New(rand.NewSource(7))
|
|
canvas := image.NewNRGBA(image.Rect(0, 0, width, height))
|
|
for offset := 0; offset < len(canvas.Pix); offset += 4 {
|
|
canvas.Pix[offset] = uint8(generator.Intn(256))
|
|
canvas.Pix[offset+1] = uint8(generator.Intn(256))
|
|
canvas.Pix[offset+2] = uint8(generator.Intn(256))
|
|
canvas.Pix[offset+3] = 255
|
|
}
|
|
return canvas
|
|
}
|
|
|
|
func animatedGIF(t *testing.T) []byte {
|
|
t.Helper()
|
|
return encodeGIF(t, 2)
|
|
}
|
|
|
|
func stillGIF(t *testing.T) []byte {
|
|
t.Helper()
|
|
return encodeGIF(t, 1)
|
|
}
|
|
|
|
func encodeGIF(t *testing.T, frames int) []byte {
|
|
t.Helper()
|
|
palette := color.Palette{color.White, color.Black}
|
|
animation := &gif.GIF{}
|
|
for frame := 0; frame < frames; frame++ {
|
|
paletted := image.NewPaletted(image.Rect(0, 0, 8, 8), palette)
|
|
paletted.SetColorIndex(frame, frame, 1)
|
|
animation.Image = append(animation.Image, paletted)
|
|
animation.Delay = append(animation.Delay, 10)
|
|
}
|
|
var buffer bytes.Buffer
|
|
if err := gif.EncodeAll(&buffer, animation); err != nil {
|
|
t.Fatalf("gif encode failed: %v", err)
|
|
}
|
|
return buffer.Bytes()
|
|
}
|
|
|
|
func decodeImage(t *testing.T, content []byte) (image.Image, string) {
|
|
t.Helper()
|
|
decoded, format, err := image.Decode(bytes.NewReader(content))
|
|
if err != nil {
|
|
t.Fatalf("decode failed: %v", err)
|
|
}
|
|
return decoded, format
|
|
}
|
|
|
|
func decodedSize(t *testing.T, content []byte) (int, int) {
|
|
t.Helper()
|
|
config, _, err := image.DecodeConfig(bytes.NewReader(content))
|
|
if err != nil {
|
|
t.Fatalf("decode config failed: %v", err)
|
|
}
|
|
return config.Width, config.Height
|
|
}
|
|
|
|
func webpSize(t *testing.T, content []byte) (int, int) {
|
|
t.Helper()
|
|
config, err := webp.DecodeConfig(bytes.NewReader(content))
|
|
if err != nil {
|
|
t.Fatalf("webp decode config failed: %v", err)
|
|
}
|
|
return config.Width, config.Height
|
|
}
|
|
|
|
func pixelAt(decoded image.Image, x int, y int) color.NRGBA {
|
|
return color.NRGBAModel.Convert(decoded.At(x, y)).(color.NRGBA)
|
|
}
|
|
|
|
func padSizedPNG(t *testing.T, size int) []byte {
|
|
t.Helper()
|
|
content := solidPNG(t, 8, 8)
|
|
if len(content) > size {
|
|
t.Fatalf("base png is larger than %d bytes", size)
|
|
}
|
|
return append(content, make([]byte, size-len(content))...)
|
|
}
|