OLD | NEW |
| (Empty) |
1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "third_party/courgette/streams.h" | |
6 | |
7 #include "testing/gtest/include/gtest/gtest.h" | |
8 | |
9 TEST(StreamsTest, SimpleWriteRead) { | |
10 const unsigned int kValue1 = 12345; | |
11 courgette::SinkStream sink; | |
12 | |
13 sink.WriteVarint32(kValue1); | |
14 | |
15 const uint8* sink_buffer = sink.Buffer(); | |
16 size_t length = sink.Length(); | |
17 | |
18 courgette::SourceStream source; | |
19 source.Init(sink_buffer, length); | |
20 | |
21 unsigned int value; | |
22 bool can_read = source.ReadVarint32(&value); | |
23 EXPECT_EQ(true, can_read); | |
24 EXPECT_EQ(kValue1, value); | |
25 EXPECT_EQ(0, source.Remaining()); | |
26 } | |
27 | |
28 TEST(StreamsTest, SimpleWriteRead2) { | |
29 courgette::SinkStream sink; | |
30 | |
31 sink.Write("Hello", 5); | |
32 | |
33 const uint8* sink_buffer = sink.Buffer(); | |
34 size_t sink_length = sink.Length(); | |
35 | |
36 courgette::SourceStream source; | |
37 source.Init(sink_buffer, sink_length); | |
38 | |
39 char text[10] = {0}; | |
40 bool can_read = source.Read(text, 5); | |
41 EXPECT_EQ(true, can_read); | |
42 EXPECT_EQ(0, memcmp("Hello", text, 5)); | |
43 EXPECT_EQ(0, source.Remaining()); | |
44 } | |
45 | |
46 TEST(StreamsTest, StreamSetWriteRead) { | |
47 courgette::SinkStreamSet out; | |
48 out.Init(4); | |
49 | |
50 const unsigned int kValue1 = 12345; | |
51 | |
52 out.stream(3)->WriteVarint32(kValue1); | |
53 | |
54 courgette::SinkStream collected; | |
55 | |
56 out.CopyTo(&collected); | |
57 | |
58 const uint8* collected_buffer = collected.Buffer(); | |
59 size_t collected_length = collected.Length(); | |
60 | |
61 courgette::SourceStreamSet in; | |
62 bool can_init = in.Init(collected_buffer, collected_length); | |
63 EXPECT_EQ(true, can_init); | |
64 | |
65 uint32 value; | |
66 bool can_read = in.stream(3)->ReadVarint32(&value); | |
67 EXPECT_EQ(true, can_read); | |
68 EXPECT_EQ(kValue1, value); | |
69 EXPECT_EQ(0, in.stream(3)->Remaining()); | |
70 EXPECT_EQ(0, in.stream(2)->Remaining()); | |
71 } | |
72 | |
73 TEST(StreamsTest, StreamSetWriteRead2) { | |
74 const size_t kNumberOfStreams = 4; | |
75 const unsigned int kEnd = ~0U; | |
76 | |
77 courgette::SinkStreamSet out; | |
78 out.Init(kNumberOfStreams); | |
79 | |
80 static const unsigned int data[] = { | |
81 3, 123, 3, 1000, 0, 100, 2, 100, 0, 999999, | |
82 0, 0, 0, 0, 1, 2, 1, 3, 1, 5, 0, 66, | |
83 // varint32 edge case values: | |
84 1, 127, 1, 128, 1, 129, 1, 16383, 1, 16384, | |
85 kEnd | |
86 }; | |
87 | |
88 for (size_t i = 0; data[i] != kEnd; i += 2) { | |
89 size_t id = data[i]; | |
90 size_t datum = data[i + 1]; | |
91 out.stream(id)->WriteVarint32(datum); | |
92 } | |
93 | |
94 courgette::SinkStream collected; | |
95 | |
96 out.CopyTo(&collected); | |
97 | |
98 courgette::SourceStreamSet in; | |
99 bool can_init = in.Init(collected.Buffer(), collected.Length()); | |
100 EXPECT_EQ(true, can_init); | |
101 | |
102 for (size_t i = 0; data[i] != kEnd; i += 2) { | |
103 size_t id = data[i]; | |
104 size_t datum = data[i + 1]; | |
105 uint32 value = 77; | |
106 bool can_read = in.stream(id)->ReadVarint32(&value); | |
107 EXPECT_EQ(true, can_read); | |
108 EXPECT_EQ(datum, value); | |
109 } | |
110 | |
111 for (size_t i = 0; i < kNumberOfStreams; ++i) { | |
112 EXPECT_EQ(0, in.stream(i)->Remaining()); | |
113 } | |
114 } | |
115 | |
116 TEST(StreamsTest, SignedVarint32) { | |
117 courgette::SinkStream out; | |
118 | |
119 static const int32 data[] = { | |
120 0, 64, 128, 8192, 16384, | |
121 1 << 20, 1 << 21, 1 << 22, | |
122 1 << 27, 1 << 28, | |
123 0x7fffffff, -0x7fffffff | |
124 }; | |
125 | |
126 std::vector<int32> values; | |
127 for (size_t i = 0; i < sizeof(data)/sizeof(data[0]); ++i) { | |
128 int32 basis = data[i]; | |
129 for (int delta = -4; delta <= 4; ++delta) { | |
130 out.WriteVarint32Signed(basis + delta); | |
131 values.push_back(basis + delta); | |
132 out.WriteVarint32Signed(-basis + delta); | |
133 values.push_back(-basis + delta); | |
134 } | |
135 } | |
136 | |
137 courgette::SourceStream in; | |
138 in.Init(out); | |
139 | |
140 for (size_t i = 0; i < values.size(); ++i) { | |
141 int written_value = values[i]; | |
142 int32 datum; | |
143 bool can_read = in.ReadVarint32Signed(&datum); | |
144 EXPECT_EQ(written_value, datum); | |
145 } | |
146 | |
147 EXPECT_EQ(true, in.Empty()); | |
148 } | |
149 | |
150 TEST(StreamsTest, StreamSetReadWrite) { | |
151 courgette::SinkStreamSet out; | |
152 | |
153 { // Local scope for temporary stream sets. | |
154 courgette::SinkStreamSet subset1; | |
155 subset1.stream(3)->WriteVarint32(30000); | |
156 subset1.stream(5)->WriteVarint32(50000); | |
157 out.WriteSet(&subset1); | |
158 | |
159 courgette::SinkStreamSet subset2; | |
160 subset2.stream(2)->WriteVarint32(20000); | |
161 subset2.stream(6)->WriteVarint32(60000); | |
162 out.WriteSet(&subset2); | |
163 } | |
164 | |
165 courgette::SinkStream collected; | |
166 out.CopyTo(&collected); | |
167 courgette::SourceStreamSet in; | |
168 bool can_init_in = in.Init(collected.Buffer(), collected.Length()); | |
169 EXPECT_EQ(true, can_init_in); | |
170 | |
171 courgette::SourceStreamSet subset1; | |
172 bool can_read_1 = in.ReadSet(&subset1); | |
173 EXPECT_EQ(true, can_read_1); | |
174 EXPECT_EQ(false, in.Empty()); | |
175 | |
176 courgette::SourceStreamSet subset2; | |
177 bool can_read_2 = in.ReadSet(&subset2); | |
178 EXPECT_EQ(true, can_read_2); | |
179 EXPECT_EQ(true, in.Empty()); | |
180 | |
181 courgette::SourceStreamSet subset3; | |
182 bool can_read_3 = in.ReadSet(&subset3); | |
183 EXPECT_EQ(false, can_read_3); | |
184 | |
185 EXPECT_EQ(false, subset1.Empty()); | |
186 EXPECT_EQ(false, subset1.Empty()); | |
187 | |
188 uint32 datum; | |
189 EXPECT_EQ(true, subset1.stream(3)->ReadVarint32(&datum)); | |
190 EXPECT_EQ(30000, datum); | |
191 EXPECT_EQ(true, subset1.stream(5)->ReadVarint32(&datum)); | |
192 EXPECT_EQ(50000, datum); | |
193 EXPECT_EQ(true, subset1.Empty()); | |
194 | |
195 EXPECT_EQ(true, subset2.stream(2)->ReadVarint32(&datum)); | |
196 EXPECT_EQ(20000, datum); | |
197 EXPECT_EQ(true, subset2.stream(6)->ReadVarint32(&datum)); | |
198 EXPECT_EQ(60000, datum); | |
199 EXPECT_EQ(true, subset2.Empty()); | |
200 } | |
OLD | NEW |