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 "courgette/streams.h" 6 7 #include <vector> 8 9 #include "testing/gtest/include/gtest/gtest.h" 10 11 TEST(StreamsTest, SimpleWriteRead) { 12 const unsigned int kValue1 = 12345; 13 courgette::SinkStream sink; 14 15 EXPECT_TRUE(sink.WriteVarint32(kValue1)); 16 17 const uint8* sink_buffer = sink.Buffer(); 18 size_t length = sink.Length(); 19 20 courgette::SourceStream source; 21 source.Init(sink_buffer, length); 22 23 unsigned int value; 24 bool can_read = source.ReadVarint32(&value); 25 EXPECT_TRUE(can_read); 26 EXPECT_EQ(kValue1, value); 27 EXPECT_EQ(0U, source.Remaining()); 28 } 29 30 TEST(StreamsTest, SimpleWriteRead2) { 31 courgette::SinkStream sink; 32 33 EXPECT_TRUE(sink.Write("Hello", 5)); 34 35 const uint8* sink_buffer = sink.Buffer(); 36 size_t sink_length = sink.Length(); 37 38 courgette::SourceStream source; 39 source.Init(sink_buffer, sink_length); 40 41 char text[10] = {0}; 42 bool can_read = source.Read(text, 5); 43 EXPECT_TRUE(can_read); 44 EXPECT_EQ(0, memcmp("Hello", text, 5)); 45 EXPECT_EQ(0U, source.Remaining()); 46 } 47 48 TEST(StreamsTest, StreamSetWriteRead) { 49 courgette::SinkStreamSet out; 50 out.Init(4); 51 52 const unsigned int kValue1 = 12345; 53 54 EXPECT_TRUE(out.stream(3)->WriteVarint32(kValue1)); 55 56 courgette::SinkStream collected; 57 58 EXPECT_TRUE(out.CopyTo(&collected)); 59 60 const uint8* collected_buffer = collected.Buffer(); 61 size_t collected_length = collected.Length(); 62 63 courgette::SourceStreamSet in; 64 bool can_init = in.Init(collected_buffer, collected_length); 65 EXPECT_TRUE(can_init); 66 67 uint32 value; 68 bool can_read = in.stream(3)->ReadVarint32(&value); 69 EXPECT_TRUE(can_read); 70 EXPECT_EQ(kValue1, value); 71 EXPECT_EQ(0U, in.stream(3)->Remaining()); 72 EXPECT_EQ(0U, in.stream(2)->Remaining()); 73 } 74 75 TEST(StreamsTest, StreamSetWriteRead2) { 76 const size_t kNumberOfStreams = 4; 77 const unsigned int kEnd = ~0U; 78 79 courgette::SinkStreamSet out; 80 out.Init(kNumberOfStreams); 81 82 static const unsigned int data[] = { 83 3, 123, 3, 1000, 0, 100, 2, 100, 0, 999999, 84 0, 0, 0, 0, 1, 2, 1, 3, 1, 5, 0, 66, 85 // varint32 edge case values: 86 1, 127, 1, 128, 1, 129, 1, 16383, 1, 16384, 87 kEnd 88 }; 89 90 for (size_t i = 0; data[i] != kEnd; i += 2) { 91 size_t id = data[i]; 92 size_t datum = data[i + 1]; 93 EXPECT_TRUE(out.stream(id)->WriteVarint32(datum)); 94 } 95 96 courgette::SinkStream collected; 97 98 EXPECT_TRUE(out.CopyTo(&collected)); 99 100 courgette::SourceStreamSet in; 101 bool can_init = in.Init(collected.Buffer(), collected.Length()); 102 EXPECT_TRUE(can_init); 103 104 for (size_t i = 0; data[i] != kEnd; i += 2) { 105 size_t id = data[i]; 106 size_t datum = data[i + 1]; 107 uint32 value = 77; 108 bool can_read = in.stream(id)->ReadVarint32(&value); 109 EXPECT_TRUE(can_read); 110 EXPECT_EQ(datum, value); 111 } 112 113 for (size_t i = 0; i < kNumberOfStreams; ++i) { 114 EXPECT_EQ(0U, in.stream(i)->Remaining()); 115 } 116 } 117 118 TEST(StreamsTest, SignedVarint32) { 119 courgette::SinkStream out; 120 121 static const int32 data[] = { 122 0, 64, 128, 8192, 16384, 123 1 << 20, 1 << 21, 1 << 22, 124 1 << 27, 1 << 28, 125 0x7fffffff, -0x7fffffff 126 }; 127 128 std::vector<int32> values; 129 for (size_t i = 0; i < sizeof(data)/sizeof(data[0]); ++i) { 130 int32 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); 136 } 137 } 138 139 courgette::SourceStream in; 140 in.Init(out); 141 142 for (size_t i = 0; i < values.size(); ++i) { 143 int written_value = values[i]; 144 int32 datum; 145 bool can_read = in.ReadVarint32Signed(&datum); 146 EXPECT_TRUE(can_read); 147 EXPECT_EQ(written_value, datum); 148 } 149 150 EXPECT_TRUE(in.Empty()); 151 } 152 153 TEST(StreamsTest, StreamSetReadWrite) { 154 courgette::SinkStreamSet out; 155 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)); 161 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)); 166 } 167 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); 173 174 courgette::SourceStreamSet subset1; 175 bool can_read_1 = in.ReadSet(&subset1); 176 EXPECT_TRUE(can_read_1); 177 EXPECT_FALSE(in.Empty()); 178 179 courgette::SourceStreamSet subset2; 180 bool can_read_2 = in.ReadSet(&subset2); 181 EXPECT_TRUE(can_read_2); 182 EXPECT_TRUE(in.Empty()); 183 184 courgette::SourceStreamSet subset3; 185 bool can_read_3 = in.ReadSet(&subset3); 186 EXPECT_FALSE(can_read_3); 187 188 EXPECT_FALSE(subset1.Empty()); 189 EXPECT_FALSE(subset1.Empty()); 190 191 uint32 datum; 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()); 197 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()); 203 } 204
