// Files need to be explicitly created using CreateFile or CreateDirectory.
// Automatically creating them on first use would be a bug.
TEST_F(FileSystemTest, NonExistingFiles)
{
const Result<Metadata> metadata = m_fs->GetMetadata(Uid{0}, Gid{0}, "/tmp/foo");
ASSERT_FALSE(metadata.Succeeded());
EXPECT_EQ(metadata.Error(), ResultCode::NotFound);
const Result<FileHandle> file = m_fs->OpenFile(Uid{0}, Gid{0}, "/tmp/foo", Mode::Read);
ASSERT_FALSE(file.Succeeded());
EXPECT_EQ(file.Error(), ResultCode::NotFound);
const Result<std::vector<std::string>> children = m_fs->ReadDirectory(Uid{0}, Gid{0}, "/foo");
ASSERT_FALSE(children.Succeeded());
EXPECT_EQ(children.Error(), ResultCode::NotFound);
}
void OlaCallbackClient::HandleSetCallback(
ola::SingleUseCallback1<void, const string&> *callback,
const Result &result) {
if (callback) {
callback->Run(result.Error());
}
}
void ShowRecorder::RegisterComplete(const Result &result) {
if (!result.Success()) {
OLA_WARN << "Register failed: " << result.Error();
} else {
OLA_INFO << "Register completed";
}
}
/*
* @param list_ids_only show ids only
* @params plugins a vector of OlaPlugins
*/
void DisplayPlugins(SelectServer *ss,
bool list_ids_only,
const Result &result,
const vector <OlaPlugin> &plugins) {
vector<OlaPlugin>::const_iterator iter;
if (!result.Success()) {
cerr << result.Error() << endl;
ss->Terminate();
return;
}
if (list_ids_only) {
for (iter = plugins.begin(); iter != plugins.end(); ++iter) {
cout << iter->Id() << endl;
}
} else {
cout << setw(5) << "Id" << "\tPlugin Name" << endl;
cout << "--------------------------------------" << endl;
for (iter = plugins.begin(); iter != plugins.end(); ++iter) {
cout << setw(5) << iter->Id() << "\t" << iter->Name() << endl;
}
cout << "--------------------------------------" << endl;
}
ss->Terminate();
}
/*
* This is called when we receive universe results from the client
* @param list_ids_only show ids only
* @param universes a vector of OlaUniverses
*/
void DisplayUniverses(SelectServer *ss,
bool list_ids_only,
const Result &result,
const vector <OlaUniverse> &universes) {
vector<OlaUniverse>::const_iterator iter;
if (!result.Success()) {
cerr << result.Error() << endl;
ss->Terminate();
return;
}
if (list_ids_only) {
for (iter = universes.begin(); iter != universes.end(); ++iter) {
cout << iter->Id() << endl;
}
} else {
cout << setw(5) << "Id" << "\t" << setw(30) << "Name" << "\t\tMerge Mode"
<< endl;
cout << "----------------------------------------------------------"
<< endl;
for (iter = universes.begin(); iter != universes.end(); ++iter) {
cout << setw(5) << iter->Id() << "\t" << setw(30) << iter->Name()
<< "\t\t"
<< (iter->MergeMode() == OlaUniverse::MERGE_HTP ? "HTP" : "LTP")
<< endl;
}
cout << "----------------------------------------------------------" <<
endl;
}
ss->Terminate();
}
void DmxMonitor::RegisterComplete(const Result &result) {
if (!result.Success()) {
std::cerr << "Register command failed with " << result.Error() <<
std::endl;
m_client.GetSelectServer()->Terminate();
}
}
// ReadDirectory is used by official titles to determine whether a path is a file.
// If it is not a file, ResultCode::Invalid must be returned.
TEST_F(FileSystemTest, ReadDirectoryOnFile)
{
ASSERT_EQ(m_fs->CreateFile(Uid{0}, Gid{0}, "/tmp/f", 0, Mode::Read, Mode::None, Mode::None),
ResultCode::Success);
const Result<std::vector<std::string>> result = m_fs->ReadDirectory(Uid{0}, Gid{0}, "/tmp/f");
ASSERT_FALSE(result.Succeeded());
EXPECT_EQ(result.Error(), ResultCode::Invalid);
}
/*
* Print a plugin description
*/
void DisplayPluginDescription(SelectServer *ss,
const Result &result,
const string &description) {
if (!result.Success()) {
cerr << result.Error() << endl;
} else {
cout << description << endl;
}
ss->Terminate();
return;
}
/*
* Print a plugin state
*/
void DisplayPluginState(SelectServer *ss,
const Result &result,
const ola::client::PluginState &state) {
if (!result.Success()) {
cerr << result.Error() << endl;
} else {
cout << state.name << endl;
cout << "Enabled: " << (state.enabled ? "True" : "False") << endl;
cout << "Active: " << (state.active ? "True" : "False") << endl;
vector<OlaPlugin>::const_iterator iter = state.conflicting_plugins.begin();
cout << "Conflicts with:" << endl;
for (; iter != state.conflicting_plugins.end(); ++iter) {
cout << " " << iter->Name() << "(" << iter->Id() << ")" << endl;
}
}
ss->Terminate();
return;
}
/*
* @param devices a vector of OlaDevices
*/
void DisplayDevices(SelectServer *ss,
const Result &result,
const vector <OlaDevice> &devices) {
vector<OlaDevice>::const_iterator iter;
if (!result.Success()) {
cerr << result.Error() << endl;
ss->Terminate();
return;
}
for (iter = devices.begin(); iter != devices.end(); ++iter) {
cout << "Device " << iter->Alias() << ": " << iter->Name() << endl;
vector<OlaInputPort> input_ports = iter->InputPorts();
ListPorts(input_ports, true);
vector<OlaOutputPort> output_ports = iter->OutputPorts();
ListPorts(output_ports, false);
}
ss->Terminate();
}
void OlaCallbackClient::GetResponseStatusAndData(
const Result &result,
ola::rdm::rdm_response_code response_code,
const ola::rdm::RDMResponse *response,
rdm::ResponseStatus *response_status,
string *data) {
response_status->error = result.Error();
response_status->response_code = ola::rdm::RDM_FAILED_TO_SEND;
if (result.Success()) {
response_status->response_code = response_code;
if (response_code == ola::rdm::RDM_COMPLETED_OK && response) {
response_status->response_type = response->PortIdResponseType();
response_status->message_count = response->MessageCount();
response_status->pid_value = response->ParamId();
response_status->set_command = (
response->CommandClass() == ola::rdm::RDMCommand::SET_COMMAND_RESPONSE
? true : false);
switch (response->PortIdResponseType()) {
case ola::rdm::RDM_ACK:
data->append(reinterpret_cast<const char*>(response->ParamData()),
response->ParamDataSize());
break;
case ola::rdm::RDM_ACK_TIMER:
GetParamFromReply("ack timer", response, response_status);
break;
case ola::rdm::RDM_NACK_REASON:
GetParamFromReply("nack", response, response_status);
break;
default:
OLA_WARN << "Invalid response type 0x" << std::hex
<< static_cast<int>(response->PortIdResponseType());
response_status->response_type = ola::rdm::RDM_INVALID_RESPONSE;
}
}
}
}
TEST_F(FileSystemTest, Seek)
{
const std::vector<u8> TEST_DATA(10);
ASSERT_EQ(m_fs->CreateFile(Uid{0}, Gid{0}, "/tmp/f", 0, Mode::ReadWrite, Mode::None, Mode::None),
ResultCode::Success);
const Result<FileHandle> file = m_fs->OpenFile(Uid{0}, Gid{0}, "/tmp/f", Mode::ReadWrite);
ASSERT_TRUE(file.Succeeded());
// An empty file should have a size of exactly 0 bytes.
EXPECT_EQ(file->GetStatus()->size, 0u);
// The file position should be set to the start right after an open.
EXPECT_EQ(file->GetStatus()->offset, 0u);
// Write some dummy data.
ASSERT_TRUE(file->Write(TEST_DATA.data(), TEST_DATA.size()).Succeeded());
EXPECT_EQ(file->GetStatus()->size, TEST_DATA.size());
EXPECT_EQ(file->GetStatus()->offset, TEST_DATA.size());
auto seek_and_check = [&file](u32 offset, SeekMode mode, u32 expected_position) {
const Result<u32> new_offset = file->Seek(offset, mode);
ASSERT_TRUE(new_offset.Succeeded());
EXPECT_EQ(*new_offset, expected_position);
EXPECT_EQ(file->GetStatus()->offset, expected_position);
};
seek_and_check(0, SeekMode::Set, 0);
seek_and_check(5, SeekMode::Set, 5);
seek_and_check(0, SeekMode::Current, 5);
seek_and_check(2, SeekMode::Current, 7);
seek_and_check(0, SeekMode::End, 10);
// Test past-EOF seeks.
const Result<u32> new_position = file->Seek(11, SeekMode::Set);
ASSERT_FALSE(new_position.Succeeded());
EXPECT_EQ(new_position.Error(), ResultCode::Invalid);
}
void OlaCallbackClient::HandleRepeatableSetCallback(
ola::Callback1<void, const string&> *callback,
const Result &result) {
callback->Run(result.Error());
}
/*
* Called when a generic set command completes
*/
void HandleAck(SelectServer *ss, const Result &result) {
if (!result.Success()) {
cerr << result.Error() << endl;
}
ss->Terminate();
}
