mirror of https://mirror.trustie.net/root/bimg.git
255 lines
5.2 KiB
Go
255 lines
5.2 KiB
Go
package bimg
|
|
|
|
import (
|
|
"io/ioutil"
|
|
"os"
|
|
"path"
|
|
"testing"
|
|
)
|
|
|
|
func TestVipsRead(t *testing.T) {
|
|
files := []struct {
|
|
name string
|
|
expected ImageType
|
|
}{
|
|
{"test.jpg", JPEG},
|
|
{"test.png", PNG},
|
|
{"test.webp", WEBP},
|
|
}
|
|
|
|
for _, file := range files {
|
|
image, imageType, _ := vipsRead(readImage(file.name))
|
|
if image == nil {
|
|
t.Fatal("Empty image")
|
|
}
|
|
if imageType != file.expected {
|
|
t.Fatal("Invalid image type")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestVipsSave(t *testing.T) {
|
|
types := [...]ImageType{JPEG, PNG, WEBP}
|
|
|
|
for _, typ := range types {
|
|
image, _, _ := vipsRead(readImage("test.jpg"))
|
|
options := vipsSaveOptions{Quality: 95, Type: typ, StripMetadata: true}
|
|
|
|
buf, err := vipsSave(image, options)
|
|
if err != nil {
|
|
t.Fatalf("Cannot save the image as '%v'", ImageTypes[typ])
|
|
}
|
|
if len(buf) == 0 {
|
|
t.Fatalf("Empty saved '%v' image", ImageTypes[typ])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestVipsSaveTiff(t *testing.T) {
|
|
if !IsTypeSupportedSave(TIFF) {
|
|
t.Skipf("Format %#v is not supported", ImageTypes[TIFF])
|
|
}
|
|
image, _, _ := vipsRead(readImage("test.jpg"))
|
|
options := vipsSaveOptions{Quality: 95, Type: TIFF}
|
|
buf, _ := vipsSave(image, options)
|
|
|
|
if len(buf) == 0 {
|
|
t.Fatalf("Empty saved '%v' image", ImageTypes[TIFF])
|
|
}
|
|
}
|
|
|
|
func TestVipsSaveAvif(t *testing.T) {
|
|
if !IsTypeSupportedSave(AVIF) {
|
|
t.Skipf("Format %#v is not supported", ImageTypes[AVIF])
|
|
}
|
|
image, _, _ := vipsRead(readImage("test.jpg"))
|
|
options := vipsSaveOptions{Quality: 95, Type: AVIF, Speed: 8}
|
|
buf, err := vipsSave(image, options)
|
|
if err != nil {
|
|
t.Fatalf("Error saving image type %v: %v", ImageTypes[AVIF], err)
|
|
}
|
|
|
|
if len(buf) == 0 {
|
|
t.Fatalf("Empty saved '%v' image", ImageTypes[AVIF])
|
|
}
|
|
}
|
|
|
|
func TestVipsRotate(t *testing.T) {
|
|
files := []struct {
|
|
name string
|
|
rotate Angle
|
|
}{
|
|
{"test.jpg", D90},
|
|
{"test_square.jpg", D45},
|
|
}
|
|
|
|
for _, file := range files {
|
|
image, _, _ := vipsRead(readImage(file.name))
|
|
|
|
newImg, err := vipsRotate(image, file.rotate)
|
|
if err != nil {
|
|
t.Fatal("Cannot rotate the image")
|
|
}
|
|
|
|
buf, _ := vipsSave(newImg, vipsSaveOptions{Quality: 95})
|
|
if len(buf) == 0 {
|
|
t.Fatal("Empty image")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestVipsAutoRotate(t *testing.T) {
|
|
if VipsMajorVersion <= 8 && VipsMinorVersion < 10 {
|
|
t.Skip("Skip test in libvips < 8.10")
|
|
return
|
|
}
|
|
|
|
files := []struct {
|
|
name string
|
|
orientation int
|
|
}{
|
|
{"test.jpg", 0},
|
|
{"test_exif.jpg", 0},
|
|
{"exif/Landscape_1.jpg", 0},
|
|
{"exif/Landscape_2.jpg", 0},
|
|
{"exif/Landscape_3.jpg", 0},
|
|
{"exif/Landscape_4.jpg", 0},
|
|
{"exif/Landscape_5.jpg", 5},
|
|
{"exif/Landscape_6.jpg", 0},
|
|
{"exif/Landscape_7.jpg", 7},
|
|
}
|
|
|
|
for _, file := range files {
|
|
image, _, _ := vipsRead(readImage(file.name))
|
|
|
|
newImg, err := vipsAutoRotate(image)
|
|
if err != nil {
|
|
t.Fatal("Cannot auto rotate the image")
|
|
}
|
|
|
|
orientation := vipsExifOrientation(newImg)
|
|
if orientation != file.orientation {
|
|
t.Fatalf("Invalid image orientation: %d != %d", orientation, file.orientation)
|
|
}
|
|
|
|
buf, _ := vipsSave(newImg, vipsSaveOptions{Quality: 95})
|
|
if len(buf) == 0 {
|
|
t.Fatal("Empty image")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestVipsZoom(t *testing.T) {
|
|
image, _, _ := vipsRead(readImage("test.jpg"))
|
|
|
|
newImg, err := vipsZoom(image, 1)
|
|
if err != nil {
|
|
t.Fatal("Cannot save the image")
|
|
}
|
|
|
|
buf, _ := vipsSave(newImg, vipsSaveOptions{Quality: 95})
|
|
if len(buf) == 0 {
|
|
t.Fatal("Empty image")
|
|
}
|
|
}
|
|
|
|
func TestVipsWatermark(t *testing.T) {
|
|
image, _, _ := vipsRead(readImage("test.jpg"))
|
|
|
|
watermark := Watermark{
|
|
Text: "Copy me if you can",
|
|
Font: "sans bold 12",
|
|
Opacity: 0.5,
|
|
Width: 200,
|
|
DPI: 100,
|
|
Margin: 100,
|
|
Background: Color{255, 255, 255},
|
|
}
|
|
|
|
newImg, err := vipsWatermark(image, watermark)
|
|
if err != nil {
|
|
t.Errorf("Cannot add watermark: %s", err)
|
|
}
|
|
|
|
buf, _ := vipsSave(newImg, vipsSaveOptions{Quality: 95})
|
|
if len(buf) == 0 {
|
|
t.Fatal("Empty image")
|
|
}
|
|
}
|
|
|
|
func TestVipsWatermarkWithImage(t *testing.T) {
|
|
image, _, _ := vipsRead(readImage("test.jpg"))
|
|
|
|
watermark := readImage("transparent.png")
|
|
|
|
options := WatermarkImage{Left: 100, Top: 100, Opacity: 1.0, Buf: watermark}
|
|
newImg, err := vipsDrawWatermark(image, options)
|
|
if err != nil {
|
|
t.Errorf("Cannot add watermark: %s", err)
|
|
}
|
|
|
|
buf, _ := vipsSave(newImg, vipsSaveOptions{Quality: 95})
|
|
if len(buf) == 0 {
|
|
t.Fatal("Empty image")
|
|
}
|
|
}
|
|
|
|
func TestVipsImageType(t *testing.T) {
|
|
imgType := vipsImageType(readImage("test.jpg"))
|
|
if imgType != JPEG {
|
|
t.Fatal("Invalid image type")
|
|
}
|
|
}
|
|
|
|
func TestVipsImageTypeInvalid(t *testing.T) {
|
|
imgType := vipsImageType([]byte("vip"))
|
|
if imgType != UNKNOWN {
|
|
t.Fatal("Invalid image type")
|
|
}
|
|
}
|
|
|
|
func TestVipsMemory(t *testing.T) {
|
|
mem := VipsMemory()
|
|
|
|
if mem.Memory < 1024 {
|
|
t.Fatal("Invalid memory")
|
|
}
|
|
if mem.Allocations == 0 {
|
|
t.Fatal("Invalid memory allocations")
|
|
}
|
|
}
|
|
|
|
func TestVipsExifShort(t *testing.T) {
|
|
tt := []struct {
|
|
input string
|
|
expected string
|
|
}{
|
|
{
|
|
input: `( ()`,
|
|
expected: `(`,
|
|
},
|
|
{
|
|
input: ` ()`,
|
|
expected: ` ()`,
|
|
},
|
|
{
|
|
input: `sRGB`,
|
|
expected: `sRGB`,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tt {
|
|
got := vipsExifShort(tc.input)
|
|
if got != tc.expected {
|
|
t.Fatalf("expected: %s; got: %s", tc.expected, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func readImage(file string) []byte {
|
|
img, _ := os.Open(path.Join("testdata", file))
|
|
buf, _ := ioutil.ReadAll(img)
|
|
defer img.Close()
|
|
return buf
|
|
}
|