| /* |
| * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include "webrtc/base/fileutils.h" |
| #include "webrtc/base/gunit.h" |
| #include "webrtc/base/pathutils.h" |
| #include "webrtc/base/stream.h" |
| #include "webrtc/test/testsupport/gtest_disable.h" |
| |
| namespace rtc { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // TestStream |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| class TestStream : public StreamInterface { |
| public: |
| TestStream() : pos_(0) { } |
| |
| virtual StreamState GetState() const { return SS_OPEN; } |
| virtual StreamResult Read(void* buffer, size_t buffer_len, |
| size_t* read, int* error) { |
| unsigned char* uc_buffer = static_cast<unsigned char*>(buffer); |
| for (size_t i = 0; i < buffer_len; ++i) { |
| uc_buffer[i] = static_cast<unsigned char>(pos_++); |
| } |
| if (read) |
| *read = buffer_len; |
| return SR_SUCCESS; |
| } |
| virtual StreamResult Write(const void* data, size_t data_len, |
| size_t* written, int* error) { |
| if (error) |
| *error = -1; |
| return SR_ERROR; |
| } |
| virtual void Close() { } |
| virtual bool SetPosition(size_t position) { |
| pos_ = position; |
| return true; |
| } |
| virtual bool GetPosition(size_t* position) const { |
| if (position) *position = pos_; |
| return true; |
| } |
| virtual bool GetSize(size_t* size) const { |
| return false; |
| } |
| virtual bool GetAvailable(size_t* size) const { |
| return false; |
| } |
| |
| private: |
| size_t pos_; |
| }; |
| |
| bool VerifyTestBuffer(unsigned char* buffer, size_t len, |
| unsigned char value) { |
| bool passed = true; |
| for (size_t i = 0; i < len; ++i) { |
| if (buffer[i] != value++) { |
| passed = false; |
| break; |
| } |
| } |
| // Ensure that we don't pass again without re-writing |
| memset(buffer, 0, len); |
| return passed; |
| } |
| |
| void SeekTest(StreamInterface* stream, const unsigned char value) { |
| size_t bytes; |
| unsigned char buffer[13] = { 0 }; |
| const size_t kBufSize = sizeof(buffer); |
| |
| EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS); |
| EXPECT_EQ(bytes, kBufSize); |
| EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value)); |
| EXPECT_TRUE(stream->GetPosition(&bytes)); |
| EXPECT_EQ(13U, bytes); |
| |
| EXPECT_TRUE(stream->SetPosition(7)); |
| |
| EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS); |
| EXPECT_EQ(bytes, kBufSize); |
| EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value + 7)); |
| EXPECT_TRUE(stream->GetPosition(&bytes)); |
| EXPECT_EQ(20U, bytes); |
| } |
| |
| TEST(FifoBufferTest, TestAll) { |
| const size_t kSize = 16; |
| const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV"; |
| char out[kSize * 2]; |
| void* p; |
| const void* q; |
| size_t bytes; |
| FifoBuffer buf(kSize); |
| StreamInterface* stream = &buf; |
| |
| // Test assumptions about base state |
| EXPECT_EQ(SS_OPEN, stream->GetState()); |
| EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL)); |
| EXPECT_TRUE(NULL != stream->GetReadData(&bytes)); |
| EXPECT_EQ((size_t)0, bytes); |
| stream->ConsumeReadData(0); |
| EXPECT_TRUE(NULL != stream->GetWriteBuffer(&bytes)); |
| EXPECT_EQ(kSize, bytes); |
| stream->ConsumeWriteBuffer(0); |
| |
| // Try a full write |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL)); |
| EXPECT_EQ(kSize, bytes); |
| |
| // Try a write that should block |
| EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL)); |
| |
| // Try a full read |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL)); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize)); |
| |
| // Try a read that should block |
| EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL)); |
| |
| // Try a too-big write |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 2, &bytes, NULL)); |
| EXPECT_EQ(bytes, kSize); |
| |
| // Try a too-big read |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL)); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize)); |
| |
| // Try some small writes and reads |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize / 2)); |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize / 2)); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize / 2)); |
| |
| // Try wraparound reads and writes in the following pattern |
| // WWWWWWWWWWWW.... 0123456789AB.... |
| // RRRRRRRRXXXX.... ........89AB.... |
| // WWWW....XXXXWWWW 4567....89AB0123 |
| // XXXX....RRRRXXXX 4567........0123 |
| // XXXXWWWWWWWWXXXX 4567012345670123 |
| // RRRRXXXXXXXXRRRR ....01234567.... |
| // ....RRRRRRRR.... ................ |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL)); |
| EXPECT_EQ(kSize * 3 / 4, bytes); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize / 2)); |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 4, &bytes, NULL)); |
| EXPECT_EQ(kSize / 4 , bytes); |
| EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4)); |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2 , bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize / 2)); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(kSize / 2 , bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize / 2)); |
| |
| // Use GetWriteBuffer to reset the read_position for the next tests |
| stream->GetWriteBuffer(&bytes); |
| stream->ConsumeWriteBuffer(0); |
| |
| // Try using GetReadData to do a full read |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL)); |
| q = stream->GetReadData(&bytes); |
| EXPECT_TRUE(NULL != q); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_EQ(0, memcmp(q, in, kSize)); |
| stream->ConsumeReadData(kSize); |
| EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL)); |
| |
| // Try using GetReadData to do some small reads |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL)); |
| q = stream->GetReadData(&bytes); |
| EXPECT_TRUE(NULL != q); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_EQ(0, memcmp(q, in, kSize / 2)); |
| stream->ConsumeReadData(kSize / 2); |
| q = stream->GetReadData(&bytes); |
| EXPECT_TRUE(NULL != q); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(0, memcmp(q, in + kSize / 2, kSize / 2)); |
| stream->ConsumeReadData(kSize / 2); |
| EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL)); |
| |
| // Try using GetReadData in a wraparound case |
| // WWWWWWWWWWWWWWWW 0123456789ABCDEF |
| // RRRRRRRRRRRRXXXX ............CDEF |
| // WWWWWWWW....XXXX 01234567....CDEF |
| // ............RRRR 01234567........ |
| // RRRRRRRR........ ................ |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL)); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL)); |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL)); |
| q = stream->GetReadData(&bytes); |
| EXPECT_TRUE(NULL != q); |
| EXPECT_EQ(kSize / 4, bytes); |
| EXPECT_EQ(0, memcmp(q, in + kSize * 3 / 4, kSize / 4)); |
| stream->ConsumeReadData(kSize / 4); |
| q = stream->GetReadData(&bytes); |
| EXPECT_TRUE(NULL != q); |
| EXPECT_EQ(kSize / 2, bytes); |
| EXPECT_EQ(0, memcmp(q, in, kSize / 2)); |
| stream->ConsumeReadData(kSize / 2); |
| |
| // Use GetWriteBuffer to reset the read_position for the next tests |
| stream->GetWriteBuffer(&bytes); |
| stream->ConsumeWriteBuffer(0); |
| |
| // Try using GetWriteBuffer to do a full write |
| p = stream->GetWriteBuffer(&bytes); |
| EXPECT_TRUE(NULL != p); |
| EXPECT_EQ(kSize, bytes); |
| memcpy(p, in, kSize); |
| stream->ConsumeWriteBuffer(kSize); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL)); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize)); |
| |
| // Try using GetWriteBuffer to do some small writes |
| p = stream->GetWriteBuffer(&bytes); |
| EXPECT_TRUE(NULL != p); |
| EXPECT_EQ(kSize, bytes); |
| memcpy(p, in, kSize / 2); |
| stream->ConsumeWriteBuffer(kSize / 2); |
| p = stream->GetWriteBuffer(&bytes); |
| EXPECT_TRUE(NULL != p); |
| EXPECT_EQ(kSize / 2, bytes); |
| memcpy(p, in + kSize / 2, kSize / 2); |
| stream->ConsumeWriteBuffer(kSize / 2); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL)); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize)); |
| |
| // Try using GetWriteBuffer in a wraparound case |
| // WWWWWWWWWWWW.... 0123456789AB.... |
| // RRRRRRRRXXXX.... ........89AB.... |
| // ........XXXXWWWW ........89AB0123 |
| // WWWW....XXXXXXXX 4567....89AB0123 |
| // RRRR....RRRRRRRR ................ |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL)); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL)); |
| p = stream->GetWriteBuffer(&bytes); |
| EXPECT_TRUE(NULL != p); |
| EXPECT_EQ(kSize / 4, bytes); |
| memcpy(p, in, kSize / 4); |
| stream->ConsumeWriteBuffer(kSize / 4); |
| p = stream->GetWriteBuffer(&bytes); |
| EXPECT_TRUE(NULL != p); |
| EXPECT_EQ(kSize / 2, bytes); |
| memcpy(p, in + kSize / 4, kSize / 4); |
| stream->ConsumeWriteBuffer(kSize / 4); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL)); |
| EXPECT_EQ(kSize * 3 / 4, bytes); |
| EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4)); |
| EXPECT_EQ(0, memcmp(in, out + kSize / 4, kSize / 4)); |
| |
| // Check that the stream is now empty |
| EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL)); |
| |
| // Try growing the buffer |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL)); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_TRUE(buf.SetCapacity(kSize * 2)); |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in + kSize, kSize, &bytes, NULL)); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL)); |
| EXPECT_EQ(kSize * 2, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize * 2)); |
| |
| // Try shrinking the buffer |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL)); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_TRUE(buf.SetCapacity(kSize)); |
| EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL)); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL)); |
| EXPECT_EQ(kSize, bytes); |
| EXPECT_EQ(0, memcmp(in, out, kSize)); |
| |
| // Write to the stream, close it, read the remaining bytes |
| EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL)); |
| stream->Close(); |
| EXPECT_EQ(SS_CLOSED, stream->GetState()); |
| EXPECT_EQ(SR_EOS, stream->Write(in, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL)); |
| EXPECT_EQ(0, memcmp(in, out, kSize / 2)); |
| EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, NULL)); |
| } |
| |
| TEST(FifoBufferTest, FullBufferCheck) { |
| FifoBuffer buff(10); |
| buff.ConsumeWriteBuffer(10); |
| |
| size_t free; |
| EXPECT_TRUE(buff.GetWriteBuffer(&free) != NULL); |
| EXPECT_EQ(0U, free); |
| } |
| |
| TEST(FifoBufferTest, WriteOffsetAndReadOffset) { |
| const size_t kSize = 16; |
| const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV"; |
| char out[kSize * 2]; |
| FifoBuffer buf(kSize); |
| |
| // Write 14 bytes. |
| EXPECT_EQ(SR_SUCCESS, buf.Write(in, 14, NULL, NULL)); |
| |
| // Make sure data is in |buf|. |
| size_t buffered; |
| EXPECT_TRUE(buf.GetBuffered(&buffered)); |
| EXPECT_EQ(14u, buffered); |
| |
| // Read 10 bytes. |
| buf.ConsumeReadData(10); |
| |
| // There should be now 12 bytes of available space. |
| size_t remaining; |
| EXPECT_TRUE(buf.GetWriteRemaining(&remaining)); |
| EXPECT_EQ(12u, remaining); |
| |
| // Write at offset 12, this should fail. |
| EXPECT_EQ(SR_BLOCK, buf.WriteOffset(in, 10, 12, NULL)); |
| |
| // Write 8 bytes at offset 4, this wraps around the buffer. |
| EXPECT_EQ(SR_SUCCESS, buf.WriteOffset(in, 8, 4, NULL)); |
| |
| // Number of available space remains the same until we call |
| // ConsumeWriteBuffer(). |
| EXPECT_TRUE(buf.GetWriteRemaining(&remaining)); |
| EXPECT_EQ(12u, remaining); |
| buf.ConsumeWriteBuffer(12); |
| |
| // There's 4 bytes bypassed and 4 bytes no read so skip them and verify the |
| // 8 bytes written. |
| size_t read; |
| EXPECT_EQ(SR_SUCCESS, buf.ReadOffset(out, 8, 8, &read)); |
| EXPECT_EQ(8u, read); |
| EXPECT_EQ(0, memcmp(out, in, 8)); |
| |
| // There should still be 16 bytes available for reading. |
| EXPECT_TRUE(buf.GetBuffered(&buffered)); |
| EXPECT_EQ(16u, buffered); |
| |
| // Read at offset 16, this should fail since we don't have that much data. |
| EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, NULL)); |
| } |
| |
| class CircularFileStreamTest : public ::testing::Test { |
| protected: |
| static size_t const kMaxSize = 12; |
| |
| CircularFileStreamTest() : is_open_(false), stream_(kMaxSize) { |
| Pathname temp_dir; |
| if (Filesystem::GetAppTempFolder(&temp_dir)) { |
| logfile_name_ = |
| Filesystem::TempFilename(temp_dir, "CircularFileStreamTest"); |
| } |
| } |
| |
| virtual void SetUp() { |
| int error = -1; |
| is_open_ = stream_.Open(logfile_name_, "wb", &error); |
| } |
| |
| virtual void TearDown() { |
| if (!Filesystem::IsAbsent(logfile_name_)) { |
| Filesystem::DeleteFile(logfile_name_); |
| } |
| } |
| |
| bool is_open_; |
| CircularFileStream stream_; |
| std::string logfile_name_; |
| }; |
| |
| TEST_F(CircularFileStreamTest, ReadWriteWithinCapacity) { |
| EXPECT_TRUE(is_open_); |
| // Write contents. |
| const uint8_t bytes[] = {1, 2, 3, 4, 5, 6}; |
| size_t written = 0; |
| int error = 0; |
| EXPECT_EQ(SR_SUCCESS, stream_.Write(bytes, sizeof(bytes), &written, &error)); |
| EXPECT_EQ(0, error); |
| EXPECT_EQ(written, sizeof(bytes)); |
| stream_.Close(); |
| |
| // Check file contents. |
| uint8_t content_bytes[sizeof(bytes)] = {}; |
| scoped_ptr<FileStream> content_stream( |
| Filesystem::OpenFile(logfile_name_, "r")); |
| size_t num_content_bytes_read = 0; |
| EXPECT_TRUE(content_stream); |
| error = 0; |
| EXPECT_EQ(SR_SUCCESS, |
| content_stream->Read(content_bytes, sizeof(content_bytes), |
| &num_content_bytes_read, &error)); |
| EXPECT_EQ(sizeof(content_bytes), num_content_bytes_read); |
| ASSERT_EQ(sizeof(content_bytes), sizeof(bytes)); |
| EXPECT_EQ(0, memcmp(content_bytes, bytes, sizeof(content_bytes))); |
| |
| // Check read result. |
| error = 0; |
| size_t file_size = 0; |
| EXPECT_TRUE(stream_.Open(logfile_name_, "r", &error)); |
| EXPECT_TRUE(stream_.GetSize(&file_size)); |
| EXPECT_EQ(0, error); |
| EXPECT_EQ(sizeof(bytes), file_size); |
| scoped_ptr<uint8_t[]> read_bytes(new uint8_t[file_size]); |
| size_t num_read_bytes = 0; |
| error = 0; |
| EXPECT_EQ(SR_SUCCESS, stream_.ReadAll(read_bytes.get(), file_size, |
| &num_read_bytes, &error)); |
| EXPECT_EQ(sizeof(bytes), num_read_bytes); |
| EXPECT_EQ(0, memcmp(bytes, read_bytes.get(), file_size)); |
| } |
| |
| TEST_F(CircularFileStreamTest, ReadWriteAtCapacity) { |
| EXPECT_TRUE(is_open_); |
| // Write contents. |
| const uint8_t bytes[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; |
| size_t written = 0; |
| int error = 0; |
| EXPECT_EQ(SR_SUCCESS, stream_.Write(bytes, sizeof(bytes), &written, &error)); |
| EXPECT_EQ(0, error); |
| EXPECT_EQ(written, sizeof(bytes)); |
| stream_.Close(); |
| |
| // Check file contents. |
| uint8_t content_bytes[sizeof(bytes)] = {}; |
| scoped_ptr<FileStream> content_stream( |
| Filesystem::OpenFile(logfile_name_, "r")); |
| size_t num_content_bytes_read = 0; |
| EXPECT_TRUE(content_stream); |
| error = 0; |
| EXPECT_EQ(SR_SUCCESS, |
| content_stream->Read(content_bytes, sizeof(content_bytes), |
| &num_content_bytes_read, &error)); |
| EXPECT_EQ(sizeof(content_bytes), num_content_bytes_read); |
| ASSERT_EQ(sizeof(content_bytes), sizeof(bytes)); |
| EXPECT_EQ(0, memcmp(content_bytes, bytes, sizeof(content_bytes))); |
| |
| // Check read result. |
| error = 0; |
| size_t file_size = 0; |
| EXPECT_TRUE(stream_.Open(logfile_name_, "r", &error)); |
| EXPECT_TRUE(stream_.GetSize(&file_size)); |
| EXPECT_EQ(0, error); |
| EXPECT_EQ(sizeof(bytes), file_size); |
| scoped_ptr<uint8_t[]> read_bytes(new uint8_t[file_size]); |
| size_t num_read_bytes = 0; |
| error = 0; |
| EXPECT_EQ(SR_SUCCESS, stream_.ReadAll(read_bytes.get(), file_size, |
| &num_read_bytes, &error)); |
| EXPECT_EQ(sizeof(bytes), num_read_bytes); |
| EXPECT_EQ(0, memcmp(bytes, read_bytes.get(), file_size)); |
| } |
| |
| TEST_F(CircularFileStreamTest, ReadWriteOverCapacity) { |
| EXPECT_TRUE(is_open_); |
| // Write contents. |
| const uint8_t bytes[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; |
| size_t written = 0; |
| int error = 0; |
| EXPECT_EQ(SR_SUCCESS, |
| stream_.WriteAll(bytes, sizeof(bytes), &written, &error)); |
| EXPECT_EQ(0, error); |
| EXPECT_EQ(written, sizeof(bytes)); |
| stream_.Close(); |
| |
| // Check file contents. |
| uint8_t content_bytes[kMaxSize] = {}; |
| scoped_ptr<FileStream> content_stream( |
| Filesystem::OpenFile(logfile_name_, "r")); |
| size_t num_content_bytes_read = 0; |
| EXPECT_TRUE(content_stream); |
| error = 0; |
| EXPECT_EQ(SR_SUCCESS, |
| content_stream->Read(content_bytes, sizeof(content_bytes), |
| &num_content_bytes_read, &error)); |
| EXPECT_EQ(sizeof(content_bytes), num_content_bytes_read); |
| const uint8_t expected_content_bytes[] = { |
| 1, 2, 3, 4, 5, 6, 13, 14, 15, 10, 11, 12}; |
| ASSERT_EQ(sizeof(content_bytes), sizeof(expected_content_bytes)); |
| EXPECT_EQ( |
| 0, memcmp(expected_content_bytes, content_bytes, sizeof(content_bytes))); |
| |
| // Check read result. |
| error = 0; |
| size_t file_size = 0; |
| EXPECT_TRUE(stream_.Open(logfile_name_, "r", &error)); |
| EXPECT_TRUE(stream_.GetSize(&file_size)); |
| EXPECT_EQ(0, error); |
| EXPECT_EQ(sizeof(content_bytes), file_size); |
| scoped_ptr<uint8_t[]> read_bytes(new uint8_t[file_size]); |
| size_t num_read_bytes = 0; |
| error = 0; |
| EXPECT_EQ(SR_SUCCESS, stream_.ReadAll(read_bytes.get(), file_size, |
| &num_read_bytes, &error)); |
| |
| const uint8_t expected_read_bytes[] = { |
| 1, 2, 3, 4, 5, 6, 10, 11, 12, 13, 14, 15}; |
| EXPECT_EQ(sizeof(expected_read_bytes), num_read_bytes); |
| EXPECT_EQ(0, memcmp(expected_read_bytes, read_bytes.get(), file_size)); |
| } |
| |
| } // namespace rtc |