courgette/streams_unittest.cc

   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 <stddef.h>
   8 #include <stdint.h>
   9
  10 #include <vector>
  11
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 TEST(StreamsTest, SimpleWriteRead) {
  15   const unsigned int kValue1 = 12345;
  16   courgette::SinkStream sink;
  17
  18   EXPECT_TRUE(sink.WriteVarint32(kValue1));
  19
  20   const uint8_t* sink_buffer = sink.Buffer();
  21   size_t length = sink.Length();
  22
  23   courgette::SourceStream source;
  24   source.Init(sink_buffer, length);
  25
  26   unsigned int value;
  27   bool can_read = source.ReadVarint32(&value);
  28   EXPECT_TRUE(can_read);
  29   EXPECT_EQ(kValue1, value);
  30   EXPECT_EQ(0U, source.Remaining());
  31 }
  32
  33 TEST(StreamsTest, SimpleWriteRead2) {
  34   courgette::SinkStream sink;
  35
  36   EXPECT_TRUE(sink.Write("Hello", 5));
  37
  38   const uint8_t* sink_buffer = sink.Buffer();
  39   size_t sink_length = sink.Length();
  40
  41   courgette::SourceStream source;
  42   source.Init(sink_buffer, sink_length);
  43
  44   char text[10] = {0};
  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());
  49 }
  50
  51 TEST(StreamsTest, StreamSetWriteRead) {
  52   courgette::SinkStreamSet out;
  53   out.Init(4);
  54
  55   const unsigned int kValue1 = 12345;
  56
  57   EXPECT_TRUE(out.stream(3)->WriteVarint32(kValue1));
  58
  59   courgette::SinkStream collected;
  60
  61   EXPECT_TRUE(out.CopyTo(&collected));
  62
  63   const uint8_t* collected_buffer = collected.Buffer();
  64   size_t collected_length = collected.Length();
  65
  66   courgette::SourceStreamSet in;
  67   bool can_init = in.Init(collected_buffer, collected_length);
  68   EXPECT_TRUE(can_init);
  69
  70   uint32_t value;
  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());
  76 }
  77
  78 TEST(StreamsTest, StreamSetWriteRead2) {
  79   const size_t kNumberOfStreams = 4;
  80   const unsigned int kEnd = ~0U;
  81
  82   courgette::SinkStreamSet out;
  83   out.Init(kNumberOfStreams);
  84
  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,
  90     kEnd
  91   };
  92
  93   for (size_t i = 0;  data[i] != kEnd;  i += 2) {
  94     size_t id = data[i];
  95     size_t datum = data[i + 1];
  96     EXPECT_TRUE(out.stream(id)->WriteVarint32(datum));
  97   }
  98
  99   courgette::SinkStream collected;
 100
 101   EXPECT_TRUE(out.CopyTo(&collected));
 102
 103   courgette::SourceStreamSet in;
 104   bool can_init = in.Init(collected.Buffer(), collected.Length());
 105   EXPECT_TRUE(can_init);
 106
 107   for (size_t i = 0;  data[i] != kEnd;  i += 2) {
 108     size_t id = data[i];
 109     size_t datum = data[i + 1];
 110     uint32_t value = 77;
 111     bool can_read = in.stream(id)->ReadVarint32(&value);
 112     EXPECT_TRUE(can_read);
 113     EXPECT_EQ(datum, value);
 114   }
 115
 116   for (size_t i = 0;  i < kNumberOfStreams;  ++i) {
 117     EXPECT_EQ(0U, in.stream(i)->Remaining());
 118   }
 119 }
 120
 121 TEST(StreamsTest, SignedVarint32) {
 122   courgette::SinkStream out;
 123
 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};
 127
 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);
 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_t 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_t 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 }