Macintosh-HW/RASCSI
1
0
Fork 0
mirror of https://github.com/akuker/RASCSI.git synced 2026-04-21 18:17:07 +00:00
Code Issues Projects Releases Wiki Activity

Cleaned up dependencies on controller manager (#964)

Browse Source 
* Cleaned up dependencies on controller manager

* Removed global fields

* Simplified setting up RascsiResponse and RascsiExecutor

* Got rid of remaining raw pointers

* Use references instead of pointers

* Improved encapsulation
This commit is contained in:
Uwe Seimet
2022-11-04 08:22:32 +01:00
committed by GitHub
parent 921ba7d2ed
commit c98c52ffb8
44 changed files with 1071 additions and 965 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cpp/test/abstract_controller_test.cpp
+74 -38
View File
@@ -15,7 +15,9 @@ using namespace scsi_defs;
TEST(AbstractControllerTest, AllocateCmd)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
EXPECT_EQ(16, controller.GetCmd().size());
controller.AllocateCmd(1234);
@@ -24,7 +26,9 @@ TEST(AbstractControllerTest, AllocateCmd)
TEST(AbstractControllerTest, AllocateBuffer)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
controller.AllocateBuffer(1);
EXPECT_LE(1, controller.GetBuffer().size());
@@ -34,22 +38,26 @@ TEST(AbstractControllerTest, AllocateBuffer)
TEST(AbstractControllerTest, Reset)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
controller.AddDevice(device);
controller->AddDevice(device);
controller.SetPhase(BUS::phase_t::status);
EXPECT_EQ(BUS::phase_t::status, controller.GetPhase());
controller.Reset();
EXPECT_TRUE(controller.IsBusFree());
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(0, controller.GetLength());
controller->SetPhase(BUS::phase_t::status);
EXPECT_EQ(BUS::phase_t::status, controller->GetPhase());
controller->Reset();
EXPECT_TRUE(controller->IsBusFree());
EXPECT_EQ(status::GOOD, controller->GetStatus());
EXPECT_EQ(0, controller->GetLength());
}
TEST(AbstractControllerTest, Next)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
controller.SetNext(0x1234);
EXPECT_EQ(0x1234, controller.GetNext());
@@ -59,7 +67,9 @@ TEST(AbstractControllerTest, Next)
TEST(AbstractControllerTest, Message)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
controller.SetMessage(0x12);
EXPECT_EQ(0x12, controller.GetMessage());
@@ -67,7 +77,9 @@ TEST(AbstractControllerTest, Message)
TEST(AbstractControllerTest, ByteTransfer)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
controller.SetByteTransfer(false);
EXPECT_FALSE(controller.IsByteTransfer());
@@ -77,7 +89,9 @@ TEST(AbstractControllerTest, ByteTransfer)
TEST(AbstractControllerTest, BytesToTransfer)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
controller.SetBytesToTransfer(0x1234);
EXPECT_EQ(0x1234, controller.GetBytesToTransfer());
@@ -87,14 +101,18 @@ TEST(AbstractControllerTest, BytesToTransfer)
TEST(AbstractControllerTest, GetMaxLuns)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
EXPECT_EQ(32, controller.GetMaxLuns());
}
TEST(AbstractControllerTest, Status)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
controller.SetStatus(status::RESERVATION_CONFLICT);
EXPECT_EQ(status::RESERVATION_CONFLICT, controller.GetStatus());
@@ -102,7 +120,9 @@ TEST(AbstractControllerTest, Status)
TEST(AbstractControllerTest, ProcessPhase)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
controller.SetPhase(BUS::phase_t::selection);
EXPECT_CALL(controller, Selection);
@@ -152,25 +172,27 @@ TEST(AbstractControllerTest, DeviceLunLifeCycle)
const int ID = 1;
const int LUN = 4;
MockAbstractController controller(make_shared<MockBus>(), ID);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, ID);
auto device1 = make_shared<MockPrimaryDevice>(LUN);
auto device2 = make_shared<MockPrimaryDevice>(32);
auto device3 = make_shared<MockPrimaryDevice>(-1);
EXPECT_EQ(0, controller.GetLunCount());
EXPECT_EQ(ID, controller.GetTargetId());
EXPECT_TRUE(controller.AddDevice(device1));
EXPECT_FALSE(controller.AddDevice(device2));
EXPECT_FALSE(controller.AddDevice(device3));
EXPECT_TRUE(controller.GetLunCount() > 0);
EXPECT_TRUE(controller.HasDeviceForLun(LUN));
EXPECT_FALSE(controller.HasDeviceForLun(0));
EXPECT_NE(nullptr, controller.GetDeviceForLun(LUN));
EXPECT_EQ(nullptr, controller.GetDeviceForLun(0));
EXPECT_TRUE(controller.RemoveDevice(device1));
EXPECT_EQ(0, controller.GetLunCount());
EXPECT_FALSE(controller.RemoveDevice(device1));
EXPECT_EQ(0, controller->GetLunCount());
EXPECT_EQ(ID, controller->GetTargetId());
EXPECT_TRUE(controller->AddDevice(device1));
EXPECT_FALSE(controller->AddDevice(device2));
EXPECT_FALSE(controller->AddDevice(device3));
EXPECT_TRUE(controller->GetLunCount() > 0);
EXPECT_TRUE(controller->HasDeviceForLun(LUN));
EXPECT_FALSE(controller->HasDeviceForLun(0));
EXPECT_NE(nullptr, controller->GetDeviceForLun(LUN));
EXPECT_EQ(nullptr, controller->GetDeviceForLun(0));
EXPECT_TRUE(controller->RemoveDevice(device1));
EXPECT_EQ(0, controller->GetLunCount());
EXPECT_FALSE(controller->RemoveDevice(device1));
}
TEST(AbstractControllerTest, ExtractInitiatorId)
@@ -179,7 +201,9 @@ TEST(AbstractControllerTest, ExtractInitiatorId)
const int INITIATOR_ID = 7;
const int UNKNOWN_INITIATOR_ID = -1;
MockAbstractController controller(make_shared<MockBus>(), ID);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, ID);
EXPECT_EQ(INITIATOR_ID, controller.ExtractInitiatorId((1 << INITIATOR_ID) | ( 1 << ID)));
EXPECT_EQ(UNKNOWN_INITIATOR_ID, controller.ExtractInitiatorId(1 << ID));
@@ -187,7 +211,9 @@ TEST(AbstractControllerTest, ExtractInitiatorId)
TEST(AbstractControllerTest, GetOpcode)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
auto& cmd = controller.GetCmd();
@@ -199,7 +225,9 @@ TEST(AbstractControllerTest, GetLun)
{
const int LUN = 3;
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
auto& cmd = controller.GetCmd();
@@ -209,7 +237,9 @@ TEST(AbstractControllerTest, GetLun)
TEST(AbstractControllerTest, Blocks)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
controller.SetBlocks(1);
EXPECT_EQ(1, controller.GetBlocks());
@@ -219,7 +249,9 @@ TEST(AbstractControllerTest, Blocks)
TEST(AbstractControllerTest, Length)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
EXPECT_FALSE(controller.HasValidLength());
@@ -230,7 +262,9 @@ TEST(AbstractControllerTest, Length)
TEST(AbstractControllerTest, UpdateOffsetAndLength)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
EXPECT_FALSE(controller.HasValidLength());
@@ -240,7 +274,9 @@ TEST(AbstractControllerTest, UpdateOffsetAndLength)
TEST(AbstractControllerTest, Offset)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
controller.ResetOffset();
EXPECT_EQ(0, controller.GetOffset());
cpp/test/controller_manager_test.cpp
+26 -44
View File
@@ -18,32 +18,32 @@ TEST(ControllerManagerTest, LifeCycle)
const int LUN2 = 3;
auto bus = make_shared<MockBus>();
ControllerManager controller_manager(bus);
auto controller_manager = make_shared<ControllerManager>(*bus);
DeviceFactory device_factory;
auto device = device_factory.CreateDevice(controller_manager, SCHS, -1, "");
EXPECT_FALSE(controller_manager.AttachToScsiController(ID, device));
auto device = device_factory.CreateDevice(SCHS, -1, "");
EXPECT_FALSE(controller_manager->AttachToScsiController(ID, device));
device = device_factory.CreateDevice(controller_manager, SCHS, LUN1, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device));
auto controller = controller_manager.FindController(ID);
device = device_factory.CreateDevice(SCHS, LUN1, "");
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device));
auto controller = controller_manager->FindController(ID);
EXPECT_NE(nullptr, controller);
EXPECT_EQ(1, controller->GetLunCount());
EXPECT_NE(nullptr, controller_manager.IdentifyController(1 << ID));
EXPECT_EQ(nullptr, controller_manager.IdentifyController(0));
EXPECT_EQ(nullptr, controller_manager.FindController(0));
EXPECT_NE(nullptr, controller_manager.GetDeviceByIdAndLun(ID, LUN1));
EXPECT_EQ(nullptr, controller_manager.GetDeviceByIdAndLun(0, 0));
EXPECT_NE(nullptr, controller_manager->IdentifyController(1 << ID));
EXPECT_EQ(nullptr, controller_manager->IdentifyController(0));
EXPECT_EQ(nullptr, controller_manager->FindController(0));
EXPECT_NE(nullptr, controller_manager->GetDeviceByIdAndLun(ID, LUN1));
EXPECT_EQ(nullptr, controller_manager->GetDeviceByIdAndLun(0, 0));
device = device_factory.CreateDevice(controller_manager, SCHS, LUN2, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device));
controller = controller_manager.FindController(ID);
EXPECT_TRUE(controller_manager.DeleteController(controller));
EXPECT_EQ(nullptr, controller_manager.FindController(ID));
device = device_factory.CreateDevice(SCHS, LUN2, "");
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device));
controller = controller_manager->FindController(ID);
EXPECT_TRUE(controller_manager->DeleteController(controller));
EXPECT_EQ(nullptr, controller_manager->FindController(ID));
controller_manager.DeleteAllControllers();
EXPECT_EQ(nullptr, controller_manager.FindController(ID));
EXPECT_EQ(nullptr, controller_manager.GetDeviceByIdAndLun(ID, LUN1));
controller_manager->DeleteAllControllers();
EXPECT_EQ(nullptr, controller_manager->FindController(ID));
EXPECT_EQ(nullptr, controller_manager->GetDeviceByIdAndLun(ID, LUN1));
}
TEST(ControllerManagerTest, AttachToScsiController)
@@ -53,32 +53,14 @@ TEST(ControllerManagerTest, AttachToScsiController)
const int LUN2 = 0;
auto bus = make_shared<MockBus>();
ControllerManager controller_manager(bus);
auto controller_manager = make_shared<ControllerManager>(*bus);
DeviceFactory device_factory;
auto device1 = device_factory.CreateDevice(controller_manager, SCHS, LUN1, "");
EXPECT_FALSE(controller_manager.AttachToScsiController(ID, device1)) << "LUN 0 is missing";
auto device1 = device_factory.CreateDevice(SCHS, LUN1, "");
EXPECT_FALSE(controller_manager->AttachToScsiController(ID, device1)) << "LUN 0 is missing";
auto device2 = device_factory.CreateDevice(controller_manager, SCLP, LUN2, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device2));
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device1));
EXPECT_FALSE(controller_manager.AttachToScsiController(ID, device1));
}
TEST(ControllerManagerTest, ResetAllControllers)
{
const int ID = 2;
auto bus = make_shared<MockBus>();
ControllerManager controller_manager(bus);
DeviceFactory device_factory;
auto device = device_factory.CreateDevice(controller_manager, SCHS, 0, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device));
auto controller = controller_manager.FindController(ID);
EXPECT_NE(nullptr, controller);
controller->SetStatus(status::RESERVATION_CONFLICT);
controller_manager.ResetAllControllers();
EXPECT_EQ(status::GOOD, controller->GetStatus());
auto device2 = device_factory.CreateDevice(SCLP, LUN2, "");
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device2));
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device1));
EXPECT_FALSE(controller_manager->AttachToScsiController(ID, device1));
}
cpp/test/device_factory_test.cpp
+18 -29
View File
@@ -122,27 +122,24 @@ TEST(DeviceFactoryTest, GetDefaultParams)
TEST(DeviceFactoryTest, UnknownDeviceType)
{
auto bus = make_shared<MockBus>();
DeviceFactory device_factory;
ControllerManager controller_manager(bus);
auto device1 = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "test");
auto device1 = device_factory.CreateDevice(UNDEFINED, 0, "test");
EXPECT_EQ(nullptr, device1);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
auto device2 = device_factory.CreateDevice(controller_manager, SAHD, 0, "test");
auto device2 = device_factory.CreateDevice(SAHD, 0, "test");
#pragma GCC diagnostic pop
EXPECT_EQ(nullptr, device2);
}
TEST(DeviceFactoryTest, SCHD_Device_Defaults)
{
auto bus = make_shared<MockBus>();
DeviceFactory device_factory;
ControllerManager controller_manager(bus);
auto device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "test.hda");
auto device = device_factory.CreateDevice(UNDEFINED, 0, "test.hda");
const unordered_map<string, string> params;
device->Init(params);
@@ -165,26 +162,23 @@ TEST(DeviceFactoryTest, SCHD_Device_Defaults)
EXPECT_EQ(string(rascsi_get_version_string()).substr(0, 2) + string(rascsi_get_version_string()).substr(3, 2),
device->GetRevision());
device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "test.hds");
device = device_factory.CreateDevice(UNDEFINED, 0, "test.hds");
EXPECT_NE(nullptr, device);
EXPECT_EQ(SCHD, device->GetType());
device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "test.hdi");
device = device_factory.CreateDevice(UNDEFINED, 0, "test.hdi");
EXPECT_NE(nullptr, device);
EXPECT_EQ(SCHD, device->GetType());
device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "test.nhd");
device = device_factory.CreateDevice(UNDEFINED, 0, "test.nhd");
EXPECT_NE(nullptr, device);
EXPECT_EQ(SCHD, device->GetType());
}
void TestRemovableDrive(PbDeviceType type, const string& filename, const string& product)
{
auto bus = make_shared<MockBus>();
DeviceFactory device_factory;
ControllerManager controller_manager(bus);
auto device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, filename);
auto device = device_factory.CreateDevice(UNDEFINED, 0, filename);
const unordered_map<string, string> params;
device->Init(params);
@@ -221,11 +215,10 @@ TEST(DeviceFactoryTest, SCMO_Device_Defaults)
TEST(DeviceFactoryTest, SCCD_Device_Defaults)
{
auto bus = make_shared<MockBus>();
DeviceFactory device_factory;
ControllerManager controller_manager(bus);
auto device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "test.iso");
auto device = device_factory.CreateDevice(UNDEFINED, 0, "test.iso");
const unordered_map<string, string> params;
device->Init(params);
@@ -251,11 +244,10 @@ TEST(DeviceFactoryTest, SCCD_Device_Defaults)
TEST(DeviceFactoryTest, SCBR_Device_Defaults)
{
auto bus = make_shared<MockBus>();
DeviceFactory device_factory;
ControllerManager controller_manager(bus);
auto device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "bridge");
auto device = device_factory.CreateDevice(UNDEFINED, 0, "bridge");
const unordered_map<string, string> params;
device->Init(params);
@@ -281,11 +273,10 @@ TEST(DeviceFactoryTest, SCBR_Device_Defaults)
TEST(DeviceFactoryTest, SCDP_Device_Defaults)
{
auto bus = make_shared<MockBus>();
DeviceFactory device_factory;
ControllerManager controller_manager(bus);
auto device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "daynaport");
auto device = device_factory.CreateDevice(UNDEFINED, 0, "daynaport");
const unordered_map<string, string> params;
device->Init(params);
@@ -310,11 +301,10 @@ TEST(DeviceFactoryTest, SCDP_Device_Defaults)
TEST(DeviceFactoryTest, SCHS_Device_Defaults)
{
auto bus = make_shared<MockBus>();
DeviceFactory device_factory;
ControllerManager controller_manager(bus);
auto device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "services");
auto device = device_factory.CreateDevice(UNDEFINED, 0, "services");
const unordered_map<string, string> params;
device->Init(params);
@@ -340,11 +330,10 @@ TEST(DeviceFactoryTest, SCHS_Device_Defaults)
TEST(DeviceFactoryTest, SCLP_Device_Defaults)
{
auto bus = make_shared<MockBus>();
DeviceFactory device_factory;
ControllerManager controller_manager(bus);
auto device = device_factory.CreateDevice(controller_manager, UNDEFINED, 0, "printer");
auto device = device_factory.CreateDevice(UNDEFINED, 0, "printer");
const unordered_map<string, string> params;
device->Init(params);
cpp/test/disk_test.cpp
+188 -136
View File
@@ -18,34 +18,38 @@ using namespace scsi_command_util;
TEST(DiskTest, Dispatch)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
disk->SetRemovable(true);
disk->SetMediumChanged(false);
disk->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdTestUnitReady);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
disk->SetMediumChanged(true);
EXPECT_CALL(controller, Error);
EXPECT_CALL(*controller, Error);
disk->Dispatch(scsi_command::eCmdTestUnitReady);
EXPECT_FALSE(disk->IsMediumChanged());
}
TEST(DiskTest, Rezero)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdRezero); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::NOT_READY),
@@ -54,21 +58,23 @@ TEST(DiskTest, Rezero)
disk->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdRezero);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(DiskTest, FormatUnit)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdFormatUnit); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::NOT_READY),
@@ -77,9 +83,9 @@ TEST(DiskTest, FormatUnit)
disk->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdFormatUnit);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
cmd[1] = 0x10;
cmd[4] = 1;
@@ -90,12 +96,14 @@ TEST(DiskTest, FormatUnit)
TEST(DiskTest, ReassignBlocks)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdReassignBlocks); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::NOT_READY),
@@ -104,21 +112,23 @@ TEST(DiskTest, ReassignBlocks)
disk->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdReassignBlocks);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(DiskTest, Seek6)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdSeek6); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -135,21 +145,23 @@ TEST(DiskTest, Seek6)
disk->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdSeek6);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(DiskTest, Seek10)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdSeek10); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -166,19 +178,21 @@ TEST(DiskTest, Seek10)
disk->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdSeek10);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(DiskTest, ReadCapacity10)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdReadCapacity10); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::NOT_READY),
@@ -192,30 +206,32 @@ TEST(DiskTest, ReadCapacity10)
<< "READ CAPACITY(10) must fail because the medium has no capacity";
disk->SetBlockCount(0x12345678);
EXPECT_CALL(controller, DataIn);
EXPECT_CALL(*controller, DataIn);
disk->Dispatch(scsi_command::eCmdReadCapacity10);
auto& buf = controller.GetBuffer();
auto& buf = controller->GetBuffer();
EXPECT_EQ(0x1234, GetInt16(buf, 0));
EXPECT_EQ(0x5677, GetInt16(buf, 2));
disk->SetBlockCount(0x1234567887654321);
EXPECT_CALL(controller, DataIn);
EXPECT_CALL(*controller, DataIn);
disk->Dispatch(scsi_command::eCmdReadCapacity10);
buf = controller.GetBuffer();
buf = controller->GetBuffer();
EXPECT_EQ(0xffff, GetInt16(buf, 0));
EXPECT_EQ(0xffff, GetInt16(buf, 2));
}
TEST(DiskTest, ReadCapacity16)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
cmd[1] = 0x00;
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdReadCapacity16_ReadLong16); }, Throws<scsi_exception>(AllOf(
@@ -238,9 +254,9 @@ TEST(DiskTest, ReadCapacity16)
disk->SetBlockCount(0x1234567887654321);
disk->SetSectorSizeInBytes(1024);
EXPECT_CALL(controller, DataIn);
EXPECT_CALL(*controller, DataIn);
disk->Dispatch(scsi_command::eCmdReadCapacity16_ReadLong16);
const auto& buf = controller.GetBuffer();
const auto& buf = controller->GetBuffer();
EXPECT_EQ(0x1234, GetInt16(buf, 0));
EXPECT_EQ(0x5678, GetInt16(buf, 2));
EXPECT_EQ(0x8765, GetInt16(buf, 4));
@@ -251,12 +267,14 @@ TEST(DiskTest, ReadCapacity16)
TEST(DiskTest, Read6)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdRead6); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -268,12 +286,14 @@ TEST(DiskTest, Read6)
TEST(DiskTest, Read10)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdRead10); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -281,21 +301,23 @@ TEST(DiskTest, Read10)
<< "READ(10) must fail for a medium with 0 blocks";
disk->SetBlockCount(1);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdRead10);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
// Further testing requires filesystem access
}
TEST(DiskTest, Read16)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdRead16); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -303,21 +325,23 @@ TEST(DiskTest, Read16)
<< "READ(16) must fail for a medium with 0 blocks";
disk->SetBlockCount(1);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdRead16);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
// Further testing requires filesystem access
}
TEST(DiskTest, Write6)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdWrite6); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -337,12 +361,14 @@ TEST(DiskTest, Write6)
TEST(DiskTest, Write10)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdWrite10); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -350,21 +376,23 @@ TEST(DiskTest, Write10)
<< "WRITE(10) must fail for a medium with 0 blocks";
disk->SetBlockCount(1);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdWrite10);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
// Further testing requires filesystem access
}
TEST(DiskTest, Write16)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdWrite16); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -372,21 +400,23 @@ TEST(DiskTest, Write16)
<< "WRITE(16) must fail for a medium with 0 blocks";
disk->SetBlockCount(1);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdWrite16);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
// Further testing requires filesystem access
}
TEST(DiskTest, Verify10)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdVerify10); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -394,21 +424,23 @@ TEST(DiskTest, Verify10)
<< "VERIFY(10) must fail for a medium with 0 blocks";
disk->SetBlockCount(1);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdVerify10);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
// Further testing requires filesystem access
}
TEST(DiskTest, Verify16)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdVerify16); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -416,27 +448,29 @@ TEST(DiskTest, Verify16)
<< "VERIFY(16) must fail for a medium with 0 blocks";
disk->SetBlockCount(1);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdVerify16);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
// Further testing requires filesystem access
}
TEST(DiskTest, ReadLong10)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdReadLong10);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
cmd[2] = 1;
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdReadLong10); }, Throws<scsi_exception>(AllOf(
@@ -454,14 +488,16 @@ TEST(DiskTest, ReadLong10)
TEST(DiskTest, ReadLong16)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// READ LONG(16), not READ CAPACITY(16)
cmd[1] = 0x11;
@@ -472,9 +508,9 @@ TEST(DiskTest, ReadLong16)
<< "READ LONG(16) must fail because the capacity is exceeded";
cmd[2] = 0;
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdReadCapacity16_ReadLong16);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
cmd[13] = 1;
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdReadCapacity16_ReadLong16); }, Throws<scsi_exception>(AllOf(
@@ -485,18 +521,20 @@ TEST(DiskTest, ReadLong16)
TEST(DiskTest, WriteLong10)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdWriteLong10);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
cmd[2] = 1;
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdWriteLong10); }, Throws<scsi_exception>(AllOf(
@@ -514,14 +552,16 @@ TEST(DiskTest, WriteLong10)
TEST(DiskTest, WriteLong16)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
cmd[2] = 1;
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdWriteLong16); }, Throws<scsi_exception>(AllOf(
@@ -530,9 +570,9 @@ TEST(DiskTest, WriteLong16)
<< "WRITE LONG(16) must fail because the capacity is exceeded";
cmd[2] = 0;
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdWriteLong16);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
cmd[13] = 1;
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdWriteLong16); }, Throws<scsi_exception>(AllOf(
@@ -543,33 +583,35 @@ TEST(DiskTest, WriteLong16)
TEST(DiskTest, StartStopUnit)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
disk->SetRemovable(true);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// Stop/Unload
disk->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
EXPECT_CALL(*disk, FlushCache);
disk->Dispatch(scsi_command::eCmdStartStop);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
EXPECT_TRUE(disk->IsStopped());
// Stop/Load
cmd[4] = 0x02;
disk->SetReady(true);
disk->SetLocked(false);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
EXPECT_CALL(*disk, FlushCache);
disk->Dispatch(scsi_command::eCmdStartStop);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
disk->SetReady(false);
EXPECT_CALL(*disk, FlushCache).Times(0);
@@ -586,28 +628,30 @@ TEST(DiskTest, StartStopUnit)
// Start/Unload
cmd[4] = 0x01;
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdStartStop);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
EXPECT_FALSE(disk->IsStopped());
// Start/Load
cmd[4] = 0x03;
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdStartStop);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(DiskTest, PreventAllowMediumRemoval)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_THAT([&] { disk->Dispatch(scsi_command::eCmdPreventAllowMediumRemoval); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::NOT_READY),
@@ -616,15 +660,15 @@ TEST(DiskTest, PreventAllowMediumRemoval)
disk->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdPreventAllowMediumRemoval);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
EXPECT_FALSE(disk->IsLocked());
cmd[4] = 1;
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdPreventAllowMediumRemoval);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
EXPECT_TRUE(disk->IsLocked());
}
@@ -657,9 +701,9 @@ TEST(DiskTest, Eject)
EXPECT_TRUE(disk.Eject(true));
}
void DiskTest_ValidateFormatPage(AbstractController& controller, int offset)
void DiskTest_ValidateFormatPage(shared_ptr<AbstractController> controller, int offset)
{
const auto& buf = controller.GetBuffer();
const auto& buf = controller->GetBuffer();
EXPECT_EQ(0x08, buf[offset + 3]) << "Wrong number of trackes in one zone";
EXPECT_EQ(25, GetInt16(buf, offset + 10)) << "Wrong number of sectors per track";
EXPECT_EQ(1024, GetInt16(buf, offset + 12)) << "Wrong number of bytes per sector";
@@ -670,18 +714,18 @@ void DiskTest_ValidateFormatPage(AbstractController& controller, int offset)
EXPECT_TRUE(buf[offset + 20] & 0x40) << "Wrong hard-sectored flag";
}
void DiskTest_ValidateDrivePage(AbstractController& controller, int offset)
void DiskTest_ValidateDrivePage(shared_ptr<AbstractController> controller, int offset)
{
const auto& buf = controller.GetBuffer();
const auto& buf = controller->GetBuffer();
EXPECT_EQ(0x17, buf[offset + 2]);
EXPECT_EQ(0x4d3b, GetInt16(buf, offset + 3));
EXPECT_EQ(8, buf[offset + 5]) << "Wrong number of heads";
EXPECT_EQ(7200, GetInt16(buf, offset + 20)) << "Wrong medium rotation rate";
}
void DiskTest_ValidateCachePage(AbstractController& controller, int offset)
void DiskTest_ValidateCachePage(shared_ptr<AbstractController> controller, int offset)
{
const auto& buf = controller.GetBuffer();
const auto& buf = controller->GetBuffer();
EXPECT_EQ(0xffff, GetInt16(buf, offset + 4)) << "Wrong pre-fetch transfer length";
EXPECT_EQ(0xffff, GetInt16(buf, offset + 8)) << "Wrong maximum pre-fetch";
EXPECT_EQ(0xffff, GetInt16(buf, offset + 10)) << "Wrong maximum pre-fetch ceiling";
@@ -689,14 +733,16 @@ void DiskTest_ValidateCachePage(AbstractController& controller, int offset)
TEST(DiskTest, ModeSense6)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// Drive must be ready on order to return all data
disk->SetReady(true);
@@ -705,18 +751,18 @@ TEST(DiskTest, ModeSense6)
// ALLOCATION LENGTH
cmd[4] = 255;
disk->Dispatch(scsi_command::eCmdModeSense6);
EXPECT_EQ(0x08, controller.GetBuffer()[3]) << "Wrong block descriptor length";
EXPECT_EQ(0x08, controller->GetBuffer()[3]) << "Wrong block descriptor length";
// No block descriptor
cmd[1] = 0x08;
disk->Dispatch(scsi_command::eCmdModeSense6);
EXPECT_EQ(0x00, controller.GetBuffer()[2]) << "Wrong device-specific parameter";
EXPECT_EQ(0x00, controller->GetBuffer()[2]) << "Wrong device-specific parameter";
disk->SetReadOnly(false);
disk->SetProtectable(true);
disk->SetProtected(true);
disk->Dispatch(scsi_command::eCmdModeSense6);
const auto& buf = controller.GetBuffer();
const auto& buf = controller->GetBuffer();
EXPECT_EQ(0x80, buf[2]) << "Wrong device-specific parameter";
// Return block descriptor
@@ -742,14 +788,16 @@ TEST(DiskTest, ModeSense6)
TEST(DiskTest, ModeSense10)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// Drive must be ready on order to return all data
disk->SetReady(true);
@@ -758,19 +806,19 @@ TEST(DiskTest, ModeSense10)
// ALLOCATION LENGTH
cmd[8] = 255;
disk->Dispatch(scsi_command::eCmdModeSense10);
EXPECT_EQ(0x08, controller.GetBuffer()[7]) << "Wrong block descriptor length";
EXPECT_EQ(0x08, controller->GetBuffer()[7]) << "Wrong block descriptor length";
// No block descriptor
cmd[1] = 0x08;
disk->Dispatch(scsi_command::eCmdModeSense10);
auto& buf = controller.GetBuffer();
EXPECT_EQ(0x00, controller.GetBuffer()[3]) << "Wrong device-specific parameter";
auto& buf = controller->GetBuffer();
EXPECT_EQ(0x00, controller->GetBuffer()[3]) << "Wrong device-specific parameter";
disk->SetReadOnly(false);
disk->SetProtectable(true);
disk->SetProtected(true);
disk->Dispatch(scsi_command::eCmdModeSense10);
buf = controller.GetBuffer();
buf = controller->GetBuffer();
EXPECT_EQ(0x80, buf[3]) << "Wrong device-specific parameter";
// Return short block descriptor
@@ -778,7 +826,7 @@ TEST(DiskTest, ModeSense10)
disk->SetBlockCount(0x1234);
disk->SetSectorSizeInBytes(1024);
disk->Dispatch(scsi_command::eCmdModeSense10);
buf = controller.GetBuffer();
buf = controller->GetBuffer();
EXPECT_EQ(0x00, buf[4]) << "Wrong LONGLBA field";
EXPECT_EQ(0x08, buf[7]) << "Wrong block descriptor length";
EXPECT_EQ(0x00, GetInt16(buf, 8));
@@ -790,7 +838,7 @@ TEST(DiskTest, ModeSense10)
cmd[1] = 0x10;
disk->SetBlockCount((uint64_t)0xffffffff + 1);
disk->Dispatch(scsi_command::eCmdModeSense10);
buf = controller.GetBuffer();
buf = controller->GetBuffer();
EXPECT_EQ(0x01, buf[4]) << "Wrong LONGLBA field";
EXPECT_EQ(0x10, buf[7]) << "Wrong block descriptor length";
EXPECT_EQ(0x00, GetInt16(buf, 8));
@@ -821,36 +869,40 @@ TEST(DiskTest, ModeSense10)
TEST(DiskTest, SynchronizeCache)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_CALL(*disk, FlushCache);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdSynchronizeCache10);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
EXPECT_CALL(*disk, FlushCache);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
disk->Dispatch(scsi_command::eCmdSynchronizeCache16);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(DiskTest, ReadDefectData)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto disk = make_shared<MockDisk>();
const unordered_map<string, string> params;
disk->Init(params);
controller.AddDevice(disk);
controller->AddDevice(disk);
EXPECT_CALL(controller, DataIn);
EXPECT_CALL(*controller, DataIn);
disk->Dispatch(scsi_command::eCmdReadDefectData10);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(DiskTest, SectorSize)
cpp/test/host_services_test.cpp
+39 -32
View File
@@ -22,12 +22,14 @@ void HostServices_SetUpModePages(map<int, vector<byte>>& pages)
TEST(HostServicesTest, TestUnitReady)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto services = CreateDevice(SCHS, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto services = CreateDevice(SCHS, *controller);
EXPECT_CALL(controller, Status());
EXPECT_CALL(*controller, Status());
services->Dispatch(scsi_command::eCmdTestUnitReady);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(HostServicesTest, Inquiry)
@@ -37,30 +39,32 @@ TEST(HostServicesTest, Inquiry)
TEST(HostServicesTest, StartStopUnit)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto services = CreateDevice(SCHS, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto services = CreateDevice(SCHS, *controller);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// STOP
EXPECT_CALL(controller, ScheduleShutdown(AbstractController::rascsi_shutdown_mode::STOP_RASCSI));
EXPECT_CALL(controller, Status());
EXPECT_CALL(*controller, ScheduleShutdown(AbstractController::rascsi_shutdown_mode::STOP_RASCSI));
EXPECT_CALL(*controller, Status());
services->Dispatch(scsi_command::eCmdStartStop);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
// LOAD
cmd[4] = 0x02;
EXPECT_CALL(controller, ScheduleShutdown(AbstractController::rascsi_shutdown_mode::STOP_PI));
EXPECT_CALL(controller, Status());
EXPECT_CALL(*controller, ScheduleShutdown(AbstractController::rascsi_shutdown_mode::STOP_PI));
EXPECT_CALL(*controller, Status());
services->Dispatch(scsi_command::eCmdStartStop);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
// UNLOAD
cmd[4] = 0x03;
EXPECT_CALL(controller, ScheduleShutdown(AbstractController::rascsi_shutdown_mode::RESTART_PI));
EXPECT_CALL(controller, Status());
EXPECT_CALL(*controller, ScheduleShutdown(AbstractController::rascsi_shutdown_mode::RESTART_PI));
EXPECT_CALL(*controller, Status());
services->Dispatch(scsi_command::eCmdStartStop);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
// START
cmd[4] = 0x01;
@@ -71,12 +75,14 @@ TEST(HostServicesTest, StartStopUnit)
TEST(HostServicesTest, ModeSense6)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto services = CreateDevice(SCHS, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto services = CreateDevice(SCHS, *controller);
const unordered_map<string, string> params;
services->Init(params);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_THAT([&] { services->Dispatch(scsi_command::eCmdModeSense6); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -92,9 +98,9 @@ TEST(HostServicesTest, ModeSense6)
cmd[1] = 0x08;
// ALLOCATION LENGTH
cmd[4] = 255;
EXPECT_CALL(controller, DataIn());
EXPECT_CALL(*controller, DataIn());
services->Dispatch(scsi_command::eCmdModeSense6);
vector<uint8_t>& buffer = controller.GetBuffer();
vector<uint8_t>& buffer = controller->GetBuffer();
// Major version 1
EXPECT_EQ(0x01, buffer[6]);
// Minor version 0
@@ -106,20 +112,22 @@ TEST(HostServicesTest, ModeSense6)
// ALLOCATION LENGTH
cmd[4] = 2;
EXPECT_CALL(controller, DataIn());
EXPECT_CALL(*controller, DataIn());
services->Dispatch(scsi_command::eCmdModeSense6);
buffer = controller.GetBuffer();
buffer = controller->GetBuffer();
EXPECT_EQ(0x02, buffer[0]);
}
TEST(HostServicesTest, ModeSense10)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto services = CreateDevice(SCHS, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto services = CreateDevice(SCHS, *controller);
const unordered_map<string, string> params;
services->Init(params);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_THAT([&] { services->Dispatch(scsi_command::eCmdModeSense10); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -135,9 +143,9 @@ TEST(HostServicesTest, ModeSense10)
cmd[1] = 0x08;
// ALLOCATION LENGTH
cmd[8] = 255;
EXPECT_CALL(controller, DataIn());
EXPECT_CALL(*controller, DataIn());
services->Dispatch(scsi_command::eCmdModeSense10);
vector<uint8_t>& buffer = controller.GetBuffer();
vector<uint8_t>& buffer = controller->GetBuffer();
// Major version 1
EXPECT_EQ(0x01, buffer[10]);
// Minor version 0
@@ -149,16 +157,15 @@ TEST(HostServicesTest, ModeSense10)
// ALLOCATION LENGTH
cmd[8] = 2;
EXPECT_CALL(controller, DataIn());
EXPECT_CALL(*controller, DataIn());
services->Dispatch(scsi_command::eCmdModeSense10);
buffer = controller.GetBuffer();
buffer = controller->GetBuffer();
EXPECT_EQ(0x02, buffer[1]);
}
TEST(HostServicesTest, SetUpModePages)
{
ControllerManager controller_manager(make_shared<MockBus>());
MockHostServices services(0, controller_manager);
MockHostServices services(0);
map<int, vector<byte>> pages;
// Non changeable
cpp/test/mocks.h
+8 -5
View File
@@ -103,6 +103,7 @@ class MockAbstractController : public AbstractController //NOSONAR Having many f
FRIEND_TEST(AbstractControllerTest, Length);
FRIEND_TEST(AbstractControllerTest, UpdateOffsetAndLength);
FRIEND_TEST(AbstractControllerTest, Offset);
FRIEND_TEST(ScsiControllerTest, Selection);
FRIEND_TEST(PrimaryDeviceTest, Inquiry);
FRIEND_TEST(PrimaryDeviceTest, TestUnitReady);
FRIEND_TEST(PrimaryDeviceTest, RequestSense);
@@ -153,14 +154,15 @@ public:
MOCK_METHOD(void, MsgOut, (), ());
MOCK_METHOD(void, ScheduleShutdown, (rascsi_shutdown_mode), (override));
explicit MockAbstractController(shared_ptr<MockBus> bus, int target_id) : AbstractController(bus, target_id, 32) {
explicit MockAbstractController(shared_ptr<ControllerManager> controller_manager, int target_id)
: AbstractController(controller_manager, target_id, 32) {
AllocateBuffer(512);
}
~MockAbstractController() override = default;
// Permit access to all tests without the need for numerous FRIEND_TEST
vector<int>& GetCmd() { return AbstractController::GetCmd(); } //NOSONAR Hides function on purpose
shared_ptr<BUS> GetBus() { return AbstractController::GetBus(); } //NOSONAR Hides function on purpose
BUS& GetBus() { return AbstractController::GetBus(); } //NOSONAR Hides function on purpose
};
class MockScsiController : public ScsiController
@@ -184,9 +186,10 @@ public:
MOCK_METHOD(void, Execute, (), ());
using ScsiController::ScsiController;
explicit MockScsiController(shared_ptr<NiceMock<MockBus>> bus, int target_id) : ScsiController(bus, target_id) {}
explicit MockScsiController(shared_ptr<MockBus> bus, int target_id) : ScsiController(bus, target_id) {}
explicit MockScsiController(shared_ptr<MockBus> bus) : ScsiController(bus, 0) {}
MockScsiController(shared_ptr<ControllerManager> controller_manager, int target_id)
: ScsiController(controller_manager, target_id) {}
explicit MockScsiController(shared_ptr<ControllerManager> controller_manager)
: ScsiController(controller_manager, 0) {}
~MockScsiController() override = default;
};
cpp/test/mode_page_device_test.cpp
+22 -14
View File
@@ -80,27 +80,31 @@ TEST(ModePageDeviceTest, AddVendorPage)
TEST(ModePageDeviceTest, ModeSense6)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device = make_shared<NiceMock<MockModePageDevice>>();
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
EXPECT_CALL(controller, DataIn());
EXPECT_CALL(*controller, DataIn());
device->Dispatch(scsi_command::eCmdModeSense6);
}
TEST(ModePageDeviceTest, ModeSense10)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device = make_shared<NiceMock<MockModePageDevice>>();
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
EXPECT_CALL(controller, DataIn());
EXPECT_CALL(*controller, DataIn());
device->Dispatch(scsi_command::eCmdModeSense10);
}
@@ -122,16 +126,18 @@ TEST(ModePageDeviceTest, ModeSelect)
TEST(ModePageDeviceTest, ModeSelect6)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device = make_shared<MockModePageDevice>();
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_CALL(controller, DataOut());
EXPECT_CALL(*controller, DataOut());
device->Dispatch(scsi_command::eCmdModeSelect6);
cmd[1] = 0x01;
@@ -143,16 +149,18 @@ TEST(ModePageDeviceTest, ModeSelect6)
TEST(ModePageDeviceTest, ModeSelect10)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device = make_shared<MockModePageDevice>();
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_CALL(controller, DataOut());
EXPECT_CALL(*controller, DataOut());
device->Dispatch(scsi_command::eCmdModeSelect10);
cmd[1] = 0x01;
cpp/test/primary_device_test.cpp
+70 -46
View File
@@ -21,44 +21,50 @@ TEST(PrimaryDeviceTest, GetId)
{
const int ID = 5;
MockAbstractController controller(make_shared<MockBus>(), ID);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, ID);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
EXPECT_EQ(-1, device->GetId()) << "Device ID cannot be known without assignment to a controller";
controller.AddDevice(device);
controller->AddDevice(device);
EXPECT_EQ(ID, device->GetId());
}
TEST(PrimaryDeviceTest, PhaseChange)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
device->EnterStatusPhase();
EXPECT_CALL(controller, DataIn);
EXPECT_CALL(*controller, DataIn);
device->EnterDataInPhase();
EXPECT_CALL(controller, DataOut);
EXPECT_CALL(*controller, DataOut);
device->EnterDataOutPhase();
}
TEST(PrimaryDeviceTest, Reset)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
device->Dispatch(scsi_command::eCmdReserve6);
EXPECT_FALSE(device->CheckReservation(1, scsi_command::eCmdTestUnitReady, false))
@@ -70,12 +76,14 @@ TEST(PrimaryDeviceTest, Reset)
TEST(PrimaryDeviceTest, CheckReservation)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
EXPECT_TRUE(device->CheckReservation(0, scsi_command::eCmdTestUnitReady, false))
<< "Device must not be reserved for initiator ID 0";
@@ -102,12 +110,14 @@ TEST(PrimaryDeviceTest, CheckReservation)
TEST(PrimaryDeviceTest, ReserveReleaseUnit)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
device->Dispatch(scsi_command::eCmdReserve6);
EXPECT_FALSE(device->CheckReservation(1, scsi_command::eCmdTestUnitReady, false))
@@ -117,7 +127,7 @@ TEST(PrimaryDeviceTest, ReserveReleaseUnit)
EXPECT_TRUE(device->CheckReservation(1, scsi_command::eCmdTestUnitReady, false))
<< "Device must not be reserved anymore for initiator ID 1";
ON_CALL(controller, GetInitiatorId).WillByDefault(Return(-1));
ON_CALL(*controller, GetInitiatorId).WillByDefault(Return(-1));
device->Dispatch(scsi_command::eCmdReserve6);
EXPECT_FALSE(device->CheckReservation(1, scsi_command::eCmdTestUnitReady, false))
<< "Device must be reserved for unknown initiator";
@@ -129,12 +139,14 @@ TEST(PrimaryDeviceTest, ReserveReleaseUnit)
TEST(PrimaryDeviceTest, DiscardReservation)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
device->Dispatch(scsi_command::eCmdReserve6);
EXPECT_FALSE(device->CheckReservation(1, scsi_command::eCmdTestUnitReady, false))
@@ -146,56 +158,60 @@ TEST(PrimaryDeviceTest, DiscardReservation)
TEST(PrimaryDeviceTest, TestUnitReady)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
device->SetReset(true);
device->SetAttn(true);
device->SetReady(false);
EXPECT_CALL(controller, DataIn).Times(0);
EXPECT_CALL(*controller, DataIn).Times(0);
EXPECT_THAT([&] { device->Dispatch(scsi_command::eCmdTestUnitReady); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::UNIT_ATTENTION),
Property(&scsi_exception::get_asc, asc::POWER_ON_OR_RESET))));
device->SetReset(false);
EXPECT_CALL(controller, DataIn).Times(0);
EXPECT_CALL(*controller, DataIn).Times(0);
EXPECT_THAT([&] { device->Dispatch(scsi_command::eCmdTestUnitReady); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::UNIT_ATTENTION),
Property(&scsi_exception::get_asc, asc::NOT_READY_TO_READY_CHANGE))));
device->SetReset(true);
device->SetAttn(false);
EXPECT_CALL(controller, DataIn).Times(0);
EXPECT_CALL(*controller, DataIn).Times(0);
EXPECT_THAT([&] { device->Dispatch(scsi_command::eCmdTestUnitReady); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::UNIT_ATTENTION),
Property(&scsi_exception::get_asc, asc::POWER_ON_OR_RESET))));
device->SetReset(false);
device->SetAttn(true);
EXPECT_CALL(controller, DataIn).Times(0);
EXPECT_CALL(*controller, DataIn).Times(0);
EXPECT_THAT([&] { device->Dispatch(scsi_command::eCmdTestUnitReady); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::UNIT_ATTENTION),
Property(&scsi_exception::get_asc, asc::NOT_READY_TO_READY_CHANGE))));
device->SetAttn(false);
EXPECT_CALL(controller, DataIn).Times(0);
EXPECT_CALL(*controller, DataIn).Times(0);
EXPECT_THAT([&] { device->Dispatch(scsi_command::eCmdTestUnitReady); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::NOT_READY),
Property(&scsi_exception::get_asc, asc::MEDIUM_NOT_PRESENT))));
device->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
device->Dispatch(scsi_command::eCmdTestUnitReady);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(PrimaryDeviceTest, Inquiry)
{
auto controller = make_shared<NiceMock<MockAbstractController>>(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
@@ -266,14 +282,16 @@ TEST(PrimaryDeviceTest, Inquiry)
TEST(PrimaryDeviceTest, RequestSense)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// ALLOCATION LENGTH
cmd[4] = 255;
@@ -283,25 +301,27 @@ TEST(PrimaryDeviceTest, RequestSense)
Property(&scsi_exception::get_asc, asc::MEDIUM_NOT_PRESENT))));
device->SetReady(true);
EXPECT_CALL(controller, DataIn);
EXPECT_CALL(*controller, DataIn);
device->Dispatch(scsi_command::eCmdRequestSense);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(PrimaryDeviceTest, SendDiagnostic)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
device->Dispatch(scsi_command::eCmdSendDiagnostic);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
cmd[1] = 0x10;
EXPECT_THAT([&] { device->Dispatch(scsi_command::eCmdSendDiagnostic); }, Throws<scsi_exception>(AllOf(
@@ -328,25 +348,27 @@ TEST(PrimaryDeviceTest, ReportLuns)
const int LUN1 = 1;
const int LUN2 = 4;
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device1 = make_shared<MockPrimaryDevice>(LUN1);
auto device2 = make_shared<MockPrimaryDevice>(LUN2);
const unordered_map<string, string> params;
device1->Init(params);
device2->Init(params);
controller.AddDevice(device1);
EXPECT_TRUE(controller.HasDeviceForLun(LUN1));
controller.AddDevice(device2);
EXPECT_TRUE(controller.HasDeviceForLun(LUN2));
controller->AddDevice(device1);
EXPECT_TRUE(controller->HasDeviceForLun(LUN1));
controller->AddDevice(device2);
EXPECT_TRUE(controller->HasDeviceForLun(LUN2));
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// ALLOCATION LENGTH
cmd[9] = 255;
EXPECT_CALL(controller, DataIn);
EXPECT_CALL(*controller, DataIn);
device1->Dispatch(scsi_command::eCmdReportLuns);
const vector<uint8_t>& buffer = controller.GetBuffer();
const vector<uint8_t>& buffer = controller->GetBuffer();
EXPECT_EQ(0, GetInt16(buffer, 0)) << "Wrong data length";
EXPECT_EQ(16, GetInt16(buffer, 2)) << "Wrong data length";
EXPECT_EQ(0, GetInt16(buffer, 8)) << "Wrong LUN1 number";
@@ -367,12 +389,14 @@ TEST(PrimaryDeviceTest, ReportLuns)
TEST(PrimaryDeviceTest, Dispatch)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
EXPECT_THROW(device->Dispatch(static_cast<scsi_command>(0x1f)), scsi_exception) << "Unknown command";
}
cpp/test/rascsi_executor_test.cpp
+82 -92
View File
@@ -40,12 +40,10 @@ TEST_F(RascsiExecutorTest, ProcessDeviceCmd)
const int LUN = 0;
auto bus = make_shared<MockBus>();
DeviceFactory device_factory;
MockAbstractController controller(bus, ID);
ControllerManager controller_manager(bus);
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, ID);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
auto executor = make_shared<MockRascsiExecutor>(rascsi_response, rascsi_image, device_factory, controller_manager);
auto executor = make_shared<MockRascsiExecutor>(rascsi_image, *controller_manager);
PbDeviceDefinition definition;
PbCommand command;
MockCommandContext context;
@@ -68,19 +66,19 @@ TEST_F(RascsiExecutorTest, ProcessDeviceCmd)
EXPECT_FALSE(executor->ProcessDeviceCmd(context, definition, command, true)) << "Operation for unknown device type must fail";
auto device1 = make_shared<MockPrimaryDevice>(LUN);
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device1));
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device1));
definition.set_type(SCHS);
command.set_operation(INSERT);
EXPECT_FALSE(executor->ProcessDeviceCmd(context, definition, command, true)) << "Operation unsupported by device must fail";
controller_manager.DeleteAllControllers();
controller_manager->DeleteAllControllers();
definition.set_type(SCRM);
auto device2 = make_shared<MockSCSIHD_NEC>(LUN);
device2->SetRemovable(true);
device2->SetProtectable(true);
device2->SetReady(true);
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device2));
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device2));
command.set_operation(ATTACH);
EXPECT_FALSE(executor->ProcessDeviceCmd(context, definition, command, true)) << "ID and LUN already exist";
@@ -113,7 +111,7 @@ TEST_F(RascsiExecutorTest, ProcessDeviceCmd)
command.set_operation(DETACH);
EXPECT_TRUE(executor->ProcessDeviceCmd(context, definition, command, true));
EXPECT_TRUE(executor->ProcessDeviceCmd(context, definition, command, false));
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device2));
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device2));
command.set_operation(CHECK_AUTHENTICATION);
EXPECT_TRUE(executor->ProcessDeviceCmd(context, definition, command, true));
@@ -152,13 +150,11 @@ TEST_F(RascsiExecutorTest, ProcessDeviceCmd)
TEST_F(RascsiExecutorTest, ProcessCmd)
{
shared_ptr<MockBus> bus;
DeviceFactory device_factory;
MockAbstractController controller(bus, 0);
ControllerManager controller_manager(bus);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
auto executor = make_shared<MockRascsiExecutor>(rascsi_response, rascsi_image, device_factory, controller_manager);
auto executor = make_shared<MockRascsiExecutor>(rascsi_image, *controller_manager);
PbCommand command1;
PbCommand command2;
MockCommandContext context;
@@ -219,11 +215,11 @@ TEST_F(RascsiExecutorTest, ProcessCmd)
TEST_F(RascsiExecutorTest, SetLogLevel)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockAbstractController controller(controller_manager, 0);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
EXPECT_TRUE(executor.SetLogLevel("trace"));
EXPECT_TRUE(executor.SetLogLevel("debug"));
@@ -240,17 +236,17 @@ TEST_F(RascsiExecutorTest, Attach)
const int LUN = 0;
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
PbDeviceDefinition definition;
MockCommandContext context;
definition.set_unit(32);
EXPECT_FALSE(executor.Attach(context, definition, false));
auto device = device_factory.CreateDevice(controller_manager, SCHD, LUN, "");
auto device = device_factory.CreateDevice(SCHD, LUN, "");
definition.set_id(ID);
definition.set_unit(LUN);
@@ -262,7 +258,7 @@ TEST_F(RascsiExecutorTest, Attach)
definition.set_type(PbDeviceType::SCHS);
EXPECT_TRUE(executor.Attach(context, definition, false));
controller_manager.DeleteAllControllers();
controller_manager->DeleteAllControllers();
definition.set_type(PbDeviceType::SCHD);
EXPECT_FALSE(executor.Attach(context, definition, false)) << "Drive without sectors not rejected";
@@ -290,7 +286,7 @@ TEST_F(RascsiExecutorTest, Attach)
bool result = executor.Attach(context, definition, false);
remove(filename);
EXPECT_TRUE(result);
controller_manager.DeleteAllControllers();
controller_manager->DeleteAllControllers();
filename = CreateTempFile(513);
SetParam(definition, "file", filename.c_str());
@@ -315,20 +311,20 @@ TEST_F(RascsiExecutorTest, Attach)
remove(filename);
EXPECT_TRUE(result);
controller_manager.DeleteAllControllers();
controller_manager->DeleteAllControllers();
}
TEST_F(RascsiExecutorTest, Insert)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
PbDeviceDefinition definition;
MockCommandContext context;
auto device = device_factory.CreateDevice(controller_manager, SCRM, 0, "test");
auto device = device_factory.CreateDevice(SCRM, 0, "test");
device->SetRemoved(false);
EXPECT_FALSE(executor.Insert(context, definition, device, false)) << "Medium is not removed";
@@ -381,23 +377,23 @@ TEST_F(RascsiExecutorTest, Detach)
const int LUN2 = 1;
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
MockCommandContext context;
auto device1 = device_factory.CreateDevice(controller_manager, SCHS, LUN1, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device1));
auto device2 = device_factory.CreateDevice(controller_manager, SCHS, LUN2, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device2));
auto device1 = device_factory.CreateDevice(SCHS, LUN1, "");
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device1));
auto device2 = device_factory.CreateDevice(SCHS, LUN2, "");
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device2));
auto d1 = controller_manager.GetDeviceByIdAndLun(ID, LUN1);
auto d1 = controller_manager->GetDeviceByIdAndLun(ID, LUN1);
EXPECT_FALSE(executor.Detach(context, d1, false)) << "LUNs > 0 have to be detached first";
auto d2 = controller_manager.GetDeviceByIdAndLun(ID, LUN2);
auto d2 = controller_manager->GetDeviceByIdAndLun(ID, LUN2);
EXPECT_TRUE(executor.Detach(context, d2, false));
EXPECT_TRUE(executor.Detach(context, d1, false));
EXPECT_TRUE(controller_manager.GetAllDevices().empty());
EXPECT_TRUE(controller_manager->GetAllDevices().empty());
EXPECT_FALSE(executor.Detach(context, d1, false));
}
@@ -407,28 +403,27 @@ TEST_F(RascsiExecutorTest, DetachAll)
const int ID = 4;
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
auto device = device_factory.CreateDevice(controller_manager, SCHS, 0, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device));
EXPECT_NE(nullptr, controller_manager.FindController(ID));
EXPECT_FALSE(controller_manager.GetAllDevices().empty());
auto device = device_factory.CreateDevice(SCHS, 0, "");
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device));
EXPECT_NE(nullptr, controller_manager->FindController(ID));
EXPECT_FALSE(controller_manager->GetAllDevices().empty());
executor.DetachAll();
EXPECT_EQ(nullptr, controller_manager.FindController(ID));
EXPECT_TRUE(controller_manager.GetAllDevices().empty());
EXPECT_EQ(nullptr, controller_manager->FindController(ID));
EXPECT_TRUE(controller_manager->GetAllDevices().empty());
}
TEST_F(RascsiExecutorTest, ShutDown)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
MockCommandContext context;
EXPECT_FALSE(executor.ShutDown(context, ""));
@@ -441,10 +436,10 @@ TEST_F(RascsiExecutorTest, ShutDown)
TEST_F(RascsiExecutorTest, SetReservedIds)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
string error = executor.SetReservedIds("xyz");
EXPECT_FALSE(error.empty());
@@ -472,8 +467,8 @@ TEST_F(RascsiExecutorTest, SetReservedIds)
EXPECT_NE(reserved_ids.end(), reserved_ids.find(5));
EXPECT_NE(reserved_ids.end(), reserved_ids.find(7));
auto device = device_factory.CreateDevice(controller_manager, SCHS, 0, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(5, device));
auto device = device_factory.CreateDevice(SCHS, 0, "");
EXPECT_TRUE(controller_manager->AttachToScsiController(5, device));
error = executor.SetReservedIds("5");
EXPECT_FALSE(error.empty());
}
@@ -481,14 +476,14 @@ TEST_F(RascsiExecutorTest, SetReservedIds)
TEST_F(RascsiExecutorTest, ValidateImageFile)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
MockCommandContext context;
string full_path;
auto device = dynamic_pointer_cast<StorageDevice>(device_factory.CreateDevice(controller_manager, SCHD, 0, "test"));
auto device = dynamic_pointer_cast<StorageDevice>(device_factory.CreateDevice(SCHD, 0, "test"));
EXPECT_TRUE(executor.ValidateImageFile(context, *device, "", full_path));
EXPECT_TRUE(full_path.empty());
@@ -499,10 +494,10 @@ TEST_F(RascsiExecutorTest, ValidateImageFile)
TEST_F(RascsiExecutorTest, ValidateLunSetup)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
PbCommand command;
auto device1 = command.add_devices();
@@ -514,8 +509,8 @@ TEST_F(RascsiExecutorTest, ValidateLunSetup)
error = executor.ValidateLunSetup(command);
EXPECT_FALSE(error.empty());
auto device2 = device_factory.CreateDevice(controller_manager, SCHS, 0, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(0, device2));
auto device2 = device_factory.CreateDevice(SCHS, 0, "");
EXPECT_TRUE(controller_manager->AttachToScsiController(0, device2));
error = executor.ValidateLunSetup(command);
EXPECT_TRUE(error.empty());
}
@@ -527,26 +522,25 @@ TEST_F(RascsiExecutorTest, VerifyExistingIdAndLun)
const int LUN2 = 3;
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
MockCommandContext context;
EXPECT_FALSE(executor.VerifyExistingIdAndLun(context, ID, LUN1));
auto device = device_factory.CreateDevice(controller_manager, SCHS, LUN1, "");
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device));
auto device = device_factory.CreateDevice(SCHS, LUN1, "");
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device));
EXPECT_TRUE(executor.VerifyExistingIdAndLun(context, ID, LUN1));
EXPECT_FALSE(executor.VerifyExistingIdAndLun(context, ID, LUN2));
}
TEST_F(RascsiExecutorTest, CreateDevice)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
MockCommandContext context;
EXPECT_EQ(nullptr, executor.CreateDevice(context, UNDEFINED, 0, ""));
@@ -560,11 +554,10 @@ TEST_F(RascsiExecutorTest, CreateDevice)
TEST_F(RascsiExecutorTest, SetSectorSize)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
MockCommandContext context;
unordered_set<uint32_t> sizes;
@@ -580,11 +573,10 @@ TEST_F(RascsiExecutorTest, SetSectorSize)
TEST_F(RascsiExecutorTest, ValidateOperationAgainstDevice)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
MockCommandContext context;
auto device = make_shared<MockPrimaryDevice>(0);
@@ -634,11 +626,10 @@ TEST_F(RascsiExecutorTest, ValidateOperationAgainstDevice)
TEST_F(RascsiExecutorTest, ValidateIdAndLun)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
MockCommandContext context;
EXPECT_FALSE(executor.ValidateIdAndLun(context, -1, 0));
@@ -651,11 +642,10 @@ TEST_F(RascsiExecutorTest, ValidateIdAndLun)
TEST_F(RascsiExecutorTest, SetProductData)
{
DeviceFactory device_factory;
ControllerManager controller_manager(make_shared<MockBus>());
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiImage rascsi_image;
RascsiResponse rascsi_response(device_factory, controller_manager, 32);
RascsiExecutor executor(rascsi_response, rascsi_image, device_factory, controller_manager);
RascsiExecutor executor(rascsi_image, *controller_manager);
MockCommandContext context;
PbDeviceDefinition definition;
cpp/test/rascsi_response_test.cpp
+29 -46
View File
@@ -18,10 +18,7 @@ using namespace rascsi_interface;
TEST(RascsiResponseTest, Operation_Count)
{
auto bus = make_shared<MockBus>();
ControllerManager controller_manager(bus);
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
RascsiResponse response;
PbResult result;
const auto info = response.GetOperationInfo(result, 0);
@@ -31,17 +28,17 @@ TEST(RascsiResponseTest, Operation_Count)
void TestNonDiskDevice(PbDeviceType type, int default_param_count)
{
auto bus = make_shared<MockBus>();
ControllerManager controller_manager(bus);
auto controller_manager = make_shared<ControllerManager>(*bus);
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
RascsiResponse response;
auto d = device_factory.CreateDevice(controller_manager, type, 0, "");
auto d = device_factory.CreateDevice(type, 0, "");
const unordered_map<string, string> params;
d->Init(params);
EXPECT_TRUE(controller_manager.AttachToScsiController(0, d));
EXPECT_TRUE(controller_manager->AttachToScsiController(0, d));
PbServerInfo info;
response.GetDevices(info, "image_folder");
response.GetDevices(controller_manager->GetAllDevices(), info, "image_folder");
EXPECT_EQ(1, info.devices_info().devices().size());
@@ -73,9 +70,7 @@ TEST(RascsiResponseTest, GetDevices)
TEST(RascsiResponseTest, GetImageFile)
{
ControllerManager controller_manager(make_shared<MockBus>());
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
RascsiResponse response;
PbImageFile image_file;
EXPECT_FALSE(response.GetImageFile(image_file, "default_folder", ""));
@@ -88,10 +83,7 @@ TEST(RascsiResponseTest, GetImageFile)
TEST(RascsiResponseTest, GetReservedIds)
{
auto bus = make_shared<MockBus>();
ControllerManager controller_manager(bus);
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
RascsiResponse response;
unordered_set<int> ids;
PbResult result;
@@ -113,20 +105,20 @@ TEST(RascsiResponseTest, GetDevicesInfo)
const int LUN2 = 5;
const int LUN3 = 6;
ControllerManager controller_manager(make_shared<MockBus>());
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiResponse response;
PbCommand command;
PbResult result;
response.GetDevicesInfo(result, command, "");
response.GetDevicesInfo(controller_manager->GetAllDevices(), result, command, "");
EXPECT_TRUE(result.status());
EXPECT_TRUE(result.devices_info().devices().empty());
auto device1 = make_shared<MockHostServices>(LUN1, controller_manager);
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device1));
auto device1 = make_shared<MockHostServices>(LUN1);
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device1));
response.GetDevicesInfo(result, command, "");
response.GetDevicesInfo(controller_manager->GetAllDevices(), result, command, "");
EXPECT_TRUE(result.status());
auto& devices1 = result.devices_info().devices();
EXPECT_EQ(1, devices1.size());
@@ -135,9 +127,9 @@ TEST(RascsiResponseTest, GetDevicesInfo)
EXPECT_EQ(LUN1, devices1[0].unit());
auto device2 = make_shared<MockSCSIHD_NEC>(LUN2);
EXPECT_TRUE(controller_manager.AttachToScsiController(ID, device2));
EXPECT_TRUE(controller_manager->AttachToScsiController(ID, device2));
response.GetDevicesInfo(result, command, "");
response.GetDevicesInfo(controller_manager->GetAllDevices(), result, command, "");
EXPECT_TRUE(result.status());
auto& devices2 = result.devices_info().devices();
EXPECT_EQ(2, devices2.size()) << "Data for all devices must be returned";
@@ -145,7 +137,7 @@ TEST(RascsiResponseTest, GetDevicesInfo)
auto requested_device = command.add_devices();
requested_device->set_id(ID);
requested_device->set_unit(LUN1);
response.GetDevicesInfo(result, command, "");
response.GetDevicesInfo(controller_manager->GetAllDevices(), result, command, "");
EXPECT_TRUE(result.status());
auto& devices3 = result.devices_info().devices();
EXPECT_EQ(1, devices3.size()) << "Only data for the specified ID and LUN must be returned";
@@ -155,15 +147,13 @@ TEST(RascsiResponseTest, GetDevicesInfo)
requested_device->set_id(ID);
requested_device->set_unit(LUN3);
response.GetDevicesInfo(result, command, "");
response.GetDevicesInfo(controller_manager->GetAllDevices(), result, command, "");
EXPECT_FALSE(result.status()) << "Only data for the specified ID and LUN must be returned";
}
TEST(RascsiResponseTest, GetDeviceTypesInfo)
{
ControllerManager controller_manager(make_shared<MockBus>());
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
RascsiResponse response;
PbResult result;
const auto& info = response.GetDeviceTypesInfo(result);
@@ -173,13 +163,14 @@ TEST(RascsiResponseTest, GetDeviceTypesInfo)
TEST(RascsiResponseTest, GetServerInfo)
{
ControllerManager controller_manager(make_shared<MockBus>());
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
RascsiResponse response;
const unordered_set<shared_ptr<PrimaryDevice>> devices;
const unordered_set<int> ids = { 1, 3 };
PbResult result;
const auto& info = response.GetServerInfo(result, ids, "log_level", "default_folder", "", "", 1234);
const auto& info = response.GetServerInfo(devices, result, ids, "log_level", "default_folder", "", "", 1234);
EXPECT_TRUE(result.status());
EXPECT_EQ(rascsi_major_version, info->version_info().major_version());
EXPECT_EQ(rascsi_minor_version, info->version_info().minor_version());
@@ -192,9 +183,7 @@ TEST(RascsiResponseTest, GetServerInfo)
TEST(RascsiResponseTest, GetVersionInfo)
{
ControllerManager controller_manager(make_shared<MockBus>());
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
RascsiResponse response;
PbResult result;
const auto& info = response.GetVersionInfo(result);
@@ -206,9 +195,7 @@ TEST(RascsiResponseTest, GetVersionInfo)
TEST(RascsiResponseTest, GetLogLevelInfo)
{
ControllerManager controller_manager(make_shared<MockBus>());
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
RascsiResponse response;
PbResult result;
const auto& info = response.GetLogLevelInfo(result, "level");
@@ -219,9 +206,7 @@ TEST(RascsiResponseTest, GetLogLevelInfo)
TEST(RascsiResponseTest, GetNetworkInterfacesInfo)
{
ControllerManager controller_manager(make_shared<MockBus>());
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
RascsiResponse response;
PbResult result;
const auto& info = response.GetNetworkInterfacesInfo(result);
@@ -231,9 +216,7 @@ TEST(RascsiResponseTest, GetNetworkInterfacesInfo)
TEST(RascsiResponseTest, GetMappingInfo)
{
ControllerManager controller_manager(make_shared<MockBus>());
DeviceFactory device_factory;
RascsiResponse response(device_factory, controller_manager, 32);
RascsiResponse response;
PbResult result;
const auto& info = response.GetMappingInfo(result);
cpp/test/scsi_controller_test.cpp
+50 -36
View File
@@ -18,7 +18,9 @@ TEST(ScsiControllerTest, GetInitiatorId)
{
const int ID = 2;
MockScsiController controller(make_shared<NiceMock<MockBus>>());
auto bus = make_shared<NiceMock<MockBus>>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockScsiController controller(controller_manager, 0);
controller.Process(ID);
EXPECT_EQ(ID, controller.GetInitiatorId());
@@ -29,7 +31,8 @@ TEST(ScsiControllerTest, GetInitiatorId)
TEST(ScsiControllerTest, Process)
{
auto bus = make_shared<NiceMock<MockBus>>();
MockScsiController controller(bus);
auto controller_manager = make_shared<ControllerManager>(*bus);
MockScsiController controller(controller_manager, 0);
controller.SetPhase(BUS::phase_t::reserved);
ON_CALL(*bus, GetRST).WillByDefault(Return(true));
@@ -55,7 +58,9 @@ TEST(ScsiControllerTest, Process)
TEST(ScsiControllerTest, BusFree)
{
MockScsiController controller(make_shared<NiceMock<MockBus>>());
auto bus = make_shared<NiceMock<MockBus>>();
auto controller_manager = make_shared<ControllerManager>(*bus);
MockScsiController controller(controller_manager, 0);
controller.SetPhase(BUS::phase_t::busfree);
controller.BusFree();
@@ -87,63 +92,65 @@ TEST(ScsiControllerTest, BusFree)
TEST(ScsiControllerTest, Selection)
{
auto bus = make_shared<NiceMock<MockBus>>();
MockScsiController controller(bus, 0);
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockScsiController>(controller_manager, 0);
controller.SetPhase(BUS::phase_t::selection);
controller->SetPhase(BUS::phase_t::selection);
ON_CALL(*bus, GetSEL).WillByDefault(Return(true));
ON_CALL(*bus, GetBSY).WillByDefault(Return(true));
EXPECT_CALL(*bus, GetATN).Times(0);
controller.Selection();
EXPECT_EQ(BUS::phase_t::selection, controller.GetPhase());
controller->Selection();
EXPECT_EQ(BUS::phase_t::selection, controller->GetPhase());
ON_CALL(*bus, GetSEL).WillByDefault(Return(true));
ON_CALL(*bus, GetBSY).WillByDefault(Return(false));
EXPECT_CALL(*bus, GetATN).Times(0);
EXPECT_CALL(controller, Status);
controller.Selection();
EXPECT_EQ(BUS::phase_t::selection, controller.GetPhase());
EXPECT_CALL(*controller, Status);
controller->Selection();
EXPECT_EQ(BUS::phase_t::selection, controller->GetPhase());
ON_CALL(*bus, GetSEL).WillByDefault(Return(false));
ON_CALL(*bus, GetBSY).WillByDefault(Return(false));
EXPECT_CALL(*bus, GetATN).Times(0);
controller.Selection();
EXPECT_EQ(BUS::phase_t::selection, controller.GetPhase());
controller->Selection();
EXPECT_EQ(BUS::phase_t::selection, controller->GetPhase());
ON_CALL(*bus, GetSEL).WillByDefault(Return(false));
ON_CALL(*bus, GetBSY).WillByDefault(Return(true));
ON_CALL(*bus, GetATN).WillByDefault(Return(false));
EXPECT_CALL(*bus, GetATN);
controller.Selection();
EXPECT_EQ(BUS::phase_t::command, controller.GetPhase());
controller->Selection();
EXPECT_EQ(BUS::phase_t::command, controller->GetPhase());
controller.SetPhase(BUS::phase_t::selection);
controller->SetPhase(BUS::phase_t::selection);
ON_CALL(*bus, GetSEL).WillByDefault(Return(false));
ON_CALL(*bus, GetBSY).WillByDefault(Return(true));
ON_CALL(*bus, GetATN).WillByDefault(Return(true));
EXPECT_CALL(*bus, GetATN);
controller.Selection();
EXPECT_EQ(BUS::phase_t::msgout, controller.GetPhase());
controller->Selection();
EXPECT_EQ(BUS::phase_t::msgout, controller->GetPhase());
controller.SetPhase(BUS::phase_t::reserved);
controller->SetPhase(BUS::phase_t::reserved);
ON_CALL(*bus, GetDAT).WillByDefault(Return(0));
controller.Selection();
EXPECT_EQ(BUS::phase_t::reserved, controller.GetPhase());
controller->Selection();
EXPECT_EQ(BUS::phase_t::reserved, controller->GetPhase());
ON_CALL(*bus, GetDAT).WillByDefault(Return(1));
controller.Selection();
EXPECT_EQ(BUS::phase_t::reserved, controller.GetPhase()) << "There is no device that can be selected";
controller->Selection();
EXPECT_EQ(BUS::phase_t::reserved, controller->GetPhase()) << "There is no device that can be selected";
auto device = make_shared<MockPrimaryDevice>(0);
controller.AddDevice(device);
controller->AddDevice(device);
EXPECT_CALL(*bus, SetBSY(true));
controller.Selection();
EXPECT_EQ(BUS::phase_t::selection, controller.GetPhase());
controller->Selection();
EXPECT_EQ(BUS::phase_t::selection, controller->GetPhase());
}
TEST(ScsiControllerTest, Command)
{
auto bus = make_shared<NiceMock<MockBus>>();
MockScsiController controller(bus, 0);
auto controller_manager = make_shared<ControllerManager>(*bus);
MockScsiController controller(controller_manager, 0);
controller.SetPhase(BUS::phase_t::command);
EXPECT_CALL(controller, Status);
@@ -170,7 +177,8 @@ TEST(ScsiControllerTest, Command)
TEST(ScsiControllerTest, MsgIn)
{
auto bus = make_shared<NiceMock<MockBus>>();
MockScsiController controller(bus, 0);
auto controller_manager = make_shared<ControllerManager>(*bus);
MockScsiController controller(controller_manager, 0);
controller.SetPhase(BUS::phase_t::reserved);
EXPECT_CALL(*bus, SetMSG(true));
@@ -185,7 +193,8 @@ TEST(ScsiControllerTest, MsgIn)
TEST(ScsiControllerTest, MsgOut)
{
auto bus = make_shared<NiceMock<MockBus>>();
MockScsiController controller(bus, 0);
auto controller_manager = make_shared<ControllerManager>(*bus);
MockScsiController controller(controller_manager, 0);
controller.SetPhase(BUS::phase_t::reserved);
EXPECT_CALL(*bus, SetMSG(true));
@@ -200,7 +209,8 @@ TEST(ScsiControllerTest, MsgOut)
TEST(ScsiControllerTest, DataIn)
{
auto bus = make_shared<NiceMock<MockBus>>();
MockScsiController controller(bus, 0);
auto controller_manager = make_shared<ControllerManager>(*bus);
MockScsiController controller(controller_manager, 0);
controller.SetPhase(BUS::phase_t::reserved);
controller.SetLength(0);
@@ -220,7 +230,8 @@ TEST(ScsiControllerTest, DataIn)
TEST(ScsiControllerTest, DataOut)
{
auto bus = make_shared<NiceMock<MockBus>>();
MockScsiController controller(bus, 0);
auto controller_manager = make_shared<ControllerManager>(*bus);
MockScsiController controller(controller_manager, 0);
controller.SetPhase(BUS::phase_t::reserved);
controller.SetLength(0);
@@ -240,7 +251,8 @@ TEST(ScsiControllerTest, DataOut)
TEST(ScsiControllerTest, Error)
{
auto bus = make_shared<NiceMock<MockBus>>();
MockScsiController controller(bus, 0);
auto controller_manager = make_shared<ControllerManager>(*bus);
MockScsiController controller(controller_manager, 0);
ON_CALL(*bus, GetRST).WillByDefault(Return(true));
controller.SetPhase(BUS::phase_t::reserved);
@@ -282,21 +294,23 @@ TEST(ScsiControllerTest, Error)
TEST(ScsiControllerTest, RequestSense)
{
MockScsiController controller(make_shared<NiceMock<MockBus>>());
auto bus = make_shared<NiceMock<MockBus>>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockScsiController>(controller_manager, 0);
auto device = make_shared<MockPrimaryDevice>(0);
const unordered_map<string, string> params;
device->Init(params);
controller.AddDevice(device);
controller->AddDevice(device);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// ALLOCATION LENGTH
cmd[4] = 255;
// Non-existing LUN
cmd[1] = 0x20;
device->SetReady(true);
EXPECT_CALL(controller, Status);
EXPECT_CALL(*controller, Status);
device->Dispatch(scsi_command::eCmdRequestSense);
EXPECT_EQ(status::GOOD, controller.GetStatus()) << "Illegal CHECK CONDITION for non-existing LUN";
EXPECT_EQ(status::GOOD, controller->GetStatus()) << "Wrong CHECK CONDITION for non-existing LUN";
}
cpp/test/scsi_daynaport_test.cpp
+51 -33
View File
@@ -18,21 +18,25 @@ TEST(ScsiDaynaportTest, Inquiry)
TEST(ScsiDaynaportTest, TestUnitReady)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto daynaport = CreateDevice(SCDP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto daynaport = CreateDevice(SCDP, *controller);
EXPECT_CALL(controller, Status());
EXPECT_CALL(*controller, Status());
daynaport->Dispatch(scsi_command::eCmdTestUnitReady);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(ScsiDaynaportTest, Read)
{
vector<uint8_t> buf(0);
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto daynaport = dynamic_pointer_cast<SCSIDaynaPort>(CreateDevice(SCDP, controller));
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto daynaport = dynamic_pointer_cast<SCSIDaynaPort>(CreateDevice(SCDP, *controller));
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// ALLOCATION LENGTH
cmd[4] = 1;
@@ -42,10 +46,12 @@ TEST(ScsiDaynaportTest, Read)
TEST(ScsiDaynaportTest, WriteBytes)
{
vector<uint8_t> buf(0);
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto daynaport = dynamic_pointer_cast<SCSIDaynaPort>(CreateDevice(SCDP, controller));
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto daynaport = dynamic_pointer_cast<SCSIDaynaPort>(CreateDevice(SCDP, *controller));
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// Unknown data format
cmd[5] = 0xff;
@@ -54,10 +60,12 @@ TEST(ScsiDaynaportTest, WriteBytes)
TEST(ScsiDaynaportTest, Read6)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto daynaport = CreateDevice(SCDP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto daynaport = CreateDevice(SCDP, *controller);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
cmd[5] = 0xff;
EXPECT_THAT([&] { daynaport->Dispatch(scsi_command::eCmdRead6); }, Throws<scsi_exception>(AllOf(
@@ -68,10 +76,12 @@ TEST(ScsiDaynaportTest, Read6)
TEST(ScsiDaynaportTest, Write6)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto daynaport = CreateDevice(SCDP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto daynaport = CreateDevice(SCDP, *controller);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
cmd[5] = 0x00;
EXPECT_THAT([&] { daynaport->Dispatch(scsi_command::eCmdWrite6); }, Throws<scsi_exception>(AllOf(
@@ -98,23 +108,27 @@ TEST(ScsiDaynaportTest, Write6)
TEST(ScsiDaynaportTest, TestRetrieveStats)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto daynaport = CreateDevice(SCDP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto daynaport = CreateDevice(SCDP, *controller);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// ALLOCATION LENGTH
cmd[4] = 255;
EXPECT_CALL(controller, DataIn());
EXPECT_CALL(*controller, DataIn());
daynaport->Dispatch(scsi_command::eCmdRetrieveStats);
}
TEST(ScsiDaynaportTest, SetInterfaceMode)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto daynaport = CreateDevice(SCDP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto daynaport = CreateDevice(SCDP, *controller);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// Unknown interface command
EXPECT_THAT([&] { daynaport->Dispatch(scsi_command::eCmdSetIfaceMode); }, Throws<scsi_exception>(AllOf(
@@ -123,12 +137,12 @@ TEST(ScsiDaynaportTest, SetInterfaceMode)
// Not implemented, do nothing
cmd[5] = SCSIDaynaPort::CMD_SCSILINK_SETMODE;
EXPECT_CALL(controller, Status());
EXPECT_CALL(*controller, Status());
daynaport->Dispatch(scsi_command::eCmdSetIfaceMode);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
cmd[5] = SCSIDaynaPort::CMD_SCSILINK_SETMAC;
EXPECT_CALL(controller, DataOut());
EXPECT_CALL(*controller, DataOut());
daynaport->Dispatch(scsi_command::eCmdSetIfaceMode);
// Not implemented
@@ -152,10 +166,12 @@ TEST(ScsiDaynaportTest, SetInterfaceMode)
TEST(ScsiDaynaportTest, SetMcastAddr)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto daynaport = CreateDevice(SCDP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto daynaport = CreateDevice(SCDP, *controller);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_THAT([&] { daynaport->Dispatch(scsi_command::eCmdSetMcastAddr); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
@@ -163,16 +179,18 @@ TEST(ScsiDaynaportTest, SetMcastAddr)
<< "Length of 0 is not supported";
cmd[4] = 1;
EXPECT_CALL(controller, DataOut());
EXPECT_CALL(*controller, DataOut());
daynaport->Dispatch(scsi_command::eCmdSetMcastAddr);
}
TEST(ScsiDaynaportTest, EnableInterface)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto daynaport = CreateDevice(SCDP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
auto daynaport = CreateDevice(SCDP, *controller);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// Enable
EXPECT_THAT([&] { daynaport->Dispatch(scsi_command::eCmdEnableInterface); }, Throws<scsi_exception>(AllOf(
cpp/test/scsi_printer_test.cpp
+48 -30
View File
@@ -16,8 +16,10 @@ using namespace std;
TEST(ScsiPrinterTest, Init)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto printer = CreateDevice(SCLP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto printer = CreateDevice(SCLP, *controller);
unordered_map<string, string> params;
EXPECT_TRUE(printer->Init(params));
@@ -31,12 +33,14 @@ TEST(ScsiPrinterTest, Init)
TEST(ScsiPrinterTest, TestUnitReady)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto printer = CreateDevice(SCLP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto printer = CreateDevice(SCLP, *controller);
EXPECT_CALL(controller, Status());
EXPECT_CALL(*controller, Status());
printer->Dispatch(scsi_command::eCmdTestUnitReady);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(ScsiPrinterTest, Inquiry)
@@ -46,42 +50,50 @@ TEST(ScsiPrinterTest, Inquiry)
TEST(ScsiPrinterTest, ReserveUnit)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto printer = CreateDevice(SCLP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto printer = CreateDevice(SCLP, *controller);
EXPECT_CALL(controller, Status()).Times(1);
EXPECT_CALL(*controller, Status()).Times(1);
printer->Dispatch(scsi_command::eCmdReserve6);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(ScsiPrinterTest, ReleaseUnit)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto printer = CreateDevice(SCLP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto printer = CreateDevice(SCLP, *controller);
EXPECT_CALL(controller, Status()).Times(1);
EXPECT_CALL(*controller, Status()).Times(1);
printer->Dispatch(scsi_command::eCmdRelease6);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(ScsiPrinterTest, SendDiagnostic)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto printer = CreateDevice(SCLP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto printer = CreateDevice(SCLP, *controller);
EXPECT_CALL(controller, Status()).Times(1);
EXPECT_CALL(*controller, Status()).Times(1);
printer->Dispatch(scsi_command::eCmdSendDiagnostic);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(ScsiPrinterTest, Print)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto printer = CreateDevice(SCLP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto printer = CreateDevice(SCLP, *controller);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
EXPECT_CALL(controller, DataOut());
EXPECT_CALL(*controller, DataOut());
printer->Dispatch(scsi_command::eCmdPrint);
cmd[3] = 0xff;
@@ -94,18 +106,22 @@ TEST(ScsiPrinterTest, Print)
TEST(ScsiPrinterTest, StopPrint)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto printer = CreateDevice(SCLP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto printer = CreateDevice(SCLP, *controller);
EXPECT_CALL(controller, Status());
EXPECT_CALL(*controller, Status());
printer->Dispatch(scsi_command::eCmdStopPrint);
EXPECT_EQ(status::GOOD, controller.GetStatus());
EXPECT_EQ(status::GOOD, controller->GetStatus());
}
TEST(ScsiPrinterTest, SynchronizeBuffer)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto printer = CreateDevice(SCLP, controller);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto printer = CreateDevice(SCLP, *controller);
EXPECT_THAT([&] { printer->Dispatch(scsi_command::eCmdSynchronizeBuffer); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ABORTED_COMMAND),
@@ -117,8 +133,10 @@ TEST(ScsiPrinterTest, SynchronizeBuffer)
TEST(ScsiPrinterTest, WriteByteSequence)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto printer = dynamic_pointer_cast<SCSIPrinter>(CreateDevice(SCLP, controller));
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto printer = CreateDevice(SCLP, *controller);
vector<uint8_t> buf(1);
EXPECT_TRUE(printer->WriteByteSequence(buf, buf.size()));
cpp/test/scsicd_test.cpp
+4 -2
View File
@@ -112,13 +112,15 @@ TEST(ScsiCdTest, Open)
TEST(ScsiCdTest, ReadToc)
{
MockAbstractController controller(make_shared<MockBus>(), 0);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<MockAbstractController>(controller_manager, 0);
const unordered_set<uint32_t> sector_sizes;
auto cd = make_shared<MockSCSICD>(0, sector_sizes);
const unordered_map<string, string> params;
cd->Init(params);
controller.AddDevice(cd);
controller->AddDevice(cd);
EXPECT_THAT([&] { cd->Dispatch(scsi_command::eCmdReadToc); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::NOT_READY),
cpp/test/test_shared.cpp
+8 -7
View File
@@ -23,9 +23,8 @@ using namespace filesystem;
shared_ptr<PrimaryDevice> CreateDevice(PbDeviceType type, MockAbstractController& controller, const string& extension)
{
DeviceFactory device_factory;
auto controller_manager = make_shared<ControllerManager>(controller.GetBus());
auto device = device_factory.CreateDevice(*controller_manager, type, 0, extension);
auto device = device_factory.CreateDevice(type, 0, extension);
unordered_map<string, string> params;
device->Init(params);
@@ -37,16 +36,18 @@ shared_ptr<PrimaryDevice> CreateDevice(PbDeviceType type, MockAbstractController
void TestInquiry(PbDeviceType type, device_type t, scsi_level l, const string& ident, int additional_length,
bool removable, const string& extension)
{
NiceMock<MockAbstractController> controller(make_shared<MockBus>(), 0);
auto device = CreateDevice(type, controller, extension);
auto bus = make_shared<MockBus>();
auto controller_manager = make_shared<ControllerManager>(*bus);
auto controller = make_shared<NiceMock<MockAbstractController>>(controller_manager, 0);
auto device = CreateDevice(type, *controller, extension);
auto& cmd = controller.GetCmd();
auto& cmd = controller->GetCmd();
// ALLOCATION LENGTH
cmd[4] = 255;
EXPECT_CALL(controller, DataIn());
EXPECT_CALL(*controller, DataIn());
device->Dispatch(scsi_command::eCmdInquiry);
const vector<uint8_t>& buffer = controller.GetBuffer();
const vector<uint8_t>& buffer = controller->GetBuffer();
EXPECT_EQ(t, static_cast<device_type>(buffer[0]));
EXPECT_EQ(removable ? 0x80: 0x00, buffer[1]);
EXPECT_EQ(l, static_cast<scsi_level>(buffer[2]));