code review 13453043: go.image/tiff: decoder support tiled tiff format

tiff/reader_test.go

 // Copyright 2011 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 tiff
 
 import (
         "image"
         "io/ioutil"
         "os"
         "strings"
         "testing"
 
         _ "image/png"
 )
 
 const testdataDir = "../testdata/"
 
 // Read makes *buffer implements io.Reader, so that we can pass one to Decode.
 func (*buffer) Read([]byte) (int, error) {
         panic("unimplemented")
 }
 
 // TestNoRPS tries to decode an image that has no RowsPerStrip tag.
 // The tag is mandatory according to the spec but some software omits
 // it in the case of a single strip.
 func TestNoRPS(t *testing.T) {
-        f, err := os.Open(testdataDir + "no_rps.tiff")
-        if err != nil {
-                t.Fatal(err)
-        }
-        defer f.Close()
-        _, err = Decode(f)
+        _, err := load("no_rps.tiff")
         if err != nil {
                 t.Fatal(err)
         }
 }
 
 // TestUnpackBits tests the decoding of PackBits-encoded data.
 func TestUnpackBits(t *testing.T) {
         var unpackBitsTests = []struct {
                 compressed   string
                 uncompressed string
@@ skipping 27 matching lines @@
                         c1 := img1.At(x+x1, y+y1)
                         r0, g0, b0, a0 := c0.RGBA()
                         r1, g1, b1, a1 := c1.RGBA()
                         if r0 != r1 || g0 != g1 || b0 != b1 || a0 != a1 {
                                 t.Fatalf("pixel at (%d, %d) has wrong color: want %v, got %v", x, y, c0, c1)
                         }
                 }
         }
 }
 
 func load(name string) (image.Image, error) {

[nigeltao, 2013/09/06 10:04:38]

I'd now move this function to before its first use in TestNoRPS.

         f, err := os.Open(testdataDir + name)
         if err != nil {
                 return nil, err
         }
         defer f.Close()
         img, _, err := image.Decode(f)
         if err != nil {
                 return nil, err
         }
         return img, nil
@@ skipping 27 matching lines @@
 // TestDecompress tests that decoding some TIFF images that use different
 // compression formats result in the same pixel data.
 func TestDecompress(t *testing.T) {
         var decompressTests = []string{
                 "bw-uncompressed.tiff",
                 "bw-deflate.tiff",
                 "bw-packbits.tiff",
         }
         var img0 image.Image
         for _, name := range decompressTests {
-                f, err := os.Open(testdataDir + name)
-                if err != nil {
-                        t.Fatal(err)
-                }
-                defer f.Close()
-                if img0 == nil {
-                        img0, err = Decode(f)
-                        if err != nil {
-                                t.Fatalf("decoding %s: %v", name, err)
-                        }
-                        continue
-                }
-
-                img1, err := Decode(f)
+                img1, err := load(name)
                 if err != nil {
                         t.Fatalf("decoding %s: %v", name, err)
+                }
+                if img0 == nil {
+                        img0 = img1
+                        continue
                 }
                 compare(t, img0, img1)
         }
 }
 
 // benchmarkDecode benchmarks the decoding of an image.
 func benchmarkDecode(b *testing.B, filename string) {
         b.StopTimer()
         contents, err := ioutil.ReadFile(testdataDir + filename)
         if err != nil {
                 panic(err)
         }
         r := &buffer{buf: contents}
         b.StartTimer()
         for i := 0; i < b.N; i++ {
                 _, err := Decode(r)
                 if err != nil {
                         b.Fatal("Decode:", err)
                 }
         }
 }
 
 func BenchmarkDecodeCompressed(b *testing.B)   { benchmarkDecode(b, "video-001.tiff") }
 func BenchmarkDecodeUncompressed(b *testing.B) { benchmarkDecode(b, "video-001-uncompressed.tiff") }