Files
mtusi2026lab6/internal/imaging/imaging_test.go
T

209 lines
5.9 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package imaging
import (
"bytes"
"context"
"encoding/binary"
"image"
"image/color"
"image/jpeg"
"image/png"
"os"
"os/exec"
"testing"
)
func solid(w, h int, c color.Color) *image.NRGBA {
m := image.NewNRGBA(image.Rect(0, 0, w, h))
for y := 0; y < h; y++ {
for x := 0; x < w; x++ {
m.Set(x, y, c)
}
}
return m
}
func encPNG(t *testing.T, img image.Image) []byte {
var b bytes.Buffer
if err := png.Encode(&b, img); err != nil {
t.Fatal(err)
}
return b.Bytes()
}
func TestFitSize(t *testing.T) {
cases := []struct {
w, h, box int
up bool
ww, wh int
}{
{320, 200, 256, false, 256, 160}, // fixture курса
{200, 320, 256, false, 160, 256},
{100, 50, 256, false, 100, 50}, // без увеличения
{5000, 1, 256, false, 256, 1}, // минимум 1 px
{1, 5000, 256, false, 1, 256},
{257, 255, 256, false, 256, 254}, // округление вниз
{40, 30, 128, true, 128, 96},
{3000, 2000, 1280, false, 1280, 853},
}
for _, c := range cases {
if w, h := FitSize(c.w, c.h, c.box, c.up); w != c.ww || h != c.wh {
t.Errorf("FitSize(%d,%d,%d,%v)=%d×%d want %d×%d", c.w, c.h, c.box, c.up, w, h, c.ww, c.wh)
}
}
}
func jpegSize(t *testing.T, data []byte) (int, int) {
cfg, err := jpeg.DecodeConfig(bytes.NewReader(data))
if err != nil {
t.Fatal(err)
}
return cfg.Width, cfg.Height
}
func TestCourseFixtureThumbnail(t *testing.T) {
data, err := os.ReadFile("../../tests/fixtures/sample.png")
if err != nil {
t.Skip("fixture not found")
}
img, err := Decode(data)
if err != nil {
t.Fatal(err)
}
th, err := Thumbnail(img, ParamsFor(1, 80))
if err != nil {
t.Fatal(err)
}
if w, h := jpegSize(t, th.Data); w != 256 || h != 160 || th.Width != 256 || th.Height != 160 {
t.Fatalf("thumbnail %d×%d (meta %d×%d), want 256×160", w, h, th.Width, th.Height)
}
again, _ := Thumbnail(img, ParamsFor(1, 80))
if !bytes.Equal(th.Data, again.Data) {
t.Error("thumbnail encoding is not deterministic")
}
cr, err := Crop(img, ParamsFor(1, 80))
if err != nil {
t.Fatal(err)
}
if w, h := jpegSize(t, cr.Data); w != 128 || h != 128 {
t.Fatalf("crop %d×%d", w, h)
}
v2, _ := Thumbnail(img, ParamsFor(2, 80))
if bytes.Equal(v2.Data, th.Data) {
t.Error("pipeline v2 must produce a different thumbnail")
}
}
func TestSmallImageNotUpscaledButCropIs(t *testing.T) {
img, err := Decode(encPNG(t, solid(40, 30, color.RGBA{10, 20, 30, 255})))
if err != nil {
t.Fatal(err)
}
th, _ := Thumbnail(img, ParamsFor(1, 80))
if th.Width != 40 || th.Height != 30 {
t.Errorf("small thumbnail upscaled to %d×%d", th.Width, th.Height)
}
cr, _ := Crop(img, ParamsFor(1, 80))
if w, h := jpegSize(t, cr.Data); w != 128 || h != 128 {
t.Errorf("crop of small image %d×%d", w, h)
}
}
func TestAlphaOnWhite(t *testing.T) {
img, err := Decode(encPNG(t, solid(10, 10, color.NRGBA{0, 0, 0, 0})))
if err != nil {
t.Fatal(err)
}
if c := img.RGBAAt(5, 5); c.R != 255 || c.G != 255 || c.B != 255 {
t.Errorf("transparent pixel composited to %v, want white", c)
}
half, _ := Decode(encPNG(t, solid(4, 4, color.NRGBA{0, 0, 0, 128})))
if c := half.RGBAAt(1, 1); c.R < 120 || c.R > 135 {
t.Errorf("50%% black over white = %v, want ~127", c)
}
}
// withExif вставляет APP1 Exif с orientation сразу после SOI.
func withExif(jpg []byte, orientation uint16) []byte {
var tiff bytes.Buffer
tiff.WriteString("MM\x00\x2a")
binary.Write(&tiff, binary.BigEndian, uint32(8))
binary.Write(&tiff, binary.BigEndian, uint16(1))
binary.Write(&tiff, binary.BigEndian, uint16(0x0112))
binary.Write(&tiff, binary.BigEndian, uint16(3))
binary.Write(&tiff, binary.BigEndian, uint32(1))
binary.Write(&tiff, binary.BigEndian, orientation)
tiff.Write([]byte{0, 0})
binary.Write(&tiff, binary.BigEndian, uint32(0))
seg := append([]byte("Exif\x00\x00"), tiff.Bytes()...)
var out bytes.Buffer
out.Write(jpg[:2])
out.Write([]byte{0xFF, 0xE1})
binary.Write(&out, binary.BigEndian, uint16(len(seg)+2))
out.Write(seg)
out.Write(jpg[2:])
return out.Bytes()
}
func TestExifOrientation(t *testing.T) {
// 300×100: слева красный, справа синий.
src := image.NewRGBA(image.Rect(0, 0, 300, 100))
for y := 0; y < 100; y++ {
for x := 0; x < 300; x++ {
c := color.RGBA{255, 0, 0, 255}
if x >= 150 {
c = color.RGBA{0, 0, 255, 255}
}
src.Set(x, y, c)
}
}
var b bytes.Buffer
jpeg.Encode(&b, src, &jpeg.Options{Quality: 95})
data := withExif(b.Bytes(), 6) // 90° по часовой
if o := ExifOrientation(data); o != 6 {
t.Fatalf("orientation %d, want 6", o)
}
img, err := Decode(data)
if err != nil {
t.Fatal(err)
}
if img.Bounds().Dx() != 100 || img.Bounds().Dy() != 300 {
t.Fatalf("rotated size %v, want 100×300", img.Bounds())
}
// После поворота на 90° по часовой левая (красная) половина оказывается сверху.
if c := img.RGBAAt(50, 20); c.R < 200 || c.B > 60 {
t.Errorf("top after rotation = %v, want red", c)
}
th, _ := Thumbnail(img, ParamsFor(1, 80))
if th.Width != 85 || th.Height != 256 {
t.Errorf("thumbnail of rotated %d×%d, want 85×256", th.Width, th.Height)
}
if ExifOrientation(b.Bytes()) != 1 {
t.Error("no exif must mean orientation 1")
}
}
func TestDecodeGarbage(t *testing.T) {
if _, err := Decode([]byte("not an image")); err == nil {
t.Fatal("garbage decoded")
}
}
func TestOptimizedWebP(t *testing.T) {
if _, err := exec.LookPath("cwebp"); err != nil {
t.Skip("cwebp not installed (worker image has libwebp-tools)")
}
img, _ := Decode(encPNG(t, solid(2000, 1000, color.RGBA{200, 100, 50, 255})))
out, err := Optimized(context.Background(), img, ParamsFor(1, 80), CWebP)
if err != nil {
t.Fatal(err)
}
if out.Width != 1280 || out.Height != 640 || out.ContentType != "image/webp" {
t.Fatalf("optimized %+v", out)
}
again, _ := Optimized(context.Background(), img, ParamsFor(1, 80), CWebP)
if !bytes.Equal(out.Data, again.Data) {
t.Error("cwebp output not deterministic")
}
}