← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/utils/size_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/utils/size_test.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the LGPLv3, see LICENCE file for details.
 
3
 
 
4
package utils_test
 
5
 
 
6
import (
 
7
        "io"
 
8
        "io/ioutil"
 
9
 
 
10
        "github.com/juju/testing"
 
11
        jc "github.com/juju/testing/checkers"
 
12
        "github.com/juju/testing/filetesting"
 
13
        gc "gopkg.in/check.v1"
 
14
 
 
15
        "github.com/juju/utils"
 
16
)
 
17
 
 
18
var _ = gc.Suite(&sizeSuite{})
 
19
 
 
20
type sizeSuite struct {
 
21
        testing.IsolationSuite
 
22
}
 
23
 
 
24
func (*sizeSuite) TestParseSize(c *gc.C) {
 
25
        type test struct {
 
26
                in  string
 
27
                out uint64
 
28
                err string
 
29
        }
 
30
        tests := []test{{
 
31
                in:  "",
 
32
                err: `expected a non-negative number, got ""`,
 
33
        }, {
 
34
                in:  "-1",
 
35
                err: `expected a non-negative number, got "-1"`,
 
36
        }, {
 
37
                in:  "1MZ",
 
38
                err: `invalid multiplier suffix "MZ", expected one of MGTPEZY`,
 
39
        }, {
 
40
                in:  "0",
 
41
                out: 0,
 
42
        }, {
 
43
                in:  "123",
 
44
                out: 123,
 
45
        }, {
 
46
                in:  "1M",
 
47
                out: 1,
 
48
        }, {
 
49
                in:  "0.5G",
 
50
                out: 512,
 
51
        }, {
 
52
                in:  "0.5GB",
 
53
                out: 512,
 
54
        }, {
 
55
                in:  "0.5GiB",
 
56
                out: 512,
 
57
        }, {
 
58
                in:  "0.5T",
 
59
                out: 524288,
 
60
        }, {
 
61
                in:  "0.5P",
 
62
                out: 536870912,
 
63
        }, {
 
64
                in:  "0.0009765625E",
 
65
                out: 1073741824,
 
66
        }, {
 
67
                in:  "1Z",
 
68
                out: 1125899906842624,
 
69
        }, {
 
70
                in:  "1Y",
 
71
                out: 1152921504606846976,
 
72
        }}
 
73
        for i, test := range tests {
 
74
                c.Logf("test %d: %+v", i, test)
 
75
                size, err := utils.ParseSize(test.in)
 
76
                if test.err != "" {
 
77
                        c.Assert(err, gc.NotNil)
 
78
                        c.Assert(err, gc.ErrorMatches, test.err)
 
79
                } else {
 
80
                        c.Assert(err, gc.IsNil)
 
81
                        c.Assert(size, gc.Equals, test.out)
 
82
                }
 
83
        }
 
84
}
 
85
 
 
86
func (*sizeSuite) TestSizingReaderOkay(c *gc.C) {
 
87
        expected := "some data"
 
88
        stub := &testing.Stub{}
 
89
        reader := filetesting.NewStubReader(stub, expected)
 
90
 
 
91
        var st utils.SizeTracker
 
92
        sizingReader := io.TeeReader(reader, &st)
 
93
        data, err := ioutil.ReadAll(sizingReader)
 
94
        c.Assert(err, jc.ErrorIsNil)
 
95
 
 
96
        stub.CheckCallNames(c, "Read", "Read")
 
97
        c.Check(string(data), gc.Equals, expected)
 
98
        c.Check(st.Size(), gc.Equals, int64(len(expected)))
 
99
}
 
100
 
 
101
func (*sizeSuite) TestSizingReaderMixedEOF(c *gc.C) {
 
102
        expected := "some data"
 
103
        stub := &testing.Stub{}
 
104
        reader := &filetesting.StubReader{
 
105
                Stub: stub,
 
106
                ReturnRead: &fakeStream{
 
107
                        data: expected,
 
108
                },
 
109
        }
 
110
 
 
111
        var st utils.SizeTracker
 
112
        sizingReader := io.TeeReader(reader, &st)
 
113
        data, err := ioutil.ReadAll(sizingReader)
 
114
        c.Assert(err, jc.ErrorIsNil)
 
115
 
 
116
        stub.CheckCallNames(c, "Read") // The EOF was mixed with the data.
 
117
        c.Check(string(data), gc.Equals, expected)
 
118
        c.Check(st.Size(), gc.Equals, int64(len(expected)))
 
119
}
 
120
 
 
121
func (*sizeSuite) TestSizingWriter(c *gc.C) {
 
122
        expected := "some data"
 
123
        stub := &testing.Stub{}
 
124
        writer, buffer := filetesting.NewStubWriter(stub)
 
125
 
 
126
        var st utils.SizeTracker
 
127
        sizingWriter := io.MultiWriter(writer, &st)
 
128
        n, err := sizingWriter.Write([]byte(expected))
 
129
        c.Assert(err, jc.ErrorIsNil)
 
130
 
 
131
        stub.CheckCallNames(c, "Write")
 
132
        c.Check(n, gc.Equals, len(expected))
 
133
        c.Check(buffer.String(), gc.Equals, expected)
 
134
        c.Check(st.Size(), gc.Equals, int64(len(expected)))
 
135
}
 
136
 
 
137
type fakeStream struct {
 
138
        data string
 
139
        pos  uint64
 
140
}
 
141
 
 
142
func (f *fakeStream) Read(data []byte) (int, error) {
 
143
        n := copy(data, f.data[f.pos:])
 
144
        f.pos += uint64(n)
 
145
        if f.pos >= uint64(len(f.data)) {
 
146
                return n, io.EOF
 
147
        }
 
148
        return n, nil
 
149
}