From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libgo/go/image/png/reader_test.go | 190 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 libgo/go/image/png/reader_test.go (limited to 'libgo/go/image/png/reader_test.go') diff --git a/libgo/go/image/png/reader_test.go b/libgo/go/image/png/reader_test.go new file mode 100644 index 000000000..fefceee3a --- /dev/null +++ b/libgo/go/image/png/reader_test.go @@ -0,0 +1,190 @@ +// Copyright 2009 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 png + +import ( + "bufio" + "fmt" + "image" + "io" + "os" + "testing" +) + +// The go PNG library currently supports only a subset of the full PNG specification. +// In particular, bit depths other than 8 or 16 are not supported, nor are grayscale- +// alpha images. +var filenames = []string{ + //"basn0g01", // bit depth is not 8 or 16 + //"basn0g02", // bit depth is not 8 or 16 + //"basn0g04", // bit depth is not 8 or 16 + "basn0g08", + "basn0g16", + "basn2c08", + "basn2c16", + //"basn3p01", // bit depth is not 8 or 16 + //"basn3p02", // bit depth is not 8 or 16 + //"basn3p04", // bit depth is not 8 or 16 + "basn3p08", + //"basn4a08", // grayscale-alpha color model + //"basn4a16", // grayscale-alpha color model + "basn6a08", + "basn6a16", +} + +func readPng(filename string) (image.Image, os.Error) { + f, err := os.Open(filename, os.O_RDONLY, 0444) + if err != nil { + return nil, err + } + defer f.Close() + return Decode(f) +} + +// An approximation of the sng command-line tool. +func sng(w io.WriteCloser, filename string, png image.Image) { + defer w.Close() + bounds := png.Bounds() + cm := png.ColorModel() + var bitdepth int + switch cm { + case image.RGBAColorModel, image.NRGBAColorModel, image.AlphaColorModel, image.GrayColorModel: + bitdepth = 8 + default: + bitdepth = 16 + } + cpm, _ := cm.(image.PalettedColorModel) + var paletted *image.Paletted + if cpm != nil { + bitdepth = 8 + paletted = png.(*image.Paletted) + } + + // Write the filename and IHDR. + io.WriteString(w, "#SNG: from "+filename+".png\nIHDR {\n") + fmt.Fprintf(w, " width: %d; height: %d; bitdepth: %d;\n", bounds.Dx(), bounds.Dy(), bitdepth) + switch { + case cm == image.RGBAColorModel, cm == image.RGBA64ColorModel: + io.WriteString(w, " using color;\n") + case cm == image.NRGBAColorModel, cm == image.NRGBA64ColorModel: + io.WriteString(w, " using color alpha;\n") + case cm == image.GrayColorModel, cm == image.Gray16ColorModel: + io.WriteString(w, " using grayscale;\n") + case cpm != nil: + io.WriteString(w, " using color palette;\n") + default: + io.WriteString(w, "unknown PNG decoder color model\n") + } + io.WriteString(w, "}\n") + + // We fake a gAMA output. The test files have a gAMA chunk but the go PNG parser ignores it + // (the PNG spec section 11.3 says "Ancillary chunks may be ignored by a decoder"). + io.WriteString(w, "gAMA {1.0000}\n") + + // Write the PLTE (if applicable). + if cpm != nil { + io.WriteString(w, "PLTE {\n") + for i := 0; i < len(cpm); i++ { + r, g, b, _ := cpm[i].RGBA() + r >>= 8 + g >>= 8 + b >>= 8 + fmt.Fprintf(w, " (%3d,%3d,%3d) # rgb = (0x%02x,0x%02x,0x%02x)\n", r, g, b, r, g, b) + } + io.WriteString(w, "}\n") + } + + // Write the IMAGE. + io.WriteString(w, "IMAGE {\n pixels hex\n") + for y := bounds.Min.Y; y < bounds.Max.Y; y++ { + switch { + case cm == image.GrayColorModel: + for x := bounds.Min.X; x < bounds.Max.X; x++ { + gray := png.At(x, y).(image.GrayColor) + fmt.Fprintf(w, "%02x", gray.Y) + } + case cm == image.Gray16ColorModel: + for x := bounds.Min.X; x < bounds.Max.X; x++ { + gray16 := png.At(x, y).(image.Gray16Color) + fmt.Fprintf(w, "%04x ", gray16.Y) + } + case cm == image.RGBAColorModel: + for x := bounds.Min.X; x < bounds.Max.X; x++ { + rgba := png.At(x, y).(image.RGBAColor) + fmt.Fprintf(w, "%02x%02x%02x ", rgba.R, rgba.G, rgba.B) + } + case cm == image.RGBA64ColorModel: + for x := bounds.Min.X; x < bounds.Max.X; x++ { + rgba64 := png.At(x, y).(image.RGBA64Color) + fmt.Fprintf(w, "%04x%04x%04x ", rgba64.R, rgba64.G, rgba64.B) + } + case cm == image.NRGBAColorModel: + for x := bounds.Min.X; x < bounds.Max.X; x++ { + nrgba := png.At(x, y).(image.NRGBAColor) + fmt.Fprintf(w, "%02x%02x%02x%02x ", nrgba.R, nrgba.G, nrgba.B, nrgba.A) + } + case cm == image.NRGBA64ColorModel: + for x := bounds.Min.X; x < bounds.Max.X; x++ { + nrgba64 := png.At(x, y).(image.NRGBA64Color) + fmt.Fprintf(w, "%04x%04x%04x%04x ", nrgba64.R, nrgba64.G, nrgba64.B, nrgba64.A) + } + case cpm != nil: + for x := bounds.Min.X; x < bounds.Max.X; x++ { + fmt.Fprintf(w, "%02x", paletted.ColorIndexAt(x, y)) + } + } + io.WriteString(w, "\n") + } + io.WriteString(w, "}\n") +} + +func TestReader(t *testing.T) { + for _, fn := range filenames { + // Read the .png file. + image, err := readPng("testdata/pngsuite/" + fn + ".png") + if err != nil { + t.Error(fn, err) + continue + } + piper, pipew := io.Pipe() + pb := bufio.NewReader(piper) + go sng(pipew, fn, image) + defer piper.Close() + + // Read the .sng file. + sf, err := os.Open("testdata/pngsuite/"+fn+".sng", os.O_RDONLY, 0444) + if err != nil { + t.Error(fn, err) + continue + } + defer sf.Close() + sb := bufio.NewReader(sf) + if err != nil { + t.Error(fn, err) + continue + } + + // Compare the two, in SNG format, line by line. + for { + ps, perr := pb.ReadString('\n') + ss, serr := sb.ReadString('\n') + if perr == os.EOF && serr == os.EOF { + break + } + if perr != nil { + t.Error(fn, perr) + break + } + if serr != nil { + t.Error(fn, serr) + break + } + if ps != ss { + t.Errorf("%s: Mismatch\n%sversus\n%s\n", fn, ps, ss) + break + } + } + } +} -- cgit v1.2.3