| 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 |