libgo: Update to Go 1.0.3.

[pf3gnuchains/gcc-fork.git] / libgo / go / image / jpeg / writer_test.go

diff --git a/libgo/go/image/jpeg/writer_test.go b/libgo/go/image/jpeg/writer_test.go
index b8e8fa3..8732df8 100644 (file)
--- a/libgo/go/image/jpeg/writer_test.go
+++ b/libgo/go/image/jpeg/writer_test.go
@@ -6,6 +6,7 @@ package jpeg
 
 import (
        "bytes"
+       "fmt"
        "image"
        "image/color"
        "image/png"
@@ -15,6 +16,87 @@ import (
        "testing"
 )
 
+// zigzag maps from the natural ordering to the zig-zag ordering. For example,
+// zigzag[0*8 + 3] is the zig-zag sequence number of the element in the fourth
+// column and first row.
+var zigzag = [blockSize]int{
+       0, 1, 5, 6, 14, 15, 27, 28,
+       2, 4, 7, 13, 16, 26, 29, 42,
+       3, 8, 12, 17, 25, 30, 41, 43,
+       9, 11, 18, 24, 31, 40, 44, 53,
+       10, 19, 23, 32, 39, 45, 52, 54,
+       20, 22, 33, 38, 46, 51, 55, 60,
+       21, 34, 37, 47, 50, 56, 59, 61,
+       35, 36, 48, 49, 57, 58, 62, 63,
+}
+
+func TestZigUnzig(t *testing.T) {
+       for i := 0; i < blockSize; i++ {
+               if unzig[zigzag[i]] != i {
+                       t.Errorf("unzig[zigzag[%d]] == %d", i, unzig[zigzag[i]])
+               }
+               if zigzag[unzig[i]] != i {
+                       t.Errorf("zigzag[unzig[%d]] == %d", i, zigzag[unzig[i]])
+               }
+       }
+}
+
+// unscaledQuantInNaturalOrder are the unscaled quantization tables in
+// natural (not zig-zag) order, as specified in section K.1.
+var unscaledQuantInNaturalOrder = [nQuantIndex][blockSize]byte{
+       // Luminance.
+       {
+               16, 11, 10, 16, 24, 40, 51, 61,
+               12, 12, 14, 19, 26, 58, 60, 55,
+               14, 13, 16, 24, 40, 57, 69, 56,
+               14, 17, 22, 29, 51, 87, 80, 62,
+               18, 22, 37, 56, 68, 109, 103, 77,
+               24, 35, 55, 64, 81, 104, 113, 92,
+               49, 64, 78, 87, 103, 121, 120, 101,
+               72, 92, 95, 98, 112, 100, 103, 99,
+       },
+       // Chrominance.
+       {
+               17, 18, 24, 47, 99, 99, 99, 99,
+               18, 21, 26, 66, 99, 99, 99, 99,
+               24, 26, 56, 99, 99, 99, 99, 99,
+               47, 66, 99, 99, 99, 99, 99, 99,
+               99, 99, 99, 99, 99, 99, 99, 99,
+               99, 99, 99, 99, 99, 99, 99, 99,
+               99, 99, 99, 99, 99, 99, 99, 99,
+               99, 99, 99, 99, 99, 99, 99, 99,
+       },
+}
+
+func TestUnscaledQuant(t *testing.T) {
+       bad := false
+       for i := quantIndex(0); i < nQuantIndex; i++ {
+               for zig := 0; zig < blockSize; zig++ {
+                       got := unscaledQuant[i][zig]
+                       want := unscaledQuantInNaturalOrder[i][unzig[zig]]
+                       if got != want {
+                               t.Errorf("i=%d, zig=%d: got %d, want %d", i, zig, got, want)
+                               bad = true
+                       }
+               }
+       }
+       if bad {
+               names := [nQuantIndex]string{"Luminance", "Chrominance"}
+               buf := &bytes.Buffer{}
+               for i, name := range names {
+                       fmt.Fprintf(buf, "// %s.\n{\n", name)
+                       for zig := 0; zig < blockSize; zig++ {
+                               fmt.Fprintf(buf, "%d, ", unscaledQuantInNaturalOrder[i][unzig[zig]])
+                               if zig%8 == 7 {
+                                       buf.WriteString("\n")
+                               }
+                       }
+                       buf.WriteString("},\n")
+               }
+               t.Logf("expected unscaledQuant values:\n%s", buf.String())
+       }
+}
+
 var testCase = []struct {
        filename  string
        quality   int