blob: aa7a23a34f8c5f0aa1c103903ca4b0e3d86e4492 [file] [log] [blame]
/*
* Copyright (C) 2016 The Android Open Source Project
*
* 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 <string>
#include <vector>
#include <android-base/test_utils.h>
#include <android-base/file.h>
#include <gtest/gtest.h>
#include "Memory.h"
class MemoryFileTest : public ::testing::Test {
protected:
void SetUp() override {
tf_ = new TemporaryFile;
}
void TearDown() override {
delete tf_;
}
void WriteTestData() {
ASSERT_TRUE(android::base::WriteStringToFd("0123456789abcdefghijklmnopqrstuvxyz", tf_->fd));
}
MemoryFileAtOffset memory_;
TemporaryFile* tf_ = nullptr;
};
TEST_F(MemoryFileTest, init_offset_0) {
WriteTestData();
ASSERT_TRUE(memory_.Init(tf_->path, 0));
std::vector<char> buffer(11);
ASSERT_TRUE(memory_.Read(0, buffer.data(), 10));
buffer[10] = '\0';
ASSERT_STREQ("0123456789", buffer.data());
}
TEST_F(MemoryFileTest, init_offset_non_zero) {
WriteTestData();
ASSERT_TRUE(memory_.Init(tf_->path, 10));
std::vector<char> buffer(11);
ASSERT_TRUE(memory_.Read(0, buffer.data(), 10));
buffer[10] = '\0';
ASSERT_STREQ("abcdefghij", buffer.data());
}
TEST_F(MemoryFileTest, init_offset_non_zero_larger_than_pagesize) {
size_t pagesize = getpagesize();
std::string large_string;
for (size_t i = 0; i < pagesize; i++) {
large_string += '1';
}
large_string += "012345678901234abcdefgh";
ASSERT_TRUE(android::base::WriteStringToFd(large_string, tf_->fd));
ASSERT_TRUE(memory_.Init(tf_->path, pagesize + 15));
std::vector<char> buffer(9);
ASSERT_TRUE(memory_.Read(0, buffer.data(), 8));
buffer[8] = '\0';
ASSERT_STREQ("abcdefgh", buffer.data());
}
TEST_F(MemoryFileTest, init_offset_pagesize_aligned) {
size_t pagesize = getpagesize();
std::string data;
for (size_t i = 0; i < 2 * pagesize; i++) {
data += static_cast<char>((i / pagesize) + '0');
data += static_cast<char>((i % 10) + '0');
}
ASSERT_TRUE(android::base::WriteStringToFd(data, tf_->fd));
ASSERT_TRUE(memory_.Init(tf_->path, 2 * pagesize));
std::vector<char> buffer(11);
ASSERT_TRUE(memory_.Read(0, buffer.data(), 10));
buffer[10] = '\0';
std::string expected_str;
for (size_t i = 0; i < 5; i++) {
expected_str += '1';
expected_str += static_cast<char>(((i + pagesize) % 10) + '0');
}
ASSERT_STREQ(expected_str.c_str(), buffer.data());
}
TEST_F(MemoryFileTest, init_offset_pagesize_aligned_plus_extra) {
size_t pagesize = getpagesize();
std::string data;
for (size_t i = 0; i < 2 * pagesize; i++) {
data += static_cast<char>((i / pagesize) + '0');
data += static_cast<char>((i % 10) + '0');
}
ASSERT_TRUE(android::base::WriteStringToFd(data, tf_->fd));
ASSERT_TRUE(memory_.Init(tf_->path, 2 * pagesize + 10));
std::vector<char> buffer(11);
ASSERT_TRUE(memory_.Read(0, buffer.data(), 10));
buffer[10] = '\0';
std::string expected_str;
for (size_t i = 0; i < 5; i++) {
expected_str += '1';
expected_str += static_cast<char>(((i + pagesize + 5) % 10) + '0');
}
ASSERT_STREQ(expected_str.c_str(), buffer.data());
}
TEST_F(MemoryFileTest, init_offset_greater_than_filesize) {
size_t pagesize = getpagesize();
std::string data;
uint64_t file_size = 2 * pagesize + pagesize / 2;
for (size_t i = 0; i < file_size; i++) {
data += static_cast<char>((i / pagesize) + '0');
}
ASSERT_TRUE(android::base::WriteStringToFd(data, tf_->fd));
// Check offset > file size fails and aligned_offset > file size.
ASSERT_FALSE(memory_.Init(tf_->path, file_size + 2 * pagesize));
// Check offset == filesize fails.
ASSERT_FALSE(memory_.Init(tf_->path, file_size));
// Check aligned_offset < filesize, but offset > filesize fails.
ASSERT_FALSE(memory_.Init(tf_->path, 2 * pagesize + pagesize / 2 + pagesize / 4));
}
TEST_F(MemoryFileTest, read_error) {
std::string data;
for (size_t i = 0; i < 5000; i++) {
data += static_cast<char>((i % 10) + '0');
}
ASSERT_TRUE(android::base::WriteStringToFd(data, tf_->fd));
std::vector<char> buffer(100);
// Read before init.
ASSERT_FALSE(memory_.Read(0, buffer.data(), 10));
ASSERT_TRUE(memory_.Init(tf_->path, 0));
ASSERT_FALSE(memory_.Read(10000, buffer.data(), 10));
ASSERT_FALSE(memory_.Read(5000, buffer.data(), 10));
ASSERT_FALSE(memory_.Read(4990, buffer.data(), 11));
ASSERT_TRUE(memory_.Read(4990, buffer.data(), 10));
ASSERT_FALSE(memory_.Read(4999, buffer.data(), 2));
ASSERT_TRUE(memory_.Read(4999, buffer.data(), 1));
// Check that overflow fails properly.
ASSERT_FALSE(memory_.Read(UINT64_MAX - 100, buffer.data(), 200));
}
TEST_F(MemoryFileTest, read_past_file_within_mapping) {
size_t pagesize = getpagesize();
ASSERT_TRUE(pagesize > 100);
std::vector<uint8_t> buffer(pagesize - 100);
for (size_t i = 0; i < pagesize - 100; i++) {
buffer[i] = static_cast<uint8_t>((i % 0x5e) + 0x20);
}
ASSERT_TRUE(android::base::WriteFully(tf_->fd, buffer.data(), buffer.size()));
ASSERT_TRUE(memory_.Init(tf_->path, 0));
for (size_t i = 0; i < 100; i++) {
uint8_t value;
ASSERT_FALSE(memory_.Read(buffer.size() + i, &value, 1)) << "Should have failed at value " << i;
}
}
TEST_F(MemoryFileTest, map_partial_offset_aligned) {
size_t pagesize = getpagesize();
std::vector<uint8_t> buffer(pagesize * 10);
for (size_t i = 0; i < pagesize * 10; i++) {
buffer[i] = i / pagesize + 1;
}
ASSERT_TRUE(android::base::WriteFully(tf_->fd, buffer.data(), buffer.size()));
// Map in only two pages of the data, and after the first page.
ASSERT_TRUE(memory_.Init(tf_->path, pagesize, pagesize * 2));
std::vector<uint8_t> read_buffer(pagesize * 2);
// Make sure that reading after mapped data is a failure.
ASSERT_FALSE(memory_.Read(pagesize * 2, read_buffer.data(), 1));
ASSERT_TRUE(memory_.Read(0, read_buffer.data(), pagesize * 2));
for (size_t i = 0; i < pagesize; i++) {
ASSERT_EQ(2, read_buffer[i]) << "Failed at byte " << i;
}
for (size_t i = pagesize; i < pagesize * 2; i++) {
ASSERT_EQ(3, read_buffer[i]) << "Failed at byte " << i;
}
}
TEST_F(MemoryFileTest, map_partial_offset_unaligned) {
size_t pagesize = getpagesize();
ASSERT_TRUE(pagesize > 0x100);
std::vector<uint8_t> buffer(pagesize * 10);
for (size_t i = 0; i < buffer.size(); i++) {
buffer[i] = i / pagesize + 1;
}
ASSERT_TRUE(android::base::WriteFully(tf_->fd, buffer.data(), buffer.size()));
// Map in only two pages of the data, and after the first page.
ASSERT_TRUE(memory_.Init(tf_->path, pagesize + 0x100, pagesize * 2));
std::vector<uint8_t> read_buffer(pagesize * 2);
// Make sure that reading after mapped data is a failure.
ASSERT_FALSE(memory_.Read(pagesize * 2, read_buffer.data(), 1));
ASSERT_TRUE(memory_.Read(0, read_buffer.data(), pagesize * 2));
for (size_t i = 0; i < pagesize - 0x100; i++) {
ASSERT_EQ(2, read_buffer[i]) << "Failed at byte " << i;
}
for (size_t i = pagesize - 0x100; i < 2 * pagesize - 0x100; i++) {
ASSERT_EQ(3, read_buffer[i]) << "Failed at byte " << i;
}
for (size_t i = 2 * pagesize - 0x100; i < pagesize * 2; i++) {
ASSERT_EQ(4, read_buffer[i]) << "Failed at byte " << i;
}
}
TEST_F(MemoryFileTest, map_overflow) {
size_t pagesize = getpagesize();
ASSERT_TRUE(pagesize > 0x100);
std::vector<uint8_t> buffer(pagesize * 10);
for (size_t i = 0; i < buffer.size(); i++) {
buffer[i] = i / pagesize + 1;
}
ASSERT_TRUE(android::base::WriteFully(tf_->fd, buffer.data(), buffer.size()));
// Map in only two pages of the data, and after the first page.
ASSERT_TRUE(memory_.Init(tf_->path, pagesize + 0x100, UINT64_MAX));
std::vector<uint8_t> read_buffer(pagesize * 10);
ASSERT_FALSE(memory_.Read(pagesize * 9 - 0x100 + 1, read_buffer.data(), 1));
ASSERT_TRUE(memory_.Read(0, read_buffer.data(), pagesize * 9 - 0x100));
}
TEST_F(MemoryFileTest, init_reinit) {
size_t pagesize = getpagesize();
std::vector<uint8_t> buffer(pagesize * 2);
for (size_t i = 0; i < buffer.size(); i++) {
buffer[i] = i / pagesize + 1;
}
ASSERT_TRUE(android::base::WriteFully(tf_->fd, buffer.data(), buffer.size()));
ASSERT_TRUE(memory_.Init(tf_->path, 0));
std::vector<uint8_t> read_buffer(buffer.size());
ASSERT_TRUE(memory_.Read(0, read_buffer.data(), pagesize));
for (size_t i = 0; i < pagesize; i++) {
ASSERT_EQ(1, read_buffer[i]) << "Failed at byte " << i;
}
// Now reinit.
ASSERT_TRUE(memory_.Init(tf_->path, pagesize));
ASSERT_TRUE(memory_.Read(0, read_buffer.data(), pagesize));
for (size_t i = 0; i < pagesize; i++) {
ASSERT_EQ(2, read_buffer[i]) << "Failed at byte " << i;
}
}