tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
platform_system_core/libappfuse/tests/FuseAppLoopTest.cc
Christopher Ferris 6ddc2c56c9 Update for v5.10 kernel headers. 
Test: Builds.
Change-Id: I6c4b04751df026ef7cbb91627174188c5e6d137c
2020-12-14 22:36:37 -08:00

299 lines
9.6 KiB
C++
Raw Blame History

/*
* 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 specic language governing permissions and
* limitations under the License.
*/
#include "libappfuse/FuseAppLoop.h"
#include <sys/socket.h>
#include <android-base/logging.h>
#include <android-base/unique_fd.h>
#include <gtest/gtest.h>
#include <thread>
#include "libappfuse/EpollController.h"
#include "libappfuse/FuseBridgeLoop.h"
namespace android {
namespace fuse {
namespace {
constexpr unsigned int kTestFileSize = 1024;
struct CallbackRequest {
uint32_t code;
uint64_t inode;
};
class Callback : public FuseAppLoopCallback {
public:
std::vector<CallbackRequest> requests;
FuseAppLoop* loop;
void OnGetAttr(uint64_t seq, uint64_t inode) override {
EXPECT_NE(FUSE_ROOT_ID, static_cast<int>(inode));
EXPECT_TRUE(loop->ReplyGetAttr(seq, inode, kTestFileSize, S_IFREG | 0777));
}
void OnLookup(uint64_t unique, uint64_t inode) override {
EXPECT_NE(FUSE_ROOT_ID, static_cast<int>(inode));
EXPECT_TRUE(loop->ReplyLookup(unique, inode, kTestFileSize));
}
void OnFsync(uint64_t seq, uint64_t inode) override {
requests.push_back({.code = FUSE_FSYNC, .inode = inode});
loop->ReplySimple(seq, 0);
}
void OnWrite(uint64_t seq, uint64_t inode, uint64_t offset ATTRIBUTE_UNUSED,
uint32_t size ATTRIBUTE_UNUSED, const void* data ATTRIBUTE_UNUSED) override {
requests.push_back({.code = FUSE_WRITE, .inode = inode});
loop->ReplyWrite(seq, 0);
}
void OnRead(uint64_t seq, uint64_t inode, uint64_t offset ATTRIBUTE_UNUSED,
uint32_t size ATTRIBUTE_UNUSED) override {
requests.push_back({.code = FUSE_READ, .inode = inode});
loop->ReplySimple(seq, 0);
}
void OnOpen(uint64_t seq, uint64_t inode) override {
requests.push_back({.code = FUSE_OPEN, .inode = inode});
loop->ReplyOpen(seq, inode);
}
void OnRelease(uint64_t seq, uint64_t inode) override {
requests.push_back({.code = FUSE_RELEASE, .inode = inode});
loop->ReplySimple(seq, 0);
}
};
class FuseAppLoopTest : public ::testing::Test {
protected:
std::thread thread_;
base::unique_fd sockets_[2];
Callback callback_;
FuseRequest request_;
FuseResponse response_;
std::unique_ptr<FuseAppLoop> loop_;
void SetUp() override {
base::SetMinimumLogSeverity(base::VERBOSE);
ASSERT_TRUE(SetupMessageSockets(&sockets_));
loop_.reset(new FuseAppLoop(std::move(sockets_[1])));
callback_.loop = loop_.get();
thread_ = std::thread([this] { loop_->Start(&callback_); });
}
void CheckCallback(
size_t data_size, uint32_t code, size_t expected_out_size) {
request_.Reset(data_size, code, 1);
request_.header.nodeid = 10;
ASSERT_TRUE(request_.Write(sockets_[0]));
ASSERT_TRUE(response_.Read(sockets_[0]));
Close();
EXPECT_EQ(kFuseSuccess, response_.header.error);
EXPECT_EQ(sizeof(fuse_out_header) + expected_out_size,
response_.header.len);
EXPECT_EQ(1u, response_.header.unique);
ASSERT_EQ(1u, callback_.requests.size());
EXPECT_EQ(code, callback_.requests[0].code);
EXPECT_EQ(10u, callback_.requests[0].inode);
}
void Close() {
sockets_[0].reset();
sockets_[1].reset();
if (thread_.joinable()) {
thread_.join();
}
}
void TearDown() override {
Close();
}
};
} // namespace
TEST_F(FuseAppLoopTest, LookUp) {
request_.Reset(3u, FUSE_LOOKUP, 1);
request_.header.nodeid = FUSE_ROOT_ID;
strcpy(request_.lookup_name, "10");
ASSERT_TRUE(request_.Write(sockets_[0].get()));
ASSERT_TRUE(response_.Read(sockets_[0].get()));
EXPECT_EQ(kFuseSuccess, response_.header.error);
EXPECT_EQ(sizeof(fuse_out_header) + sizeof(fuse_entry_out),
response_.header.len);
EXPECT_EQ(1u, response_.header.unique);
EXPECT_EQ(10u, response_.entry_out.nodeid);
EXPECT_EQ(0u, response_.entry_out.generation);
EXPECT_EQ(10u, response_.entry_out.entry_valid);
EXPECT_EQ(10u, response_.entry_out.attr_valid);
EXPECT_EQ(0u, response_.entry_out.entry_valid_nsec);
EXPECT_EQ(0u, response_.entry_out.attr_valid_nsec);
EXPECT_EQ(10u, response_.entry_out.attr.ino);
EXPECT_EQ(kTestFileSize, response_.entry_out.attr.size);
EXPECT_EQ(0u, response_.entry_out.attr.blocks);
EXPECT_EQ(0u, response_.entry_out.attr.atime);
EXPECT_EQ(0u, response_.entry_out.attr.mtime);
EXPECT_EQ(0u, response_.entry_out.attr.ctime);
EXPECT_EQ(0u, response_.entry_out.attr.atimensec);
EXPECT_EQ(0u, response_.entry_out.attr.mtimensec);
EXPECT_EQ(0u, response_.entry_out.attr.ctimensec);
EXPECT_EQ(S_IFREG | 0777u, response_.entry_out.attr.mode);
EXPECT_EQ(0u, response_.entry_out.attr.nlink);
EXPECT_EQ(0u, response_.entry_out.attr.uid);
EXPECT_EQ(0u, response_.entry_out.attr.gid);
EXPECT_EQ(0u, response_.entry_out.attr.rdev);
EXPECT_EQ(0u, response_.entry_out.attr.blksize);
EXPECT_EQ(0u, response_.entry_out.attr.flags);
}
TEST_F(FuseAppLoopTest, LookUp_InvalidName) {
request_.Reset(3u, FUSE_LOOKUP, 1);
request_.header.nodeid = FUSE_ROOT_ID;
strcpy(request_.lookup_name, "aa");
ASSERT_TRUE(request_.Write(sockets_[0].get()));
ASSERT_TRUE(response_.Read(sockets_[0].get()));
EXPECT_EQ(sizeof(fuse_out_header), response_.header.len);
EXPECT_EQ(-ENOENT, response_.header.error);
EXPECT_EQ(1u, response_.header.unique);
}
TEST_F(FuseAppLoopTest, LookUp_TooLargeName) {
request_.Reset(21u, FUSE_LOOKUP, 1);
request_.header.nodeid = FUSE_ROOT_ID;
strcpy(request_.lookup_name, "18446744073709551616");
ASSERT_TRUE(request_.Write(sockets_[0].get()));
ASSERT_TRUE(response_.Read(sockets_[0].get()));
EXPECT_EQ(sizeof(fuse_out_header), response_.header.len);
EXPECT_EQ(-ENOENT, response_.header.error);
EXPECT_EQ(1u, response_.header.unique);
}
TEST_F(FuseAppLoopTest, GetAttr) {
request_.Reset(sizeof(fuse_getattr_in), FUSE_GETATTR, 1);
request_.header.nodeid = 10;
ASSERT_TRUE(request_.Write(sockets_[0].get()));
ASSERT_TRUE(response_.Read(sockets_[0].get()));
EXPECT_EQ(kFuseSuccess, response_.header.error);
EXPECT_EQ(sizeof(fuse_out_header) + sizeof(fuse_attr_out),
response_.header.len);
EXPECT_EQ(1u, response_.header.unique);
EXPECT_EQ(10u, response_.attr_out.attr_valid);
EXPECT_EQ(0u, response_.attr_out.attr_valid_nsec);
EXPECT_EQ(10u, response_.attr_out.attr.ino);
EXPECT_EQ(kTestFileSize, response_.attr_out.attr.size);
EXPECT_EQ(0u, response_.attr_out.attr.blocks);
EXPECT_EQ(0u, response_.attr_out.attr.atime);
EXPECT_EQ(0u, response_.attr_out.attr.mtime);
EXPECT_EQ(0u, response_.attr_out.attr.ctime);
EXPECT_EQ(0u, response_.attr_out.attr.atimensec);
EXPECT_EQ(0u, response_.attr_out.attr.mtimensec);
EXPECT_EQ(0u, response_.attr_out.attr.ctimensec);
EXPECT_EQ(S_IFREG | 0777u, response_.attr_out.attr.mode);
EXPECT_EQ(0u, response_.attr_out.attr.nlink);
EXPECT_EQ(0u, response_.attr_out.attr.uid);
EXPECT_EQ(0u, response_.attr_out.attr.gid);
EXPECT_EQ(0u, response_.attr_out.attr.rdev);
EXPECT_EQ(0u, response_.attr_out.attr.blksize);
EXPECT_EQ(0u, response_.attr_out.attr.flags);
}
TEST_F(FuseAppLoopTest, GetAttr_Root) {
request_.Reset(sizeof(fuse_getattr_in), FUSE_GETATTR, 1);
request_.header.nodeid = FUSE_ROOT_ID;
ASSERT_TRUE(request_.Write(sockets_[0].get()));
ASSERT_TRUE(response_.Read(sockets_[0].get()));
EXPECT_EQ(kFuseSuccess, response_.header.error);
EXPECT_EQ(sizeof(fuse_out_header) + sizeof(fuse_attr_out),
response_.header.len);
EXPECT_EQ(1u, response_.header.unique);
EXPECT_EQ(10u, response_.attr_out.attr_valid);
EXPECT_EQ(0u, response_.attr_out.attr_valid_nsec);
EXPECT_EQ(static_cast<unsigned>(FUSE_ROOT_ID), response_.attr_out.attr.ino);
EXPECT_EQ(0u, response_.attr_out.attr.size);
EXPECT_EQ(0u, response_.attr_out.attr.blocks);
EXPECT_EQ(0u, response_.attr_out.attr.atime);
EXPECT_EQ(0u, response_.attr_out.attr.mtime);
EXPECT_EQ(0u, response_.attr_out.attr.ctime);
EXPECT_EQ(0u, response_.attr_out.attr.atimensec);
EXPECT_EQ(0u, response_.attr_out.attr.mtimensec);
EXPECT_EQ(0u, response_.attr_out.attr.ctimensec);
EXPECT_EQ(S_IFDIR | 0777u, response_.attr_out.attr.mode);
EXPECT_EQ(0u, response_.attr_out.attr.nlink);
EXPECT_EQ(0u, response_.attr_out.attr.uid);
EXPECT_EQ(0u, response_.attr_out.attr.gid);
EXPECT_EQ(0u, response_.attr_out.attr.rdev);
EXPECT_EQ(0u, response_.attr_out.attr.blksize);
EXPECT_EQ(0u, response_.attr_out.attr.flags);
}
TEST_F(FuseAppLoopTest, Open) {
CheckCallback(sizeof(fuse_open_in), FUSE_OPEN, sizeof(fuse_open_out));
}
TEST_F(FuseAppLoopTest, Fsync) {
CheckCallback(0u, FUSE_FSYNC, 0u);
}
TEST_F(FuseAppLoopTest, Release) {
CheckCallback(0u, FUSE_RELEASE, 0u);
}
TEST_F(FuseAppLoopTest, Read) {
CheckCallback(sizeof(fuse_read_in), FUSE_READ, 0u);
}
TEST_F(FuseAppLoopTest, Write) {
CheckCallback(sizeof(fuse_write_in), FUSE_WRITE, sizeof(fuse_write_out));
}
TEST_F(FuseAppLoopTest, Break) {
// Ensure that the loop started.
request_.Reset(sizeof(fuse_open_in), FUSE_OPEN, 1);
request_.header.nodeid = 10;
ASSERT_TRUE(request_.Write(sockets_[0]));
ASSERT_TRUE(response_.Read(sockets_[0]));
loop_->Break();
if (thread_.joinable()) {
thread_.join();
}
}
} // namespace fuse
} // namespace android
Reference in a new issue View git blame Copy permalink