← Back to branch summary

~sinzui/ubuntu/wily/juju-core/wily-1.24.7

« back to all changes in this revision

Viewing changes to src/github.com/juju/utils/hash/writer_test.go

  • Committer: Package Import Robot
  • Author(s): Oleg Strikov
  • Date: 2015-03-26 15:54:39 UTC
  • mfrom: (1.1.32)
  • Revision ID: package-import@ubuntu.com-20150326155439-ot7bwwyoomq13btm
Tags: 1.22.0-0ubuntu1
https://launchpad.net/bugs/1416051
https://launchpad.net/bugs/1427879
https://launchpad.net/bugs/1434092
* New upstream release (LP: #1416051).
* d/patches/fix-detect-new-release.patch: Added upstream patch to redeem
  the ability to handle future Ubuntu releases (LP: #1427879, #1434092).
* d/tests/fake-future.sh: New ability to generate fake /etc/os-release.
* d/copyright: Updated to reflect changes in the codebase.
* d/control:
  - Change build dependency from gccgo to gccgo-go.
  - Use either cloud-image-utils or cloud-utils as dependency for juju-local
    because cloud-image-utils is not available on precise.
  - Compliance to Debian Policy 3.9.6 was declared.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/utils/hash/writer_test.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the LGPLv3, see LICENCE file for details.
 
3
 
 
4
package hash_test
 
5
 
 
6
import (
 
7
        "bytes"
 
8
        "errors"
 
9
 
 
10
        "github.com/juju/testing"
 
11
        gc "gopkg.in/check.v1"
 
12
 
 
13
        "github.com/juju/utils/hash"
 
14
)
 
15
 
 
16
var _ = gc.Suite(&WriterSuite{})
 
17
 
 
18
type WriterSuite struct {
 
19
        testing.IsolationSuite
 
20
}
 
21
 
 
22
type errorWriter struct {
 
23
        err error
 
24
}
 
25
 
 
26
func (w *errorWriter) Write(data []byte) (int, error) {
 
27
        return 0, w.err
 
28
}
 
29
 
 
30
type fakeHasher struct {
 
31
        bytes.Buffer
 
32
        sum []byte
 
33
}
 
34
 
 
35
func (h *fakeHasher) Sum(b []byte) []byte {
 
36
        return h.sum
 
37
}
 
38
 
 
39
// Not used:
 
40
func (h *fakeHasher) Reset()         {}
 
41
func (h *fakeHasher) Size() int      { return -1 }
 
42
func (h *fakeHasher) BlockSize() int { return -1 }
 
43
 
 
44
func (s *WriterSuite) TestHashingWriterWriteEmpty(c *gc.C) {
 
45
        var buf bytes.Buffer
 
46
        hasher := fakeHasher{}
 
47
        w := hash.NewHashingWriter(&buf, &hasher)
 
48
        n, err := w.Write(nil)
 
49
 
 
50
        c.Check(err, gc.IsNil)
 
51
        c.Check(n, gc.Equals, 0)
 
52
        c.Check(buf.String(), gc.Equals, "")
 
53
        c.Check(hasher.String(), gc.Equals, "")
 
54
}
 
55
 
 
56
func (s *WriterSuite) TestHashingWriterWriteSmall(c *gc.C) {
 
57
        var buf bytes.Buffer
 
58
        hasher := fakeHasher{}
 
59
        w := hash.NewHashingWriter(&buf, &hasher)
 
60
        n, err := w.Write([]byte("spam"))
 
61
 
 
62
        c.Check(err, gc.IsNil)
 
63
        c.Check(n, gc.Equals, 4)
 
64
        c.Check(buf.String(), gc.Equals, "spam")
 
65
        c.Check(hasher.String(), gc.Equals, "spam")
 
66
}
 
67
 
 
68
func (s *WriterSuite) TestHashingWriterWriteFileError(c *gc.C) {
 
69
        file := errorWriter{err: errors.New("failed!")}
 
70
        hasher := fakeHasher{}
 
71
        w := hash.NewHashingWriter(&file, &hasher)
 
72
        _, err := w.Write([]byte("spam"))
 
73
 
 
74
        c.Check(err, gc.ErrorMatches, "failed!")
 
75
}
 
76
 
 
77
func (s *WriterSuite) TestHashingWriterSum(c *gc.C) {
 
78
        var buf bytes.Buffer
 
79
        hasher := fakeHasher{sum: []byte("spam")}
 
80
        w := hash.NewHashingWriter(&buf, &hasher)
 
81
        b64hash := string(w.Sum())
 
82
 
 
83
        c.Check(b64hash, gc.Equals, "spam")
 
84
}
 
85
 
 
86
func (s *WriterSuite) TestHashingWriterBase64Sum(c *gc.C) {
 
87
        var buf bytes.Buffer
 
88
        hasher := fakeHasher{sum: []byte("spam")}
 
89
        w := hash.NewHashingWriter(&buf, &hasher)
 
90
        b64hash := w.Base64Sum()
 
91
 
 
92
        c.Check(b64hash, gc.Equals, "c3BhbQ==")
 
93
}
 
94
 
 
95
func (s *WriterSuite) TestHashingWriterHexSum(c *gc.C) {
 
96
        var buf bytes.Buffer
 
97
        hasher := fakeHasher{sum: []byte("spam")}
 
98
        w := hash.NewHashingWriter(&buf, &hasher)
 
99
        rawhash := w.HexSum()
 
100
 
 
101
        c.Check(rawhash, gc.Equals, "7370616d")
 
102
}