libgo: update to go1.9

[official-gcc.git] / libgo / go / image / gif / reader_test.go

// 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"
        "compress/lzw"
        "image"
        "image/color"
        "reflect"
        "strings"
        "testing"
)

// header, palette and trailer are parts of a valid 2x1 GIF image.
const (
        headerStr = "GIF89a" +
                "\x02\x00\x01\x00" + // width=2, height=1
                "\x80\x00\x00" // headerFields=(a color table of 2 pixels), backgroundIndex, aspect
        paletteStr = "\x10\x20\x30\x40\x50\x60" // the color table, also known as a palette
        trailerStr = "\x3b"
)

// lzwEncode returns an LZW encoding (with 2-bit literals) of in.
func lzwEncode(in []byte) []byte {
        b := &bytes.Buffer{}
        w := lzw.NewWriter(b, lzw.LSB, 2)
        if _, err := w.Write(in); err != nil {
                panic(err)
        }
        if err := w.Close(); err != nil {
                panic(err)
        }
        return b.Bytes()
}

func TestDecode(t *testing.T) {
        // extra contains superfluous bytes to inject into the GIF, either at the end
        // of an existing data sub-block (past the LZW End of Information code) or in
        // a separate data sub-block. The 0x02 values are arbitrary.
        const extra = "\x02\x02\x02\x02"

        testCases := []struct {
                nPix int // The number of pixels in the image data.
                // If non-zero, write this many extra bytes inside the data sub-block
                // containing the LZW end code.
                extraExisting int
                // If non-zero, write an extra block of this many bytes.
                extraSeparate int
                wantErr       error
        }{
                {0, 0, 0, errNotEnough},
                {1, 0, 0, errNotEnough},
                {2, 0, 0, nil},
                // An extra data sub-block after the compressed section with 1 byte which we
                // silently skip.
                {2, 0, 1, nil},
                // An extra data sub-block after the compressed section with 2 bytes. In
                // this case we complain that there is too much data.
                {2, 0, 2, errTooMuch},
                // Too much pixel data.
                {3, 0, 0, errTooMuch},
                // An extra byte after LZW data, but inside the same data sub-block.
                {2, 1, 0, nil},
                // Two extra bytes after LZW data, but inside the same data sub-block.
                {2, 2, 0, nil},
        }
        for _, tc := range testCases {
                b := &bytes.Buffer{}
                b.WriteString(headerStr)
                b.WriteString(paletteStr)
                // Write an image with bounds 2x1 but tc.nPix pixels. If tc.nPix != 2
                // then this should result in an invalid GIF image. First, write a
                // magic 0x2c (image descriptor) byte, bounds=(0,0)-(2,1), a flags
                // byte, and 2-bit LZW literals.
                b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")
                if tc.nPix > 0 {
                        enc := lzwEncode(make([]byte, tc.nPix))
                        if len(enc)+tc.extraExisting > 0xff {
                                t.Errorf("nPix=%d, extraExisting=%d, extraSeparate=%d: compressed length %d is too large",
                                        tc.nPix, tc.extraExisting, tc.extraSeparate, len(enc))
                                continue
                        }

                        // Write the size of the data sub-block containing the LZW data.
                        b.WriteByte(byte(len(enc) + tc.extraExisting))

                        // Write the LZW data.
                        b.Write(enc)

                        // Write extra bytes inside the same data sub-block where LZW data
                        // ended. Each arbitrarily 0x02.
                        b.WriteString(extra[:tc.extraExisting])
                }

                if tc.extraSeparate > 0 {
                        // Data sub-block size. This indicates how many extra bytes follow.
                        b.WriteByte(byte(tc.extraSeparate))
                        b.WriteString(extra[:tc.extraSeparate])
                }
                b.WriteByte(0x00) // An empty block signifies the end of the image data.
                b.WriteString(trailerStr)

                got, err := Decode(b)
                if err != tc.wantErr {
                        t.Errorf("nPix=%d, extraExisting=%d, extraSeparate=%d\ngot  %v\nwant %v",
                                tc.nPix, tc.extraExisting, tc.extraSeparate, err, tc.wantErr)
                }

                if tc.wantErr != nil {
                        continue
                }
                want := &image.Paletted{
                        Pix:    []uint8{0, 0},
                        Stride: 2,
                        Rect:   image.Rect(0, 0, 2, 1),
                        Palette: color.Palette{
                                color.RGBA{0x10, 0x20, 0x30, 0xff},
                                color.RGBA{0x40, 0x50, 0x60, 0xff},
                        },
                }
                if !reflect.DeepEqual(got, want) {
                        t.Errorf("nPix=%d, extraExisting=%d, extraSeparate=%d\ngot  %v\nwant %v",
                                tc.nPix, tc.extraExisting, tc.extraSeparate, got, want)
                }
        }
}

func TestTransparentIndex(t *testing.T) {
        b := &bytes.Buffer{}
        b.WriteString(headerStr)
        b.WriteString(paletteStr)
        for transparentIndex := 0; transparentIndex < 3; transparentIndex++ {
                if transparentIndex < 2 {
                        // Write the graphic control for the transparent index.
                        b.WriteString("\x21\xf9\x04\x01\x00\x00")
                        b.WriteByte(byte(transparentIndex))
                        b.WriteByte(0)
                }
                // Write an image with bounds 2x1, as per TestDecode.
                b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")
                enc := lzwEncode([]byte{0x00, 0x00})
                if len(enc) > 0xff {
                        t.Fatalf("compressed length %d is too large", len(enc))
                }
                b.WriteByte(byte(len(enc)))
                b.Write(enc)
                b.WriteByte(0x00)
        }
        b.WriteString(trailerStr)

        g, err := DecodeAll(b)
        if err != nil {
                t.Fatalf("DecodeAll: %v", err)
        }
        c0 := color.RGBA{paletteStr[0], paletteStr[1], paletteStr[2], 0xff}
        c1 := color.RGBA{paletteStr[3], paletteStr[4], paletteStr[5], 0xff}
        cz := color.RGBA{}
        wants := []color.Palette{
                {cz, c1},
                {c0, cz},
                {c0, c1},
        }
        if len(g.Image) != len(wants) {
                t.Fatalf("got %d images, want %d", len(g.Image), len(wants))
        }
        for i, want := range wants {
                got := g.Image[i].Palette
                if !reflect.DeepEqual(got, want) {
                        t.Errorf("palette #%d:\ngot  %v\nwant %v", i, got, want)
                }
        }
}

// testGIF is a simple GIF that we can modify to test different scenarios.
var testGIF = []byte{
        'G', 'I', 'F', '8', '9', 'a',
        1, 0, 1, 0, // w=1, h=1 (6)
        128, 0, 0, // headerFields, bg, aspect (10)
        0, 0, 0, 1, 1, 1, // color table and graphics control (13)
        0x21, 0xf9, 0x04, 0x00, 0x00, 0x00, 0xff, 0x00, // (19)
        // frame 1 (0,0 - 1,1)
        0x2c,
        0x00, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x01, 0x00, // (32)
        0x00,
        0x02, 0x02, 0x4c, 0x01, 0x00, // lzw pixels
        // trailer
        0x3b,
}

func try(t *testing.T, b []byte, want string) {
        _, err := DecodeAll(bytes.NewReader(b))
        var got string
        if err != nil {
                got = err.Error()
        }
        if got != want {
                t.Fatalf("got %v, want %v", got, want)
        }
}

func TestBounds(t *testing.T) {
        // Make a local copy of testGIF.
        gif := make([]byte, len(testGIF))
        copy(gif, testGIF)
        // Make the bounds too big, just by one.
        gif[32] = 2
        want := "gif: frame bounds larger than image bounds"
        try(t, gif, want)

        // Make the bounds too small; does not trigger bounds
        // check, but now there's too much data.
        gif[32] = 0
        want = "gif: too much image data"
        try(t, gif, want)
        gif[32] = 1

        // Make the bounds really big, expect an error.
        want = "gif: frame bounds larger than image bounds"
        for i := 0; i < 4; i++ {
                gif[32+i] = 0xff
        }
        try(t, gif, want)
}

func TestNoPalette(t *testing.T) {
        b := &bytes.Buffer{}

        // Manufacture a GIF with no palette, so any pixel at all
        // will be invalid.
        b.WriteString(headerStr[:len(headerStr)-3])
        b.WriteString("\x00\x00\x00") // No global palette.

        // Image descriptor: 2x1, no local palette, and 2-bit LZW literals.
        b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")

        // Encode the pixels: neither is in range, because there is no palette.
        enc := lzwEncode([]byte{0x00, 0x03})
        b.WriteByte(byte(len(enc)))
        b.Write(enc)
        b.WriteByte(0x00) // An empty block signifies the end of the image data.

        b.WriteString(trailerStr)

        try(t, b.Bytes(), "gif: no color table")
}

func TestPixelOutsidePaletteRange(t *testing.T) {
        for _, pval := range []byte{0, 1, 2, 3} {
                b := &bytes.Buffer{}

                // Manufacture a GIF with a 2 color palette.
                b.WriteString(headerStr)
                b.WriteString(paletteStr)

                // Image descriptor: 2x1, no local palette, and 2-bit LZW literals.
                b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")

                // Encode the pixels; some pvals trigger the expected error.
                enc := lzwEncode([]byte{pval, pval})
                b.WriteByte(byte(len(enc)))
                b.Write(enc)
                b.WriteByte(0x00) // An empty block signifies the end of the image data.

                b.WriteString(trailerStr)

                // No error expected, unless the pixels are beyond the 2 color palette.
                want := ""
                if pval >= 2 {
                        want = "gif: invalid pixel value"
                }
                try(t, b.Bytes(), want)
        }
}

func TestTransparentPixelOutsidePaletteRange(t *testing.T) {
        b := &bytes.Buffer{}

        // Manufacture a GIF with a 2 color palette.
        b.WriteString(headerStr)
        b.WriteString(paletteStr)

        // Graphic Control Extension: transparency, transparent color index = 3.
        //
        // This index, 3, is out of range of the global palette and there is no
        // local palette in the subsequent image descriptor. This is an error
        // according to the spec, but Firefox and Google Chrome seem OK with this.
        //
        // See golang.org/issue/15059.
        b.WriteString("\x21\xf9\x04\x01\x00\x00\x03\x00")

        // Image descriptor: 2x1, no local palette, and 2-bit LZW literals.
        b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")

        // Encode the pixels.
        enc := lzwEncode([]byte{0x03, 0x03})
        b.WriteByte(byte(len(enc)))
        b.Write(enc)
        b.WriteByte(0x00) // An empty block signifies the end of the image data.

        b.WriteString(trailerStr)

        try(t, b.Bytes(), "")
}

func TestLoopCount(t *testing.T) {
        data := []byte("GIF89a000\x00000,0\x00\x00\x00\n\x00" +
                "\n\x00\x80000000\x02\b\xf01u\xb9\xfdal\x05\x00;")
        img, err := DecodeAll(bytes.NewReader(data))
        if err != nil {
                t.Fatal("DecodeAll:", err)
        }
        w := new(bytes.Buffer)
        err = EncodeAll(w, img)
        if err != nil {
                t.Fatal("EncodeAll:", err)
        }
        img1, err := DecodeAll(w)
        if err != nil {
                t.Fatal("DecodeAll:", err)
        }
        if img.LoopCount != img1.LoopCount {
                t.Errorf("loop count mismatch: %d vs %d", img.LoopCount, img1.LoopCount)
        }
}

func TestUnexpectedEOF(t *testing.T) {
        for i := len(testGIF) - 1; i >= 0; i-- {
                _, err := Decode(bytes.NewReader(testGIF[:i]))
                if err == errNotEnough {
                        continue
                }
                text := ""
                if err != nil {
                        text = err.Error()
                }
                if !strings.HasPrefix(text, "gif:") || !strings.HasSuffix(text, ": unexpected EOF") {
                        t.Errorf("Decode(testGIF[:%d]) = %v, want gif: ...: unexpected EOF", i, err)
                }
        }
}