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

#include <stdint.h>

#include <vector>

#include "buffer_writer.h"
#include "compat/test.h"

namespace quipper {

// Move the cursor around and make sure the offset is properly set each time.
TEST(BufferWriterTest, MoveOffset) {
  std::vector<uint8_t> buffer(1000);

  BufferWriter writer(buffer.data(), buffer.size());
  EXPECT_EQ(0, writer.Tell());
  EXPECT_EQ(buffer.size(), writer.size());

  // Move the write cursor around.
  writer.SeekSet(100);
  EXPECT_EQ(100, writer.Tell());
  writer.SeekSet(900);
  EXPECT_EQ(900, writer.Tell());
  writer.SeekSet(500);
  EXPECT_EQ(500, writer.Tell());

  // The cursor can be set to past the end of the buffer, but can't perform any
  // write operations there.
  writer.SeekSet(1200);
  EXPECT_EQ(1200, writer.Tell());
  int dummy = 0;
  EXPECT_FALSE(writer.WriteData(&dummy, sizeof(dummy)));
}

// Make sure that the writer can handle a write size of zero.
TEST(BufferWriterTest, WriteZeroBytes) {
  std::vector<uint8_t> output(10);
  BufferWriter writer(output.data(), output.size());
  writer.SeekSet(5);
  EXPECT_TRUE(writer.WriteData(NULL, 0));
  // Make sure the write pointer hasn't moved.
  EXPECT_EQ(5, writer.Tell());
}

// Write a chunk of data to the output buffer.
TEST(BufferWriterTest, WriteSingleChunk) {
  const string kInputData = "abcdefghijklmnopqrstuvwxyz";
  std::vector<uint8_t> output(kInputData.size());
  BufferWriter writer(output.data(), output.size());

  EXPECT_TRUE(writer.WriteData(kInputData.data(), kInputData.size()));
  EXPECT_EQ(output.size(), writer.Tell());

  // Compare input and output data, converting the latter to a string for
  // clarity of error messages.
  EXPECT_EQ(kInputData, string(output.begin(), output.end()));
}

// Test the WriteDataValue() function, which is a wrapper around WriteData().
TEST(BufferWriterTest, WriteDataValue) {
  const string kInputData = "abcdefghijklmnopqrstuvwxyz";
  std::vector<uint8_t> output(kInputData.size());
  BufferWriter writer(output.data(), output.size());

  EXPECT_TRUE(
      writer.WriteDataValue(kInputData.data(), kInputData.size(), "data"));
  EXPECT_EQ(output.size(), writer.Tell());

  EXPECT_EQ(kInputData, string(output.begin(), output.end()));
}

// Write in all data from the input buffer in multiple chunks, in order.
TEST(BufferWriterTest, WriteMultipleChunks) {
  // This string is 26 characters long.
  const string kInputData = "abcdefghijklmnopqrstuvwxyz";

  std::vector<uint8_t> output(kInputData.size());
  BufferWriter writer(output.data(), output.size());

  // Write all the data in multiple operations. Make sure the cursor is updated.
  EXPECT_TRUE(writer.WriteData(kInputData.data() + writer.Tell(), 10));
  EXPECT_EQ(10, writer.Tell());
  EXPECT_TRUE(writer.WriteData(kInputData.data() + writer.Tell(), 5));
  EXPECT_EQ(15, writer.Tell());
  EXPECT_TRUE(writer.WriteData(kInputData.data() + writer.Tell(), 5));
  EXPECT_EQ(20, writer.Tell());
  EXPECT_TRUE(writer.WriteData(kInputData.data() + writer.Tell(), 6));
  EXPECT_EQ(26, writer.Tell());

  EXPECT_EQ(kInputData, string(output.begin(), output.end()));
}

// Write all data from the input buffer in multiple chunks, but not in order.
TEST(BufferWriterTest, WriteWithJumps) {
  // This string contains four parts, each 10 characters long.
  const string kInputData =
      "0:abcdefg;"
      "1:hijklmn;"
      "2:opqrstu;"
      "3:vwxyzABC";

  std::vector<uint8_t> output(kInputData.size());
  BufferWriter writer(output.data(), output.size());

  writer.SeekSet(20);
  EXPECT_TRUE(writer.WriteData(kInputData.data() + 20, 10));
  EXPECT_EQ(30, writer.Tell());
  EXPECT_EQ("2:opqrstu;", string(output.begin() + 20, output.begin() + 30));

  writer.SeekSet(10);
  EXPECT_TRUE(writer.WriteData(kInputData.data() + 10, 10));
  EXPECT_EQ(20, writer.Tell());
  EXPECT_EQ("1:hijklmn;", string(output.begin() + 10, output.begin() + 20));

  writer.SeekSet(30);
  EXPECT_TRUE(writer.WriteData(kInputData.data() + 30, 10));
  EXPECT_EQ(40, writer.Tell());
  EXPECT_EQ("3:vwxyzABC", string(output.begin() + 30, output.begin() + 40));

  writer.SeekSet(0);
  EXPECT_TRUE(writer.WriteData(kInputData.data(), 10));
  EXPECT_EQ(10, writer.Tell());
  EXPECT_EQ("0:abcdefg;", string(output.begin(), output.begin() + 10));
}

// Test writing past the end of the buffer.
TEST(BufferWriterTest, WritePastEndOfData) {
  // This string is 26 characters long.
  const string kInputData = "abcdefghijklmnopqrstuvwxyz";
  std::vector<uint8_t> output(kInputData.size());
  BufferWriter writer(output.data(), output.size());

  // Must not be able to write past the end of the buffer.
  writer.SeekSet(0);
  EXPECT_FALSE(writer.WriteData(kInputData.data() + writer.Tell(), 30));
  // The write pointer should not have moved.
  EXPECT_EQ(0, writer.Tell());

  // Should still be able to write within the bounds of the buffer, despite the
  // out-of-bounds write earlier.
  EXPECT_TRUE(writer.WriteData(kInputData.data() + writer.Tell(), 13));
  EXPECT_EQ(13, writer.Tell());

  // Now attempt another write past the end of the buffer, but starting from the
  // ending position of the previous write operation.
  EXPECT_FALSE(writer.WriteData(kInputData.data() + writer.Tell(), 20));
  // The write pointer should be unchanged.
  EXPECT_EQ(13, writer.Tell());

  // Write the rest of the data and make sure it matches the input.
  EXPECT_TRUE(writer.WriteData(kInputData.data() + writer.Tell(), 13));
  EXPECT_EQ(26, writer.Tell());

  EXPECT_EQ(kInputData, string(output.begin(), output.end()));
}

// Test string writes.
TEST(BufferWriterTest, WriteString) {
  // Construct an input string.
  string input("The quick brown fox jumps over the lazy dog.");

  // Write the full string.
  std::vector<char> full_output(input.size());
  BufferWriter full_writer(full_output.data(), full_output.size());
  EXPECT_TRUE(full_writer.WriteString(input, input.size()));
  EXPECT_EQ(input.size(), full_writer.Tell());
  // There is no null pointer at the end of the output buffer, so create a
  // string out of it using the known length of the input string.
  EXPECT_EQ(input, string(full_output.data(), input.size()));

  // Write the full string plus the null pointer.
  std::vector<char> full_null_output(input.size() + 1);
  BufferWriter full_null_writer(full_null_output.data(),
                                full_null_output.size());
  EXPECT_TRUE(full_null_writer.WriteString(input, input.size() + 1));
  EXPECT_EQ(input.size() + 1, full_null_writer.Tell());
  // The null pointer should have been written. It should determine the end of
  // the string.
  EXPECT_EQ(input, string(full_null_output.data()));

  // Write the first half of the string.
  std::vector<char> half_output(input.size() / 2);
  BufferWriter half_writer(half_output.data(), half_output.size());
  EXPECT_TRUE(half_writer.WriteString(input, input.size() / 2));
  EXPECT_EQ(input.size() / 2, half_writer.Tell());
  // Null terminator is not guaranteed, so use the input string size to limit
  // the output string during comparison.
  EXPECT_EQ(input.substr(0, input.size() / 2),
            string(half_output.data(), input.size() / 2));

  // Attempt to write past the end of the buffer. Should fail.
  std::vector<char> past_end_buffer(input.size());
  BufferWriter past_end_writer(past_end_buffer.data(), past_end_buffer.size());
  EXPECT_FALSE(past_end_writer.WriteString(input, input.size() + 2));

  // Write string with some extra padding.
  std::vector<char> extra_padding_output(input.size() + 10);
  BufferWriter vector_writer(extra_padding_output.data(),
                             extra_padding_output.size());
  EXPECT_TRUE(vector_writer.WriteString(input, extra_padding_output.size()));
  // The writer should have written both the string data and padding bytes.
  EXPECT_EQ(extra_padding_output.size(), vector_writer.Tell());
  // But the string should still be null-terminated.
  EXPECT_EQ(input, extra_padding_output.data());
}

// Writes data to a buffer and verifies that the buffer has not been modified
// beyond the writable boundaries.
TEST(BufferWriterTest, NoWritingOutOfBounds) {
  // A sentinel value that fills memory to detect when that section of memory is
  // overwritten. If the memory shows another value, it means it has been
  // overwritten.
  const uint8_t kUnwrittenValue = 0xaa;

  std::vector<uint8_t> buffer(1000, kUnwrittenValue);
  // Only write to the range [100, 900).
  BufferWriter writer(buffer.data() + 100, 800);

  // Create some input data that's filled with zeroes. Write this to the buffer.
  std::vector<uint8_t> input(800, 0);
  EXPECT_TRUE(writer.WriteData(input.data(), input.size()));
  EXPECT_EQ(input.size(), writer.Tell());

  // Check that the data was written to the writable part of the buffer.
  EXPECT_EQ(input,
            std::vector<uint8_t>(buffer.begin() + 100, buffer.begin() + 900));

  // Now make sure that the other parts of the buffer haven't been overwritten.
  const std::vector<uint8_t> expected_unwritten_part(100, kUnwrittenValue);
  EXPECT_EQ(expected_unwritten_part,
            std::vector<uint8_t>(buffer.begin(), buffer.begin() + 100));
  EXPECT_EQ(expected_unwritten_part,
            std::vector<uint8_t>(buffer.begin() + 900, buffer.begin() + 1000));
}

// Writes a string to a buffer and verifies that the buffer has not been
// modified beyond the writable boundaries.
TEST(BufferWriterTest, NoWritingStringOutOfBounds) {
  // Construct an input string.
  string input("This line is forty characters long.....");

  // A sentinel value that fills memory to detect when that section of memory is
  // overwritten. If the memory shows another value, it means it has been
  // overwritten.
  const uint8_t kUnwrittenValue = 0xaa;
  std::vector<char> buffer(100, kUnwrittenValue);

  // Only write to the range [20, 61). This includes enough space for the string
  // and the null terminator. Make sure the string is short enough that it fits
  // inside the buffer and leaves at least one byte of extra space at the end,
  // beyond the null terminator.
  ASSERT_LT(input.size() + 1, buffer.size() - 20);
  BufferWriter writer(buffer.data() + 20, input.size() + 1);

  // Write the string plus null terminator, and verify that it was written.
  EXPECT_TRUE(writer.WriteString(input, input.size() + 1));
  EXPECT_EQ(input, buffer.data() + 20);
  EXPECT_EQ(input.size() + 1, writer.Tell());

  // Now make sure that the other parts of the buffer haven't been overwritten.
  EXPECT_EQ(std::vector<char>(20, kUnwrittenValue),
            std::vector<char>(buffer.begin(), buffer.begin() + 20));
  // There are 39 bytes between offset 61 (end of the string contents) and the
  // end of the buffer.
  EXPECT_EQ(std::vector<char>(39, kUnwrittenValue),
            std::vector<char>(buffer.begin() + 61, buffer.end()));
}

}  // namespace quipper