libgo/go/image/gif/writer_test.go - rust-lang/gcc - Git at Google

 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package gif

 import (
 	"bytes"
 	"image"
 	"image/color"
 	"image/color/palette"
 	_ "image/png"
 	"io/ioutil"
 	"math/rand"
 	"os"
 	"reflect"
 	"testing"
 )

 func readImg(filename string) (image.Image, error) {
 	f, err := os.Open(filename)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	m, _, err := image.Decode(f)
 	return m, err
 }

 func readGIF(filename string) (*GIF, error) {
 	f, err := os.Open(filename)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	return DecodeAll(f)
 }

 func delta(u0, u1 uint32) int64 {
 	d := int64(u0) - int64(u1)
 	if d < 0 {
 		return -d
 	}
 	return d
 }

 // averageDelta returns the average delta in RGB space. The two images must
 // have the same bounds.
 func averageDelta(m0, m1 image.Image) int64 {
 	b := m0.Bounds()
 	var sum, n int64
 	for y := b.Min.Y; y < b.Max.Y; y++ {
 		for x := b.Min.X; x < b.Max.X; x++ {
 			c0 := m0.At(x, y)
 			c1 := m1.At(x, y)
 			r0, g0, b0, _ := c0.RGBA()
 			r1, g1, b1, _ := c1.RGBA()
 			sum += delta(r0, r1)
 			sum += delta(g0, g1)
 			sum += delta(b0, b1)
 			n += 3
 		}
 	}
 	return sum / n
 }

 var testCase = []struct {
 	filename  string
 	tolerance int64
 }{
 	{"../testdata/video-001.png", 1 << 12},
 	{"../testdata/video-001.gif", 0},
 	{"../testdata/video-001.interlaced.gif", 0},
 }

 func TestWriter(t *testing.T) {
 	for _, tc := range testCase {
 		m0, err := readImg(tc.filename)
 		if err != nil {
 			t.Error(tc.filename, err)
 			continue
 		}
 		var buf bytes.Buffer
 		err = Encode(&buf, m0, nil)
 		if err != nil {
 			t.Error(tc.filename, err)
 			continue
 		}
 		m1, err := Decode(&buf)
 		if err != nil {
 			t.Error(tc.filename, err)
 			continue
 		}
 		if m0.Bounds() != m1.Bounds() {
 			t.Errorf("%s, bounds differ: %v and %v", tc.filename, m0.Bounds(), m1.Bounds())
 			continue
 		}
 		// Compare the average delta to the tolerance level.
 		avgDelta := averageDelta(m0, m1)
 		if avgDelta > tc.tolerance {
 			t.Errorf("%s: average delta is too high. expected: %d, got %d", tc.filename, tc.tolerance, avgDelta)
 			continue
 		}
 	}
 }

 func TestSubImage(t *testing.T) {
 	m0, err := readImg("../testdata/video-001.gif")
 	if err != nil {
 		t.Fatalf("readImg: %v", err)
 	}
 	m0 = m0.(*image.Paletted).SubImage(image.Rect(0, 0, 50, 30))
 	var buf bytes.Buffer
 	err = Encode(&buf, m0, nil)
 	if err != nil {
 		t.Fatalf("Encode: %v", err)
 	}
 	m1, err := Decode(&buf)
 	if err != nil {
 		t.Fatalf("Decode: %v", err)
 	}
 	if m0.Bounds() != m1.Bounds() {
 		t.Fatalf("bounds differ: %v and %v", m0.Bounds(), m1.Bounds())
 	}
 	if averageDelta(m0, m1) != 0 {
 		t.Fatalf("images differ")
 	}
 }

 // palettesEqual reports whether two color.Palette values are equal, ignoring
 // any trailing opaque-black palette entries.
 func palettesEqual(p, q color.Palette) bool {
 	n := len(p)
 	if n > len(q) {
 		n = len(q)
 	}
 	for i := 0; i < n; i++ {
 		if p[i] != q[i] {
 			return false
 		}
 	}
 	for i := n; i < len(p); i++ {
 		r, g, b, a := p[i].RGBA()
 		if r != 0 || g != 0 || b != 0 || a != 0xffff {
 			return false
 		}
 	}
 	for i := n; i < len(q); i++ {
 		r, g, b, a := q[i].RGBA()
 		if r != 0 || g != 0 || b != 0 || a != 0xffff {
 			return false
 		}
 	}
 	return true
 }

 var frames = []string{
 	"../testdata/video-001.gif",
 	"../testdata/video-005.gray.gif",
 }

 func testEncodeAll(t *testing.T, go1Dot5Fields bool, useGlobalColorModel bool) {
 	const width, height = 150, 103

 	g0 := &GIF{
 		Image:     make([]*image.Paletted, len(frames)),
 		Delay:     make([]int, len(frames)),
 		LoopCount: 5,
 	}
 	for i, f := range frames {
 		g, err := readGIF(f)
 		if err != nil {
 			t.Fatal(f, err)
 		}
 		m := g.Image[0]
 		if m.Bounds().Dx() != width || m.Bounds().Dy() != height {
 			t.Fatalf("frame %d had unexpected bounds: got %v, want width/height = %d/%d",
 				i, m.Bounds(), width, height)
 		}
 		g0.Image[i] = m
 	}
 	// The GIF.Disposal, GIF.Config and GIF.BackgroundIndex fields were added
 	// in Go 1.5. Valid Go 1.4 or earlier code should still produce valid GIFs.
 	//
 	// On the following line, color.Model is an interface type, and
 	// color.Palette is a concrete (slice) type.
 	globalColorModel, backgroundIndex := color.Model(color.Palette(nil)), uint8(0)
 	if useGlobalColorModel {
 		globalColorModel, backgroundIndex = color.Palette(palette.WebSafe), uint8(1)
 	}
 	if go1Dot5Fields {
 		g0.Disposal = make([]byte, len(g0.Image))
 		for i := range g0.Disposal {
 			g0.Disposal[i] = DisposalNone
 		}
 		g0.Config = image.Config{
 			ColorModel: globalColorModel,
 			Width:      width,
 			Height:     height,
 		}
 		g0.BackgroundIndex = backgroundIndex
 	}

 	var buf bytes.Buffer
 	if err := EncodeAll(&buf, g0); err != nil {
 		t.Fatal("EncodeAll:", err)
 	}
 	encoded := buf.Bytes()
 	config, err := DecodeConfig(bytes.NewReader(encoded))
 	if err != nil {
 		t.Fatal("DecodeConfig:", err)
 	}
 	g1, err := DecodeAll(bytes.NewReader(encoded))
 	if err != nil {
 		t.Fatal("DecodeAll:", err)
 	}

 	if !reflect.DeepEqual(config, g1.Config) {
 		t.Errorf("DecodeConfig inconsistent with DecodeAll")
 	}
 	if !palettesEqual(g1.Config.ColorModel.(color.Palette), globalColorModel.(color.Palette)) {
 		t.Errorf("unexpected global color model")
 	}
 	if w, h := g1.Config.Width, g1.Config.Height; w != width || h != height {
 		t.Errorf("got config width * height = %d * %d, want %d * %d", w, h, width, height)
 	}

 	if g0.LoopCount != g1.LoopCount {
 		t.Errorf("loop counts differ: %d and %d", g0.LoopCount, g1.LoopCount)
 	}
 	if backgroundIndex != g1.BackgroundIndex {
 		t.Errorf("background indexes differ: %d and %d", backgroundIndex, g1.BackgroundIndex)
 	}
 	if len(g0.Image) != len(g1.Image) {
 		t.Fatalf("image lengths differ: %d and %d", len(g0.Image), len(g1.Image))
 	}
 	if len(g1.Image) != len(g1.Delay) {
 		t.Fatalf("image and delay lengths differ: %d and %d", len(g1.Image), len(g1.Delay))
 	}
 	if len(g1.Image) != len(g1.Disposal) {
 		t.Fatalf("image and disposal lengths differ: %d and %d", len(g1.Image), len(g1.Disposal))
 	}

 	for i := range g0.Image {
 		m0, m1 := g0.Image[i], g1.Image[i]
 		if m0.Bounds() != m1.Bounds() {
 			t.Errorf("frame %d: bounds differ: %v and %v", i, m0.Bounds(), m1.Bounds())
 		}
 		d0, d1 := g0.Delay[i], g1.Delay[i]
 		if d0 != d1 {
 			t.Errorf("frame %d: delay values differ: %d and %d", i, d0, d1)
 		}
 		p0, p1 := uint8(0), g1.Disposal[i]
 		if go1Dot5Fields {
 			p0 = DisposalNone
 		}
 		if p0 != p1 {
 			t.Errorf("frame %d: disposal values differ: %d and %d", i, p0, p1)
 		}
 	}
 }

 func TestEncodeAllGo1Dot4(t *testing.T)                 { testEncodeAll(t, false, false) }
 func TestEncodeAllGo1Dot5(t *testing.T)                 { testEncodeAll(t, true, false) }
 func TestEncodeAllGo1Dot5GlobalColorModel(t *testing.T) { testEncodeAll(t, true, true) }

 func TestEncodeMismatchDelay(t *testing.T) {
 	images := make([]*image.Paletted, 2)
 	for i := range images {
 		images[i] = image.NewPaletted(image.Rect(0, 0, 5, 5), palette.Plan9)
 	}

 	g0 := &GIF{
 		Image: images,
 		Delay: make([]int, 1),
 	}
 	if err := EncodeAll(ioutil.Discard, g0); err == nil {
 		t.Error("expected error from mismatched delay and image slice lengths")
 	}

 	g1 := &GIF{
 		Image:    images,
 		Delay:    make([]int, len(images)),
 		Disposal: make([]byte, 1),
 	}
 	for i := range g1.Disposal {
 		g1.Disposal[i] = DisposalNone
 	}
 	if err := EncodeAll(ioutil.Discard, g1); err == nil {
 		t.Error("expected error from mismatched disposal and image slice lengths")
 	}
 }

 func TestEncodeZeroGIF(t *testing.T) {
 	if err := EncodeAll(ioutil.Discard, &GIF{}); err == nil {
 		t.Error("expected error from providing empty gif")
 	}
 }

 func TestEncodeAllFramesOutOfBounds(t *testing.T) {
 	images := []*image.Paletted{
 		image.NewPaletted(image.Rect(0, 0, 5, 5), palette.Plan9),
 		image.NewPaletted(image.Rect(2, 2, 8, 8), palette.Plan9),
 		image.NewPaletted(image.Rect(3, 3, 4, 4), palette.Plan9),
 	}
 	for _, upperBound := range []int{6, 10} {
 		g := &GIF{
 			Image:    images,
 			Delay:    make([]int, len(images)),
 			Disposal: make([]byte, len(images)),
 			Config: image.Config{
 				Width:  upperBound,
 				Height: upperBound,
 			},
 		}
 		err := EncodeAll(ioutil.Discard, g)
 		if upperBound >= 8 {
 			if err != nil {
 				t.Errorf("upperBound=%d: %v", upperBound, err)
 			}
 		} else {
 			if err == nil {
 				t.Errorf("upperBound=%d: got nil error, want non-nil", upperBound)
 			}
 		}
 	}
 }

 func TestEncodeNonZeroMinPoint(t *testing.T) {
 	points := []image.Point{
 		{-8, -9},
 		{-4, -4},
 		{-3, +3},
 		{+0, +0},
 		{+2, +2},
 	}
 	for _, p := range points {
 		src := image.NewPaletted(image.Rectangle{Min: p, Max: p.Add(image.Point{6, 6})}, palette.Plan9)
 		var buf bytes.Buffer
 		if err := Encode(&buf, src, nil); err != nil {
 			t.Errorf("p=%v: Encode: %v", p, err)
 			continue
 		}
 		m, err := Decode(&buf)
 		if err != nil {
 			t.Errorf("p=%v: Decode: %v", p, err)
 			continue
 		}
 		if got, want := m.Bounds(), image.Rect(0, 0, 6, 6); got != want {
 			t.Errorf("p=%v: got %v, want %v", p, got, want)
 		}
 	}
 }

 func TestEncodeImplicitConfigSize(t *testing.T) {
 	// For backwards compatibility for Go 1.4 and earlier code, the Config
 	// field is optional, and if zero, the width and height is implied by the
 	// first (and in this case only) frame's width and height.
 	//
 	// A Config only specifies a width and height (two integers) while an
 	// image.Image's Bounds method returns an image.Rectangle (four integers).
 	// For a gif.GIF, the overall bounds' top-left point is always implicitly
 	// (0, 0), and any frame whose bounds have a negative X or Y will be
 	// outside those overall bounds, so encoding should fail.
 	for _, lowerBound := range []int{-1, 0, 1} {
 		images := []*image.Paletted{
 			image.NewPaletted(image.Rect(lowerBound, lowerBound, 4, 4), palette.Plan9),
 		}
 		g := &GIF{
 			Image: images,
 			Delay: make([]int, len(images)),
 		}
 		err := EncodeAll(ioutil.Discard, g)
 		if lowerBound >= 0 {
 			if err != nil {
 				t.Errorf("lowerBound=%d: %v", lowerBound, err)
 			}
 		} else {
 			if err == nil {
 				t.Errorf("lowerBound=%d: got nil error, want non-nil", lowerBound)
 			}
 		}
 	}
 }

 func TestEncodePalettes(t *testing.T) {
 	const w, h = 5, 5
 	pals := []color.Palette{{
 		color.RGBA{0x00, 0x00, 0x00, 0xff},
 		color.RGBA{0x01, 0x00, 0x00, 0xff},
 		color.RGBA{0x02, 0x00, 0x00, 0xff},
 	}, {
 		color.RGBA{0x00, 0x00, 0x00, 0xff},
 		color.RGBA{0x00, 0x01, 0x00, 0xff},
 	}, {
 		color.RGBA{0x00, 0x00, 0x03, 0xff},
 		color.RGBA{0x00, 0x00, 0x02, 0xff},
 		color.RGBA{0x00, 0x00, 0x01, 0xff},
 		color.RGBA{0x00, 0x00, 0x00, 0xff},
 	}, {
 		color.RGBA{0x10, 0x07, 0xf0, 0xff},
 		color.RGBA{0x20, 0x07, 0xf0, 0xff},
 		color.RGBA{0x30, 0x07, 0xf0, 0xff},
 		color.RGBA{0x40, 0x07, 0xf0, 0xff},
 		color.RGBA{0x50, 0x07, 0xf0, 0xff},
 	}}
 	g0 := &GIF{
 		Image: []*image.Paletted{
 			image.NewPaletted(image.Rect(0, 0, w, h), pals[0]),
 			image.NewPaletted(image.Rect(0, 0, w, h), pals[1]),
 			image.NewPaletted(image.Rect(0, 0, w, h), pals[2]),
 			image.NewPaletted(image.Rect(0, 0, w, h), pals[3]),
 		},
 		Delay:    make([]int, len(pals)),
 		Disposal: make([]byte, len(pals)),
 		Config: image.Config{
 			ColorModel: pals[2],
 			Width:      w,
 			Height:     h,
 		},
 	}

 	var buf bytes.Buffer
 	if err := EncodeAll(&buf, g0); err != nil {
 		t.Fatalf("EncodeAll: %v", err)
 	}
 	g1, err := DecodeAll(&buf)
 	if err != nil {
 		t.Fatalf("DecodeAll: %v", err)
 	}
 	if len(g0.Image) != len(g1.Image) {
 		t.Fatalf("image lengths differ: %d and %d", len(g0.Image), len(g1.Image))
 	}
 	for i, m := range g1.Image {
 		if got, want := m.Palette, pals[i]; !palettesEqual(got, want) {
 			t.Errorf("frame %d:\ngot  %v\nwant %v", i, got, want)
 		}
 	}
 }

 func BenchmarkEncode(b *testing.B) {
 	b.StopTimer()

 	bo := image.Rect(0, 0, 640, 480)
 	rnd := rand.New(rand.NewSource(123))

 	// Restrict to a 256-color paletted image to avoid quantization path.
 	palette := make(color.Palette, 256)
 	for i := range palette {
 		palette[i] = color.RGBA{
 			uint8(rnd.Intn(256)),
 			uint8(rnd.Intn(256)),
 			uint8(rnd.Intn(256)),
 			255,
 		}
 	}
 	img := image.NewPaletted(image.Rect(0, 0, 640, 480), palette)
 	for y := bo.Min.Y; y < bo.Max.Y; y++ {
 		for x := bo.Min.X; x < bo.Max.X; x++ {
 			img.Set(x, y, palette[rnd.Intn(256)])
 		}
 	}

 	b.SetBytes(640 * 480 * 4)
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		Encode(ioutil.Discard, img, nil)
 	}
 }

 func BenchmarkQuantizedEncode(b *testing.B) {
 	b.StopTimer()
 	img := image.NewRGBA(image.Rect(0, 0, 640, 480))
 	bo := img.Bounds()
 	rnd := rand.New(rand.NewSource(123))
 	for y := bo.Min.Y; y < bo.Max.Y; y++ {
 		for x := bo.Min.X; x < bo.Max.X; x++ {
 			img.SetRGBA(x, y, color.RGBA{
 				uint8(rnd.Intn(256)),
 				uint8(rnd.Intn(256)),
 				uint8(rnd.Intn(256)),
 				255,
 			})
 		}
 	}
 	b.SetBytes(640 * 480 * 4)
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		Encode(ioutil.Discard, img, nil)
 	}
 }
	// Copyright 2013 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package gif

	import (
	"bytes"
	"image"
	"image/color"
	"image/color/palette"
	_ "image/png"
	"io/ioutil"
	"math/rand"
	"os"
	"reflect"
	"testing"
	)

	func readImg(filename string) (image.Image, error) {
	f, err := os.Open(filename)
	if err != nil {
	return nil, err
	}
	defer f.Close()
	m, _, err := image.Decode(f)
	return m, err
	}

	func readGIF(filename string) (*GIF, error) {
	f, err := os.Open(filename)
	if err != nil {
	return nil, err
	}
	defer f.Close()
	return DecodeAll(f)
	}

	func delta(u0, u1 uint32) int64 {
	d := int64(u0) - int64(u1)
	if d < 0 {
	return -d
	}
	return d
	}

	// averageDelta returns the average delta in RGB space. The two images must
	// have the same bounds.
	func averageDelta(m0, m1 image.Image) int64 {
	b := m0.Bounds()
	var sum, n int64
	for y := b.Min.Y; y < b.Max.Y; y++ {
	for x := b.Min.X; x < b.Max.X; x++ {
	c0 := m0.At(x, y)
	c1 := m1.At(x, y)
	r0, g0, b0, _ := c0.RGBA()
	r1, g1, b1, _ := c1.RGBA()
	sum += delta(r0, r1)
	sum += delta(g0, g1)
	sum += delta(b0, b1)
	n += 3
	}
	}
	return sum / n
	}

	var testCase = []struct {
	filename string
	tolerance int64
	}{
	{"../testdata/video-001.png", 1 << 12},
	{"../testdata/video-001.gif", 0},
	{"../testdata/video-001.interlaced.gif", 0},
	}

	func TestWriter(t *testing.T) {
	for _, tc := range testCase {
	m0, err := readImg(tc.filename)
	if err != nil {
	t.Error(tc.filename, err)
	continue
	}
	var buf bytes.Buffer
	err = Encode(&buf, m0, nil)
	if err != nil {
	t.Error(tc.filename, err)
	continue
	}
	m1, err := Decode(&buf)
	if err != nil {
	t.Error(tc.filename, err)
	continue
	}
	if m0.Bounds() != m1.Bounds() {
	t.Errorf("%s, bounds differ: %v and %v", tc.filename, m0.Bounds(), m1.Bounds())
	continue
	}
	// Compare the average delta to the tolerance level.
	avgDelta := averageDelta(m0, m1)
	if avgDelta > tc.tolerance {
	t.Errorf("%s: average delta is too high. expected: %d, got %d", tc.filename, tc.tolerance, avgDelta)
	continue
	}
	}
	}

	func TestSubImage(t *testing.T) {
	m0, err := readImg("../testdata/video-001.gif")
	if err != nil {
	t.Fatalf("readImg: %v", err)
	}
	m0 = m0.(*image.Paletted).SubImage(image.Rect(0, 0, 50, 30))
	var buf bytes.Buffer
	err = Encode(&buf, m0, nil)
	if err != nil {
	t.Fatalf("Encode: %v", err)
	}
	m1, err := Decode(&buf)
	if err != nil {
	t.Fatalf("Decode: %v", err)
	}
	if m0.Bounds() != m1.Bounds() {
	t.Fatalf("bounds differ: %v and %v", m0.Bounds(), m1.Bounds())
	}
	if averageDelta(m0, m1) != 0 {
	t.Fatalf("images differ")
	}
	}

	// palettesEqual reports whether two color.Palette values are equal, ignoring
	// any trailing opaque-black palette entries.
	func palettesEqual(p, q color.Palette) bool {
	n := len(p)
	if n > len(q) {
	n = len(q)
	}
	for i := 0; i < n; i++ {
	if p[i] != q[i] {
	return false
	}
	}
	for i := n; i < len(p); i++ {
	r, g, b, a := p[i].RGBA()
	if r != 0 \|\| g != 0 \|\| b != 0 \|\| a != 0xffff {
	return false
	}
	}
	for i := n; i < len(q); i++ {
	r, g, b, a := q[i].RGBA()
	if r != 0 \|\| g != 0 \|\| b != 0 \|\| a != 0xffff {
	return false
	}
	}
	return true
	}

	var frames = []string{
	"../testdata/video-001.gif",
	"../testdata/video-005.gray.gif",
	}

	func testEncodeAll(t *testing.T, go1Dot5Fields bool, useGlobalColorModel bool) {
	const width, height = 150, 103

	g0 := &GIF{
	Image: make([]*image.Paletted, len(frames)),
	Delay: make([]int, len(frames)),
	LoopCount: 5,
	}
	for i, f := range frames {
	g, err := readGIF(f)
	if err != nil {
	t.Fatal(f, err)
	}
	m := g.Image[0]
	if m.Bounds().Dx() != width \|\| m.Bounds().Dy() != height {
	t.Fatalf("frame %d had unexpected bounds: got %v, want width/height = %d/%d",
	i, m.Bounds(), width, height)
	}
	g0.Image[i] = m
	}
	// The GIF.Disposal, GIF.Config and GIF.BackgroundIndex fields were added
	// in Go 1.5. Valid Go 1.4 or earlier code should still produce valid GIFs.
	//
	// On the following line, color.Model is an interface type, and
	// color.Palette is a concrete (slice) type.
	globalColorModel, backgroundIndex := color.Model(color.Palette(nil)), uint8(0)
	if useGlobalColorModel {
	globalColorModel, backgroundIndex = color.Palette(palette.WebSafe), uint8(1)
	}
	if go1Dot5Fields {
	g0.Disposal = make([]byte, len(g0.Image))
	for i := range g0.Disposal {
	g0.Disposal[i] = DisposalNone
	}
	g0.Config = image.Config{
	ColorModel: globalColorModel,
	Width: width,
	Height: height,
	}
	g0.BackgroundIndex = backgroundIndex
	}

	var buf bytes.Buffer
	if err := EncodeAll(&buf, g0); err != nil {
	t.Fatal("EncodeAll:", err)
	}
	encoded := buf.Bytes()
	config, err := DecodeConfig(bytes.NewReader(encoded))
	if err != nil {
	t.Fatal("DecodeConfig:", err)
	}
	g1, err := DecodeAll(bytes.NewReader(encoded))
	if err != nil {
	t.Fatal("DecodeAll:", err)
	}

	if !reflect.DeepEqual(config, g1.Config) {
	t.Errorf("DecodeConfig inconsistent with DecodeAll")
	}
	if !palettesEqual(g1.Config.ColorModel.(color.Palette), globalColorModel.(color.Palette)) {
	t.Errorf("unexpected global color model")
	}
	if w, h := g1.Config.Width, g1.Config.Height; w != width \|\| h != height {
	t.Errorf("got config width * height = %d * %d, want %d * %d", w, h, width, height)
	}

	if g0.LoopCount != g1.LoopCount {
	t.Errorf("loop counts differ: %d and %d", g0.LoopCount, g1.LoopCount)
	}
	if backgroundIndex != g1.BackgroundIndex {
	t.Errorf("background indexes differ: %d and %d", backgroundIndex, g1.BackgroundIndex)
	}
	if len(g0.Image) != len(g1.Image) {
	t.Fatalf("image lengths differ: %d and %d", len(g0.Image), len(g1.Image))
	}
	if len(g1.Image) != len(g1.Delay) {
	t.Fatalf("image and delay lengths differ: %d and %d", len(g1.Image), len(g1.Delay))
	}
	if len(g1.Image) != len(g1.Disposal) {
	t.Fatalf("image and disposal lengths differ: %d and %d", len(g1.Image), len(g1.Disposal))
	}

	for i := range g0.Image {
	m0, m1 := g0.Image[i], g1.Image[i]
	if m0.Bounds() != m1.Bounds() {
	t.Errorf("frame %d: bounds differ: %v and %v", i, m0.Bounds(), m1.Bounds())
	}
	d0, d1 := g0.Delay[i], g1.Delay[i]
	if d0 != d1 {
	t.Errorf("frame %d: delay values differ: %d and %d", i, d0, d1)
	}
	p0, p1 := uint8(0), g1.Disposal[i]
	if go1Dot5Fields {
	p0 = DisposalNone
	}
	if p0 != p1 {
	t.Errorf("frame %d: disposal values differ: %d and %d", i, p0, p1)
	}
	}
	}

	func TestEncodeAllGo1Dot4(t *testing.T) { testEncodeAll(t, false, false) }
	func TestEncodeAllGo1Dot5(t *testing.T) { testEncodeAll(t, true, false) }
	func TestEncodeAllGo1Dot5GlobalColorModel(t *testing.T) { testEncodeAll(t, true, true) }

	func TestEncodeMismatchDelay(t *testing.T) {
	images := make([]*image.Paletted, 2)
	for i := range images {
	images[i] = image.NewPaletted(image.Rect(0, 0, 5, 5), palette.Plan9)
	}

	g0 := &GIF{
	Image: images,
	Delay: make([]int, 1),
	}
	if err := EncodeAll(ioutil.Discard, g0); err == nil {
	t.Error("expected error from mismatched delay and image slice lengths")
	}

	g1 := &GIF{
	Image: images,
	Delay: make([]int, len(images)),
	Disposal: make([]byte, 1),
	}
	for i := range g1.Disposal {
	g1.Disposal[i] = DisposalNone
	}
	if err := EncodeAll(ioutil.Discard, g1); err == nil {
	t.Error("expected error from mismatched disposal and image slice lengths")
	}
	}

	func TestEncodeZeroGIF(t *testing.T) {
	if err := EncodeAll(ioutil.Discard, &GIF{}); err == nil {
	t.Error("expected error from providing empty gif")
	}
	}

	func TestEncodeAllFramesOutOfBounds(t *testing.T) {
	images := []*image.Paletted{
	image.NewPaletted(image.Rect(0, 0, 5, 5), palette.Plan9),
	image.NewPaletted(image.Rect(2, 2, 8, 8), palette.Plan9),
	image.NewPaletted(image.Rect(3, 3, 4, 4), palette.Plan9),
	}
	for _, upperBound := range []int{6, 10} {
	g := &GIF{
	Image: images,
	Delay: make([]int, len(images)),
	Disposal: make([]byte, len(images)),
	Config: image.Config{
	Width: upperBound,
	Height: upperBound,
	},
	}
	err := EncodeAll(ioutil.Discard, g)
	if upperBound >= 8 {
	if err != nil {
	t.Errorf("upperBound=%d: %v", upperBound, err)
	}
	} else {
	if err == nil {
	t.Errorf("upperBound=%d: got nil error, want non-nil", upperBound)
	}
	}
	}
	}

	func TestEncodeNonZeroMinPoint(t *testing.T) {
	points := []image.Point{
	{-8, -9},
	{-4, -4},
	{-3, +3},
	{+0, +0},
	{+2, +2},
	}
	for _, p := range points {
	src := image.NewPaletted(image.Rectangle{Min: p, Max: p.Add(image.Point{6, 6})}, palette.Plan9)
	var buf bytes.Buffer
	if err := Encode(&buf, src, nil); err != nil {
	t.Errorf("p=%v: Encode: %v", p, err)
	continue
	}
	m, err := Decode(&buf)
	if err != nil {
	t.Errorf("p=%v: Decode: %v", p, err)
	continue
	}
	if got, want := m.Bounds(), image.Rect(0, 0, 6, 6); got != want {
	t.Errorf("p=%v: got %v, want %v", p, got, want)
	}
	}
	}

	func TestEncodeImplicitConfigSize(t *testing.T) {
	// For backwards compatibility for Go 1.4 and earlier code, the Config
	// field is optional, and if zero, the width and height is implied by the
	// first (and in this case only) frame's width and height.
	//
	// A Config only specifies a width and height (two integers) while an
	// image.Image's Bounds method returns an image.Rectangle (four integers).
	// For a gif.GIF, the overall bounds' top-left point is always implicitly
	// (0, 0), and any frame whose bounds have a negative X or Y will be
	// outside those overall bounds, so encoding should fail.
	for _, lowerBound := range []int{-1, 0, 1} {
	images := []*image.Paletted{
	image.NewPaletted(image.Rect(lowerBound, lowerBound, 4, 4), palette.Plan9),
	}
	g := &GIF{
	Image: images,
	Delay: make([]int, len(images)),
	}
	err := EncodeAll(ioutil.Discard, g)
	if lowerBound >= 0 {
	if err != nil {
	t.Errorf("lowerBound=%d: %v", lowerBound, err)
	}
	} else {
	if err == nil {
	t.Errorf("lowerBound=%d: got nil error, want non-nil", lowerBound)
	}
	}
	}
	}

	func TestEncodePalettes(t *testing.T) {
	const w, h = 5, 5
	pals := []color.Palette{{
	color.RGBA{0x00, 0x00, 0x00, 0xff},
	color.RGBA{0x01, 0x00, 0x00, 0xff},
	color.RGBA{0x02, 0x00, 0x00, 0xff},
	}, {
	color.RGBA{0x00, 0x00, 0x00, 0xff},
	color.RGBA{0x00, 0x01, 0x00, 0xff},
	}, {
	color.RGBA{0x00, 0x00, 0x03, 0xff},
	color.RGBA{0x00, 0x00, 0x02, 0xff},
	color.RGBA{0x00, 0x00, 0x01, 0xff},
	color.RGBA{0x00, 0x00, 0x00, 0xff},
	}, {
	color.RGBA{0x10, 0x07, 0xf0, 0xff},
	color.RGBA{0x20, 0x07, 0xf0, 0xff},
	color.RGBA{0x30, 0x07, 0xf0, 0xff},
	color.RGBA{0x40, 0x07, 0xf0, 0xff},
	color.RGBA{0x50, 0x07, 0xf0, 0xff},
	}}
	g0 := &GIF{
	Image: []*image.Paletted{
	image.NewPaletted(image.Rect(0, 0, w, h), pals[0]),
	image.NewPaletted(image.Rect(0, 0, w, h), pals[1]),
	image.NewPaletted(image.Rect(0, 0, w, h), pals[2]),
	image.NewPaletted(image.Rect(0, 0, w, h), pals[3]),
	},
	Delay: make([]int, len(pals)),
	Disposal: make([]byte, len(pals)),
	Config: image.Config{
	ColorModel: pals[2],
	Width: w,
	Height: h,
	},
	}

	var buf bytes.Buffer
	if err := EncodeAll(&buf, g0); err != nil {
	t.Fatalf("EncodeAll: %v", err)
	}
	g1, err := DecodeAll(&buf)
	if err != nil {
	t.Fatalf("DecodeAll: %v", err)
	}
	if len(g0.Image) != len(g1.Image) {
	t.Fatalf("image lengths differ: %d and %d", len(g0.Image), len(g1.Image))
	}
	for i, m := range g1.Image {
	if got, want := m.Palette, pals[i]; !palettesEqual(got, want) {
	t.Errorf("frame %d:\ngot %v\nwant %v", i, got, want)
	}
	}
	}

	func BenchmarkEncode(b *testing.B) {
	b.StopTimer()

	bo := image.Rect(0, 0, 640, 480)
	rnd := rand.New(rand.NewSource(123))

	// Restrict to a 256-color paletted image to avoid quantization path.
	palette := make(color.Palette, 256)
	for i := range palette {
	palette[i] = color.RGBA{
	uint8(rnd.Intn(256)),
	uint8(rnd.Intn(256)),
	uint8(rnd.Intn(256)),
	255,
	}
	}
	img := image.NewPaletted(image.Rect(0, 0, 640, 480), palette)
	for y := bo.Min.Y; y < bo.Max.Y; y++ {
	for x := bo.Min.X; x < bo.Max.X; x++ {
	img.Set(x, y, palette[rnd.Intn(256)])
	}
	}

	b.SetBytes(640 * 480 * 4)
	b.StartTimer()
	for i := 0; i < b.N; i++ {
	Encode(ioutil.Discard, img, nil)
	}
	}

	func BenchmarkQuantizedEncode(b *testing.B) {
	b.StopTimer()
	img := image.NewRGBA(image.Rect(0, 0, 640, 480))
	bo := img.Bounds()
	rnd := rand.New(rand.NewSource(123))
	for y := bo.Min.Y; y < bo.Max.Y; y++ {
	for x := bo.Min.X; x < bo.Max.X; x++ {
	img.SetRGBA(x, y, color.RGBA{
	uint8(rnd.Intn(256)),
	uint8(rnd.Intn(256)),
	uint8(rnd.Intn(256)),
	255,
	})
	}
	}
	b.SetBytes(640 * 480 * 4)
	b.StartTimer()
	for i := 0; i < b.N; i++ {
	Encode(ioutil.Discard, img, nil)
	}
	}