← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to src/pkg/encoding/git85/git_test.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-04-20 17:36:48 UTC
  • Revision ID: james.westby@ubuntu.com-20110420173648-ifergoxyrm832trd
Tags: upstream-2011.03.07.1
Import upstream version 2011.03.07.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/encoding/git85/git_test.go
 
1
// Copyright 2009 The Go Authors. All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
package git85
 
6
 
 
7
import (
 
8
        "bytes"
 
9
        "io/ioutil"
 
10
        "os"
 
11
        "testing"
 
12
)
 
13
 
 
14
type testpair struct {
 
15
        decoded, encoded string
 
16
}
 
17
 
 
18
func testEqual(t *testing.T, msg string, args ...interface{}) bool {
 
19
        if args[len(args)-2] != args[len(args)-1] {
 
20
                t.Errorf(msg, args...)
 
21
                return false
 
22
        }
 
23
        return true
 
24
}
 
25
 
 
26
func TestGitTable(t *testing.T) {
 
27
        var saw [256]bool
 
28
        for i, c := range encode {
 
29
                if decode[c] != uint8(i+1) {
 
30
                        t.Errorf("decode['%c'] = %d, want %d", c, decode[c], i+1)
 
31
                }
 
32
                saw[c] = true
 
33
        }
 
34
        for i, b := range saw {
 
35
                if !b && decode[i] != 0 {
 
36
                        t.Errorf("decode[%d] = %d, want 0", i, decode[i])
 
37
                }
 
38
        }
 
39
}
 
40
 
 
41
var gitPairs = []testpair{
 
42
        // Wikipedia example, adapted.
 
43
        {
 
44
                "Man is distinguished, not only by his reason, but by this singular passion from " +
 
45
                        "other animals, which is a lust of the mind, that by a perseverance of delight in " +
 
46
                        "the continued and indefatigable generation of knowledge, exceeds the short " +
 
47
                        "vehemence of any carnal pleasure.",
 
48
 
 
49
                "zO<`^zX>%ZCX>)XGZfA9Ab7*B`EFf-gbRchTY<VDJc_3(Mb0BhMVRLV8EFfZabRc4R\n" +
 
50
                        "zAarPHb0BkRZfA9DVR9gFVRLh7Z*CxFa&K)QZ**v7av))DX>DO_b1WctXlY|;AZc?T\n" +
 
51
                        "zVIXXEb95kYW*~HEWgu;7Ze%PVbZB98AYyqSVIXj2a&u*NWpZI|V`U(3W*}r`Y-wj`\n" +
 
52
                        "zbRcPNAarPDAY*TCbZKsNWn>^>Ze$>7Ze(R<VRUI{VPb4$AZKN6WpZJ3X>V>IZ)PBC\n" +
 
53
                        "zZf|#NWn^b%EFfigV`XJzb0BnRWgv5CZ*p`Xc4cT~ZDnp_Wgu^6AYpEKAY);2ZeeU7\n" +
 
54
                        "IaBO8^b9HiME&u=k\n",
 
55
        },
 
56
}
 
57
 
 
58
var gitBigtest = gitPairs[len(gitPairs)-1]
 
59
 
 
60
func TestEncode(t *testing.T) {
 
61
        for _, p := range gitPairs {
 
62
                buf := make([]byte, EncodedLen(len(p.decoded)))
 
63
                n := Encode(buf, []byte(p.decoded))
 
64
                if n != len(buf) {
 
65
                        t.Errorf("EncodedLen does not agree with Encode")
 
66
                }
 
67
                buf = buf[0:n]
 
68
                testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded)
 
69
        }
 
70
}
 
71
 
 
72
func TestEncoder(t *testing.T) {
 
73
        for _, p := range gitPairs {
 
74
                bb := &bytes.Buffer{}
 
75
                encoder := NewEncoder(bb)
 
76
                encoder.Write([]byte(p.decoded))
 
77
                encoder.Close()
 
78
                testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded)
 
79
        }
 
80
}
 
81
 
 
82
func TestEncoderBuffering(t *testing.T) {
 
83
        input := []byte(gitBigtest.decoded)
 
84
        for bs := 1; bs <= 12; bs++ {
 
85
                bb := &bytes.Buffer{}
 
86
                encoder := NewEncoder(bb)
 
87
                for pos := 0; pos < len(input); pos += bs {
 
88
                        end := pos + bs
 
89
                        if end > len(input) {
 
90
                                end = len(input)
 
91
                        }
 
92
                        n, err := encoder.Write(input[pos:end])
 
93
                        testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
 
94
                        testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
 
95
                }
 
96
                err := encoder.Close()
 
97
                testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
 
98
                testEqual(t, "Encoding/%d of %q = %q, want %q", bs, gitBigtest.decoded, bb.String(), gitBigtest.encoded)
 
99
        }
 
100
}
 
101
 
 
102
func TestDecode(t *testing.T) {
 
103
        for _, p := range gitPairs {
 
104
                dbuf := make([]byte, 4*len(p.encoded))
 
105
                ndst, err := Decode(dbuf, []byte(p.encoded))
 
106
                testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
 
107
                testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded))
 
108
                testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded)
 
109
        }
 
110
}
 
111
 
 
112
func TestDecoder(t *testing.T) {
 
113
        for _, p := range gitPairs {
 
114
                decoder := NewDecoder(bytes.NewBufferString(p.encoded))
 
115
                dbuf, err := ioutil.ReadAll(decoder)
 
116
                if err != nil {
 
117
                        t.Fatal("Read failed", err)
 
118
                }
 
119
                testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded))
 
120
                testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded)
 
121
                if err != nil {
 
122
                        testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF)
 
123
                }
 
124
        }
 
125
}
 
126
 
 
127
func TestDecoderBuffering(t *testing.T) {
 
128
        for bs := 1; bs <= 12; bs++ {
 
129
                decoder := NewDecoder(bytes.NewBufferString(gitBigtest.encoded))
 
130
                buf := make([]byte, len(gitBigtest.decoded)+12)
 
131
                var total int
 
132
                for total = 0; total < len(gitBigtest.decoded); {
 
133
                        n, err := decoder.Read(buf[total : total+bs])
 
134
                        testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", gitBigtest.encoded, total, n, err, os.Error(nil))
 
135
                        total += n
 
136
                }
 
137
                testEqual(t, "Decoding/%d of %q = %q, want %q", bs, gitBigtest.encoded, string(buf[0:total]), gitBigtest.decoded)
 
138
        }
 
139
}
 
140
 
 
141
func TestDecodeCorrupt(t *testing.T) {
 
142
        type corrupt struct {
 
143
                e string
 
144
                p int
 
145
        }
 
146
        examples := []corrupt{
 
147
                {"v", 0},
 
148
                {"!z!!!!!!!!!", 0},
 
149
        }
 
150
 
 
151
        for _, e := range examples {
 
152
                dbuf := make([]byte, 2*len(e.e))
 
153
                _, err := Decode(dbuf, []byte(e.e))
 
154
                switch err := err.(type) {
 
155
                case CorruptInputError:
 
156
                        testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
 
157
                default:
 
158
                        t.Error("Decoder failed to detect corruption in", e)
 
159
                }
 
160
        }
 
161
}
 
162
 
 
163
func TestGitBig(t *testing.T) {
 
164
        n := 3*1000 + 1
 
165
        raw := make([]byte, n)
 
166
        const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
167
        for i := 0; i < n; i++ {
 
168
                raw[i] = alpha[i%len(alpha)]
 
169
        }
 
170
        encoded := new(bytes.Buffer)
 
171
        w := NewEncoder(encoded)
 
172
        nn, err := w.Write(raw)
 
173
        if nn != n || err != nil {
 
174
                t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
 
175
        }
 
176
        err = w.Close()
 
177
        if err != nil {
 
178
                t.Fatalf("Encoder.Close() = %v want nil", err)
 
179
        }
 
180
        decoded, err := ioutil.ReadAll(NewDecoder(encoded))
 
181
        if err != nil {
 
182
                t.Fatalf("ioutil.ReadAll(NewDecoder(...)): %v", err)
 
183
        }
 
184
 
 
185
        if !bytes.Equal(raw, decoded) {
 
186
                var i int
 
187
                for i = 0; i < len(decoded) && i < len(raw); i++ {
 
188
                        if decoded[i] != raw[i] {
 
189
                                break
 
190
                        }
 
191
                }
 
192
                t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
 
193
        }
 
194
}