1 // Copyright 2009 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "courgette/streams.h"
12 #include "testing/gtest/include/gtest/gtest.h"
14 TEST(StreamsTest, SimpleWriteRead) {
15 const unsigned int kValue1 = 12345;
16 courgette::SinkStream sink;
18 EXPECT_TRUE(sink.WriteVarint32(kValue1));
20 const uint8_t* sink_buffer = sink.Buffer();
21 size_t length = sink.Length();
23 courgette::SourceStream source;
24 source.Init(sink_buffer, length);
27 bool can_read = source.ReadVarint32(&value);
28 EXPECT_TRUE(can_read);
29 EXPECT_EQ(kValue1, value);
30 EXPECT_EQ(0U, source.Remaining());
33 TEST(StreamsTest, SimpleWriteRead2) {
34 courgette::SinkStream sink;
36 EXPECT_TRUE(sink.Write("Hello", 5));
38 const uint8_t* sink_buffer = sink.Buffer();
39 size_t sink_length = sink.Length();
41 courgette::SourceStream source;
42 source.Init(sink_buffer, sink_length);
45 bool can_read = source.Read(text, 5);
46 EXPECT_TRUE(can_read);
47 EXPECT_EQ(0, memcmp("Hello", text, 5));
48 EXPECT_EQ(0U, source.Remaining());
51 TEST(StreamsTest, StreamSetWriteRead) {
52 courgette::SinkStreamSet out;
55 const unsigned int kValue1 = 12345;
57 EXPECT_TRUE(out.stream(3)->WriteVarint32(kValue1));
59 courgette::SinkStream collected;
61 EXPECT_TRUE(out.CopyTo(&collected));
63 const uint8_t* collected_buffer = collected.Buffer();
64 size_t collected_length = collected.Length();
66 courgette::SourceStreamSet in;
67 bool can_init = in.Init(collected_buffer, collected_length);
68 EXPECT_TRUE(can_init);
71 bool can_read = in.stream(3)->ReadVarint32(&value);
72 EXPECT_TRUE(can_read);
73 EXPECT_EQ(kValue1, value);
74 EXPECT_EQ(0U, in.stream(3)->Remaining());
75 EXPECT_EQ(0U, in.stream(2)->Remaining());
78 TEST(StreamsTest, StreamSetWriteRead2) {
79 const size_t kNumberOfStreams = 4;
80 const unsigned int kEnd = ~0U;
82 courgette::SinkStreamSet out;
83 out.Init(kNumberOfStreams);
85 static const unsigned int data[] = {
86 3, 123, 3, 1000, 0, 100, 2, 100, 0, 999999,
87 0, 0, 0, 0, 1, 2, 1, 3, 1, 5, 0, 66,
88 // varint32 edge case values:
89 1, 127, 1, 128, 1, 129, 1, 16383, 1, 16384,
93 for (size_t i = 0; data[i] != kEnd; i += 2) {
95 size_t datum = data[i + 1];
96 EXPECT_TRUE(out.stream(id)->WriteVarint32(datum));
99 courgette::SinkStream collected;
101 EXPECT_TRUE(out.CopyTo(&collected));
103 courgette::SourceStreamSet in;
104 bool can_init = in.Init(collected.Buffer(), collected.Length());
105 EXPECT_TRUE(can_init);
107 for (size_t i = 0; data[i] != kEnd; i += 2) {
109 size_t datum = data[i + 1];
111 bool can_read = in.stream(id)->ReadVarint32(&value);
112 EXPECT_TRUE(can_read);
113 EXPECT_EQ(datum, value);
116 for (size_t i = 0; i < kNumberOfStreams; ++i) {
117 EXPECT_EQ(0U, in.stream(i)->Remaining());
121 TEST(StreamsTest, SignedVarint32) {
122 courgette::SinkStream out;
124 static const int32_t data[] = {0, 64, 128, 8192,
125 16384, 1 << 20, 1 << 21, 1 << 22,
126 1 << 27, 1 << 28, 0x7fffffff, -0x7fffffff};
128 std::vector<int32_t> values;
129 for (size_t i = 0; i < sizeof(data)/sizeof(data[0]); ++i) {
130 int32_t basis = data[i];
131 for (int delta = -4; delta <= 4; ++delta) {
132 EXPECT_TRUE(out.WriteVarint32Signed(basis + delta));
133 values.push_back(basis + delta);
134 EXPECT_TRUE(out.WriteVarint32Signed(-basis + delta));
135 values.push_back(-basis + delta);
139 courgette::SourceStream in;
142 for (size_t i = 0; i < values.size(); ++i) {
143 int written_value = values[i];
145 bool can_read = in.ReadVarint32Signed(&datum);
146 EXPECT_TRUE(can_read);
147 EXPECT_EQ(written_value, datum);
150 EXPECT_TRUE(in.Empty());
153 TEST(StreamsTest, StreamSetReadWrite) {
154 courgette::SinkStreamSet out;
156 { // Local scope for temporary stream sets.
157 courgette::SinkStreamSet subset1;
158 EXPECT_TRUE(subset1.stream(3)->WriteVarint32(30000));
159 EXPECT_TRUE(subset1.stream(5)->WriteVarint32(50000));
160 EXPECT_TRUE(out.WriteSet(&subset1));
162 courgette::SinkStreamSet subset2;
163 EXPECT_TRUE(subset2.stream(2)->WriteVarint32(20000));
164 EXPECT_TRUE(subset2.stream(6)->WriteVarint32(60000));
165 EXPECT_TRUE(out.WriteSet(&subset2));
168 courgette::SinkStream collected;
169 EXPECT_TRUE(out.CopyTo(&collected));
170 courgette::SourceStreamSet in;
171 bool can_init_in = in.Init(collected.Buffer(), collected.Length());
172 EXPECT_TRUE(can_init_in);
174 courgette::SourceStreamSet subset1;
175 bool can_read_1 = in.ReadSet(&subset1);
176 EXPECT_TRUE(can_read_1);
177 EXPECT_FALSE(in.Empty());
179 courgette::SourceStreamSet subset2;
180 bool can_read_2 = in.ReadSet(&subset2);
181 EXPECT_TRUE(can_read_2);
182 EXPECT_TRUE(in.Empty());
184 courgette::SourceStreamSet subset3;
185 bool can_read_3 = in.ReadSet(&subset3);
186 EXPECT_FALSE(can_read_3);
188 EXPECT_FALSE(subset1.Empty());
189 EXPECT_FALSE(subset1.Empty());
192 EXPECT_TRUE(subset1.stream(3)->ReadVarint32(&datum));
193 EXPECT_EQ(30000U, datum);
194 EXPECT_TRUE(subset1.stream(5)->ReadVarint32(&datum));
195 EXPECT_EQ(50000U, datum);
196 EXPECT_TRUE(subset1.Empty());
198 EXPECT_TRUE(subset2.stream(2)->ReadVarint32(&datum));
199 EXPECT_EQ(20000U, datum);
200 EXPECT_TRUE(subset2.stream(6)->ReadVarint32(&datum));
201 EXPECT_EQ(60000U, datum);
202 EXPECT_TRUE(subset2.Empty());