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