streams_unittest.cc

// Copyright 2009 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "courgette/streams.h"

#include <stddef.h>
#include <stdint.h>

#include <vector>

#include "testing/gtest/include/gtest/gtest.h"

TEST(StreamsTest, SimpleWriteRead) {
  const unsigned int kValue1 = 12345;
  courgette::SinkStream sink;

  EXPECT_TRUE(sink.WriteVarint32(kValue1));

  const uint8_t* sink_buffer = sink.Buffer();
  size_t length = sink.Length();

  courgette::SourceStream source;
  source.Init(sink_buffer, length);

  unsigned int value;
  bool can_read = source.ReadVarint32(&value);
  EXPECT_TRUE(can_read);
  EXPECT_EQ(kValue1, value);
  EXPECT_EQ(0U, source.Remaining());
}

TEST(StreamsTest, SimpleWriteRead2) {
  courgette::SinkStream sink;

  EXPECT_TRUE(sink.Write("Hello", 5));

  const uint8_t* sink_buffer = sink.Buffer();
  size_t sink_length = sink.Length();

  courgette::SourceStream source;
  source.Init(sink_buffer, sink_length);

  char text[10] = {0};
  bool can_read = source.Read(text, 5);
  EXPECT_TRUE(can_read);
  EXPECT_EQ(0, memcmp("Hello", text, 5));
  EXPECT_EQ(0U, source.Remaining());
}

TEST(StreamsTest, StreamSetWriteRead) {
  courgette::SinkStreamSet out;
  out.Init(4);

  const unsigned int kValue1 = 12345;

  EXPECT_TRUE(out.stream(3)->WriteVarint32(kValue1));

  courgette::SinkStream collected;

  EXPECT_TRUE(out.CopyTo(&collected));

  const uint8_t* collected_buffer = collected.Buffer();
  size_t collected_length = collected.Length();

  courgette::SourceStreamSet in;
  bool can_init = in.Init(collected_buffer, collected_length);
  EXPECT_TRUE(can_init);

  uint32_t value;
  bool can_read = in.stream(3)->ReadVarint32(&value);
  EXPECT_TRUE(can_read);
  EXPECT_EQ(kValue1, value);
  EXPECT_EQ(0U, in.stream(3)->Remaining());
  EXPECT_EQ(0U, in.stream(2)->Remaining());
}

TEST(StreamsTest, StreamSetWriteRead2) {
  const size_t kNumberOfStreams = 4;
  const unsigned int kEnd = ~0U;

  courgette::SinkStreamSet out;
  out.Init(kNumberOfStreams);

  static const unsigned int data[] = {
    3, 123,  3, 1000,  0, 100, 2, 100,  0, 999999,
    0, 0,  0, 0,  1, 2,  1, 3,  1, 5,  0, 66,
    // varint32 edge case values:
    1, 127,  1, 128,  1, 129,  1, 16383,  1, 16384,
    kEnd
  };

  for (size_t i = 0;  data[i] != kEnd;  i += 2) {
    size_t id = data[i];
    size_t datum = data[i + 1];
    EXPECT_TRUE(out.stream(id)->WriteVarint32(datum));
  }

  courgette::SinkStream collected;

  EXPECT_TRUE(out.CopyTo(&collected));

  courgette::SourceStreamSet in;
  bool can_init = in.Init(collected.Buffer(), collected.Length());
  EXPECT_TRUE(can_init);

  for (size_t i = 0;  data[i] != kEnd;  i += 2) {
    size_t id = data[i];
    size_t datum = data[i + 1];
    uint32_t value = 77;
    bool can_read = in.stream(id)->ReadVarint32(&value);
    EXPECT_TRUE(can_read);
    EXPECT_EQ(datum, value);
  }

  for (size_t i = 0;  i < kNumberOfStreams;  ++i) {
    EXPECT_EQ(0U, in.stream(i)->Remaining());
  }
}

TEST(StreamsTest, SignedVarint32) {
  courgette::SinkStream out;

  static const int32_t data[] = {0,       64,      128,        8192,
                                 16384,   1 << 20, 1 << 21,    1 << 22,
                                 1 << 27, 1 << 28, 0x7fffffff, -0x7fffffff};

  std::vector<int32_t> values;
  for (size_t i = 0;  i < sizeof(data)/sizeof(data[0]);  ++i) {
    int32_t basis = data[i];
    for (int delta = -4; delta <= 4; ++delta) {
      EXPECT_TRUE(out.WriteVarint32Signed(basis + delta));
      values.push_back(basis + delta);
      EXPECT_TRUE(out.WriteVarint32Signed(-basis + delta));
      values.push_back(-basis + delta);
    }
  }

  courgette::SourceStream in;
  in.Init(out);

  for (size_t i = 0;  i < values.size();  ++i) {
    int written_value = values[i];
    int32_t datum;
    bool can_read = in.ReadVarint32Signed(&datum);
    EXPECT_TRUE(can_read);
    EXPECT_EQ(written_value, datum);
  }

  EXPECT_TRUE(in.Empty());
}

TEST(StreamsTest, StreamSetReadWrite) {
  courgette::SinkStreamSet out;

  { // Local scope for temporary stream sets.
    courgette::SinkStreamSet subset1;
    EXPECT_TRUE(subset1.stream(3)->WriteVarint32(30000));
    EXPECT_TRUE(subset1.stream(5)->WriteVarint32(50000));
    EXPECT_TRUE(out.WriteSet(&subset1));

    courgette::SinkStreamSet subset2;
    EXPECT_TRUE(subset2.stream(2)->WriteVarint32(20000));
    EXPECT_TRUE(subset2.stream(6)->WriteVarint32(60000));
    EXPECT_TRUE(out.WriteSet(&subset2));
  }

  courgette::SinkStream collected;
  EXPECT_TRUE(out.CopyTo(&collected));
  courgette::SourceStreamSet in;
  bool can_init_in = in.Init(collected.Buffer(), collected.Length());
  EXPECT_TRUE(can_init_in);

  courgette::SourceStreamSet subset1;
  bool can_read_1 = in.ReadSet(&subset1);
  EXPECT_TRUE(can_read_1);
  EXPECT_FALSE(in.Empty());

  courgette::SourceStreamSet subset2;
  bool can_read_2 = in.ReadSet(&subset2);
  EXPECT_TRUE(can_read_2);
  EXPECT_TRUE(in.Empty());

  courgette::SourceStreamSet subset3;
  bool can_read_3 = in.ReadSet(&subset3);
  EXPECT_FALSE(can_read_3);

  EXPECT_FALSE(subset1.Empty());
  EXPECT_FALSE(subset1.Empty());

  uint32_t datum;
  EXPECT_TRUE(subset1.stream(3)->ReadVarint32(&datum));
  EXPECT_EQ(30000U, datum);
  EXPECT_TRUE(subset1.stream(5)->ReadVarint32(&datum));
  EXPECT_EQ(50000U, datum);
  EXPECT_TRUE(subset1.Empty());

  EXPECT_TRUE(subset2.stream(2)->ReadVarint32(&datum));
  EXPECT_EQ(20000U, datum);
  EXPECT_TRUE(subset2.stream(6)->ReadVarint32(&datum));
  EXPECT_EQ(60000U, datum);
  EXPECT_TRUE(subset2.Empty());
}