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

Issues 1179 and 1182 (#1232)

Browse Source 
* Update logging

* Remove duplicate code

* Update unit tests

* Clean up includes

* Merge ProtobufSerializer into protobuf_util namespace

* Precompile regex

* Add const

* Add Split() convenience method, update log level/ID parsing

* Move log.h to legacy folder

* Elimininate gotos

* Fixes for gcc 13

* Update compiler flags

* Update default folder handling

* Use references instead of pointers

* Move code for better encapsulation

* Move code

* Remove unused method argument

* Move device logger

* Remove redundant to_string

* Rename for consistency

* Update handling of protobuf pointers

* Simplify protobuf usage

* Memory handling update

* Add hasher
This commit is contained in:
Uwe Seimet
2023-10-15 08:38:15 +02:00
committed by GitHub
parent c1f6f3ffea
commit 41bdcd4aed
161 changed files with 4767 additions and 5150 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cpp/test/scsi_printer_test.cpp
+32 -59
View File
@@ -3,27 +3,22 @@
// SCSI Target Emulator PiSCSI
// for Raspberry Pi
//
// Copyright (C) 2022 Uwe Seimet
// Copyright (C) 2022-2023 Uwe Seimet
//
//---------------------------------------------------------------------------
#include "mocks.h"
#include "shared/piscsi_exceptions.h"
#include "controllers/controller_manager.h"
#include "devices/scsi_printer.h"
using namespace std;
TEST(ScsiPrinterTest, Init)
{
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));
auto [controller, printer] = CreateDevice(SCLP);
EXPECT_TRUE(printer->Init({}));
param_map params;
params["cmd"] = "missing_filename_specifier";
EXPECT_FALSE(printer->Init(params));
@@ -33,99 +28,80 @@ TEST(ScsiPrinterTest, Init)
TEST(ScsiPrinterTest, TestUnitReady)
{
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 [controller, printer] = CreateDevice(SCLP);
EXPECT_CALL(*controller, Status());
printer->Dispatch(scsi_command::eCmdTestUnitReady);
EXPECT_EQ(status::GOOD, controller->GetStatus());
EXPECT_EQ(status::good, controller->GetStatus());
}
TEST(ScsiPrinterTest, Inquiry)
{
TestInquiry(SCLP, device_type::PRINTER, scsi_level::SCSI_2, "PiSCSI SCSI PRINTER ", 0x1f, false);
TestInquiry::Inquiry(SCLP, device_type::printer, scsi_level::scsi_2, "PiSCSI SCSI PRINTER ", 0x1f, false);
}
TEST(ScsiPrinterTest, ReserveUnit)
{
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 [controller, printer] = CreateDevice(SCLP);
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)
{
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 [controller, printer] = CreateDevice(SCLP);
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)
{
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 [controller, printer] = CreateDevice(SCLP);
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)
{
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 [controller, printer] = CreateDevice(SCLP);
// Required by the bullseye clang++ compiler
auto p = printer;
EXPECT_CALL(*controller, DataOut());
printer->Dispatch(scsi_command::eCmdPrint);
cmd[3] = 0xff;
cmd[4] = 0xff;
EXPECT_THAT([&] { printer->Dispatch(scsi_command::eCmdPrint); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ILLEGAL_REQUEST),
Property(&scsi_exception::get_asc, asc::INVALID_FIELD_IN_CDB))))
controller->SetCmdByte(3, 0xff);
controller->SetCmdByte(4, 0xff);
EXPECT_THAT([&] { p->Dispatch(scsi_command::eCmdPrint); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::illegal_request),
Property(&scsi_exception::get_asc, asc::invalid_field_in_cdb))))
<< "Buffer overflow was not reported";
}
TEST(ScsiPrinterTest, StopPrint)
{
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 [controller, printer] = CreateDevice(SCLP);
EXPECT_CALL(*controller, Status());
printer->Dispatch(scsi_command::eCmdStopPrint);
EXPECT_EQ(status::GOOD, controller->GetStatus());
EXPECT_EQ(status::good, controller->GetStatus());
}
TEST(ScsiPrinterTest, SynchronizeBuffer)
{
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 [controller, printer] = CreateDevice(SCLP);
// Required by the bullseye clang++ compiler
auto p = printer;
EXPECT_THAT([&] { printer->Dispatch(scsi_command::eCmdSynchronizeBuffer); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::ABORTED_COMMAND),
Property(&scsi_exception::get_asc, asc::NO_ADDITIONAL_SENSE_INFORMATION))))
EXPECT_THAT([&] { p->Dispatch(scsi_command::eCmdSynchronizeBuffer); }, Throws<scsi_exception>(AllOf(
Property(&scsi_exception::get_sense_key, sense_key::aborted_command),
Property(&scsi_exception::get_asc, asc::no_additional_sense_information))))
<< "Nothing to print";
// Further testing would use the printing system
@@ -133,11 +109,8 @@ TEST(ScsiPrinterTest, SynchronizeBuffer)
TEST(ScsiPrinterTest, WriteByteSequence)
{
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 [controller, printer] = CreateDevice(SCLP);
vector<uint8_t> buf(1);
EXPECT_TRUE(printer->WriteByteSequence(buf, buf.size()));
const vector<uint8_t> buf(1);
EXPECT_TRUE(printer->WriteByteSequence(buf));
}