src/cobalt/storage/virtual_file_system_test.cc - cobalt - Git at Google

 // Copyright 2015 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "cobalt/storage/virtual_file.h"
 #include "cobalt/storage/virtual_file_system.h"

 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"

 #include "starboard/client_porting/poem/string_poem.h"

 namespace cobalt {
 namespace storage {

 class VirtualFileSystemTest : public testing::Test {
  protected:
   VirtualFileSystem vfs_;
 };

 TEST_F(VirtualFileSystemTest, WriteAndRead) {
   VirtualFile* file = vfs_.Open("file1.tmp");
   ASSERT_TRUE(file);
   EXPECT_EQ(0, file->Size());

   int expected[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   file->Write(expected, sizeof(expected), 0);

   char out_data[128];
   int bytes = file->Read(out_data, sizeof(out_data), 0);
   EXPECT_EQ(bytes, sizeof(expected));
   EXPECT_EQ(0, memcmp(expected, out_data, sizeof(expected)));
 }

 TEST_F(VirtualFileSystemTest, ReadWriteOffsets) {
   VirtualFile* file = vfs_.Open("file1.tmp");
   ASSERT_TRUE(file);
   EXPECT_EQ(0, file->Size());

   char expected[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   file->Write(expected, sizeof(expected), 0);

   // Seek to position 4 and read bytes.
   char out_data[128];
   int bytes = file->Read(out_data, sizeof(out_data), 4);

   const int kDataSize = 6;
   EXPECT_EQ(kDataSize, bytes);
   EXPECT_EQ(0, memcmp(&expected[4], out_data, kDataSize));

   // Write some bytes into the middle
   file->Write(expected, 3, 3);
   char expected1[] = {0, 1, 2, 0, 1, 2, 6, 7, 8, 9};
   EXPECT_EQ(sizeof(expected1), file->Size());

   bytes = file->Read(out_data, sizeof(out_data), 0);
   EXPECT_EQ(0, memcmp(expected1, out_data, static_cast<size_t>(bytes)));

   // Try to read past the end.
   const int kOffsetPastEnd = 100000;
   bytes = file->Read(out_data, sizeof(out_data), kOffsetPastEnd);
   EXPECT_EQ(0, bytes);

   // Try to write past the end.
   file->Write(expected, sizeof(expected), kOffsetPastEnd);
   EXPECT_EQ(kOffsetPastEnd + sizeof(expected), file->Size());

   // Make sure the write past the end worked.
   bytes = file->Read(out_data, sizeof(out_data), kOffsetPastEnd);
   EXPECT_EQ(0, memcmp(expected, out_data, static_cast<size_t>(bytes)));
 }

 TEST_F(VirtualFileSystemTest, Open) {
   // Create a few files and write some data
   VirtualFile* file = vfs_.Open("file1.tmp");
   ASSERT_TRUE(file);
   EXPECT_EQ(0, file->Size());

   // Write a few bytes of random data.
   file->Write("test", 4, 0);
   EXPECT_EQ(4, file->Size());

   // Open a new file
   file = vfs_.Open("file2.tmp");
   ASSERT_TRUE(file);
   EXPECT_EQ(0, file->Size());

   // Try to reopen the existing file.
   file = vfs_.Open("file1.tmp");
   ASSERT_TRUE(file);
   EXPECT_EQ(4, file->Size());
 }

 TEST_F(VirtualFileSystemTest, Truncate) {
   VirtualFile* file = vfs_.Open("file1.tmp");
   ASSERT_TRUE(file);
   EXPECT_EQ(0, file->Size());

   const char* data = "test";
   char file_contents[4];
   // Write a few bytes of random data.
   file->Write(data, 4, 0);
   EXPECT_EQ(4, file->Size());
   int bytes = file->Read(file_contents, sizeof(file_contents), 0);
   EXPECT_EQ(4, bytes);
   EXPECT_EQ(0, memcmp(file_contents, data, static_cast<size_t>(bytes)));

   file->Truncate(3);
   EXPECT_EQ(3, file->Size());
   bytes = file->Read(file_contents, sizeof(file_contents), 0);
   EXPECT_EQ(3, bytes);
   EXPECT_EQ(0, memcmp(file_contents, data, static_cast<size_t>(bytes)));

   file->Truncate(0);
   EXPECT_EQ(0, file->Size());
   bytes = file->Read(file_contents, sizeof(file_contents), 0);
   EXPECT_EQ(0, bytes);
 }

 TEST_F(VirtualFileSystemTest, SerializeDeserialize) {
   // Create a few files and write some data
   VirtualFile* file = vfs_.Open("file1.tmp");
   EXPECT_TRUE(file != NULL);
   const char data1[] = "abc";
   int data1_size = 3;
   file->Write(data1, data1_size, 0);

   file = vfs_.Open("file2.tmp");
   EXPECT_TRUE(file != NULL);
   const char data2[] = "defg";
   int data2_size = 4;
   file->Write(data2, data2_size, 0);

   file = vfs_.Open("file3.tmp");
   EXPECT_TRUE(file != NULL);
   const char data3[] = "";
   int data3_size = 0;
   file->Write(data3, data3_size, 0);

   // First perform a dry run to figure out how much space we need.
   int bytes = vfs_.Serialize(NULL, true /*dry run*/);
   scoped_array<uint8> buffer(new uint8[static_cast<size_t>(bytes)]);

   // Now serialize and deserialize
   vfs_.Serialize(buffer.get(), false /*dry run*/);

   // Deserialize the data into a new vfs
   VirtualFileSystem new_vfs;
   ASSERT_TRUE(new_vfs.Deserialize(buffer.get(), bytes));

   // Make sure the new vfs contains all the expected data.
   char file_contents[VirtualFile::kMaxVfsPathname];
   file = new_vfs.Open("file1.tmp");
   EXPECT_TRUE(file != NULL);
   bytes = file->Read(file_contents, sizeof(file_contents), 0);
   EXPECT_EQ(data1_size, bytes);
   EXPECT_EQ(0, memcmp(file_contents, data1, static_cast<size_t>(bytes)));

   file = new_vfs.Open("file2.tmp");
   EXPECT_TRUE(file != NULL);
   bytes = file->Read(file_contents, sizeof(file_contents), 0);
   EXPECT_EQ(data2_size, bytes);
   EXPECT_EQ(0, memcmp(file_contents, data2, static_cast<size_t>(bytes)));

   file = new_vfs.Open("file3.tmp");
   EXPECT_TRUE(file != NULL);
   bytes = file->Read(file_contents, sizeof(file_contents), 0);
   EXPECT_EQ(data3_size, bytes);
   EXPECT_EQ(0, memcmp(file_contents, data3, static_cast<size_t>(bytes)));
 }

 TEST_F(VirtualFileSystemTest, DeserializeTruncated) {
   // Create a few files and write some data
   VirtualFile* file = vfs_.Open("file1.tmp");
   EXPECT_TRUE(file != NULL);
   const char data1[] = "abc";
   int data1_size = 3;
   file->Write(data1, data1_size, 0);

   file = vfs_.Open("file2.tmp");
   EXPECT_TRUE(file != NULL);
   const char data2[] = "defg";
   int data2_size = 4;
   file->Write(data2, data2_size, 0);

   // First perform a dry run to figure out how much space we need.
   int bytes = vfs_.Serialize(NULL, true /*dry run*/);
   scoped_array<uint8> buffer(new uint8[static_cast<size_t>(bytes)]);

   // Now serialize and deserialize
   vfs_.Serialize(buffer.get(), false /*dry run*/);

   for (int i = 1; i < bytes; i++) {
     // Corrupt the header
     VirtualFileSystem::SerializedHeader header;
     memcpy(&header, buffer.get(), sizeof(header));
     header.file_size = header.file_size - i;
     memcpy(buffer.get(), &header, sizeof(header));

     // Deserialize the data into a new vfs
     VirtualFileSystem new_vfs;
     EXPECT_FALSE(new_vfs.Deserialize(buffer.get(), bytes - i));
   }
 }

 TEST_F(VirtualFileSystemTest, DeserializeBadData) {
   scoped_array<uint8> buffer(new uint8[0]);
   EXPECT_EQ(false, vfs_.Deserialize(buffer.get(), 0));
   EXPECT_EQ(false, vfs_.Deserialize(buffer.get(), -1));
   buffer.reset(new uint8[1]);
   EXPECT_EQ(false, vfs_.Deserialize(buffer.get(), 1));
   buffer.reset(new uint8[sizeof(VirtualFileSystem::SerializedHeader)]);
   VirtualFileSystem::SerializedHeader header = {};
   header.version = -1;
   memcpy(buffer.get(), &header, sizeof(header));
   EXPECT_EQ(false,
             vfs_.Deserialize(buffer.get(),
                              sizeof(VirtualFileSystem::SerializedHeader)));
   memcpy(&(header.version), "SAV0", sizeof(header.version));
   header.file_size = sizeof(VirtualFileSystem::SerializedHeader);
   memcpy(buffer.get(), &header, sizeof(header));
   EXPECT_EQ(true,
             vfs_.Deserialize(buffer.get(),
                              sizeof(VirtualFileSystem::SerializedHeader)));
   ASSERT_EQ(0, vfs_.ListFiles().size());
 }

 TEST_F(VirtualFileSystemTest, GetHeaderVersion) {
   VirtualFileSystem::SerializedHeader header;
   memset(&header, 0, sizeof(header));
   header.file_size = sizeof(header);

   COMPILE_ASSERT(sizeof(header.version) == sizeof("SAV0") - 1,
                  Invalid_header_version_size);
   memcpy(&header.version, "XYZW", sizeof(header.version));
   EXPECT_EQ(-1, VirtualFileSystem::GetHeaderVersion(header));
   memcpy(&header.version, "SAV0", sizeof(header.version));
   EXPECT_EQ(0, VirtualFileSystem::GetHeaderVersion(header));
   memcpy(&header.version, "SAV1", sizeof(header.version));
   EXPECT_EQ(1, VirtualFileSystem::GetHeaderVersion(header));
 }

 }  // namespace storage
 }  // namespace cobalt
	// Copyright 2015 Google Inc. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "cobalt/storage/virtual_file.h"
	#include "cobalt/storage/virtual_file_system.h"

	#include "base/compiler_specific.h"
	#include "base/memory/scoped_ptr.h"
	#include "testing/gtest/include/gtest/gtest.h"

	#include "starboard/client_porting/poem/string_poem.h"

	namespace cobalt {
	namespace storage {

	class VirtualFileSystemTest : public testing::Test {
	protected:
	VirtualFileSystem vfs_;
	};

	TEST_F(VirtualFileSystemTest, WriteAndRead) {
	VirtualFile* file = vfs_.Open("file1.tmp");
	ASSERT_TRUE(file);
	EXPECT_EQ(0, file->Size());

	int expected[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
	file->Write(expected, sizeof(expected), 0);

	char out_data[128];
	int bytes = file->Read(out_data, sizeof(out_data), 0);
	EXPECT_EQ(bytes, sizeof(expected));
	EXPECT_EQ(0, memcmp(expected, out_data, sizeof(expected)));
	}

	TEST_F(VirtualFileSystemTest, ReadWriteOffsets) {
	VirtualFile* file = vfs_.Open("file1.tmp");
	ASSERT_TRUE(file);
	EXPECT_EQ(0, file->Size());

	char expected[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
	file->Write(expected, sizeof(expected), 0);

	// Seek to position 4 and read bytes.
	char out_data[128];
	int bytes = file->Read(out_data, sizeof(out_data), 4);

	const int kDataSize = 6;
	EXPECT_EQ(kDataSize, bytes);
	EXPECT_EQ(0, memcmp(&expected[4], out_data, kDataSize));

	// Write some bytes into the middle
	file->Write(expected, 3, 3);
	char expected1[] = {0, 1, 2, 0, 1, 2, 6, 7, 8, 9};
	EXPECT_EQ(sizeof(expected1), file->Size());

	bytes = file->Read(out_data, sizeof(out_data), 0);
	EXPECT_EQ(0, memcmp(expected1, out_data, static_cast<size_t>(bytes)));

	// Try to read past the end.
	const int kOffsetPastEnd = 100000;
	bytes = file->Read(out_data, sizeof(out_data), kOffsetPastEnd);
	EXPECT_EQ(0, bytes);

	// Try to write past the end.
	file->Write(expected, sizeof(expected), kOffsetPastEnd);
	EXPECT_EQ(kOffsetPastEnd + sizeof(expected), file->Size());

	// Make sure the write past the end worked.
	bytes = file->Read(out_data, sizeof(out_data), kOffsetPastEnd);
	EXPECT_EQ(0, memcmp(expected, out_data, static_cast<size_t>(bytes)));
	}

	TEST_F(VirtualFileSystemTest, Open) {
	// Create a few files and write some data
	VirtualFile* file = vfs_.Open("file1.tmp");
	ASSERT_TRUE(file);
	EXPECT_EQ(0, file->Size());

	// Write a few bytes of random data.
	file->Write("test", 4, 0);
	EXPECT_EQ(4, file->Size());

	// Open a new file
	file = vfs_.Open("file2.tmp");
	ASSERT_TRUE(file);
	EXPECT_EQ(0, file->Size());

	// Try to reopen the existing file.
	file = vfs_.Open("file1.tmp");
	ASSERT_TRUE(file);
	EXPECT_EQ(4, file->Size());
	}

	TEST_F(VirtualFileSystemTest, Truncate) {
	VirtualFile* file = vfs_.Open("file1.tmp");
	ASSERT_TRUE(file);
	EXPECT_EQ(0, file->Size());

	const char* data = "test";
	char file_contents[4];
	// Write a few bytes of random data.
	file->Write(data, 4, 0);
	EXPECT_EQ(4, file->Size());
	int bytes = file->Read(file_contents, sizeof(file_contents), 0);
	EXPECT_EQ(4, bytes);
	EXPECT_EQ(0, memcmp(file_contents, data, static_cast<size_t>(bytes)));

	file->Truncate(3);
	EXPECT_EQ(3, file->Size());
	bytes = file->Read(file_contents, sizeof(file_contents), 0);
	EXPECT_EQ(3, bytes);
	EXPECT_EQ(0, memcmp(file_contents, data, static_cast<size_t>(bytes)));

	file->Truncate(0);
	EXPECT_EQ(0, file->Size());
	bytes = file->Read(file_contents, sizeof(file_contents), 0);
	EXPECT_EQ(0, bytes);
	}

	TEST_F(VirtualFileSystemTest, SerializeDeserialize) {
	// Create a few files and write some data
	VirtualFile* file = vfs_.Open("file1.tmp");
	EXPECT_TRUE(file != NULL);
	const char data1[] = "abc";
	int data1_size = 3;
	file->Write(data1, data1_size, 0);

	file = vfs_.Open("file2.tmp");
	EXPECT_TRUE(file != NULL);
	const char data2[] = "defg";
	int data2_size = 4;
	file->Write(data2, data2_size, 0);

	file = vfs_.Open("file3.tmp");
	EXPECT_TRUE(file != NULL);
	const char data3[] = "";
	int data3_size = 0;
	file->Write(data3, data3_size, 0);

	// First perform a dry run to figure out how much space we need.
	int bytes = vfs_.Serialize(NULL, true /dry run/);
	scoped_array<uint8> buffer(new uint8[static_cast<size_t>(bytes)]);

	// Now serialize and deserialize
	vfs_.Serialize(buffer.get(), false /dry run/);

	// Deserialize the data into a new vfs
	VirtualFileSystem new_vfs;
	ASSERT_TRUE(new_vfs.Deserialize(buffer.get(), bytes));

	// Make sure the new vfs contains all the expected data.
	char file_contents[VirtualFile::kMaxVfsPathname];
	file = new_vfs.Open("file1.tmp");
	EXPECT_TRUE(file != NULL);
	bytes = file->Read(file_contents, sizeof(file_contents), 0);
	EXPECT_EQ(data1_size, bytes);
	EXPECT_EQ(0, memcmp(file_contents, data1, static_cast<size_t>(bytes)));

	file = new_vfs.Open("file2.tmp");
	EXPECT_TRUE(file != NULL);
	bytes = file->Read(file_contents, sizeof(file_contents), 0);
	EXPECT_EQ(data2_size, bytes);
	EXPECT_EQ(0, memcmp(file_contents, data2, static_cast<size_t>(bytes)));

	file = new_vfs.Open("file3.tmp");
	EXPECT_TRUE(file != NULL);
	bytes = file->Read(file_contents, sizeof(file_contents), 0);
	EXPECT_EQ(data3_size, bytes);
	EXPECT_EQ(0, memcmp(file_contents, data3, static_cast<size_t>(bytes)));
	}

	TEST_F(VirtualFileSystemTest, DeserializeTruncated) {
	// Create a few files and write some data
	VirtualFile* file = vfs_.Open("file1.tmp");
	EXPECT_TRUE(file != NULL);
	const char data1[] = "abc";
	int data1_size = 3;
	file->Write(data1, data1_size, 0);

	file = vfs_.Open("file2.tmp");
	EXPECT_TRUE(file != NULL);
	const char data2[] = "defg";
	int data2_size = 4;
	file->Write(data2, data2_size, 0);

	// First perform a dry run to figure out how much space we need.
	int bytes = vfs_.Serialize(NULL, true /dry run/);
	scoped_array<uint8> buffer(new uint8[static_cast<size_t>(bytes)]);

	// Now serialize and deserialize
	vfs_.Serialize(buffer.get(), false /dry run/);

	for (int i = 1; i < bytes; i++) {
	// Corrupt the header
	VirtualFileSystem::SerializedHeader header;
	memcpy(&header, buffer.get(), sizeof(header));
	header.file_size = header.file_size - i;
	memcpy(buffer.get(), &header, sizeof(header));

	// Deserialize the data into a new vfs
	VirtualFileSystem new_vfs;
	EXPECT_FALSE(new_vfs.Deserialize(buffer.get(), bytes - i));
	}
	}

	TEST_F(VirtualFileSystemTest, DeserializeBadData) {
	scoped_array<uint8> buffer(new uint8[0]);
	EXPECT_EQ(false, vfs_.Deserialize(buffer.get(), 0));
	EXPECT_EQ(false, vfs_.Deserialize(buffer.get(), -1));
	buffer.reset(new uint8[1]);
	EXPECT_EQ(false, vfs_.Deserialize(buffer.get(), 1));
	buffer.reset(new uint8[sizeof(VirtualFileSystem::SerializedHeader)]);
	VirtualFileSystem::SerializedHeader header = {};
	header.version = -1;
	memcpy(buffer.get(), &header, sizeof(header));
	EXPECT_EQ(false,
	vfs_.Deserialize(buffer.get(),
	sizeof(VirtualFileSystem::SerializedHeader)));
	memcpy(&(header.version), "SAV0", sizeof(header.version));
	header.file_size = sizeof(VirtualFileSystem::SerializedHeader);
	memcpy(buffer.get(), &header, sizeof(header));
	EXPECT_EQ(true,
	vfs_.Deserialize(buffer.get(),
	sizeof(VirtualFileSystem::SerializedHeader)));
	ASSERT_EQ(0, vfs_.ListFiles().size());
	}

	TEST_F(VirtualFileSystemTest, GetHeaderVersion) {
	VirtualFileSystem::SerializedHeader header;
	memset(&header, 0, sizeof(header));
	header.file_size = sizeof(header);

	COMPILE_ASSERT(sizeof(header.version) == sizeof("SAV0") - 1,
	Invalid_header_version_size);
	memcpy(&header.version, "XYZW", sizeof(header.version));
	EXPECT_EQ(-1, VirtualFileSystem::GetHeaderVersion(header));
	memcpy(&header.version, "SAV0", sizeof(header.version));
	EXPECT_EQ(0, VirtualFileSystem::GetHeaderVersion(header));
	memcpy(&header.version, "SAV1", sizeof(header.version));
	EXPECT_EQ(1, VirtualFileSystem::GetHeaderVersion(header));
	}

	} // namespace storage
	} // namespace cobalt