// 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 "compat/test.h"
#include "file_reader.h"
#include "file_utils.h"
#include "scoped_temp_path.h"
#include "test_utils.h"

namespace quipper {

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

  ScopedTempFile input_file;
  ASSERT_TRUE(BufferToFile(input_file.path(), input_data));

  // Create a reader for reading.
  FileReader reader(input_file.path());
  EXPECT_EQ(input_data.size(), reader.size());
  EXPECT_EQ(0, reader.Tell());

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

  // The cursor can be set to past the end of the file, but can't perform any
  // read operations there.
  reader.SeekSet(1200);
  EXPECT_EQ(1200, reader.Tell());
  int dummy;
  EXPECT_FALSE(reader.ReadData(sizeof(dummy), &dummy));
}

// Make sure that the reader can handle a read size of zero.
TEST(FileReaderTest, ReadZeroBytes) {
  std::vector<uint8_t> input_data(10);

  ScopedTempFile input_file;
  ASSERT_TRUE(BufferToFile(input_file.path(), input_data));

  FileReader reader(input_file.path());
  reader.SeekSet(5);
  EXPECT_TRUE(reader.ReadData(0, NULL));

  // Make sure the read pointer hasn't moved.
  EXPECT_EQ(5, reader.Tell());
}

// Read in all data from the input file at once.
TEST(FileReaderTest, ReadSingleChunk) {
  const string kInputData = "abcdefghijklmnopqrstuvwxyz";

  ScopedTempFile input_file;
  ASSERT_TRUE(BufferToFile(input_file.path(), kInputData));
  FileReader reader(input_file.path());

  // Read all the data from the file in one go.
  std::vector<uint8_t> output(kInputData.size());
  EXPECT_TRUE(reader.ReadData(output.size(), output.data()));
  EXPECT_EQ(output.size(), reader.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 ReadDataValue() function, which is a wrapper around ReadData().
TEST(FileReaderTest, ReadDataValue) {
  const string kInputData = "abcdefghijklmnopqrstuvwxyz";

  ScopedTempFile input_file;
  ASSERT_TRUE(BufferToFile(input_file.path(), kInputData));
  FileReader reader(input_file.path());

  // Read all the data from the file in one go.
  std::vector<uint8_t> output(kInputData.size());
  EXPECT_TRUE(reader.ReadDataValue(output.size(), "data", output.data()));
  EXPECT_EQ(output.size(), reader.Tell());

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

// Read in all data from the input file in multiple chunks, in order.
TEST(FileReaderTest, ReadMultipleChunks) {
  // This string is 26 characters long.
  const string kInputData = "abcdefghijklmnopqrstuvwxyz";

  ScopedTempFile input_file;
  ASSERT_TRUE(BufferToFile(input_file.path(), kInputData));
  FileReader reader(input_file.path());

  // Read the data in multiple operations. Make sure the cursor is updated.
  std::vector<uint8_t> output(kInputData.size());
  EXPECT_TRUE(reader.ReadData(10, output.data() + reader.Tell()));
  EXPECT_EQ(10, reader.Tell());
  EXPECT_TRUE(reader.ReadData(5, output.data() + reader.Tell()));
  EXPECT_EQ(15, reader.Tell());
  EXPECT_TRUE(reader.ReadData(5, output.data() + reader.Tell()));
  EXPECT_EQ(20, reader.Tell());
  EXPECT_TRUE(reader.ReadData(6, output.data() + reader.Tell()));
  EXPECT_EQ(26, reader.Tell());

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

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

  ScopedTempFile input_file;
  ASSERT_TRUE(BufferToFile(input_file.path(), kInputData));
  FileReader reader(input_file.path());

  // Read the data in multiple operations, but not in order. The destination
  // offset must still match the source offset.
  std::vector<uint8_t> output(10);

  reader.SeekSet(10);
  EXPECT_TRUE(reader.ReadData(10, output.data()));
  EXPECT_EQ(20, reader.Tell());
  EXPECT_EQ("1:hijklmn;", string(output.begin(), output.end()));

  reader.SeekSet(30);
  EXPECT_TRUE(reader.ReadData(10, output.data()));
  EXPECT_EQ(40, reader.Tell());
  EXPECT_EQ("3:vwxyzABC", string(output.begin(), output.end()));

  reader.SeekSet(0);
  EXPECT_TRUE(reader.ReadData(10, output.data()));
  EXPECT_EQ(10, reader.Tell());
  EXPECT_EQ("0:abcdefg;", string(output.begin(), output.end()));
}

// Test reading past the end of the file.
TEST(FileReaderTest, ReadPastEndOfData) {
  // This string is 26 characters long.
  const string kInputData = "abcdefghijklmnopqrstuvwxyz";

  ScopedTempFile input_file;
  ASSERT_TRUE(BufferToFile(input_file.path(), kInputData));
  FileReader reader(input_file.path());

  // Must not be able to read past the end of the file.
  std::vector<uint8_t> output(kInputData.size());
  reader.SeekSet(0);
  EXPECT_FALSE(reader.ReadData(30, output.data()));
  // The read pointer should not have moved.
  EXPECT_EQ(0, reader.Tell());

  // Should still be able to read within the bounds of the file, despite the
  // out-of-bounds read earlier.
  EXPECT_TRUE(reader.ReadData(13, output.data()));
  EXPECT_EQ(13, reader.Tell());

  // Now attempt another read past the end of the file, but starting from the
  // ending position of the previous read operation.
  EXPECT_FALSE(reader.ReadData(20, output.data() + reader.Tell()));
  // The read pointer should be unchanged.
  EXPECT_EQ(13, reader.Tell());

  // Read the rest of the data and make sure it matches the input.
  EXPECT_TRUE(reader.ReadData(13, output.data() + reader.Tell()));
  EXPECT_EQ(26, reader.Tell());

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

// Test string reads.
TEST(FileReaderTest, ReadString) {
  // Construct an input string.
  string input_string("The quick brown fox jumps over the lazy dog.");

  ScopedTempFile input_file;
  ASSERT_TRUE(BufferToFile(input_file.path(), input_string));

  // Read the full string.
  FileReader full_reader(input_file.path());
  string full_reader_output;
  EXPECT_TRUE(full_reader.ReadString(input_string.size(), &full_reader_output));
  EXPECT_EQ(input_string.size(), full_reader.Tell());
  EXPECT_EQ(input_string, full_reader_output);

  // Read the first half of the string.
  FileReader half_reader(input_file.path());
  string half_reader_output;
  EXPECT_TRUE(
      half_reader.ReadString(input_string.size() / 2, &half_reader_output));
  EXPECT_EQ(input_string.size() / 2, half_reader.Tell());
  EXPECT_EQ(input_string.substr(0, input_string.size() / 2),
            half_reader_output);

  // Attempt to read past the end of the string.
  FileReader past_end_reader(input_file.path());
  string past_end_reader_output = "previous string value";
  EXPECT_FALSE(past_end_reader.ReadString(input_string.size() + 1,
                                          &past_end_reader_output));
  EXPECT_EQ("previous string value", past_end_reader_output);

  // Create a string with some extra padding behind it. The padding should be
  // all zeroes. Read from this string, with a size that encompasses the
  // padding.
  string input_string_with_padding(input_string.begin(), input_string.end());
  input_string_with_padding.resize(input_string.size() + 10, '\0');

  ScopedTempFile input_file_padded;
  ASSERT_TRUE(
      BufferToFile(input_file_padded.path(), input_string_with_padding));

  // Read everything including the padding.
  FileReader padding_reader(input_file_padded.path());
  string padding_reader_output;
  EXPECT_TRUE(padding_reader.ReadString(input_string_with_padding.size(),
                                        &padding_reader_output));
  // The reader should have read past the padding too.
  EXPECT_EQ(input_string_with_padding.size(), padding_reader.Tell());
  // However, the output string itself should not have padding.
  EXPECT_EQ(input_string, padding_reader_output);
}

// Reads data to a buffer and verifies that the buffer has not been modified
// beyond the writable boundaries.
TEST(FileReaderTest, NoWritingOutOfBounds) {
  // The input data contains all zeroes.
  std::vector<uint8_t> input_data(800, 0);

  // Write it to file.
  ScopedTempFile input_file;
  ASSERT_TRUE(BufferToFile(input_file.path(), input_data));
  FileReader reader(input_file.path());

  // 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 char kUnwrittenValue = 0xaa;

  // Create a destination buffer filled with the above sentinel value.
  std::vector<uint8_t> buffer(1000, kUnwrittenValue);
  // Only write to the range [100, 900).
  EXPECT_TRUE(reader.ReadData(800, buffer.data() + 100));

  // Check that the data was written to the writable part of the buffer.
  EXPECT_EQ(input_data,
            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));
}

}  // namespace quipper