rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/external/icing/icing/file/file-backed-vector_test.cc

705 lines
25 KiB
C++
Raw Blame History

// Copyright (C) 2019 Google LLC
//
// 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 "icing/file/file-backed-vector.h"
#include <unistd.h>
#include <algorithm>
#include <cerrno>
#include <cstdint>
#include <memory>
#include <string_view>
#include <vector>
#include "knowledge/cerebra/sense/text_classifier/lib3/utils/base/status.h"
#include "testing/base/public/gmock.h"
#include "testing/base/public/gunit.h"
#include "third_party/icing/file/filesystem.h"
#include "third_party/icing/file/memory-mapped-file.h"
#include "third_party/icing/file/mock-filesystem.h"
#include "third_party/icing/testing/common-matchers.h"
#include "third_party/icing/testing/tmp-directory.h"
#include "third_party/icing/util/crc32.h"
#include "third_party/icing/util/logging.h"
using ::testing::Eq;
using ::testing::IsTrue;
using ::testing::Pointee;
using ::testing::Return;
namespace icing {
namespace lib {
namespace {
class FileBackedVectorTest : public testing::Test {
protected:
void SetUp() override {
file_path_ = GetTestTempDir() + "/test.array";
fd_ = filesystem_.OpenForWrite(file_path_.c_str());
ASSERT_NE(-1, fd_);
ASSERT_TRUE(filesystem_.Truncate(fd_, 0));
}
void TearDown() override {
close(fd_);
filesystem_.DeleteFile(file_path_.c_str());
}
// Helper method to loop over some data and insert into the vector at some idx
template <typename T>
void Insert(FileBackedVector<T>* vector, int32_t idx, std::string data) {
for (int i = 0; i < data.length(); ++i) {
ICING_ASSERT_OK(vector->Set(idx + i, data.at(i)));
}
}
// Helper method to retrieve data from the beginning of the vector
template <typename T>
std::string_view Get(FileBackedVector<T>* vector, int32_t expected_len) {
return Get(vector, 0, expected_len);
}
template <typename T>
std::string_view Get(FileBackedVector<T>* vector, int32_t idx,
int32_t expected_len) {
return std::string_view(vector->array() + idx, expected_len);
}
const Filesystem& filesystem() const { return filesystem_; }
Filesystem filesystem_;
std::string file_path_;
int fd_;
};
TEST_F(FileBackedVectorTest, Create) {
{
// Create a vector for a new file
ICING_ASSERT_OK_AND_ASSIGN(
auto vector, FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
}
{
// We can create it again based on the same file.
ICING_ASSERT_OK_AND_ASSIGN(
auto vector, FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
}
}
TEST_F(FileBackedVectorTest, SimpleShared) {
// Create a vector and add some data.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(0)));
std::string expected = "abcde";
Insert(vector.get(), 0, expected);
EXPECT_EQ(expected.length(), vector->num_elements());
EXPECT_EQ(expected, Get(vector.get(), expected.length()));
uint32_t good_crc_value = 1134899064U;
const Crc32 good_crc(good_crc_value);
// Explicit call to update the crc does update the value
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(good_crc));
// PersistToDisk does nothing bad.
ICING_EXPECT_OK(vector->PersistToDisk());
// Close out the old vector to ensure everything persists properly before we
// reassign it
vector.reset();
// Write a bad crc, this would be a mismatch compared to the computed crc of
// the contents on reinitialization.
uint32_t bad_crc_value = 123;
filesystem_.PWrite(file_path_.data(),
offsetof(FileBackedVector<char>::Header, vector_checksum),
&bad_crc_value, sizeof(bad_crc_value));
ASSERT_THAT(FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC),
StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION));
// Get it back into an ok state
filesystem_.PWrite(file_path_.data(),
offsetof(FileBackedVector<char>::Header, vector_checksum),
&good_crc_value, sizeof(good_crc_value));
ICING_ASSERT_OK_AND_ASSIGN(
vector, FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
EXPECT_EQ(expected, Get(vector.get(), expected.length()));
// Close out the old vector to ensure everything persists properly before we
// reassign it
vector.reset();
// Can reinitialize it safely
ICING_ASSERT_OK_AND_ASSIGN(
vector, FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
// Truncate the content
ICING_EXPECT_OK(vector->TruncateTo(0));
// Crc is cleared after truncation and reset to 0.
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(0)));
EXPECT_EQ(0u, vector->num_elements());
}
TEST_F(FileBackedVectorTest, Get) {
// Create a vector and add some data.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(0)));
std::string expected = "abc";
Insert(vector.get(), 0, expected);
EXPECT_EQ(expected.length(), vector->num_elements());
EXPECT_THAT(vector->Get(0), IsOkAndHolds(Pointee(Eq('a'))));
EXPECT_THAT(vector->Get(1), IsOkAndHolds(Pointee(Eq('b'))));
EXPECT_THAT(vector->Get(2), IsOkAndHolds(Pointee(Eq('c'))));
// Out of bounds error
EXPECT_THAT(vector->Get(3),
StatusIs(libtextclassifier3::StatusCode::OUT_OF_RANGE));
EXPECT_THAT(vector->Get(-1),
StatusIs(libtextclassifier3::StatusCode::OUT_OF_RANGE));
}
TEST_F(FileBackedVectorTest, IncrementalCrc_NonOverlappingChanges) {
int num_elements = 1000;
int incremental_size = 3;
// Create an array with some data.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
Insert(vector.get(), 0, std::string(num_elements, 'a'));
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(2620640643U)));
// Non-overlapping changes to the array, with increasing intervals
// between updating the checksum. Validate by mapping another array on top.
uint32_t next_update = 2;
for (uint32_t i = 0; i < num_elements; i += incremental_size) {
Insert(vector.get(), i, std::string(incremental_size, 'b'));
if (i >= next_update) {
ICING_ASSERT_OK_AND_ASSIGN(Crc32 incremental_crc,
vector->ComputeChecksum());
ICING_LOG(INFO) << "Now crc @" << incremental_crc.Get();
Crc32 full_crc;
std::string_view reconstructed_view =
std::string_view(vector->array(), vector->num_elements());
full_crc.Append(reconstructed_view);
ASSERT_EQ(incremental_crc, full_crc);
next_update *= 2;
}
}
for (uint32_t i = 0; i < num_elements; ++i) {
EXPECT_THAT(vector->Get(i), IsOkAndHolds(Pointee(Eq('b'))));
}
}
TEST_F(FileBackedVectorTest, IncrementalCrc_OverlappingChanges) {
int num_elements = 1000;
int incremental_size = 3;
// Create an array with some data.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
Insert(vector.get(), 0, std::string(num_elements, 'a'));
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(2620640643U)));
// Overlapping changes to the array, with increasing intervals
// between updating the checksum. Validate by mapping another array on top.
uint32_t next_update = 2;
for (uint32_t i = 0; i < num_elements; i++) {
Insert(vector.get(), i, std::string(incremental_size, 'b'));
if (i >= next_update) {
ICING_ASSERT_OK_AND_ASSIGN(Crc32 incremental_crc,
vector->ComputeChecksum());
ICING_LOG(INFO) << "Now crc @" << incremental_crc.Get();
Crc32 full_crc;
std::string_view reconstructed_view =
std::string_view(vector->array(), vector->num_elements());
full_crc.Append(reconstructed_view);
ASSERT_EQ(incremental_crc, full_crc);
next_update *= 2;
}
}
for (uint32_t i = 0; i < num_elements; ++i) {
EXPECT_THAT(vector->Get(i), IsOkAndHolds(Pointee(Eq('b'))));
}
}
TEST_F(FileBackedVectorTest, Grow) {
// This is the same value as FileBackedVector::kMaxNumElts
constexpr int32_t kMaxNumElts = 1U << 20;
ASSERT_TRUE(filesystem_.Truncate(fd_, 0));
// Create an array and add some data.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(0)));
EXPECT_THAT(vector->Set(kMaxNumElts + 11, 'a'),
StatusIs(libtextclassifier3::StatusCode::OUT_OF_RANGE));
EXPECT_THAT(vector->Set(-1, 'a'),
StatusIs(libtextclassifier3::StatusCode::OUT_OF_RANGE));
uint32_t start = kMaxNumElts - 13;
Insert(vector.get(), start, "abcde");
// Crc works?
const Crc32 good_crc(1134899064U);
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(good_crc));
// PersistToDisk does nothing bad, and ensures the content is still there
// after we recreate the vector
ICING_EXPECT_OK(vector->PersistToDisk());
// Close out the old vector to ensure everything persists properly before we
// reassign it
vector.reset();
ICING_ASSERT_OK_AND_ASSIGN(
vector, FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
std::string expected = "abcde";
EXPECT_EQ(expected, Get(vector.get(), start, expected.length()));
}
TEST_F(FileBackedVectorTest, GrowsInChunks) {
// This is the same value as FileBackedVector::kGrowElements
constexpr int32_t kGrowElements = 1U << 14; // 16K
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<int>> vector,
FileBackedVector<int>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
// Our initial file size should just be the size of the header. Disk usage
// will indicate that one block has been allocated, which contains the header.
int header_size = sizeof(FileBackedVector<char>::Header);
int page_size = getpagesize();
EXPECT_THAT(filesystem_.GetFileSize(fd_), Eq(header_size));
EXPECT_THAT(filesystem_.GetDiskUsage(fd_), Eq(page_size));
// Once we add something though, we'll grow to be kGrowElements big. From this
// point on, file size and disk usage should be the same because Growing will
// explicitly allocate the number of blocks needed to accomodate the file.
Insert(vector.get(), 0, "a");
int file_size = kGrowElements * sizeof(int);
EXPECT_THAT(filesystem_.GetFileSize(fd_), Eq(file_size));
EXPECT_THAT(filesystem_.GetDiskUsage(fd_), Eq(file_size));
// Should still be the same size, don't need to grow underlying file
Insert(vector.get(), 1, "b");
EXPECT_THAT(filesystem_.GetFileSize(fd_), Eq(file_size));
EXPECT_THAT(filesystem_.GetDiskUsage(fd_), Eq(file_size));
// Now we grow by a kGrowElements chunk, so the underlying file is 2
// kGrowElements big
file_size *= 2;
Insert(vector.get(), 2, std::string(kGrowElements, 'c'));
EXPECT_THAT(filesystem_.GetFileSize(fd_), Eq(file_size));
EXPECT_THAT(filesystem_.GetDiskUsage(fd_), Eq(file_size));
// Destroy/persist the contents.
vector.reset();
// Reinitialize
ICING_ASSERT_OK_AND_ASSIGN(
vector, FileBackedVector<int>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
// Should be the same file size as before
EXPECT_THAT(filesystem_.GetFileSize(file_path_.c_str()),
Eq(kGrowElements * 2 * sizeof(int)));
}
TEST_F(FileBackedVectorTest, Delete) {
// Can delete even if there's nothing there
ICING_EXPECT_OK(FileBackedVector<int64_t>::Delete(filesystem_, file_path_));
// Create a vector and add some data.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(0)));
std::string expected = "abcde";
Insert(vector.get(), 0, expected);
ASSERT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(1134899064U)));
ASSERT_EQ(expected.length(), vector->num_elements());
// Close out the old vector to ensure everything persists properly before we
// delete the underlying files
vector.reset();
ICING_EXPECT_OK(FileBackedVector<int64_t>::Delete(filesystem_, file_path_));
EXPECT_FALSE(filesystem_.FileExists(file_path_.data()));
// Can successfully create again.
ICING_ASSERT_OK_AND_ASSIGN(
vector, FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
}
TEST_F(FileBackedVectorTest, TruncateTo) {
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(0)));
Insert(vector.get(), 0, "A");
Insert(vector.get(), 1, "Z");
EXPECT_EQ(2, vector->num_elements());
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(1658635950)));
// Modify 1 element, out of 2 total elements. 1/2 changes exceeds the partial
// crc limit, so our next checksum call will recompute the entire vector's
// checksum.
Insert(vector.get(), 1, "J");
// We'll ignore everything after the 1st element, so the full vector's
// checksum will only include "J".
ICING_EXPECT_OK(vector->TruncateTo(1));
EXPECT_EQ(1, vector->num_elements());
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(31158534)));
// Truncating clears the checksum and resets it to 0
ICING_EXPECT_OK(vector->TruncateTo(0));
EXPECT_EQ(0, vector->num_elements());
EXPECT_THAT(vector->ComputeChecksum(), IsOkAndHolds(Crc32(0)));
// Can't truncate past end.
EXPECT_THAT(vector->TruncateTo(100),
StatusIs(libtextclassifier3::StatusCode::OUT_OF_RANGE));
// Must be greater than or equal to 0
EXPECT_THAT(vector->TruncateTo(-1),
StatusIs(libtextclassifier3::StatusCode::OUT_OF_RANGE));
}
TEST_F(FileBackedVectorTest, TruncateAndReReadFile) {
{
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<float>> vector,
FileBackedVector<float>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
ICING_ASSERT_OK(vector->Set(0, 1.0));
ICING_ASSERT_OK(vector->Set(1, 2.0));
ICING_ASSERT_OK(vector->Set(2, 2.0));
ICING_ASSERT_OK(vector->Set(3, 2.0));
ICING_ASSERT_OK(vector->Set(4, 2.0));
} // Destroying the vector should trigger a checksum of the 5 elements
{
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<float>> vector,
FileBackedVector<float>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
EXPECT_EQ(5, vector->num_elements());
ICING_EXPECT_OK(vector->TruncateTo(4));
EXPECT_EQ(4, vector->num_elements());
} // Destroying the vector should update the checksum to 4 elements
// Creating again should double check that our checksum of 4 elements matches
// what was previously saved.
{
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<float>> vector,
FileBackedVector<float>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
EXPECT_EQ(vector->num_elements(), 4);
}
}
TEST_F(FileBackedVectorTest, InitFileTooSmallForHeaderFails) {
{
// 1. Create a vector with a few elements.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
Insert(vector.get(), 0, "A");
Insert(vector.get(), 1, "Z");
ASSERT_THAT(vector->PersistToDisk(), IsOk());
}
// 2. Shrink the file to be smaller than the header.
filesystem_.Truncate(fd_, sizeof(FileBackedVector<char>::Header) - 1);
{
// 3. Attempt to create the file and confirm that it fails.
EXPECT_THAT(FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC),
StatusIs(libtextclassifier3::StatusCode::INTERNAL));
}
}
TEST_F(FileBackedVectorTest, InitWrongDataSizeFails) {
{
// 1. Create a vector with a few elements.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
Insert(vector.get(), 0, "A");
Insert(vector.get(), 1, "Z");
ASSERT_THAT(vector->PersistToDisk(), IsOk());
}
{
// 2. Attempt to create the file with a different element size and confirm
// that it fails.
EXPECT_THAT(FileBackedVector<int>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC),
StatusIs(libtextclassifier3::StatusCode::INTERNAL));
}
}
TEST_F(FileBackedVectorTest, InitCorruptHeaderFails) {
{
// 1. Create a vector with a few elements.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
Insert(vector.get(), 0, "A");
Insert(vector.get(), 1, "Z");
ASSERT_THAT(vector->PersistToDisk(), IsOk());
}
// 2. Modify the header, but don't update the checksum. This would be similar
// to corruption of the header.
FileBackedVector<char>::Header header;
ASSERT_THAT(filesystem_.PRead(fd_, &header, sizeof(header), /*offset=*/0),
IsTrue());
header.num_elements = 1;
ASSERT_THAT(filesystem_.PWrite(fd_, /*offset=*/0, &header, sizeof(header)),
IsTrue());
{
// 3. Attempt to create the file with a header that doesn't match its
// checksum and confirm that it fails.
EXPECT_THAT(FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC),
StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION));
}
}
TEST_F(FileBackedVectorTest, InitHeaderElementSizeTooBigFails) {
{
// 1. Create a vector with a few elements.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
Insert(vector.get(), 0, "A");
Insert(vector.get(), 1, "Z");
ASSERT_THAT(vector->PersistToDisk(), IsOk());
}
// 2. Modify the header so that the number of elements exceeds the actual size
// of the underlying file.
FileBackedVector<char>::Header header;
ASSERT_THAT(filesystem_.PRead(fd_, &header, sizeof(header), /*offset=*/0),
IsTrue());
int64_t file_size = filesystem_.GetFileSize(fd_);
int64_t allocated_elements_size = file_size - sizeof(header);
header.num_elements = (allocated_elements_size / sizeof(char)) + 1;
header.header_checksum = header.CalculateHeaderChecksum();
ASSERT_THAT(filesystem_.PWrite(fd_, /*offset=*/0, &header, sizeof(header)),
IsTrue());
{
// 3. Attempt to create the file with num_elements that is larger than the
// underlying file and confirm that it fails.
EXPECT_THAT(FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC),
StatusIs(libtextclassifier3::StatusCode::INTERNAL));
}
}
TEST_F(FileBackedVectorTest, InitCorruptElementsFails) {
{
// 1. Create a vector with a few elements.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
Insert(vector.get(), 0, "A");
Insert(vector.get(), 1, "Z");
ASSERT_THAT(vector->PersistToDisk(), IsOk());
}
// 2. Overwrite the values of the first two elements.
std::string corrupted_content = "BY";
ASSERT_THAT(
filesystem_.PWrite(fd_, /*offset=*/sizeof(FileBackedVector<char>::Header),
corrupted_content.c_str(), corrupted_content.length()),
IsTrue());
{
// 3. Attempt to create the file with elements that don't match their
// checksum and confirm that it fails.
EXPECT_THAT(FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC),
StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION));
}
}
TEST_F(FileBackedVectorTest, InitNormalSucceeds) {
{
// 1. Create a vector with a few elements.
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<char>> vector,
FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
Insert(vector.get(), 0, "A");
Insert(vector.get(), 1, "Z");
ASSERT_THAT(vector->PersistToDisk(), IsOk());
}
{
// 2. Attempt to create the file with a completely valid header and elements
// region. This should succeed.
EXPECT_THAT(FileBackedVector<char>::Create(
filesystem_, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC),
IsOk());
}
}
TEST_F(FileBackedVectorTest, RemapFailureStillValidInstance) {
auto mock_filesystem = std::make_unique<MockFilesystem>();
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<int>> vector,
FileBackedVector<int>::Create(
*mock_filesystem, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
// 1. Write data to just before the first block resize. Running the test
// locally has determined that we'll first resize at 65531st entry.
constexpr int kResizingIndex = 16378;
for (int i = 0; i < kResizingIndex; ++i) {
ICING_ASSERT_OK(vector->Set(i, 7));
}
// 2. The next Set call should cause a resize and a remap. Make that remap
// fail.
int num_calls = 0;
auto open_lambda = [this, &num_calls](const char* file_name){
if (++num_calls == 2) {
return -1;
}
return this->filesystem().OpenForWrite(file_name);
};
ON_CALL(*mock_filesystem, OpenForWrite(_)).WillByDefault(open_lambda);
EXPECT_THAT(vector->Set(kResizingIndex, 7),
StatusIs(libtextclassifier3::StatusCode::INTERNAL));
// 3. We should still be able to call set correctly for earlier regions.
ICING_EXPECT_OK(vector->Set(kResizingIndex / 2, 9));
EXPECT_THAT(vector->Get(kResizingIndex / 2), IsOkAndHolds(Pointee(Eq(9))));
}
TEST_F(FileBackedVectorTest, BadFileSizeDuringGrowReturnsError) {
auto mock_filesystem = std::make_unique<MockFilesystem>();
ICING_ASSERT_OK_AND_ASSIGN(
std::unique_ptr<FileBackedVector<int>> vector,
FileBackedVector<int>::Create(
*mock_filesystem, file_path_,
MemoryMappedFile::Strategy::READ_WRITE_AUTO_SYNC));
// At first, the vector is empty and has no mapping established. The first Set
// call will cause a Grow.
// During Grow, we will attempt to check the underlying file size to see if
// growing is actually necessary. Return an error on the call to GetFileSize.
ON_CALL(*mock_filesystem, GetFileSize(A<const char*>()))
.WillByDefault(Return(Filesystem::kBadFileSize));
// We should fail gracefully and return an INTERNAL error to indicate that
// there was an issue retrieving the file size.
EXPECT_THAT(vector->Set(0, 7),
StatusIs(libtextclassifier3::StatusCode::INTERNAL));
}
} // namespace
} // namespace lib
} // namespace icing
Reference in New Issue View Git Blame Copy Permalink