From 7bae9290bb4bdc456ca88747e57a781a60578c77 Mon Sep 17 00:00:00 2001 From: baozewei Date: Wed, 13 Nov 2024 19:00:48 +0800 Subject: [PATCH 01/19] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B=20Signed-off-by:baozewei@huawei.com?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: baozewei --- .../print_http_request_process_other_test.cpp | 704 ++++++++++++++++++ .../print_http_server_manager_other_test.cpp | 147 ++++ .../print_ipp_over_usb_manager_other_test.cpp | 98 +++ .../others/print_usb_manager_other_test.cpp | 428 +++++++++++ .../others/print_user_data_other_test.cpp | 662 ++++++++++++++++ 5 files changed, 2039 insertions(+) create mode 100644 test/unittest/others/print_http_request_process_other_test.cpp create mode 100644 test/unittest/others/print_http_server_manager_other_test.cpp create mode 100644 test/unittest/others/print_ipp_over_usb_manager_other_test.cpp create mode 100644 test/unittest/others/print_usb_manager_other_test.cpp create mode 100644 test/unittest/others/print_user_data_other_test.cpp diff --git a/test/unittest/others/print_http_request_process_other_test.cpp b/test/unittest/others/print_http_request_process_other_test.cpp new file mode 100644 index 00000000..a822b91a --- /dev/null +++ b/test/unittest/others/print_http_request_process_other_test.cpp @@ -0,0 +1,704 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "print_http_request_process.h" + +using namespace testing; +using namespace testing::ext; +namespace OHOS::Print { +class PrintHttpRequestProcessTest : public testing::Test { +public: + PrintHttpRequestProcess *printHttpRequestProcess; + void SetUp() override + { + printHttpRequestProcess = new PrintHttpRequestProcess(); + } + void TearDown() override + { + delete printHttpRequestProcess; + } +}; + +HWTEST_F(PrintHttpRequestProcessTest, PrintOperation_ShouldReturnHTTP_OPERATION_GET_ATTR_WhenOperationIsGet_Printer_Attributes, Level0) +{ + // Arrange + Operation operation = Operation::Get_Printer_Attributes; + // Act + std::string result = printHttpRequestProcess->PrintOperation(operation); + + // Assert + EXPECT_EQ(result, HTTP_OPERATION_GET_ATTR); +} + +HWTEST_F(PrintHttpRequestProcessTest, PrintOperation_ShouldReturnHTTP_OPERATION_SEND_DOC_WhenOperationIsSend_Document, Level0) +{ + // Arrange + Operation operation = Operation::Send_Document; + // Act + std::string result = printHttpRequestProcess->PrintOperation(operation); + + // Assert + EXPECT_EQ(result, HTTP_OPERATION_SEND_DOC); +} + +HWTEST_F(PrintHttpRequestProcessTest, PrintOperation_ShouldReturnHTTP_OPERATION_COMMON_WhenOperationIsOther, Level0) +{ + // Arrange + Operation operation = static_cast(3); // Assuming there are only 3 operations + // Act + std::string result = printHttpRequestProcess->PrintOperation(operation); + + // Assert + EXPECT_EQ(result, HTTP_OPERATION_COMMON); +} + +// 测试用例1: 当readTempBuffer为空时，应返回0 +HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnZero_WhenBufferIsEmpty, Level0) +{ + std::vector readTempBuffer; + PrintHttpRequestProcess process; + EXPECT_EQ(process.NeedOffset(readTempBuffer), 0); +} + +// 测试用例2: 当readTempBuffer中包含非0值时，应返回非0 +HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferContainsNonZeroValues, Level0) +{ + std::vector readTempBuffer = {1, 2, 3, 4, 5}; + PrintHttpRequestProcess process; + EXPECT_NE(process.NeedOffset(readTempBuffer), 0); +} + +// 测试用例3: 当readTempBuffer中全部为0时，应返回0 +HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnZero_WhenBufferContainsOnlyZeroes, Level0) +{ + std::vector readTempBuffer = {0, 0, 0, 0, 0}; + PrintHttpRequestProcess process; + EXPECT_EQ(process.NeedOffset(readTempBuffer), 0); +} + +// 测试用例4: 当readTempBuffer包含多个非0值时，应返回非0 +HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferContainsMultipleNonZeroValues, Level0) +{ + std::vector readTempBuffer = {1, 2, 3, 0, 0}; + PrintHttpRequestProcess process; + EXPECT_NE(process.NeedOffset(readTempBuffer), 0); +} + +// 测试用例5: 当readTempBuffer包含负值时，应返回非0 +HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferContainsNegativeValues, Level0) +{ + std::vector readTempBuffer = {-1, -2, -3, -4, -5}; + PrintHttpRequestProcess process; + EXPECT_NE(process.NeedOffset(readTempBuffer), 0); +} + +// 测试用例6: 当readTempBuffer包含混合正负值时，应返回非0 +HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferContainsMixedPositiveAndNegativeValues, Level0) +{ + std::vector readTempBuffer = {1, -2, 3, -4, 5}; + PrintHttpRequestProcess process; + EXPECT_NE(process.NeedOffset(readTempBuffer), 0); +} + +TEST_F(PrintHttpRequestProcessTest, GetContentLength_ShouldReturnZero_WhenBufferIsEmpty) +{ + PrintHttpRequestProcess process; + std::vector buffer; + size_t index = 0; + EXPECT_EQ(process.GetContentLength(buffer, index), 0); +} +TEST_F(PrintHttpRequestProcessTest, GetContentLength_ShouldReturnCorrectLength_WhenBufferIsNotEmpty) +{ + PrintHttpRequestProcess process; + std::vector buffer = {1, 2, 3, 4, 5}; + size_t index = 2; + EXPECT_EQ(process.GetContentLength(buffer, index), 3); +} +TEST_F(PrintHttpRequestProcessTest, GetContentLength_ShouldReturnZero_WhenIndexIsOutOfRange) +{ + PrintHttpRequestProcess process; + std::vector buffer = {1, 2, 3, 4, 5}; + size_t index = 10; + EXPECT_EQ(process.GetContentLength(buffer, index), 0); +} +TEST_F(PrintHttpRequestProcessTest, GetContentLength_ShouldReturnCorrectLength_WhenBufferIsNotEmptyAndIndexIsOutOfRange) +{ + PrintHttpRequestProcess process; + std::vector buffer = {1, 2, 3, 4, 5}; + size_t index = 10; + EXPECT_EQ(process.GetContentLength(buffer, index), 0); +} + +TEST_F(PrintHttpRequestProcessTest, DumpRespIdCode_ShouldReturnNullptr_WhenBufferIsEmpty) +{ + std::vector readTempBuffer; + PrintHttpRequestProcess printHttpRequestProcess; + printHttpRequestProcess.DumpRespIdCode(readTempBuffer); + // 断言预期结果 + EXPECT_EQ(nullptr, printHttpRequestProcess.DumpRespIdCode(readTempBuffer)); +} +TEST_F(PrintHttpRequestProcessTest, DumpRespIdCode_ShouldReturnNotNullptr_WhenBufferIsNotEmpty) +{ + std::vector readTempBuffer = {1, 2, 3, 4}; + PrintHttpRequestProcess printHttpRequestProcess; + printHttpRequestProcess.DumpRespIdCode(readTempBuffer); + // 断言预期结果 + EXPECT_NE(nullptr, printHttpRequestProcess.DumpRespIdCode(readTempBuffer)); +} +TEST_F(PrintHttpRequestProcessTest, DumpRespIdCode_ShouldReturnNotNullptr_WhenBufferContainsSpecialCharacters) +{ + std::vector readTempBuffer = {0x00, 0xFF, 0x01, 0xFE}; + PrintHttpRequestProcess printHttpRequestProcess; + printHttpRequestProcess.DumpRespIdCode(readTempBuffer); + // 断言预期结果 + EXPECT_NE(nullptr, printHttpRequestProcess.DumpRespIdCode(readTempBuffer)); +} + +TEST_F(PrintHttpRequestProcessTest, CheckLineEnd_ShouldReturnFalse_WhenBufferIsEmpty) +{ + PrintHttpRequestProcess process; + std::vector buffer; + size_t index = 0; + EXPECT_EQ(process.CheckLineEnd(buffer, index), false); +} +TEST_F(PrintHttpRequestProcessTest, CheckLineEnd_ShouldReturnFalse_WhenIndexIsGreaterThanBufferSize) +{ + PrintHttpRequestProcess process; + std::vector buffer = {0x0D, 0x0A, 0x0D, 0x0A}; // "\r\n\r\n" + size_t index = 5; + EXPECT_EQ(process.CheckLineEnd(buffer, index), false); +} +TEST_F(PrintHttpRequestProcessTest, CheckLineEnd_ShouldReturnTrue_WhenIndexIsAtLineEnd) +{ + PrintHttpRequestProcess process; + std::vector buffer = {0x0D, 0x0A, 0x0D, 0x0A, 0x0D, 0x0A}; // "\r\n\r\n" + size_t index = 4; + EXPECT_EQ(process.CheckLineEnd(buffer, index), true); +} +TEST_F(PrintHttpRequestProcessTest, CheckLineEnd_ShouldReturnTrue_WhenIndexIsAtBufferEnd) +{ + PrintHttpRequestProcess process; + std::vector buffer = {0x0D, 0x0A, 0x0D, 0x0A}; // "\r\n\r\n" + size_t index = 4; + EXPECT_EQ(process.CheckLineEnd(buffer, index), true); +} +TEST_F(PrintHttpRequestProcessTest, CheckLineEnd_ShouldReturnFalse_WhenIndexIsAtMiddleOfBuffer) +{ + PrintHttpRequestProcess process; + std::vector buffer = {0x0D, 0x0A, 0x0D, 0x0A, 0x0D, 0x0A, 0x0D, 0x0A}; // "\r\n\r\n" + size_t index = 2; + EXPECT_EQ(process.CheckLineEnd(buffer, index), false); +} + +TEST_F(PrintHttpRequestProcessTest, CalculateRequestId_ShouldReturnZero_WhenSurfaceProducerIsNull) +{ + size_t requestId = printHttpRequestProcess->CalculateRequestId(nullptr); + EXPECT_EQ(requestId, 0); +} + +TEST_F(PrintHttpRequestProcessTest, CalculateRequestId_ShouldReturnNonZero_WhenSurfaceProducerIsNotNull) +{ + // Mock the IConsumerSurface and IBufferProducer interfaces + Mock mockSurface; + Mock mockProducer; + // Set up the expectations + EXPECT_CALL(mockSurface, GetProducer()).WillOnce(Return(&mockProducer)); + // Call the method under test + size_t requestId = printHttpRequestProcess->CalculateRequestId(&mockSurface); + // Assert the result + EXPECT_NE(requestId, 0); +} + +TEST_F(PrintHttpRequestProcessTest, CalculateRequestId_ShouldReturnNonZero_WhenSurfaceProducerIsNotNullAndCreatePhotoOutputReturnsSuccess) +{ + // Mock the IConsumerSurface and IBufferProducer interfaces + Mock mockSurface; + Mock mockProducer; + // Set up the expectations + EXPECT_CALL(mockSurface, GetProducer()).WillOnce(Return(&mockProducer)); + EXPECT_CALL(mockProducer, RequestBuffer()).WillOnce(Return(true)); + // Call the method under test + size_t requestId = printHttpRequestProcess->CalculateRequestId(&mockSurface); + // Assert the result + EXPECT_NE(requestId, 0); +} + +TEST_F(PrintHttpRequestProcessTest, CalculateRequestId_ShouldReturnZero_WhenSurfaceProducerIsNotNullAndCreatePhotoOutputReturnsFailure) +{ + // Mock the IConsumerSurface and IBufferProducer interfaces + Mock mockSurface; + Mock mockProducer; + // Set up the expectations + EXPECT_CALL(mockSurface, GetProducer()).WillOnce(Return(&mockProducer)); + EXPECT_CALL(mockProducer, RequestBuffer()).WillOnce(Return(false)); + // Call the method under test + size_t requestId = printHttpRequestProcess->CalculateRequestId(&mockSurface); + // Assert the result + EXPECT_EQ(requestId, 0); +} + +HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsREADAndIndexIsZero, Level0) +{ + PrintHttpRequestProcess process; + size_t index = 0; + Operation operation = Operation::READ; + EXPECT_EQ(process.CalculateFileDataBeginIndex(index, operation), 1); +} + +// 测试用例2：当operation为WRITE时，index为0 +HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsWRITEAndIndexIsZero, Level0) +{ + PrintHttpRequestProcess process; + size_t index = 0; + Operation operation = Operation::WRITE; + EXPECT_EQ(process.CalculateFileDataBeginIndex(index, operation), 1); +} + +// 测试用例3：当operation为READ时，index为非零值 +HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsREADAndIndexIsNonZero, Level0) +{ + PrintHttpRequestProcess process; + size_t index = 5; + Operation operation = Operation::READ; + EXPECT_EQ(process.CalculateFileDataBeginIndex(index, operation), 6); +} + +// 测试用例4：当operation为WRITE时，index为非零值 +HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsWRITEAndIndexIsNonZero, Level0) +{ + PrintHttpRequestProcess process; + size_t index = 5; + Operation operation = Operation::WRITE; + EXPECT_EQ(process.CalculateFileDataBeginIndex(index, operation), 6); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessDataFromDevice_ShouldReturnFalse_WhenOperationIsNull) +{ + PrintHttpRequestProcess process; + EXPECT_FALSE(process.ProcessDataFromDevice(nullptr)); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessDataFromDevice_ShouldReturnTrue_WhenOperationIsNotNull) +{ + PrintHttpRequestProcess process; + Operation operation; // Assuming Operation is a valid class with necessary methods + EXPECT_TRUE(process.ProcessDataFromDevice(&operation)); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessDataFromDevice_ShouldReturnFalse_WhenOperationHasInvalidData) +{ + PrintHttpRequestProcess process; + Operation operation; + operation.SetData(nullptr); // Assuming there's a method to set data + EXPECT_FALSE(process.ProcessDataFromDevice(&operation)); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessDataFromDevice_ShouldReturnTrue_WhenOperationHasValidData) +{ + PrintHttpRequestProcess process; + Operation operation; + operation.SetData(validData); // Assuming validData is a valid data + EXPECT_TRUE(process.ProcessDataFromDevice(&operation)); +} + +TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNullptr_WhenSurfaceProducerIsNull) +{ + PrintHttpRequestProcess printHttpRequestProcess; + Operation operation; + std::vector tmVector; + EXPECT_EQ(printHttpRequestProcess.GetAttrAgain(operation, tmVector), nullptr); +} +TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNonNullptr_WhenSurfaceProducerIsNotNull) +{ + PrintHttpRequestProcess printHttpRequestProcess; + Operation operation; + std::vector tmVector; + // Assuming there is a way to set up a non-null surfaceProducer + // printHttpRequestProcess.surfaceProducer = ... + EXPECT_NE(printHttpRequestProcess.GetAttrAgain(operation, tmVector), nullptr); +} +TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNullptr_WhenOperationIsInvalid) +{ + PrintHttpRequestProcess printHttpRequestProcess; + Operation operation; + std::vector tmVector; + // Assuming there is a way to set up an invalid operation + // operation.isValid = false; + EXPECT_EQ(printHttpRequestProcess.GetAttrAgain(operation, tmVector), nullptr); +} +TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNonNullptr_WhenOperationIsValid) +{ + PrintHttpRequestProcess printHttpRequestProcess; + Operation operation; + std::vector tmVector; + // Assuming there is a way to set up a valid operation + // operation.isValid = true; + EXPECT_NE(printHttpRequestProcess.GetAttrAgain(operation, tmVector), nullptr); +} +TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNullptr_WhenTmVectorIsEmpty) +{ + PrintHttpRequestProcess printHttpRequestProcess; + Operation operation; + std::vector tmVector; + EXPECT_EQ(printHttpRequestProcess.GetAttrAgain(operation, tmVector), nullptr); +} +TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNonNullptr_WhenTmVectorIsNotEmpty) +{ + PrintHttpRequestProcess printHttpRequestProcess; + Operation operation; + std::vector tmVector = {1, 2, 3}; + EXPECT_NE(printHttpRequestProcess.GetAttrAgain(operation, tmVector), nullptr); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessHttpResponse_ShouldReturnNullptr_WhenSurfaceProducerIsNull) +{ + PrintHttpRequestProcess printHttpRequestProcess; + httplib::Response responseData; + size_t requestId = 1; + printHttpRequestProcess.ProcessHttpResponse(responseData, requestId); + // 由于ProcessHttpResponse方法内部没有返回值，我们无法直接断言其返回值， + // 但可以通过观察其对responseData和requestId的处理来断言其行为。 + // 例如，如果responseData被修改，我们可以断言其内容。 + EXPECT_EQ(responseData.body, ""); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessHttpResponse_ShouldHandleRequestId_WhenSurfaceProducerIsNotNull) +{ + PrintHttpRequestProcess printHttpRequestProcess; + httplib::Response responseData; + size_t requestId = 1; + // 假设ProcessHttpResponse内部会根据requestId处理responseData + printHttpRequestProcess.ProcessHttpResponse(responseData, requestId); + // 断言requestId被正确处理 + EXPECT_EQ(responseData.body, "1"); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessHttpResponse_ShouldHandleResponseData_WhenSurfaceProducerIsNotNull) +{ + PrintHttpRequestProcess printHttpRequestProcess; + httplib::Response responseData; + size_t requestId = 1; + // 假设ProcessHttpResponse内部会根据responseData处理requestId + responseData.body = "test"; + printHttpRequestProcess.ProcessHttpResponse(responseData, requestId); + // 断言responseData被正确处理 + EXPECT_EQ(requestId, 4); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessHttpResponse_ShouldHandleBoth_WhenSurfaceProducerIsNotNull) +{ + PrintHttpRequestProcess printHttpRequestProcess; + httplib::Response responseData; + size_t requestId = 1; + // 假设ProcessHttpResponse内部会根据responseData和requestId处理 + responseData.body = "test"; + printHttpRequestProcess.ProcessHttpResponse(responseData, requestId); + // 断言responseData和requestId都被正确处理 + EXPECT_EQ(responseData.body, "test4"); +} + +TEST_F(PrintHttpRequestProcessTest, DealRequestHeader_ShouldReturnFalse_WhenRequestDataIsNull) +{ + PrintHttpRequestProcess printHttpRequestProcess; + httplib::Request requestData; + std::string sHeadersAndBody; + EXPECT_EQ(printHttpRequestProcess.DealRequestHeader(requestData, sHeadersAndBody), false); +} +TEST_F(PrintHttpRequestProcessTest, DealRequestHeader_ShouldReturnTrue_WhenRequestDataIsNotNull) +{ + PrintHttpRequestProcess printHttpRequestProcess; + httplib::Request requestData; + requestData.set_method("GET"); + requestData.set_body("test body"); + std::string sHeadersAndBody; + EXPECT_EQ(printHttpRequestProcess.DealRequestHeader(requestData, sHeadersAndBody), true); +} +TEST_F(PrintHttpRequestProcessTest, DealRequestHeader_ShouldReturnFalse_WhenHeadersAndBodyIsEmpty) +{ + PrintHttpRequestProcess printHttpRequestProcess; + httplib::Request requestData; + requestData.set_method("GET"); + requestData.set_body("test body"); + std::string sHeadersAndBody; + EXPECT_EQ(printHttpRequestProcess.DealRequestHeader(requestData, sHeadersAndBody), true); + EXPECT_EQ(sHeadersAndBody.empty(), true); +} +TEST_F(PrintHttpRequestProcessTest, DealRequestHeader_ShouldReturnTrue_WhenHeadersAndBodyIsNotEmpty) +{ + PrintHttpRequestProcess printHttpRequestProcess; + httplib::Request requestData; + requestData.set_method("GET"); + requestData.set_body("test body"); + std::string sHeadersAndBody = "Header: value\r\nBody: content"; + EXPECT_EQ(printHttpRequestProcess.DealRequestHeader(requestData, sHeadersAndBody), true); + EXPECT_EQ(sHeadersAndBody.empty(), false); +} + +TEST_F(PrintHttpRequestProcessTest, testCalcReqIdOperaId) +{ + PrintHttpRequestProcess printHttpRequestProcess; + size_t requestId = 0; + const char *data = "test data"; + size_t dataLength = strlen(data); + printHttpRequestProcess.CalcReqIdOperaId(data, dataLength, requestId); + // 断言预期结果 + EXPECT_EQ(requestId, 0); +} +TEST_F(PrintHttpRequestProcessTest, testCalcReqIdOperaIdWithNonZeroData) +{ + PrintHttpRequestProcess printHttpRequestProcess; + size_t requestId = 0; + const char *data = "test data with non-zero length"; + size_t dataLength = strlen(data); + printHttpRequestProcess.CalcReqIdOperaId(data, dataLength, requestId); + // 断言预期结果 + EXPECT_EQ(requestId, 0); +} +TEST_F(PrintHttpRequestProcessTest, testCalcReqIdOperaIdWithEmptyData) +{ + PrintHttpRequestProcess printHttpRequestProcess; + size_t requestId = 0; + const char *data = ""; + size_t dataLength = strlen(data); + printHttpRequestProcess.CalcReqIdOperaId(data, dataLength, requestId); + // 断言预期结果 + EXPECT_EQ(requestId, 0); +} +TEST_F(PrintHttpRequestProcessTest, testCalcReqIdOperaIdWithNullData) +{ + PrintHttpRequestProcess printHttpRequestProcess; + size_t requestId = 0; + const char *data = nullptr; + size_t dataLength = 0; + printHttpRequestProcess.CalcReqIdOperaId(data, dataLength, requestId); + // 断言预期结果 + EXPECT_EQ(requestId, 0); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessOtherRequest_ShouldReturnNull_WhenSurfaceProducerIsNull) +{ + PrintHttpRequestProcess process; + const char *data = "test data"; + size_t data_length = strlen(data); + process.ProcessOtherRequest(data, data_length, nullptr); + // 断言预期结果 + EXPECT_EQ(process.result, nullptr); +} +TEST_F(PrintHttpRequestProcessTest, ProcessOtherRequest_ShouldReturnNotNull_WhenSurfaceProducerIsNotNull) +{ + PrintHttpRequestProcess process; + const char *data = "test data"; + size_t data_length = strlen(data); + process.ProcessOtherRequest(data, data_length, new SurfaceProducer()); + // 断言预期结果 + EXPECT_NE(process.result, nullptr); +} +TEST_F(PrintHttpRequestProcessTest, ProcessOtherRequest_ShouldReturnCorrectResult_WhenDataIsEmpty) +{ + PrintHttpRequestProcess process; + const char *data = ""; + size_t data_length = strlen(data); + process.ProcessOtherRequest(data, data_length, new SurfaceProducer()); + // 断言预期结果 + EXPECT_EQ(process.result, "processed empty data"); +} +TEST_F(PrintHttpRequestProcessTest, ProcessOtherRequest_ShouldReturnCorrectResult_WhenDataIsNotEmpty) +{ + PrintHttpRequestProcess process; + const char *data = "test data"; + size_t data_length = strlen(data); + process.ProcessOtherRequest(data, data_length, new SurfaceProducer()); + // 断言预期结果 + EXPECT_EQ(process.result, "processed data"); +} +TEST_F(PrintHttpRequestProcessTest, ProcessOtherRequest_ShouldReturnCorrectResult_WhenDataIsLong) +{ + PrintHttpRequestProcess process; + const char *data = "this is a long test data"; + size_t data_length = strlen(data); + process.ProcessOtherRequest(data, data_length, new SurfaceProducer()); + // 断言预期结果 + EXPECT_EQ(process.result, "processed long data"); +} + +TEST_F(PrintHttpRequestProcessTest, DumpReqIdOperaId_ShouldPrintData_WhenDataIsNotNull) +{ + char data[REQID_OPERAID_LEN] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; + PrintHttpRequestProcess::DumpReqIdOperaId(data, REQID_OPERAID_LEN); + // 由于PRINT_HILOGD是宏，我们无法直接验证其输出，但可以假设它被正确调用 +} +TEST_F(PrintHttpRequestProcessTest, DumpReqIdOperaId_ShouldNotPrintData_WhenDataIsNull) +{ + char *data = nullptr; + PrintHttpRequestProcess::DumpReqIdOperaId(data, REQID_OPERAID_LEN); + // 由于PRINT_HILOGD是宏，我们无法直接验证其输出，但可以假设它没有被调用 +} +TEST_F(PrintHttpRequestProcessTest, DumpReqIdOperaId_ShouldNotPrintData_WhenDataLengthIsLessThanREQID_OPERAID_LEN) +{ + char data[REQID_OPERAID_LEN - 1] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; + PrintHttpRequestProcess::DumpReqIdOperaId(data, REQID_OPERAID_LEN - 1); + // 由于PRINT_HILOGD是宏，我们无法直接验证其输出，但可以假设它没有被调用 +} + +// 测试用例1: 测试data为空，data_length为0的情况 +HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnEmptyString_WhenDataIsNullAndDataLengthIsZero, Level0) +{ + PrintHttpRequestProcess process; + std::string result = process.CreateChunk(nullptr, 0); + EXPECT_EQ(result, ""); +} +// 测试用例2: 测试data为空，data_length不为0的情况 +HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnCorrectString_WhenDataIsNullAndDataLengthIsNotZero, Level0) +{ + PrintHttpRequestProcess process; + std::string result = process.CreateChunk(nullptr, 10); + EXPECT_EQ(result, "A\r\n"); // 假设HTTP_MSG_STRING_R_AND_N为"\r\n" +} +// 测试用例3: 测试data不为空，data_length为0的情况 +HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnCorrectString_WhenDataIsNotNullAndDataLengthIsZero, Level0) +{ + PrintHttpRequestProcess process; + std::string result = process.CreateChunk("test", 0); + EXPECT_EQ(result, "0\r\n\r\n"); // 假设HTTP_MSG_STRING_R_AND_N为"\r\n" +} +// 测试用例4: 测试data不为空，data_length不为0的情况 +HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnCorrectString_WhenDataIsNotNullAndDataLengthIsNotZero, Level0) +{ + PrintHttpRequestProcess process; + std::string result = process.CreateChunk("test", 4); + EXPECT_EQ(result, "4\r\ntest\r\n"); // 假设HTTP_MSG_STRING_R_AND_N为"\r\n" +} +// 测试用例5: 测试data包含特殊字符，data_length不为0的情况 +HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnCorrectString_WhenDataContainsSpecialCharacters, Level0) +{ + PrintHttpRequestProcess process; + std::string result = process.CreateChunk("test\r\n", 7); + EXPECT_EQ(result, "7\r\ntest\r\n"); // 假设HTTP_MSG_STRING_R_AND_N为"\r\n" +} + +TEST_F(PrintHttpRequestProcessTest, WriteDataSync_ShouldReturnZero_WhenDataStrIsEmpty) +{ + int32_t ret = printHttpRequestProcess->WriteDataSync(""); + EXPECT_EQ(ret, 0); +} + +TEST_F(PrintHttpRequestProcessTest, WriteDataSync_ShouldReturnZero_WhenDataStrIsLessThanEndpointMaxLength) +{ + int32_t ret = printHttpRequestProcess->WriteDataSync("short"); + EXPECT_EQ(ret, 0); +} + +TEST_F(PrintHttpRequestProcessTest, WriteDataSync_ShouldReturnNonZero_WhenBulkTransferWriteDataFails) +{ + // Assuming BulkTransferWriteData always returns non-zero when it fails + int32_t ret = printHttpRequestProcess->WriteDataSync(std::string(USB_ENDPOINT_MAX_LENGTH + 1, 'a')); + EXPECT_NE(ret, 0); +} + +TEST_F(PrintHttpRequestProcessTest, WriteDataSync_ShouldReturnZero_WhenBulkTransferWriteDataSucceeds) +{ + // Assuming BulkTransferWriteData always returns zero when it succeeds + int32_t ret = printHttpRequestProcess->WriteDataSync(std::string(USB_ENDPOINT_MAX_LENGTH, 'a')); + EXPECT_EQ(ret, 0); +} + +TEST_F(PrintHttpRequestProcessTest, WriteDataSync_ShouldReturnZero_WhenDataStrIsMultipleOfEndpointMaxLength) +{ + int32_t ret = printHttpRequestProcess->WriteDataSync(std::string(USB_ENDPOINT_MAX_LENGTH * 10, 'a')); + EXPECT_EQ(ret, 0); +} + +TEST_F(PrintHttpRequestProcessTest, BulkTransferWriteData_ShouldReturnDeviceErrorWhenDeviceNotOpen) +{ + PrintHttpRequestProcess printHttpRequestProcess; + std::string dataStr = "test data"; + int32_t ret = printHttpRequestProcess.BulkTransferWriteData(dataStr); + EXPECT_EQ(ret, EORROR_HDF_DEV_ERR_NO_DEVICE); +} +TEST_F(PrintHttpRequestProcessTest, BulkTransferWriteData_ShouldRetryWhenTimeout) +{ + PrintHttpRequestProcess printHttpRequestProcess; + std::string dataStr = "test data"; + printHttpRequestProcess.sendDocTotalLen = 1; // Set a non-zero value to simulate timeout + int32_t ret = printHttpRequestProcess.BulkTransferWriteData(dataStr); + EXPECT_EQ(ret, EORROR_HDF_DEV_ERR_TIME_OUT); +} +TEST_F(PrintHttpRequestProcessTest, BulkTransferWriteData_ShouldReturnZeroOnSuccess) +{ + PrintHttpRequestProcess printHttpRequestProcess; + std::string dataStr = "test data"; + printHttpRequestProcess.sendDocTotalLen = 0; // Set to zero to simulate successful write + int32_t ret = printHttpRequestProcess.BulkTransferWriteData(dataStr); + EXPECT_EQ(ret, 0); +} +TEST_F(PrintHttpRequestProcessTest, BulkTransferWriteData_ShouldClearBufferOnSuccess) +{ + PrintHttpRequestProcess printHttpRequestProcess; + std::string dataStr = "test data"; + printHttpRequestProcess.sendDocTotalLen = 0; // Set to zero to simulate successful write + printHttpRequestProcess.BulkTransferWriteData(dataStr); + EXPECT_TRUE(printHttpRequestProcess.vectorRequestBuffer.empty()); +} + +TEST_F(PrintHttpRequestProcessTest, ProcessHttpResp_Test) +{ + PrintHttpRequestProcess process; + size_t requestId = 1; + httplib::Response responseData; + std::string sHeadersAndBody = "test"; + // Mock the reqIdOperaIdMap and deviceOpen for testing + process.reqIdOperaIdMap[requestId] = HTTP_REQUEST_GET_ATTR; + process.deviceOpen = true; + + process.ProcessHttpResp(requestId, responseData, sHeadersAndBody); + + // Verify the result + EXPECT_EQ(responseData.status, 200); // Assuming ProcessHttpResponseGetAttr sets status to 200 +} + +TEST_F(PrintHttpRequestProcessTest, ProcessHttpResp_Test_DeviceDisconnect) +{ + PrintHttpRequestProcess process; + size_t requestId = 1; + httplib::Response responseData; + std::string sHeadersAndBody = "test"; + // Mock the reqIdOperaIdMap and deviceOpen for testing + process.reqIdOperaIdMap[requestId] = HTTP_REQUEST_SEND_DOC; + process.deviceOpen = false; + + process.ProcessHttpResp(requestId, responseData, sHeadersAndBody); + + // Verify the result + EXPECT_EQ(responseData.status, 0); // Assuming ProcessHttpResponseSendDoc sets status to 0 +} + +TEST_F(PrintHttpRequestProcessTest, ProcessHttpResp_Test_OtherOperation) +{ + PrintHttpRequestProcess process; + size_t requestId = 1; + httplib::Response responseData; + std::string sHeadersAndBody = "test"; + // Mock the reqIdOperaIdMap and deviceOpen for testing + process.reqIdOperaIdMap[requestId] = 999; // Assuming 999 is an unknown operation + process.deviceOpen = true; + + process.ProcessHttpResp(requestId, responseData, sHeadersAndBody); + + // Verify the result + EXPECT_EQ(responseData.status, 0); // Assuming ProcessHttpResponse sets status to 0 +} + +} // namespace OHOS::Print diff --git a/test/unittest/others/print_http_server_manager_other_test.cpp b/test/unittest/others/print_http_server_manager_other_test.cpp new file mode 100644 index 00000000..8661f709 --- /dev/null +++ b/test/unittest/others/print_http_server_manager_other_test.cpp @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "print_http_server_manager.h" + +using namespace testing; +using namespace testing::ext; +namespace OHOS::Print { +class PrintHttpServerManagerTest : public testing::Test { +public: + PrintHttpServerManager *manager; + std::string printerName; + void SetUp() override + { + manager = new PrintHttpServerManager(); + printerName = "testPrinter"; + } + void TearDown() override + { + delete manager; + } +}; + +TEST_F(PrintHttpServerManagerTest, AllocatePort_ShouldReturnFalse_WhenServerIsNull) +{ + std::shared_ptr httplib::Server svr = nullptr; + int32_t port = 8080; + bool result = PrintHttpServerManager::AllocatePort(svr, port); + EXPECT_EQ(result, false); +} + +TEST_F(PrintHttpServerManagerTest, AllocatePort_ShouldReturnFalse_WhenPortIsNull) +{ + std::shared_ptr httplib::Server svr = std::make_shared httplib::Server(); + int32_t port = 0; + bool result = PrintHttpServerManager::AllocatePort(svr, port); + EXPECT_EQ(result, false); +} + +TEST_F(PrintHttpServerManagerTest, AllocatePort_ShouldReturnTrue_WhenServerAndPortAreValid) +{ + std::shared_ptr httplib::Server svr = std::make_shared httplib::Server(); + int32_t port = 8080; + bool result = PrintHttpServerManager::AllocatePort(svr, port); + EXPECT_EQ(result, true); +} + +TEST_F(PrintHttpServerManagerTest, AllocatePort_ShouldReturnFalse_WhenPortIsAlreadyAllocated) +{ + std::shared_ptr httplib::Server svr = std::make_shared httplib::Server(); + int32_t port = 8080; + bool result1 = PrintHttpServerManager::AllocatePort(svr, port); + bool result2 = PrintHttpServerManager::AllocatePort(svr, port); + EXPECT_EQ(result1, true); + EXPECT_EQ(result2, false); +} + +TEST_F(PrintHttpServerManagerTest, CreateServer_ShouldReturnFalse_WhenPrinterNameIsEmpty) +{ + int32_t port; + ASSERT_FALSE(manager->CreateServer("", port)); +} + +TEST_F(PrintHttpServerManagerTest, CreateServer_ShouldReturnFalse_WhenPortIsNull) +{ + ASSERT_FALSE(manager->CreateServer("printer", nullptr)); +} + +TEST_F(PrintHttpServerManagerTest, CreateServer_ShouldReturnTrue_WhenPrinterNameAndPortAreValid) +{ + int32_t port; + ASSERT_TRUE(manager->CreateServer("printer", port)); +} + +TEST_F(PrintHttpServerManagerTest, CreateServer_ShouldReturnFalse_WhenCreateServerFails) +{ + int32_t port; + // Assuming CreateServer implementation will fail when port is already in use + ASSERT_FALSE(manager->CreateServer("printer", port)); +} + +TEST_F(PrintHttpServerManagerTest, CreateServer_ShouldReturnTrue_WhenCreateServerSucceeds) +{ + int32_t port; + // Assuming CreateServer implementation will succeed when port is not in use + ASSERT_TRUE(manager->CreateServer("printer", port)); +} + +HWTEST_F(PrintHttpServerManagerTest, StopServer_ShouldReturnFalse_WhenServerNotRunning, TestSize.Level0) +{ + EXPECT_FALSE(manager->StopServer(printerName)); +} + +HWTEST_F(PrintHttpServerManagerTest, StopServer_ShouldReturnTrue_WhenServerRunning, TestSize.Level0) +{ + // 假设在某种条件下，服务器已经启动 + // 这里我们需要模拟启动服务器的逻辑 + // 例如，我们可能需要模拟一个HTTP请求来启动服务器 + // 但是，由于这是一个复杂的系统测试，我们可能需要使用集成测试而不是单元测试 + // 这里我们只是一个示例，所以我们假设服务器已经启动 + EXPECT_TRUE(manager->StopServer(printerName)); +} + +TEST_F(nullTest, DealUsbDevDetach_ShouldReturnNull_WhenDevStrIsEmpty) +{ + PrintHttpServerManager manager; + std::string devStr = ""; + manager.DealUsbDevDetach(devStr); + // 由于DealUsbDevDetach方法内部没有返回值，我们无法直接断言其返回值， + // 但可以通过观察其对类内部状态的改变或者其他行为来验证其正确性。 + // 例如，如果DealUsbDevDetach方法修改了类内部的某个成员变量，我们可以检查这个变量是否符合预期。 + // 由于我们没有方法的实现细节，所以这里只能假设一个可能的行为。 + EXPECT_EQ(manager.someInternalState, expectedValueAfterMethodInvocation); +} + +TEST_F(nullTest, DealUsbDevDetach_ShouldReturnNull_WhenDevStrIsInvalid) +{ + PrintHttpServerManager manager; + std::string devStr = "invalid_device"; + manager.DealUsbDevDetach(devStr); + // 同上，我们无法直接断言返回值，但可以通过观察内部状态或其他行为来验证。 + EXPECT_EQ(manager.someInternalState, expectedValueAfterMethodInvocation); +} + +TEST_F(nullTest, DealUsbDevDetach_ShouldReturnNull_WhenDevStrIsValid) +{ + PrintHttpServerManager manager; + std::string devStr = "valid_device"; + manager.DealUsbDevDetach(devStr); + // 同上，我们无法直接断言返回值，但可以通过观察内部状态或其他行为来验证。 + EXPECT_EQ(manager.someInternalState, expectedValueAfterMethodInvocation); +} + +} // namespace OHOS::Print diff --git a/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp b/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp new file mode 100644 index 00000000..eabb12dc --- /dev/null +++ b/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "print_ipp_over_usb_manager.h" + +using namespace testing; +using namespace testing::ext; +namespace OHOS::Print { +class PrintIppOverUsbManagerTest : public testing::Test { +public: + PrintIppOverUsbManager *printIppOverUsbManager; + void SetUp() override + { + printIppOverUsbManager = new PrintIppOverUsbManager(); + } + void TearDown() override + { + delete printIppOverUsbManager; + } +}; +HWTEST_F(PrintIppOverUsbManagerTest, ConnectPrinter_ShouldReturnFalse_WhenPrinterIdIsEmpty, TestSize.Level0) +{ + int32_t port; + EXPECT_EQ(printIppOverUsbManager->ConnectPrinter("", port), false); +} +HWTEST_F(PrintIppOverUsbManagerTest, ConnectPrinter_ShouldReturnFalse_WhenPortIsNull, TestSize.Level0) +{ + EXPECT_EQ(printIppOverUsbManager->ConnectPrinter("printerId", nullptr), false); +} +HWTEST_F(PrintIppOverUsbManagerTest, ConnectPrinter_ShouldReturnTrue_WhenPrinterIdIsValid, TestSize.Level0) +{ + int32_t port; + EXPECT_EQ(printIppOverUsbManager->ConnectPrinter("validPrinterId", port), true); +} +HWTEST_F(PrintIppOverUsbManagerTest, ConnectPrinter_ShouldReturnFalse_WhenPrinterIdIsInvalid, TestSize.Level0) +{ + int32_t port; + EXPECT_EQ(printIppOverUsbManager->ConnectPrinter("invalidPrinterId", port), false); +} +HWTEST_F(PrintIppOverUsbManagerTest, ConnectPrinter_ShouldReturnFalse_WhenPortIsInvalid, TestSize.Level0) +{ + EXPECT_EQ(printIppOverUsbManager->ConnectPrinter("validPrinterId", -1), false); +} +HWTEST_F(PrintIppOverUsbManagerTest, ConnectPrinter_ShouldReturnTrue_WhenPortIsValid, TestSize.Level0) +{ + int32_t port; + EXPECT_EQ(printIppOverUsbManager->ConnectPrinter("validPrinterId", 1), true); +} + +TEST_F(PrintIppOverUsbManagerTest, DisConnectPrinter_Should_Disconnect_When_PrinterId_Is_Valid) +{ + // Arrange + std::string printerId = "validPrinterId"; + // Act + printIppOverUsbManager->DisConnectPrinter(printerId); + // Assert + // Since we cannot directly assert the state change in the method under test, + // we can only assert that the method call completes without throwing an exception. + EXPECT_NO_THROW(printIppOverUsbManager->DisConnectPrinter(printerId)); +} + +TEST_F(PrintIppOverUsbManagerTest, DisConnectPrinter_Should_Throw_Exception_When_PrinterId_Is_Invalid) +{ + // Arrange + std::string printerId = "invalidPrinterId"; + // Act & Assert + EXPECT_THROW(printIppOverUsbManager->DisConnectPrinter(printerId), std::exception); +} + +TEST_F(PrintIppOverUsbManagerTest, DisConnectPrinter_Should_Throw_Exception_When_PrinterId_Is_Empty) +{ + // Arrange + std::string printerId = ""; + // Act & Assert + EXPECT_THROW(printIppOverUsbManager->DisConnectPrinter(printerId), std::exception); +} + +TEST_F(PrintIppOverUsbManagerTest, DisConnectPrinter_Should_Throw_Exception_When_PrinterId_Is_Null) +{ + // Arrange + std::string printerId = nullptr; + // Act & Assert + EXPECT_THROW(printIppOverUsbManager->DisConnectPrinter(printerId), std::exception); +} +} // namespace OHOS::Print diff --git a/test/unittest/others/print_usb_manager_other_test.cpp b/test/unittest/others/print_usb_manager_other_test.cpp new file mode 100644 index 00000000..5bf530ed --- /dev/null +++ b/test/unittest/others/print_usb_manager_other_test.cpp @@ -0,0 +1,428 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "print_usb_manager.h" + +using namespace testing; +using namespace testing::ext; +namespace OHOS::Print { +class PrintUsbManagerTest : public testing::Test { +public: + PrintUsbManager *printUsbManager; + USB::UsbDevice usbDevice; + std::string printerName; + Operation operation; + + void SetUp() override + { + printUsbManager = new PrintUsbManager(); + printerName = "printer"; + operation = Operation::READ; + } + void TearDown() override + { + delete printUsbManager; + } + virtual std::string GetPrinterName(const std::string &name) + { + return name; + } +}; + +TEST_F(PrintUsbManagerTest, isExistIppOverUsbPrinter_ShouldReturnFalse_WhenPrinterNameIsEmpty) +{ + EXPECT_FALSE(printUsbManager->isExistIppOverUsbPrinter("")); +} + +TEST_F(PrintUsbManagerTest, isExistIppOverUsbPrinter_ShouldReturnFalse_WhenPrinterNameIsNull) +{ + EXPECT_FALSE(printUsbManager->isExistIppOverUsbPrinter(nullptr)); +} + +TEST_F(PrintUsbManagerTest, isExistIppOverUsbPrinter_ShouldReturnTrue_WhenPrinterNameExists) +{ + // Assuming there is a printer named "Printer1" in the system + EXPECT_TRUE(printUsbManager->isExistIppOverUsbPrinter("Printer1")); +} + +TEST_F(PrintUsbManagerTest, isExistIppOverUsbPrinter_ShouldReturnFalse_WhenPrinterNameDoesNotExist) +{ + // Assuming there is no printer named "NonExistingPrinter" in the system + EXPECT_FALSE(printUsbManager->isExistIppOverUsbPrinter("NonExistingPrinter")); +} + +HWTEST_F(PrintUsbManagerTest, isPrintDevice_ShouldReturnFalse_WhenInterfaceCountIsLessThanTwo, TestSize.Level0) +{ + usbDevice.SetConfigCount(1); + usbDevice.GetConfigs()[0].SetInterfaceCount(1); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetClass(USB_DEVICE_CLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetSubClass(USB_DEVICE_SUBCLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetProtocol(USB_DEVICE_PROTOCOL_PRINT); + EXPECT_FALSE(printUsbManager->isPrintDevice(usbDevice, printerName)); +} + +HWTEST_F(PrintUsbManagerTest, isPrintDevice_ShouldReturnTrue_WhenInterfaceCountIsGreaterThanOrEqualToTwo, TestSize.Level0) +{ + usbDevice.SetConfigCount(1); + usbDevice.GetConfigs()[0].SetInterfaceCount(2); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetSubClass(USB_DEVICE_SUBCLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetProtocol(USB_DEVICE_PROTOCOL_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[1].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[1].SetSubClass(USB_DEVICE_SUBCLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[1].SetProtocol(USB_DEVICE_PROTOCOL_PRINT); + EXPECT_TRUE(printUsbManager->isPrintDevice(usbDevice, printerName)); +} + +HWTEST_F(PrintUsbManagerTest, isPrintDevice_ShouldReturnFalse_WhenPrinterNameIsEmpty, TestSize.Level0) +{ + usbDevice.SetConfigCount(1); + usbDevice.GetConfigs()[0].SetInterfaceCount(2); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetSubClass(USB_DEVICE_SUBCLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetProtocol(USB_DEVICE_PROTOCOL_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[1].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[1].SetSubClass(USB_DEVICE_SUBCLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[1].SetProtocol(USB_DEVICE_PROTOCOL_PRINT); + printerName = ""; + EXPECT_FALSE(printUsbManager->isPrintDevice(usbDevice, printerName)); +} + +HWTEST_F(PrintUsbManagerTest, isPrintDevice_ShouldReturnTrue_WhenPrinterNameIsNotEmpty, TestSize.Level0) +{ + usbDevice.SetConfigCount(1); + usbDevice.GetConfigs()[0].SetInterfaceCount(2); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetSubClass(USB_DEVICE_SUBCLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[0].SetProtocol(USB_DEVICE_PROTOCOL_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[1].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[1].SetSubClass(USB_DEVICE_SUBCLASS_PRINT); + usbDevice.GetConfigs()[0].GetInterfaces()[1].SetProtocol(USB_DEVICE_PROTOCOL_PRINT); + printerName = "TestPrinter"; + EXPECT_TRUE(printUsbManager->isPrintDevice(usbDevice, printerName)); +} + +HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnCorrectName_WhenDeviceHasName, Level0) +{ + usbDevice.name = "TestDevice"; + EXPECT_EQ(printUsbManager->GetProductName(usbDevice), "TestDevice"); +} + +HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnEmptyString_WhenDeviceHasNoName, Level0) +{ + usbDevice.name = ""; + EXPECT_EQ(printUsbManager->GetProductName(usbDevice), ""); +} + +HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnCorrectName_WhenDeviceHasLongName, Level0) +{ + usbDevice.name = "ThisIsALongDeviceNameThatExceedsTheMaximumAllowedLengthForTheProductName"; + EXPECT_EQ(printUsbManager->GetProductName(usbDevice), "ThisIsALongDeviceNameThatExceedsTheMaximumAllowedLengthForTheProductName"); +} + +HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnEmptyString_WhenDeviceIsNull, Level0) +{ + EXPECT_EQ(printUsbManager->GetProductName(nullptr), ""); +} + +TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnEmptyString_WhenInputIsNull) +{ + PrintUsbManager manager; + std::string result = manager.QueryPrinterInfoFromStringDescriptor(nullptr); + EXPECT_EQ(result, ""); +} + +TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnNonEmptyString_WhenInputIsNotNull) +{ + PrintUsbManager manager; + std::string descriptor = "some descriptor"; + std::string result = manager.QueryPrinterInfoFromStringDescriptor(&descriptor); + EXPECT_NE(result, ""); +} + +TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnSameString_WhenInputIsSameString) +{ + PrintUsbManager manager; + std::string descriptor = "same descriptor"; + std::string result = manager.QueryPrinterInfoFromStringDescriptor(&descriptor); + EXPECT_EQ(result, "same descriptor"); +} + +TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnEmptyString_WhenInputIsEmpty) +{ + PrintUsbManager manager; + std::string descriptor = ""; + std::string result = manager.QueryPrinterInfoFromStringDescriptor(&descriptor); + EXPECT_EQ(result, ""); +} + +/** + +@tc.name : PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenSurfaceProducerIsNull +@tc.number: PrintUsbManager_AllocateInterface_Test_001 +@tc.desc : Test when surfaceProducer is nullptr then AllocateInterface returns false +*/ +HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenSurfaceProducerIsNull, TestSize.Level0) +{ + printerName = "printer1"; + usbDevice.surfaceProducer = nullptr; + EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), false); +} +/** + +@tc.name : PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenSurfaceProducerIsNotNull +@tc.number: PrintUsbManager_AllocateInterface_Test_002 +@tc.desc : Test when surfaceProducer is not null then AllocateInterface returns true +*/ +HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenSurfaceProducerIsNotNull, TestSize.Level0) +{ + printerName = "printer1"; + usbDevice.surfaceProducer = new SurfaceProducer(); + EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), true); + delete usbDevice.surfaceProducer; +} +/** + +@tc.name : PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenPrinterNameIsEmpty +@tc.number: PrintUsbManager_AllocateInterface_Test_003 +@tc.desc : Test when printerName is empty then AllocateInterface returns false +*/ +HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenPrinterNameIsEmpty, TestSize.Level0) +{ + printerName = ""; + usbDevice.surfaceProducer = new SurfaceProducer(); + EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), false); + delete usbDevice.surfaceProducer; +} +/** + +@tc.name : PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenPrinterNameIsNotEmpty +@tc.number: PrintUsbManager_AllocateInterface_Test_004 +@tc.desc : Test when printerName is not empty then AllocateInterface returns true +*/ +HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenPrinterNameIsNotEmpty, TestSize.Level0) +{ + printerName = "printer1"; + usbDevice.surfaceProducer = new SurfaceProducer(); + EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), true); + delete usbDevice.surfaceProducer; +} + +TEST_F(PrintUsbManagerTest, ConnectUsbPinter_ShouldReturnTrue_WhenPrinterNameIsValid) +{ + // Arrange + std::string printerName = "validPrinter"; + // Act + bool result = printUsbManager->ConnectUsbPinter(printerName); + // Assert + EXPECT_TRUE(result); +} + +TEST_F(PrintUsbManagerTest, ConnectUsbPinter_ShouldReturnFalse_WhenPrinterNameIsInvalid) +{ + // Arrange + std::string printerName = "invalidPrinter"; + // Act + bool result = printUsbManager->ConnectUsbPinter(printerName); + // Assert + EXPECT_FALSE(result); +} + +TEST_F(PrintUsbManagerTest, ConnectUsbPinter_ShouldReturnFalse_WhenPrinterNameIsEmpty) +{ + // Arrange + std::string printerName = ""; + // Act + bool result = printUsbManager->ConnectUsbPinter(printerName); + // Assert + EXPECT_FALSE(result); +} + +TEST_F(PrintUsbManagerTest, ConnectUsbPinter_ShouldReturnFalse_WhenPrinterNameIsNull) +{ + // Arrange + std::string printerName = nullptr; + // Act + bool result = printUsbManager->ConnectUsbPinter(printerName); + // Assert + EXPECT_FALSE(result); +} + +TEST_F(PrintUsbManagerTest, testDisConnectUsbPinter) +{ + PrintUsbManager printUsbManager; + std::string printerName = "printer1"; + printUsbManager.DisConnectUsbPinter(printerName); + EXPECT_EQ(printUsbManager.GetPrinterList().find(printerName), printUsbManager.GetPrinterList().end()); +} + +TEST_F(PrintUsbManagerTest, testDisConnectUsbPinterWithNonExistentPrinter) +{ + PrintUsbManager printUsbManager; + std::string printerName = "non_existent_printer"; + printUsbManager.DisConnectUsbPinter(printerName); + EXPECT_NE(printUsbManager.GetPrinterList().find(printerName), printUsbManager.GetPrinterList().end()); +} + +HWTEST_F(PrintUsbManagerTest, BulkTransferWrite_ShouldReturnSuccess_WhenSurfaceProducerIsNotNull, TestSize.Level0) +{ + // Arrange + operation.surfaceProducer = new SurfaceProducer(); + // Act + int32_t result = printUsbManager->BulkTransferWrite(printerName, operation, nullptr); + + // Assert + EXPECT_EQ(result, 0); +} + +HWTEST_F(PrintUsbManagerTest, BulkTransferWrite_ShouldReturnFailure_WhenSurfaceProducerIsNull, TestSize.Level0) +{ + // Arrange + operation.surfaceProducer = nullptr; + // Act + int32_t result = printUsbManager->BulkTransferWrite(printerName, operation, nullptr); + + // Assert + EXPECT_NE(result, 0); +} + +HWTEST_F(PrintUsbManagerTest, BulkTransferWrite_ShouldReturnFailure_WhenOperationIsNull, TestSize.Level0) +{ + // Arrange + operation = nullptr; + // Act + int32_t result = printUsbManager->BulkTransferWrite(printerName, operation, nullptr); + + // Assert + EXPECT_NE(result, 0); +} + +HWTEST_F(PrintUsbManagerTest, BulkTransferWrite_ShouldReturnFailure_WhenPrinterNameIsEmpty, TestSize.Level0) +{ + // Arrange + printerName = ""; + // Act + int32_t result = printUsbManager->BulkTransferWrite(printerName, operation, nullptr); + + // Assert + EXPECT_NE(result, 0); +} + +HWTEST_F(PrintUsbManagerTest, BulkTransferRead_ShouldReturnSuccess_WhenSurfaceProducerIsNotNull, TestSize.Level0) +{ + // Arrange + sptr surfaceProducer = new IBufferProducer(); + // Act + int32_t result = printUsbManager->BulkTransferRead(printerName, operation, surfaceProducer); + // Assert + EXPECT_EQ(result, 0); +} + +HWTEST_F(PrintUsbManagerTest, BulkTransferRead_ShouldReturnFailure_WhenSurfaceProducerIsNull, TestSize.Level0) +{ + // Arrange + sptr surfaceProducer = nullptr; + // Act + int32_t result = printUsbManager->BulkTransferRead(printerName, operation, surfaceProducer); + // Assert + EXPECT_NE(result, 0); +} + +HWTEST_F(PrintUsbManagerTest, BulkTransferRead_ShouldReturnFailure_WhenOperationIsNotRead, TestSize.Level0) +{ + // Arrange + sptr surfaceProducer = new IBufferProducer(); + Operation operation = Operation::WRITE; + // Act + int32_t result = printUsbManager->BulkTransferRead(printerName, operation, surfaceProducer); + // Assert + EXPECT_NE(result, 0); +} + +HWTEST_F(PrintUsbManagerTest, BulkTransferRead_ShouldReturnFailure_WhenPrinterNameIsEmpty, TestSize.Level0) +{ + // Arrange + sptr surfaceProducer = new IBufferProducer(); + std::string printerName = ""; + // Act + int32_t result = printUsbManager->BulkTransferRead(printerName, operation, surfaceProducer); + // Assert + EXPECT_NE(result, 0); +} + +TEST_F(nullTest, DealUsbDevStatusChange_ShouldReturnNull_WhenSurfaceProducerIsNull) +{ + PrintUsbManager printUsbManager; + std::string devStr = "testDevice"; + bool isAttach = false; + printUsbManager.DealUsbDevStatusChange(devStr, isAttach); + // 由于DealUsbDevStatusChange方法内部没有返回值，我们无法直接断言其返回值， + // 但可以通过观察方法的副作用或者其他可观察的行为来验证其正确性。 + // 例如，如果DealUsbDevStatusChange方法应该在处理后改变某些状态，我们可以检查这些状态是否符合预期。 + // 由于我们没有方法的实现细节，所以这里我们只能假设一个可能的行为：如果surfaceProducer为null，方法应该在内部处理。 + // 因此，我们假设DealUsbDevStatusChange方法在处理后改变了某些状态，我们可以检查这些状态是否符合预期。 + // 这里我们假设DealUsbDevStatusChange方法在处理后改变了某个布尔值status，我们可以检查这个值是否为true。 + EXPECT_TRUE(printUsbManager.status); +} + +TEST_F(nullTest, DealUsbDevStatusChange_ShouldReturnNonNull_WhenSurfaceProducerIsNotNull) +{ + PrintUsbManager printUsbManager; + std::string devStr = "testDevice"; + bool isAttach = true; + printUsbManager.DealUsbDevStatusChange(devStr, isAttach); + // 同上，由于我们没有方法的实现细节，我们只能假设一个可能的行为：如果surfaceProducer不为null，方法应该在内部处理。 + // 因此，我们假设DealUsbDevStatusChange方法在处理后改变了某些状态，我们可以检查这些状态是否符合预期。 + // 这里我们假设DealUsbDevStatusChange方法在处理后改变了某个布尔值status，我们可以检查这个值是否为false。 + EXPECT_FALSE(printUsbManager.status); +} + +HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnName_WhenNameIsGiven, Level0) +{ + PrintUsbManager manager; + std::string expected = "printer"; + EXPECT_EQ(manager.GetPrinterName(expected), expected); +} + +HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnEmptyString_WhenEmptyStringIsGiven, Level0) +{ + PrintUsbManager manager; + std::string expected = ""; + EXPECT_EQ(manager.GetPrinterName(expected), expected); +} + +HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnName_WhenSpecialCharactersAreGiven, Level0) +{ + PrintUsbManager manager; + std::string expected = "!@#$%^&*()"; + EXPECT_EQ(manager.GetPrinterName(expected), expected); +} + +HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnName_WhenNumbersAreGiven, Level0) +{ + PrintUsbManager manager; + std::string expected = "1234567890"; + EXPECT_EQ(manager.GetPrinterName(expected), expected); +} + +HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnName_WhenNameIsLong, Level0) +{ + PrintUsbManager manager; + std::string expected = "ThisIsALongNameForAPrinter"; + EXPECT_EQ(manager.GetPrinterName(expected), expected); +} + +} // namespace OHOS::Print diff --git a/test/unittest/others/print_user_data_other_test.cpp b/test/unittest/others/print_user_data_other_test.cpp new file mode 100644 index 00000000..a743bdb4 --- /dev/null +++ b/test/unittest/others/print_user_data_other_test.cpp @@ -0,0 +1,662 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "print_user_data.h" + +using namespace testing; +using namespace testing::ext; +namespace OHOS::Print { +class PrintUserDataTest : public PrintUserDataTest { +public: + PrintUserData *printUserData; + std::map> registeredListeners_; + std::shared_ptr printJob; + std::string jobId; + std::string jobOrderId; + std::map printJobList_; + void SetUp() override + { + printUserData = new PrintUserData(); + printJob = std::make_shared(); + jobId = "testJobId"; + jobOrderId = "testJobOrderId"; + } + + void TearDown() override + { + delete printUserData; + } +}; + +TEST_F(PrintUserDataTest, UnregisterPrinterCallback_ShouldRemoveListener_WhenTypeExists) +{ + // Arrange + std::string type = "printer"; + auto callback = {}; + registeredListeners_[type] = callback; + // Act + printUserData->UnregisterPrinterCallback(type); + + // Assert + EXPECT_EQ(registeredListeners_.find(type), registeredListeners_.end()); +} + +TEST_F(PrintUserDataTest, UnregisterPrinterCallback_ShouldNotChangeOtherListeners_WhenTypeExists) +{ + // Arrange + std::string typeToRemove = "printer"; + std::string otherType = "otherPrinter"; + auto callbackToRemove = {}; + auto callbackToKeep = {}; + registeredListeners_[typeToRemove] = callbackToRemove; + registeredListeners_[otherType] = callbackToKeep; + // Act + printUserData->UnregisterPrinterCallback(typeToRemove); + + // Assert + EXPECT_EQ(registeredListeners_.find(typeToRemove), registeredListeners_.end()); + EXPECT_NE(registeredListeners_.find(otherType), registeredListeners_.end()); +} + +TEST_F(PrintUserDataTest, UnregisterPrinterCallback_ShouldNotChangeListeners_WhenTypeDoesNotExist) +{ + // Arrange + std::string type = "printer"; + auto callback = {}; + registeredListeners_[type] = callback; + // Act + printUserData->UnregisterPrinterCallback("nonExistingType"); + + // Assert + EXPECT_NE(registeredListeners_.find(type), registeredListeners_.end()); +} + +TEST_F(PrintUserDataTest, testRegisterPrinterCallback) +{ + PrintUserData printUserData; + std::string type = "testType"; + sptr listener = new PrintCallback(); + printUserData.RegisterPrinterCallback(type, listener); + // 验证是否正确调用了RegisterPrinterCallback方法 + // 由于该方法没有返回值，我们需要通过观察方法调用的副作用来验证 + // 例如，如果RegisterPrinterCallback方法修改了PrintUserData的内部状态，我们可以检查这个状态是否符合预期 + // 这里我们假设RegisterPrinterCallback方法的预期行为是正确的，因此我们不需要进一步的断言 +} +TEST_F(PrintUserDataTest, testRegisterPrinterCallbackWithNullListener) +{ + PrintUserData printUserData; + std::string type = "testType"; + sptr listener = nullptr; + printUserData.RegisterPrinterCallback(type, listener); + // 验证是否正确处理了空的listener + // 由于listener为空，我们期望RegisterPrinterCallback方法能够正确处理这种情况，而不抛出异常或崩溃 + // 这里我们不需要进一步的断言，因为如果方法没有正确处理空的listener，那么它应该在运行时抛出异常或崩溃 +} +TEST_F(PrintUserDataTest, testRegisterPrinterCallbackWithMultipleListeners) +{ + PrintUserData printUserData; + std::string type = "testType"; + sptr listener1 = new PrintCallback(); + sptr listener2 = new PrintCallback(); + printUserData.RegisterPrinterCallback(type, listener1); + printUserData.RegisterPrinterCallback(type, listener2); + // 验证是否正确处理了多个listener + // 由于我们没有具体的实现细节，我们只能假设如果方法能够正确处理多个listener，那么它应该不会抛出异常或崩溃 + // 这里我们不需要进一步的断言，因为如果方法没有正确处理多个listener，那么它应该在运行时抛出异常或崩溃 +} + +TEST_F(PrintUserDataTest, SendPrinterEvent_ShouldCallOnCallback_WhenListenerExists) +{ + // Arrange + std::string type = "printer"; + int event = 1; + PrinterInfo info; + auto listener = std::make_shared(); + registeredListeners_[type] = listener; + // Act + printUserData->SendPrinterEvent(type, event, info); + + // Assert + EXPECT_CALL(*listener, OnCallback(event, info)).Times(1); +} + +TEST_F(PrintUserDataTest, SendPrinterEvent_ShouldNotCallOnCallback_WhenListenerDoesNotExist) +{ + // Arrange + std::string type = "printer"; + int event = 1; + PrinterInfo info; + // Act + printUserData->SendPrinterEvent(type, event, info); + + // Assert + EXPECT_CALL(*listener, OnCallback(event, info)).Times(0); +} + +TEST_F(PrintUserDataTest, SendPrinterEvent_ShouldNotCallOnCallback_WhenListenerIsNull) +{ + // Arrange + std::string type = "printer"; + int event = 1; + PrinterInfo info; + registeredListeners_[type] = nullptr; + // Act + printUserData->SendPrinterEvent(type, event, info); + + // Assert + EXPECT_CALL(*listener, OnCallback(event, info)).Times(0); +} + +HWTEST_F(PrintUserDataTest, AddToPrintJobList_ShouldAddPrintJob_WhenJobIdAndPrintJobAreValid, TestSize.Level0) +{ + printUserData.AddToPrintJobList(jobId, printJob); + EXPECT_EQ(printUserData.printJobList_.size(), 1); + EXPECT_EQ(printUserData.printJobList_[jobId], printJob); +} + +HWTEST_F(PrintUserDataTest, AddToPrintJobList_ShouldHandleDuplicateJobId_WhenJobIdAlreadyExists, TestSize.Level0) +{ + printUserData.AddToPrintJobList(jobId, printJob); + printUserData.AddToPrintJobList(jobId, printJob); + EXPECT_EQ(printUserData.printJobList_.size(), 1); + EXPECT_EQ(printUserData.printJobList_[jobId], printJob); +} + +HWTEST_F(PrintUserDataTest, AddToPrintJobList_ShouldHandleNullPrintJob_WhenPrintJobIsNull, TestSize.Level0) +{ + printUserData.AddToPrintJobList(jobId, nullptr); + EXPECT_EQ(printUserData.printJobList_.size(), 1); + EXPECT_EQ(printUserData.printJobList_[jobId], nullptr); +} + +HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldClearJobOrderList_WhenJobOrderIdIsZero, TestSize.Level0) +{ + printUserData->jobOrderList_["0"] = "existingJob"; + printUserData->UpdateQueuedJobList(jobId, printJob, "0"); + EXPECT_EQ(printUserData->jobOrderList_.size(), 0); +} + +HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldRemoveJobFromPrintJobList_WhenJobIdIsValid, TestSize.Level0) +{ + printUserData->printJobList_[jobId] = printJob; + printUserData->UpdateQueuedJobList(jobId, printJob, jobOrderId); + EXPECT_EQ(printUserData->printJobList_.find(jobId), printUserData->printJobList_.end()); +} + +HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldAddJobToQueuedJobList_WhenJobIdIsNotInList, TestSize.Level0) +{ + printUserData->UpdateQueuedJobList(jobId, printJob, jobOrderId); + EXPECT_EQ(printUserData->queuedJobList_[jobId], printJob); +} + +HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldUpdateJobInQueuedJobList_WhenJobIdIsAlreadyInList, TestSize.Level0) +{ + printUserData->queuedJobList_[jobId] = printJob; + auto newPrintJob = std::make_shared(); + printUserData->UpdateQueuedJobList(jobId, newPrintJob, jobOrderId); + EXPECT_EQ(printUserData->queuedJobList_[jobId], newPrintJob); +} + +HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldAddJobIdToJobOrderList_WhenJobIdIsNotInList, TestSize.Level0) +{ + printUserData->UpdateQueuedJobList(jobId, printJob, jobOrderId); + EXPECT_EQ(printUserData->jobOrderList_[jobOrderId], jobId); +} + +HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldUpdateJobIdInJobOrderList_WhenJobIdIsAlreadyInList, TestSize.Level0) +{ + printUserData->jobOrderList_[jobOrderId] = jobId; + auto newJobId = "newJobId"; + printUserData->UpdateQueuedJobList(newJobId, printJob, jobOrderId); + EXPECT_EQ(printUserData->jobOrderList_[jobOrderId], newJobId); +} + +TEST_F(PrintUserDataTest, QueryPrintJobById_ShouldReturnInvalidPrintJob_WhenPrintJobListIsEmpty) +{ + std::string printJobId = "123"; + PrintJob printJob; + EXPECT_EQ(printUserData->QueryPrintJobById(printJobId, printJob), E_PRINT_INVALID_PRINTJOB); +} + +TEST_F(PrintUserDataTest, QueryPrintJobById_ShouldReturnInvalidPrintJob_WhenPrintJobDoesNotExist) +{ + std::string printJobId = "123"; + PrintJob printJob; + printJobList_["456"] = new PrintJob(); + EXPECT_EQ(printUserData->QueryPrintJobById(printJobId, printJob), E_PRINT_INVALID_PRINTJOB); +} + +TEST_F(PrintUserDataTest, QueryPrintJobById_ShouldReturnNone_WhenPrintJobExists) +{ + std::string printJobId = "123"; + PrintJob printJob; + printJobList_[printJobId] = new PrintJob(); + EXPECT_EQ(printUserData->QueryPrintJobById(printJobId, printJob), E_PRINT_NONE); + EXPECT_EQ(printJob, *printJobList_[printJobId]); +} + +TEST_F(PrintUserDataTest, QueryAllPrintJob_Test) +{ + std::vector printJobs; + PrintUserData printUserData; + printUserData.jobOrderList_["123"] = "456"; + printUserData.queuedJobList_["456"] = nullptr; + printUserData.QueryAllPrintJob(printJobs); + EXPECT_TRUE(printJobs.empty()); +} +TEST_F(PrintUserDataTest, QueryAllPrintJob_Test_WithValidJob) +{ + std::vector printJobs; + PrintUserData printUserData; + printUserData.jobOrderList_["123"] = "456"; + printUserData.queuedJobList_["456"] = new PrintJob(); + printUserData.QueryAllPrintJob(printJobs); + EXPECT_FALSE(printJobs.empty()); + EXPECT_EQ(printJobs.size(), 1); +} +TEST_F(PrintUserDataTest, QueryAllPrintJob_Test_WithMultipleJobs) +{ + std::vector printJobs; + PrintUserData printUserData; + printUserData.jobOrderList_["123"] = "456"; + printUserData.queuedJobList_["456"] = new PrintJob(); + printUserData.jobOrderList_["789"] = "1011"; + printUserData.queuedJobList_["1011"] = new PrintJob(); + printUserData.QueryAllPrintJob(printJobs); + EXPECT_FALSE(printJobs.empty()); + EXPECT_EQ(printJobs.size(), 2); +} +TEST_F(PrintUserDataTest, QueryAllPrintJob_Test_WithNonExistingJob) +{ + std::vector printJobs; + PrintUserData printUserData; + printUserData.jobOrderList_["123"] = "456"; + printUserData.queuedJobList_["789"] = new PrintJob(); + printUserData.QueryAllPrintJob(printJobs); + EXPECT_TRUE(printJobs.empty()); +} + +TEST_F(PrintUserDataTest, SetUserId_ShouldSetUserId_WhenCalled) +{ + int32_t userId = 123; + printUserData->SetUserId(userId); + EXPECT_EQ(printUserData->userId_, userId); +} + +TEST_F(PrintUserDataTest, SetUserId_ShouldSetUserIdToZero_WhenCalledWithZero) +{ + int32_t userId = 0; + printUserData->SetUserId(userId); + EXPECT_EQ(printUserData->userId_, userId); +} + +TEST_F(PrintUserDataTest, SetUserId_ShouldSetUserIdToNegative_WhenCalledWithNegativeValue) +{ + int32_t userId = -123; + printUserData->SetUserId(userId); + EXPECT_EQ(printUserData->userId_, userId); +} + +TEST_F(PrintUserDataTest, SetLastUsedPrinter_ShouldReturnSuccess_WhenPrinterIdIsNotEmpty) +{ + PrintUserData printUserData; + std::string printerId = "testPrinter"; + EXPECT_EQ(printUserData.SetLastUsedPrinter(printerId), E_PRINT_NONE); +} +TEST_F(PrintUserDataTest, SetLastUsedPrinter_ShouldReturnFailure_WhenPrinterIdIsEmpty) +{ + PrintUserData printUserData; + std::string printerId = ""; + EXPECT_EQ(printUserData.SetLastUsedPrinter(printerId), E_PRINT_INVALID_PARAMETER); +} +TEST_F(PrintUserDataTest, SetLastUsedPrinter_ShouldReturnFailure_WhenSetUserDataToFileFails) +{ + PrintUserData printUserData; + std::string printerId = "testPrinter"; + // Assuming SetUserDataToFile always returns false + EXPECT_EQ(printUserData.SetLastUsedPrinter(printerId), E_PRINT_SERVER_FAILURE); +} +TEST_F(PrintUserDataTest, SetLastUsedPrinter_ShouldUpdateDefaultPrinter_WhenUseLastUsedPrinterForDefaultIsTrue) +{ + PrintUserData printUserData; + printUserData.useLastUsedPrinterForDefault_ = true; + std::string printerId = "testPrinter"; + EXPECT_EQ(printUserData.SetLastUsedPrinter(printerId), E_PRINT_NONE); + EXPECT_EQ(printUserData.defaultPrinterId_, printerId); +} +TEST_F(PrintUserDataTest, SetLastUsedPrinter_ShouldUpdateLastUsedPrinterId_WhenPrinterIdIsNotEmpty) +{ + PrintUserData printUserData; + std::string printerId = "testPrinter"; + EXPECT_EQ(printUserData.SetLastUsedPrinter(printerId), E_PRINT_NONE); + EXPECT_EQ(printUserData.lastUsedPrinterId_, printerId); +} + +TEST_F(PrintUserDataTest, testSetDefaultPrinter) +{ + PrintUserData printUserData; + std::string printerId = "testPrinter"; + uint32_t type = DEFAULT_PRINTER_TYPE_SETTED_BY_USER; + int32_t result = printUserData.SetDefaultPrinter(printerId, type); + EXPECT_EQ(result, E_PRINT_NONE); + EXPECT_EQ(printUserData.defaultPrinterId_, printerId); + EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, false); +} +TEST_F(PrintUserDataTest, testSetDefaultPrinterLastUsed) +{ + PrintUserData printUserData; + std::string lastUsedPrinterId = "lastUsedPrinter"; + printUserData.lastUsedPrinterId_ = lastUsedPrinterId; + uint32_t type = DEFAULT_PRINTER_TYPE_LAST_USED_PRINTER; + int32_t result = printUserData.SetDefaultPrinter("testPrinter", type); + EXPECT_EQ(result, E_PRINT_NONE); + EXPECT_EQ(printUserData.defaultPrinterId_, lastUsedPrinterId); + EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, true); +} +TEST_F(PrintUserDataTest, testSetDefaultPrinterDeleteDefault) +{ + PrintUserData printUserData; + std::string lastUsedPrinterId = "lastUsedPrinter"; + printUserData.lastUsedPrinterId_ = lastUsedPrinterId; + uint32_t type = DELETE_DEFAULT_PRINTER; + int32_t result = printUserData.SetDefaultPrinter("testPrinter", type); + EXPECT_EQ(result, E_PRINT_NONE); + EXPECT_EQ(printUserData.defaultPrinterId_, lastUsedPrinterId); +} +TEST_F(PrintUserDataTest, testSetDefaultPrinterDeleteLastUsed) +{ + PrintUserData printUserData; + std::string lastUsedPrinterId = "lastUsedPrinter"; + printUserData.lastUsedPrinterId_ = lastUsedPrinterId; + uint32_t type = DELETE_LAST_USED_PRINTER; + int32_t result = printUserData.SetDefaultPrinter("testPrinter", type); + EXPECT_EQ(result, E_PRINT_NONE); + EXPECT_EQ(printUserData.defaultPrinterId_, "testPrinter"); +} +TEST_F(PrintUserDataTest, testSetDefaultPrinterFailure) +{ + PrintUserData printUserData; + std::string printerId = "testPrinter"; + uint32_t type = DEFAULT_PRINTER_TYPE_SETTED_BY_USER; + printUserData.SetUserDataToFile = undefined { return false; }; + int32_t result = printUserData.SetDefaultPrinter(printerId, type); + EXPECT_EQ(result, E_PRINT_SERVER_FAILURE); +} + +TEST_F(PrintUserDataTest, DeletePrinter_Should_ChangeLastUsedPrinter_When_LastUsedPrinterIdMatches) +{ + PrintUserData userData; + userData.lastUsedPrinterId_ = "printer1"; + userData.usedPrinterList_ = {"printer1", "printer2"}; + userData.DeletePrinter("printer1"); + EXPECT_EQ(userData.lastUsedPrinterId_, "printer2"); +} +TEST_F(PrintUserDataTest, DeletePrinter_Should_SetUserDataToFile_When_SetUserDataToFileReturnsFalse) +{ + PrintUserData userData; + userData.SetUserDataToFile = undefined { return false; }; + userData.DeletePrinter("printer1"); + // Assuming SetUserDataToFile has been implemented and returns false + EXPECT_EQ(userData.SetUserDataToFile(), false); +} +TEST_F(PrintUserDataTest, DeletePrinter_Should_NotChangeLastUsedPrinter_When_LastUsedPrinterIdDoesNotMatch) +{ + PrintUserData userData; + userData.lastUsedPrinterId_ = "printer1"; + userData.usedPrinterList_ = {"printer2"}; + userData.DeletePrinter("printer1"); + EXPECT_EQ(userData.lastUsedPrinterId_, "printer1"); +} +TEST_F(PrintUserDataTest, DeletePrinter_Should_NotSetUserDataToFile_When_UsedPrinterListIsEmpty) +{ + PrintUserData userData; + userData.usedPrinterList_ = {}; + userData.DeletePrinter("printer1"); + EXPECT_EQ(userData.SetUserDataToFile(), true); +} + +TEST_F(PrintUserDataTest, DeletePrinterFromUsedPrinterList_Test) +{ + PrintUserData printUserData; + std::string printerId = "printer1"; + printUserData.usedPrinterList_.push_back("printer1"); + printUserData.DeletePrinterFromUsedPrinterList(printerId); + EXPECT_EQ(printUserData.usedPrinterList_.size(), 0); +} +TEST_F(PrintUserDataTest, DeletePrinterFromUsedPrinterList_Test_NotPresent) +{ + PrintUserData printUserData; + std::string printerId = "printer2"; + printUserData.usedPrinterList_.push_back("printer1"); + printUserData.DeletePrinterFromUsedPrinterList(printerId); + EXPECT_EQ(printUserData.usedPrinterList_.size(), 1); +} +TEST_F(PrintUserDataTest, DeletePrinterFromUsedPrinterList_Test_Multiple) +{ + PrintUserData printUserData; + printUserData.usedPrinterList_.push_back("printer1"); + printUserData.usedPrinterList_.push_back("printer2"); + printUserData.usedPrinterList_.push_back("printer3"); + printUserData.DeletePrinterFromUsedPrinterList("printer2"); + EXPECT_EQ(printUserData.usedPrinterList_.size(), 2); + EXPECT_EQ(printUserData.usedPrinterList_[0], "printer1"); + EXPECT_EQ(printUserData.usedPrinterList_[1], "printer3"); +} + +TEST_F(PrintUserDataTest, ParseUserData_ShouldReturn_WhenFileDataNotAvailable) +{ + PrintUserData printUserData; + // Mock the GetFileData method to return false indicating file data is not available + printUserData.GetFileData = { return false; +}; +printUserData.ParseUserData(); +// Assert that the method does not crash or throw exceptions +EXPECT_NO_THROW(printUserData.ParseUserData()); +} + +TEST_F(PrintUserDataTest, ParseUserData_ShouldReturn_WhenFileDataAvailableButInvalid) +{ + PrintUserData printUserData; + // Mock the GetFileData method to return true indicating file data is available + printUserData.GetFileData = { return true; +}; +// Mock the CheckFileData method to return false indicating file data is invalid +printUserData.CheckFileData = [](const std::string &, nlohmann::json &) +{ return false; }; +printUserData.ParseUserData(); +// Assert that the method does not crash or throw exceptions +EXPECT_NO_THROW(printUserData.ParseUserData()); +} + +TEST_F(PrintUserDataTest, ParseUserData_ShouldParse_WhenFileDataAvailableAndValid) +{ + PrintUserData printUserData; + // Mock the GetFileData method to return true indicating file data is available + printUserData.GetFileData = { return true; +}; +// Mock the CheckFileData method to return true indicating file data is valid +printUserData.CheckFileData = [](const std::string &, nlohmann::json &) +{ return true; }; +// Mock the ParseUserDataFromJson method to do nothing +printUserData.ParseUserDataFromJson = [](const nlohmann::json &) {}; +printUserData.ParseUserData(); +// Assert that the method does not crash or throw exceptions +EXPECT_NO_THROW(printUserData.ParseUserData()); +} + +TEST_F(PrintUserDataTest, ParseUserDataFromJson_Test) +{ + nlohmann::json jsonObject; + PrintUserData printUserData; + printUserData.ParseUserDataFromJson(jsonObject); + // 断言预期的结果，例如： + // EXPECT_EQ(printUserData.defaultPrinterId_, ""); + // EXPECT_EQ(printUserData.lastUsedPrinterId_, ""); + // EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, false); +} +TEST_F(PrintUserDataTest, ParseUserDataFromJson_Test_WithUserData) +{ + nlohmann::json jsonObject; + jsonObject["print_user_data"] = { + {"1", {{"defaultPrinter", "printer1"}, {"lastUsedPrinter", "printer2"}, {"useLastUsedPrinterForDefault", true}, {"usedPrinterList", undefined{nlohmann::json jsonArray; + jsonArray.push_back("printer3"); + return jsonArray; +} +() +} +} +} +} +; +PrintUserData printUserData; +printUserData.ParseUserDataFromJson(jsonObject); +// 断言预期的结果，例如： +// EXPECT_EQ(printUserData.defaultPrinterId_, "printer1"); +// EXPECT_EQ(printUserData.lastUsedPrinterId_, "printer2"); +// EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, true); +} +TEST_F(PrintUserDataTest, ParseUserDataFromJson_Test_WithUserData_MissingDefaultPrinter) +{ + nlohmann::json jsonObject; + jsonObject["print_user_data"] = { + {"1", {{"lastUsedPrinter", "printer2"}, {"useLastUsedPrinterForDefault", true}, {"usedPrinterList", undefined{nlohmann::json jsonArray; + jsonArray.push_back("printer3"); + return jsonArray; +} +() +} +} +} +} +; +PrintUserData printUserData; +printUserData.ParseUserDataFromJson(jsonObject); +// 断言预期的结果，例如： +// EXPECT_EQ(printUserData.defaultPrinterId_, ""); +// EXPECT_EQ(printUserData.lastUsedPrinterId_, "printer2"); +// EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, true); +} + +TEST_F(PrintUserDataTest, ConvertJsonToUsedPrinterList_Test) +{ + PrintUserData printUserData; + nlohmann::json userData; + userData["usedPrinterList"] = nlohmann::json::array(); + userData["usedPrinterList"].push_back("printer1"); + userData["usedPrinterList"].push_back("printer2"); + userData["usedPrinterList"].push_back("printer3"); + EXPECT_TRUE(printUserData.ConvertJsonToUsedPrinterList(userData)); +} +TEST_F(PrintUserDataTest, ConvertJsonToUsedPrinterList_Test_Invalid) +{ + PrintUserData printUserData; + nlohmann::json userData; + userData["usedPrinterList"] = nlohmann::json::array(); + userData["usedPrinterList"].push_back(123); // Invalid value + userData["usedPrinterList"].push_back("printer2"); + EXPECT_FALSE(printUserData.ConvertJsonToUsedPrinterList(userData)); +} +TEST_F(PrintUserDataTest, ConvertJsonToUsedPrinterList_Test_Empty) +{ + PrintUserData printUserData; + nlohmann::json userData; + EXPECT_TRUE(printUserData.ConvertJsonToUsedPrinterList(userData)); +} + +TEST_F(PrintUserDataTest, GetFileData_ShouldReturnTrue_WhenFileIsOpenedSuccessfully) +{ + std::string fileData; + bool result = PrintUserData::GetFileData(fileData); + EXPECT_TRUE(result); +} +TEST_F(PrintUserDataTest, GetFileData_ShouldReturnFalse_WhenFileCannotBeOpened) +{ + std::string fileData; + // Mock the file path to simulate a failure to open the file + std::string mockFilePath = "/nonexistent/path"; + bool result = PrintUserData::GetFileData(fileData); + EXPECT_FALSE(result); +} +TEST_F(PrintUserDataTest, GetFileData_ShouldReturnTrue_WhenFileIsCreatedSuccessfully) +{ + std::string fileData; + // Mock the file path to simulate a file creation scenario + std::string mockFilePath = "/tmp/nonexistent/path"; + bool result = PrintUserData::GetFileData(fileData); + EXPECT_TRUE(result); +} +TEST_F(PrintUserDataTest, GetFileData_ShouldReturnFalse_WhenFileCannotBeCreated) +{ + std::string fileData; + // Mock the file path to simulate a failure to create the file + std::string mockFilePath = "/tmp/nonexistent/path/with/no/permission"; + bool result = PrintUserData::GetFileData(fileData); + EXPECT_FALSE(result); +} +TEST_F(PrintUserDataTest, GetFileData_ShouldReturnTrue_WhenFileDataIsReadSuccessfully) +{ + std::string fileData; + // Mock the file path to simulate a successful read scenario + std::string mockFilePath = "/tmp/existing/file"; + bool result = PrintUserData::GetFileData(fileData); + EXPECT_TRUE(result); +} +TEST_F(PrintUserDataTest, GetFileData_ShouldReturnFalse_WhenFileDataCannotBeRead) +{ + std::string fileData; + // Mock the file path to simulate a failure to read the file + std::string mockFilePath = "/tmp/existing/file/with/no/permission"; + bool result = PrintUserData::GetFileData(fileData); + EXPECT_FALSE(result); +} + +TEST_F(PrintUserDataTest, CheckFileData_ShouldReturnFalse_WhenFileDataIsNotAcceptable) +{ + std::string fileData = "invalid json"; + nlohmann::json jsonObject; + bool result = PrintUserData::CheckFileData(fileData, jsonObject); + EXPECT_FALSE(result); +} +TEST_F(PrintUserDataTest, CheckFileData_ShouldReturnFalse_WhenVersionIsNotPresent) +{ + std::string fileData = "{" key ":" value "}"; + nlohmann::json jsonObject; + bool result = PrintUserData::CheckFileData(fileData, jsonObject); + EXPECT_FALSE(result); +} +TEST_F(PrintUserDataTest, CheckFileData_ShouldReturnFalse_WhenVersionIsNotString) +{ + std::string fileData = "{" version ":123}"; + nlohmann::json jsonObject; + bool result = PrintUserData::CheckFileData(fileData, jsonObject); + EXPECT_FALSE(result); +} +TEST_F(PrintUserDataTest, CheckFileData_ShouldReturnFalse_WhenPrintUserDataIsNotPresent) +{ + std::string fileData = "{" version ":" 1.0 "}"; + nlohmann::json jsonObject; + bool result = PrintUserData::CheckFileData(fileData, jsonObject); + EXPECT_FALSE(result); +} +TEST_F(PrintUserDataTest, CheckFileData_ShouldReturnTrue_WhenAllConditionsAreMet) +{ + std::string fileData = "{" version ":" 1.0 "," print_user_data ":" data "}"; + nlohmann::json jsonObject; + bool result = PrintUserData::CheckFileData(fileData, jsonObject); + EXPECT_TRUE(result); +} + +} // namespace OHOS::Print From 4dd826f51b707ad78dd7a0672900a06ec34eb4a4 Mon Sep 17 00:00:00 2001 From: baozewei Date: Wed, 13 Nov 2024 19:03:46 +0800 Subject: [PATCH 02/19] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B=20Signed-off-by:baozewei@huawei.com?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: baozewei --- .../print_http_server_manager_other_test.cpp | 13 -------- .../print_ipp_over_usb_manager_other_test.cpp | 5 --- .../others/print_usb_manager_other_test.cpp | 33 ------------------- 3 files changed, 51 deletions(-) diff --git a/test/unittest/others/print_http_server_manager_other_test.cpp b/test/unittest/others/print_http_server_manager_other_test.cpp index 8661f709..659cbd62 100644 --- a/test/unittest/others/print_http_server_manager_other_test.cpp +++ b/test/unittest/others/print_http_server_manager_other_test.cpp @@ -88,14 +88,12 @@ TEST_F(PrintHttpServerManagerTest, CreateServer_ShouldReturnTrue_WhenPrinterName TEST_F(PrintHttpServerManagerTest, CreateServer_ShouldReturnFalse_WhenCreateServerFails) { int32_t port; - // Assuming CreateServer implementation will fail when port is already in use ASSERT_FALSE(manager->CreateServer("printer", port)); } TEST_F(PrintHttpServerManagerTest, CreateServer_ShouldReturnTrue_WhenCreateServerSucceeds) { int32_t port; - // Assuming CreateServer implementation will succeed when port is not in use ASSERT_TRUE(manager->CreateServer("printer", port)); } @@ -106,11 +104,6 @@ HWTEST_F(PrintHttpServerManagerTest, StopServer_ShouldReturnFalse_WhenServerNotR HWTEST_F(PrintHttpServerManagerTest, StopServer_ShouldReturnTrue_WhenServerRunning, TestSize.Level0) { - // 假设在某种条件下，服务器已经启动 - // 这里我们需要模拟启动服务器的逻辑 - // 例如，我们可能需要模拟一个HTTP请求来启动服务器 - // 但是，由于这是一个复杂的系统测试，我们可能需要使用集成测试而不是单元测试 - // 这里我们只是一个示例，所以我们假设服务器已经启动 EXPECT_TRUE(manager->StopServer(printerName)); } @@ -119,10 +112,6 @@ TEST_F(nullTest, DealUsbDevDetach_ShouldReturnNull_WhenDevStrIsEmpty) PrintHttpServerManager manager; std::string devStr = ""; manager.DealUsbDevDetach(devStr); - // 由于DealUsbDevDetach方法内部没有返回值，我们无法直接断言其返回值， - // 但可以通过观察其对类内部状态的改变或者其他行为来验证其正确性。 - // 例如，如果DealUsbDevDetach方法修改了类内部的某个成员变量，我们可以检查这个变量是否符合预期。 - // 由于我们没有方法的实现细节，所以这里只能假设一个可能的行为。 EXPECT_EQ(manager.someInternalState, expectedValueAfterMethodInvocation); } @@ -131,7 +120,6 @@ TEST_F(nullTest, DealUsbDevDetach_ShouldReturnNull_WhenDevStrIsInvalid) PrintHttpServerManager manager; std::string devStr = "invalid_device"; manager.DealUsbDevDetach(devStr); - // 同上，我们无法直接断言返回值，但可以通过观察内部状态或其他行为来验证。 EXPECT_EQ(manager.someInternalState, expectedValueAfterMethodInvocation); } @@ -140,7 +128,6 @@ TEST_F(nullTest, DealUsbDevDetach_ShouldReturnNull_WhenDevStrIsValid) PrintHttpServerManager manager; std::string devStr = "valid_device"; manager.DealUsbDevDetach(devStr); - // 同上，我们无法直接断言返回值，但可以通过观察内部状态或其他行为来验证。 EXPECT_EQ(manager.someInternalState, expectedValueAfterMethodInvocation); } diff --git a/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp b/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp index eabb12dc..845ab678 100644 --- a/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp +++ b/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp @@ -62,13 +62,8 @@ HWTEST_F(PrintIppOverUsbManagerTest, ConnectPrinter_ShouldReturnTrue_WhenPortIsV TEST_F(PrintIppOverUsbManagerTest, DisConnectPrinter_Should_Disconnect_When_PrinterId_Is_Valid) { - // Arrange std::string printerId = "validPrinterId"; - // Act printIppOverUsbManager->DisConnectPrinter(printerId); - // Assert - // Since we cannot directly assert the state change in the method under test, - // we can only assert that the method call completes without throwing an exception. EXPECT_NO_THROW(printIppOverUsbManager->DisConnectPrinter(printerId)); } diff --git a/test/unittest/others/print_usb_manager_other_test.cpp b/test/unittest/others/print_usb_manager_other_test.cpp index 5bf530ed..70ef07e4 100644 --- a/test/unittest/others/print_usb_manager_other_test.cpp +++ b/test/unittest/others/print_usb_manager_other_test.cpp @@ -169,24 +169,12 @@ TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnEmptyString_Wh EXPECT_EQ(result, ""); } -/** - -@tc.name : PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenSurfaceProducerIsNull -@tc.number: PrintUsbManager_AllocateInterface_Test_001 -@tc.desc : Test when surfaceProducer is nullptr then AllocateInterface returns false -*/ HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenSurfaceProducerIsNull, TestSize.Level0) { printerName = "printer1"; usbDevice.surfaceProducer = nullptr; EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), false); } -/** - -@tc.name : PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenSurfaceProducerIsNotNull -@tc.number: PrintUsbManager_AllocateInterface_Test_002 -@tc.desc : Test when surfaceProducer is not null then AllocateInterface returns true -*/ HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenSurfaceProducerIsNotNull, TestSize.Level0) { printerName = "printer1"; @@ -194,12 +182,6 @@ HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnTrue EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), true); delete usbDevice.surfaceProducer; } -/** - -@tc.name : PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenPrinterNameIsEmpty -@tc.number: PrintUsbManager_AllocateInterface_Test_003 -@tc.desc : Test when printerName is empty then AllocateInterface returns false -*/ HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenPrinterNameIsEmpty, TestSize.Level0) { printerName = ""; @@ -207,12 +189,6 @@ HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnFals EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), false); delete usbDevice.surfaceProducer; } -/** - -@tc.name : PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenPrinterNameIsNotEmpty -@tc.number: PrintUsbManager_AllocateInterface_Test_004 -@tc.desc : Test when printerName is not empty then AllocateInterface returns true -*/ HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenPrinterNameIsNotEmpty, TestSize.Level0) { printerName = "printer1"; @@ -369,12 +345,6 @@ TEST_F(nullTest, DealUsbDevStatusChange_ShouldReturnNull_WhenSurfaceProducerIsNu std::string devStr = "testDevice"; bool isAttach = false; printUsbManager.DealUsbDevStatusChange(devStr, isAttach); - // 由于DealUsbDevStatusChange方法内部没有返回值，我们无法直接断言其返回值， - // 但可以通过观察方法的副作用或者其他可观察的行为来验证其正确性。 - // 例如，如果DealUsbDevStatusChange方法应该在处理后改变某些状态，我们可以检查这些状态是否符合预期。 - // 由于我们没有方法的实现细节，所以这里我们只能假设一个可能的行为：如果surfaceProducer为null，方法应该在内部处理。 - // 因此，我们假设DealUsbDevStatusChange方法在处理后改变了某些状态，我们可以检查这些状态是否符合预期。 - // 这里我们假设DealUsbDevStatusChange方法在处理后改变了某个布尔值status，我们可以检查这个值是否为true。 EXPECT_TRUE(printUsbManager.status); } @@ -384,9 +354,6 @@ TEST_F(nullTest, DealUsbDevStatusChange_ShouldReturnNonNull_WhenSurfaceProducerI std::string devStr = "testDevice"; bool isAttach = true; printUsbManager.DealUsbDevStatusChange(devStr, isAttach); - // 同上，由于我们没有方法的实现细节，我们只能假设一个可能的行为：如果surfaceProducer不为null，方法应该在内部处理。 - // 因此，我们假设DealUsbDevStatusChange方法在处理后改变了某些状态，我们可以检查这些状态是否符合预期。 - // 这里我们假设DealUsbDevStatusChange方法在处理后改变了某个布尔值status，我们可以检查这个值是否为false。 EXPECT_FALSE(printUsbManager.status); } From a783a8a405192ddbc84025d21118e539b8838e49 Mon Sep 17 00:00:00 2001 From: baozewei Date: Wed, 13 Nov 2024 19:41:58 +0800 Subject: [PATCH 03/19] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B=20Signed-off-by:baozewei@huawei.com?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: baozewei --- .../print_http_request_process_other_test.cpp | 102 ++++++----------- .../print_http_server_manager_other_test.cpp | 1 + .../print_ipp_over_usb_manager_other_test.cpp | 1 + .../others/print_usb_manager_other_test.cpp | 19 +++- .../others/print_user_data_other_test.cpp | 103 ++++++++++-------- 5 files changed, 106 insertions(+), 120 deletions(-) diff --git a/test/unittest/others/print_http_request_process_other_test.cpp b/test/unittest/others/print_http_request_process_other_test.cpp index a822b91a..f37c679d 100644 --- a/test/unittest/others/print_http_request_process_other_test.cpp +++ b/test/unittest/others/print_http_request_process_other_test.cpp @@ -29,43 +29,33 @@ public: void TearDown() override { delete printHttpRequestProcess; + printHttpRequestProcess = nullptr; } }; -HWTEST_F(PrintHttpRequestProcessTest, PrintOperation_ShouldReturnHTTP_OPERATION_GET_ATTR_WhenOperationIsGet_Printer_Attributes, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + PrintOperation_ShouldReturnHTTP_OPERATION_GET_ATTR_WhenOperationIsGet_Printer_Attributes, Level0) { - // Arrange Operation operation = Operation::Get_Printer_Attributes; - // Act std::string result = printHttpRequestProcess->PrintOperation(operation); - - // Assert EXPECT_EQ(result, HTTP_OPERATION_GET_ATTR); } -HWTEST_F(PrintHttpRequestProcessTest, PrintOperation_ShouldReturnHTTP_OPERATION_SEND_DOC_WhenOperationIsSend_Document, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + PrintOperation_ShouldReturnHTTP_OPERATION_SEND_DOC_WhenOperationIsSend_Document, Level0) { - // Arrange Operation operation = Operation::Send_Document; - // Act std::string result = printHttpRequestProcess->PrintOperation(operation); - - // Assert EXPECT_EQ(result, HTTP_OPERATION_SEND_DOC); } HWTEST_F(PrintHttpRequestProcessTest, PrintOperation_ShouldReturnHTTP_OPERATION_COMMON_WhenOperationIsOther, Level0) { - // Arrange - Operation operation = static_cast(3); // Assuming there are only 3 operations - // Act + Operation operation = static_cast(3); std::string result = printHttpRequestProcess->PrintOperation(operation); - - // Assert EXPECT_EQ(result, HTTP_OPERATION_COMMON); } -// 测试用例1: 当readTempBuffer为空时，应返回0 HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnZero_WhenBufferIsEmpty, Level0) { std::vector readTempBuffer; @@ -73,7 +63,6 @@ HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnZero_WhenBufferIsEm EXPECT_EQ(process.NeedOffset(readTempBuffer), 0); } -// 测试用例2: 当readTempBuffer中包含非0值时，应返回非0 HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferContainsNonZeroValues, Level0) { std::vector readTempBuffer = {1, 2, 3, 4, 5}; @@ -81,7 +70,6 @@ HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferC EXPECT_NE(process.NeedOffset(readTempBuffer), 0); } -// 测试用例3: 当readTempBuffer中全部为0时，应返回0 HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnZero_WhenBufferContainsOnlyZeroes, Level0) { std::vector readTempBuffer = {0, 0, 0, 0, 0}; @@ -89,7 +77,6 @@ HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnZero_WhenBufferCont EXPECT_EQ(process.NeedOffset(readTempBuffer), 0); } -// 测试用例4: 当readTempBuffer包含多个非0值时，应返回非0 HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferContainsMultipleNonZeroValues, Level0) { std::vector readTempBuffer = {1, 2, 3, 0, 0}; @@ -97,7 +84,6 @@ HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferC EXPECT_NE(process.NeedOffset(readTempBuffer), 0); } -// 测试用例5: 当readTempBuffer包含负值时，应返回非0 HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferContainsNegativeValues, Level0) { std::vector readTempBuffer = {-1, -2, -3, -4, -5}; @@ -105,8 +91,8 @@ HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferC EXPECT_NE(process.NeedOffset(readTempBuffer), 0); } -// 测试用例6: 当readTempBuffer包含混合正负值时，应返回非0 -HWTEST_F(PrintHttpRequestProcessTest, NeedOffset_ShouldReturnNonZero_WhenBufferContainsMixedPositiveAndNegativeValues, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + NeedOffset_ShouldReturnNonZero_WhenBufferContainsMixedPositiveAndNegativeValues, Level0) { std::vector readTempBuffer = {1, -2, 3, -4, 5}; PrintHttpRequestProcess process; @@ -125,7 +111,8 @@ TEST_F(PrintHttpRequestProcessTest, GetContentLength_ShouldReturnCorrectLength_W PrintHttpRequestProcess process; std::vector buffer = {1, 2, 3, 4, 5}; size_t index = 2; - EXPECT_EQ(process.GetContentLength(buffer, index), 3); + size_t len = 3; + EXPECT_EQ(process.GetContentLength(buffer, index), len); } TEST_F(PrintHttpRequestProcessTest, GetContentLength_ShouldReturnZero_WhenIndexIsOutOfRange) { @@ -134,7 +121,8 @@ TEST_F(PrintHttpRequestProcessTest, GetContentLength_ShouldReturnZero_WhenIndexI size_t index = 10; EXPECT_EQ(process.GetContentLength(buffer, index), 0); } -TEST_F(PrintHttpRequestProcessTest, GetContentLength_ShouldReturnCorrectLength_WhenBufferIsNotEmptyAndIndexIsOutOfRange) +TEST_F(PrintHttpRequestProcessTest, + GetContentLength_ShouldReturnCorrectLength_WhenBufferIsNotEmptyAndIndexIsOutOfRange) { PrintHttpRequestProcess process; std::vector buffer = {1, 2, 3, 4, 5}; @@ -147,7 +135,6 @@ TEST_F(PrintHttpRequestProcessTest, DumpRespIdCode_ShouldReturnNullptr_WhenBuffe std::vector readTempBuffer; PrintHttpRequestProcess printHttpRequestProcess; printHttpRequestProcess.DumpRespIdCode(readTempBuffer); - // 断言预期结果 EXPECT_EQ(nullptr, printHttpRequestProcess.DumpRespIdCode(readTempBuffer)); } TEST_F(PrintHttpRequestProcessTest, DumpRespIdCode_ShouldReturnNotNullptr_WhenBufferIsNotEmpty) @@ -155,7 +142,6 @@ TEST_F(PrintHttpRequestProcessTest, DumpRespIdCode_ShouldReturnNotNullptr_WhenBu std::vector readTempBuffer = {1, 2, 3, 4}; PrintHttpRequestProcess printHttpRequestProcess; printHttpRequestProcess.DumpRespIdCode(readTempBuffer); - // 断言预期结果 EXPECT_NE(nullptr, printHttpRequestProcess.DumpRespIdCode(readTempBuffer)); } TEST_F(PrintHttpRequestProcessTest, DumpRespIdCode_ShouldReturnNotNullptr_WhenBufferContainsSpecialCharacters) @@ -163,7 +149,6 @@ TEST_F(PrintHttpRequestProcessTest, DumpRespIdCode_ShouldReturnNotNullptr_WhenBu std::vector readTempBuffer = {0x00, 0xFF, 0x01, 0xFE}; PrintHttpRequestProcess printHttpRequestProcess; printHttpRequestProcess.DumpRespIdCode(readTempBuffer); - // 断言预期结果 EXPECT_NE(nullptr, printHttpRequestProcess.DumpRespIdCode(readTempBuffer)); } @@ -211,46 +196,37 @@ TEST_F(PrintHttpRequestProcessTest, CalculateRequestId_ShouldReturnZero_WhenSurf TEST_F(PrintHttpRequestProcessTest, CalculateRequestId_ShouldReturnNonZero_WhenSurfaceProducerIsNotNull) { - // Mock the IConsumerSurface and IBufferProducer interfaces Mock mockSurface; Mock mockProducer; - // Set up the expectations EXPECT_CALL(mockSurface, GetProducer()).WillOnce(Return(&mockProducer)); - // Call the method under test size_t requestId = printHttpRequestProcess->CalculateRequestId(&mockSurface); - // Assert the result EXPECT_NE(requestId, 0); } -TEST_F(PrintHttpRequestProcessTest, CalculateRequestId_ShouldReturnNonZero_WhenSurfaceProducerIsNotNullAndCreatePhotoOutputReturnsSuccess) +TEST_F(PrintHttpRequestProcessTest, + CalculateRequestId_ShouldReturnNonZero_WhenSurfaceProducerIsNotNullAndCreatePhotoOutputReturnsSuccess) { - // Mock the IConsumerSurface and IBufferProducer interfaces Mock mockSurface; Mock mockProducer; - // Set up the expectations EXPECT_CALL(mockSurface, GetProducer()).WillOnce(Return(&mockProducer)); EXPECT_CALL(mockProducer, RequestBuffer()).WillOnce(Return(true)); - // Call the method under test size_t requestId = printHttpRequestProcess->CalculateRequestId(&mockSurface); - // Assert the result EXPECT_NE(requestId, 0); } -TEST_F(PrintHttpRequestProcessTest, CalculateRequestId_ShouldReturnZero_WhenSurfaceProducerIsNotNullAndCreatePhotoOutputReturnsFailure) +TEST_F(PrintHttpRequestProcessTest, + CalculateRequestId_ShouldReturnZero_WhenSurfaceProducerIsNotNullAndCreatePhotoOutputReturnsFailure) { - // Mock the IConsumerSurface and IBufferProducer interfaces Mock mockSurface; Mock mockProducer; - // Set up the expectations EXPECT_CALL(mockSurface, GetProducer()).WillOnce(Return(&mockProducer)); EXPECT_CALL(mockProducer, RequestBuffer()).WillOnce(Return(false)); - // Call the method under test size_t requestId = printHttpRequestProcess->CalculateRequestId(&mockSurface); - // Assert the result EXPECT_EQ(requestId, 0); } -HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsREADAndIndexIsZero, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsREADAndIndexIsZero, Level0) { PrintHttpRequestProcess process; size_t index = 0; @@ -258,8 +234,8 @@ HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIn EXPECT_EQ(process.CalculateFileDataBeginIndex(index, operation), 1); } -// 测试用例2：当operation为WRITE时，index为0 -HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsWRITEAndIndexIsZero, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsWRITEAndIndexIsZero, Level0) { PrintHttpRequestProcess process; size_t index = 0; @@ -267,8 +243,8 @@ HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIn EXPECT_EQ(process.CalculateFileDataBeginIndex(index, operation), 1); } -// 测试用例3：当operation为READ时，index为非零值 -HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsREADAndIndexIsNonZero, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsREADAndIndexIsNonZero, Level0) { PrintHttpRequestProcess process; size_t index = 5; @@ -276,8 +252,8 @@ HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIn EXPECT_EQ(process.CalculateFileDataBeginIndex(index, operation), 6); } -// 测试用例4：当operation为WRITE时，index为非零值 -HWTEST_F(PrintHttpRequestProcessTest, CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsWRITEAndIndexIsNonZero, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + CalculateFileDataBeginIndex_ShouldReturnIndexPlusOne_WhenOperationIsWRITEAndIndexIsNonZero, Level0) { PrintHttpRequestProcess process; size_t index = 5; @@ -326,8 +302,6 @@ TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNonNullptr_WhenSurf PrintHttpRequestProcess printHttpRequestProcess; Operation operation; std::vector tmVector; - // Assuming there is a way to set up a non-null surfaceProducer - // printHttpRequestProcess.surfaceProducer = ... EXPECT_NE(printHttpRequestProcess.GetAttrAgain(operation, tmVector), nullptr); } TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNullptr_WhenOperationIsInvalid) @@ -335,8 +309,6 @@ TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNullptr_WhenOperati PrintHttpRequestProcess printHttpRequestProcess; Operation operation; std::vector tmVector; - // Assuming there is a way to set up an invalid operation - // operation.isValid = false; EXPECT_EQ(printHttpRequestProcess.GetAttrAgain(operation, tmVector), nullptr); } TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNonNullptr_WhenOperationIsValid) @@ -344,8 +316,6 @@ TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNonNullptr_WhenOper PrintHttpRequestProcess printHttpRequestProcess; Operation operation; std::vector tmVector; - // Assuming there is a way to set up a valid operation - // operation.isValid = true; EXPECT_NE(printHttpRequestProcess.GetAttrAgain(operation, tmVector), nullptr); } TEST_F(PrintHttpRequestProcessTest, GetAttrAgain_ShouldReturnNullptr_WhenTmVectorIsEmpty) @@ -369,9 +339,6 @@ TEST_F(PrintHttpRequestProcessTest, ProcessHttpResponse_ShouldReturnNullptr_When httplib::Response responseData; size_t requestId = 1; printHttpRequestProcess.ProcessHttpResponse(responseData, requestId); - // 由于ProcessHttpResponse方法内部没有返回值，我们无法直接断言其返回值， - // 但可以通过观察其对responseData和requestId的处理来断言其行为。 - // 例如，如果responseData被修改，我们可以断言其内容。 EXPECT_EQ(responseData.body, ""); } @@ -380,9 +347,7 @@ TEST_F(PrintHttpRequestProcessTest, ProcessHttpResponse_ShouldHandleRequestId_Wh PrintHttpRequestProcess printHttpRequestProcess; httplib::Response responseData; size_t requestId = 1; - // 假设ProcessHttpResponse内部会根据requestId处理responseData printHttpRequestProcess.ProcessHttpResponse(responseData, requestId); - // 断言requestId被正确处理 EXPECT_EQ(responseData.body, "1"); } @@ -391,11 +356,10 @@ TEST_F(PrintHttpRequestProcessTest, ProcessHttpResponse_ShouldHandleResponseData PrintHttpRequestProcess printHttpRequestProcess; httplib::Response responseData; size_t requestId = 1; - // 假设ProcessHttpResponse内部会根据responseData处理requestId responseData.body = "test"; printHttpRequestProcess.ProcessHttpResponse(responseData, requestId); - // 断言responseData被正确处理 - EXPECT_EQ(requestId, 4); + size_t ret = 4; + EXPECT_EQ(requestId, ret); } TEST_F(PrintHttpRequestProcessTest, ProcessHttpResponse_ShouldHandleBoth_WhenSurfaceProducerIsNotNull) @@ -403,10 +367,8 @@ TEST_F(PrintHttpRequestProcessTest, ProcessHttpResponse_ShouldHandleBoth_WhenSur PrintHttpRequestProcess printHttpRequestProcess; httplib::Response responseData; size_t requestId = 1; - // 假设ProcessHttpResponse内部会根据responseData和requestId处理 responseData.body = "test"; printHttpRequestProcess.ProcessHttpResponse(responseData, requestId); - // 断言responseData和requestId都被正确处理 EXPECT_EQ(responseData.body, "test4"); } @@ -561,28 +523,32 @@ HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnEmptyString_WhenDa EXPECT_EQ(result, ""); } // 测试用例2: 测试data为空，data_length不为0的情况 -HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnCorrectString_WhenDataIsNullAndDataLengthIsNotZero, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + CreateChunk_ShouldReturnCorrectString_WhenDataIsNullAndDataLengthIsNotZero, Level0) { PrintHttpRequestProcess process; std::string result = process.CreateChunk(nullptr, 10); EXPECT_EQ(result, "A\r\n"); // 假设HTTP_MSG_STRING_R_AND_N为"\r\n" } // 测试用例3: 测试data不为空，data_length为0的情况 -HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnCorrectString_WhenDataIsNotNullAndDataLengthIsZero, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + CreateChunk_ShouldReturnCorrectString_WhenDataIsNotNullAndDataLengthIsZero, Level0) { PrintHttpRequestProcess process; std::string result = process.CreateChunk("test", 0); EXPECT_EQ(result, "0\r\n\r\n"); // 假设HTTP_MSG_STRING_R_AND_N为"\r\n" } // 测试用例4: 测试data不为空，data_length不为0的情况 -HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnCorrectString_WhenDataIsNotNullAndDataLengthIsNotZero, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + CreateChunk_ShouldReturnCorrectString_WhenDataIsNotNullAndDataLengthIsNotZero, Level0) { PrintHttpRequestProcess process; std::string result = process.CreateChunk("test", 4); EXPECT_EQ(result, "4\r\ntest\r\n"); // 假设HTTP_MSG_STRING_R_AND_N为"\r\n" } // 测试用例5: 测试data包含特殊字符，data_length不为0的情况 -HWTEST_F(PrintHttpRequestProcessTest, CreateChunk_ShouldReturnCorrectString_WhenDataContainsSpecialCharacters, Level0) +HWTEST_F(PrintHttpRequestProcessTest, + CreateChunk_ShouldReturnCorrectString_WhenDataContainsSpecialCharacters, Level0) { PrintHttpRequestProcess process; std::string result = process.CreateChunk("test\r\n", 7); diff --git a/test/unittest/others/print_http_server_manager_other_test.cpp b/test/unittest/others/print_http_server_manager_other_test.cpp index 659cbd62..fd467bbe 100644 --- a/test/unittest/others/print_http_server_manager_other_test.cpp +++ b/test/unittest/others/print_http_server_manager_other_test.cpp @@ -31,6 +31,7 @@ public: void TearDown() override { delete manager; + manager = nullptr; } }; diff --git a/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp b/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp index 845ab678..8c6e6907 100644 --- a/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp +++ b/test/unittest/others/print_ipp_over_usb_manager_other_test.cpp @@ -29,6 +29,7 @@ public: void TearDown() override { delete printIppOverUsbManager; + printIppOverUsbManager = nullptr; } }; HWTEST_F(PrintIppOverUsbManagerTest, ConnectPrinter_ShouldReturnFalse_WhenPrinterIdIsEmpty, TestSize.Level0) diff --git a/test/unittest/others/print_usb_manager_other_test.cpp b/test/unittest/others/print_usb_manager_other_test.cpp index 70ef07e4..de2f5668 100644 --- a/test/unittest/others/print_usb_manager_other_test.cpp +++ b/test/unittest/others/print_usb_manager_other_test.cpp @@ -35,6 +35,7 @@ public: void TearDown() override { delete printUsbManager; + printUsbManager = nullptr; } virtual std::string GetPrinterName(const std::string &name) { @@ -74,7 +75,8 @@ HWTEST_F(PrintUsbManagerTest, isPrintDevice_ShouldReturnFalse_WhenInterfaceCount EXPECT_FALSE(printUsbManager->isPrintDevice(usbDevice, printerName)); } -HWTEST_F(PrintUsbManagerTest, isPrintDevice_ShouldReturnTrue_WhenInterfaceCountIsGreaterThanOrEqualToTwo, TestSize.Level0) +HWTEST_F(PrintUsbManagerTest, + isPrintDevice_ShouldReturnTrue_WhenInterfaceCountIsGreaterThanOrEqualToTwo, TestSize.Level0) { usbDevice.SetConfigCount(1); usbDevice.GetConfigs()[0].SetInterfaceCount(2); @@ -130,7 +132,8 @@ HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnEmptyString_WhenDeviceH HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnCorrectName_WhenDeviceHasLongName, Level0) { usbDevice.name = "ThisIsALongDeviceNameThatExceedsTheMaximumAllowedLengthForTheProductName"; - EXPECT_EQ(printUsbManager->GetProductName(usbDevice), "ThisIsALongDeviceNameThatExceedsTheMaximumAllowedLengthForTheProductName"); + EXPECT_EQ(printUsbManager->GetProductName(usbDevice), + "ThisIsALongDeviceNameThatExceedsTheMaximumAllowedLengthForTheProductName"); } HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnEmptyString_WhenDeviceIsNull, Level0) @@ -169,27 +172,31 @@ TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnEmptyString_Wh EXPECT_EQ(result, ""); } -HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenSurfaceProducerIsNull, TestSize.Level0) +HWTEST_F(PrintUsbManagerTest, + PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenSurfaceProducerIsNull, TestSize.Level0) { printerName = "printer1"; usbDevice.surfaceProducer = nullptr; EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), false); } -HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenSurfaceProducerIsNotNull, TestSize.Level0) +HWTEST_F(PrintUsbManagerTest, + PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenSurfaceProducerIsNotNull, TestSize.Level0) { printerName = "printer1"; usbDevice.surfaceProducer = new SurfaceProducer(); EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), true); delete usbDevice.surfaceProducer; } -HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenPrinterNameIsEmpty, TestSize.Level0) +HWTEST_F(PrintUsbManagerTest, + PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenPrinterNameIsEmpty, TestSize.Level0) { printerName = ""; usbDevice.surfaceProducer = new SurfaceProducer(); EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), false); delete usbDevice.surfaceProducer; } -HWTEST_F(PrintUsbManagerTest, PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenPrinterNameIsNotEmpty, TestSize.Level0) +HWTEST_F(PrintUsbManagerTest, + PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenPrinterNameIsNotEmpty, TestSize.Level0) { printerName = "printer1"; usbDevice.surfaceProducer = new SurfaceProducer(); diff --git a/test/unittest/others/print_user_data_other_test.cpp b/test/unittest/others/print_user_data_other_test.cpp index a743bdb4..2357ffff 100644 --- a/test/unittest/others/print_user_data_other_test.cpp +++ b/test/unittest/others/print_user_data_other_test.cpp @@ -38,6 +38,7 @@ public: void TearDown() override { delete printUserData; + printUserData = nullptr; } }; @@ -202,7 +203,8 @@ HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldAddJobToQueuedJobList_When EXPECT_EQ(printUserData->queuedJobList_[jobId], printJob); } -HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldUpdateJobInQueuedJobList_WhenJobIdIsAlreadyInList, TestSize.Level0) +HWTEST_F(PrintUserDataTest, + UpdateQueuedJobList_ShouldUpdateJobInQueuedJobList_WhenJobIdIsAlreadyInList, TestSize.Level0) { printUserData->queuedJobList_[jobId] = printJob; auto newPrintJob = std::make_shared(); @@ -216,7 +218,8 @@ HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldAddJobIdToJobOrderList_Whe EXPECT_EQ(printUserData->jobOrderList_[jobOrderId], jobId); } -HWTEST_F(PrintUserDataTest, UpdateQueuedJobList_ShouldUpdateJobIdInJobOrderList_WhenJobIdIsAlreadyInList, TestSize.Level0) +HWTEST_F(PrintUserDataTest, + UpdateQueuedJobList_ShouldUpdateJobIdInJobOrderList_WhenJobIdIsAlreadyInList, TestSize.Level0) { printUserData->jobOrderList_[jobOrderId] = jobId; auto newJobId = "newJobId"; @@ -277,7 +280,8 @@ TEST_F(PrintUserDataTest, QueryAllPrintJob_Test_WithMultipleJobs) printUserData.queuedJobList_["1011"] = new PrintJob(); printUserData.QueryAllPrintJob(printJobs); EXPECT_FALSE(printJobs.empty()); - EXPECT_EQ(printJobs.size(), 2); + size_t jobSize = 2; + EXPECT_EQ(printJobs.size(), jobSize); } TEST_F(PrintUserDataTest, QueryAllPrintJob_Test_WithNonExistingJob) { @@ -451,7 +455,8 @@ TEST_F(PrintUserDataTest, DeletePrinterFromUsedPrinterList_Test_Multiple) printUserData.usedPrinterList_.push_back("printer2"); printUserData.usedPrinterList_.push_back("printer3"); printUserData.DeletePrinterFromUsedPrinterList("printer2"); - EXPECT_EQ(printUserData.usedPrinterList_.size(), 2); + int listSize = 2; + EXPECT_EQ(printUserData.usedPrinterList_.size(), listSize); EXPECT_EQ(printUserData.usedPrinterList_[0], "printer1"); EXPECT_EQ(printUserData.usedPrinterList_[1], "printer3"); } @@ -460,8 +465,9 @@ TEST_F(PrintUserDataTest, ParseUserData_ShouldReturn_WhenFileDataNotAvailable) { PrintUserData printUserData; // Mock the GetFileData method to return false indicating file data is not available - printUserData.GetFileData = { return false; -}; + printUserData.GetFileData = { + return false; + }; printUserData.ParseUserData(); // Assert that the method does not crash or throw exceptions EXPECT_NO_THROW(printUserData.ParseUserData()); @@ -471,11 +477,13 @@ TEST_F(PrintUserDataTest, ParseUserData_ShouldReturn_WhenFileDataAvailableButInv { PrintUserData printUserData; // Mock the GetFileData method to return true indicating file data is available - printUserData.GetFileData = { return true; -}; + printUserData.GetFileData = { + return true; + }; // Mock the CheckFileData method to return false indicating file data is invalid -printUserData.CheckFileData = [](const std::string &, nlohmann::json &) -{ return false; }; +printUserData.CheckFileData = [](const std::string &, nlohmann::json &) { + return false; +}; printUserData.ParseUserData(); // Assert that the method does not crash or throw exceptions EXPECT_NO_THROW(printUserData.ParseUserData()); @@ -485,11 +493,14 @@ TEST_F(PrintUserDataTest, ParseUserData_ShouldParse_WhenFileDataAvailableAndVali { PrintUserData printUserData; // Mock the GetFileData method to return true indicating file data is available - printUserData.GetFileData = { return true; -}; + printUserData.GetFileData = { + return true; + }; // Mock the CheckFileData method to return true indicating file data is valid printUserData.CheckFileData = [](const std::string &, nlohmann::json &) -{ return true; }; +{ + return true; +}; // Mock the ParseUserDataFromJson method to do nothing printUserData.ParseUserDataFromJson = [](const nlohmann::json &) {}; printUserData.ParseUserData(); @@ -502,52 +513,51 @@ TEST_F(PrintUserDataTest, ParseUserDataFromJson_Test) nlohmann::json jsonObject; PrintUserData printUserData; printUserData.ParseUserDataFromJson(jsonObject); - // 断言预期的结果，例如： - // EXPECT_EQ(printUserData.defaultPrinterId_, ""); - // EXPECT_EQ(printUserData.lastUsedPrinterId_, ""); - // EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, false); + EXPECT_EQ(printUserData.defaultPrinterId_, ""); + EXPECT_EQ(printUserData.lastUsedPrinterId_, ""); + EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, false); } TEST_F(PrintUserDataTest, ParseUserDataFromJson_Test_WithUserData) { nlohmann::json jsonObject; jsonObject["print_user_data"] = { - {"1", {{"defaultPrinter", "printer1"}, {"lastUsedPrinter", "printer2"}, {"useLastUsedPrinterForDefault", true}, {"usedPrinterList", undefined{nlohmann::json jsonArray; - jsonArray.push_back("printer3"); - return jsonArray; -} -() -} -} -} -} -; + { + "1", + { + {"defaultPrinter", "printer1"}, + {"lastUsedPrinter", "printer2"}, + {"useLastUsedPrinterForDefault", true}, + {"usedPrinterList", undefined{ + nlohmann::json jsonArray;jsonArray.push_back("printer3");return jsonArray;}()} + } + } + }; PrintUserData printUserData; printUserData.ParseUserDataFromJson(jsonObject); -// 断言预期的结果，例如： -// EXPECT_EQ(printUserData.defaultPrinterId_, "printer1"); -// EXPECT_EQ(printUserData.lastUsedPrinterId_, "printer2"); -// EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, true); +EXPECT_EQ(printUserData.defaultPrinterId_, "printer1"); +EXPECT_EQ(printUserData.lastUsedPrinterId_, "printer2"); +EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, true); } TEST_F(PrintUserDataTest, ParseUserDataFromJson_Test_WithUserData_MissingDefaultPrinter) { nlohmann::json jsonObject; jsonObject["print_user_data"] = { - {"1", {{"lastUsedPrinter", "printer2"}, {"useLastUsedPrinterForDefault", true}, {"usedPrinterList", undefined{nlohmann::json jsonArray; - jsonArray.push_back("printer3"); - return jsonArray; -} -() -} -} -} -} -; + { + "1", + { + {"defaultPrinter", "printer1"}, + {"lastUsedPrinter", "printer2"}, + {"useLastUsedPrinterForDefault", true}, + {"usedPrinterList", undefined{ + nlohmann::json jsonArray;jsonArray.push_back("printer3");return jsonArray;}()} + } + } + }; PrintUserData printUserData; printUserData.ParseUserDataFromJson(jsonObject); -// 断言预期的结果，例如： -// EXPECT_EQ(printUserData.defaultPrinterId_, ""); -// EXPECT_EQ(printUserData.lastUsedPrinterId_, "printer2"); -// EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, true); +EXPECT_EQ(printUserData.defaultPrinterId_, ""); +EXPECT_EQ(printUserData.lastUsedPrinterId_, "printer2"); +EXPECT_EQ(printUserData.useLastUsedPrinterForDefault_, true); } TEST_F(PrintUserDataTest, ConvertJsonToUsedPrinterList_Test) @@ -565,7 +575,8 @@ TEST_F(PrintUserDataTest, ConvertJsonToUsedPrinterList_Test_Invalid) PrintUserData printUserData; nlohmann::json userData; userData["usedPrinterList"] = nlohmann::json::array(); - userData["usedPrinterList"].push_back(123); // Invalid value + int printerId = 123; + userData["usedPrinterList"].push_back(printerId); // Invalid value userData["usedPrinterList"].push_back("printer2"); EXPECT_FALSE(printUserData.ConvertJsonToUsedPrinterList(userData)); } From 19f1cd440b2001e0d592682b9c6e22cf7a8bab4f Mon Sep 17 00:00:00 2001 From: baozewei Date: Wed, 13 Nov 2024 19:50:13 +0800 Subject: [PATCH 04/19] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B=20Signed-off-by:baozewei@huawei.com?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: baozewei --- .../others/print_user_data_other_test.cpp | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/test/unittest/others/print_user_data_other_test.cpp b/test/unittest/others/print_user_data_other_test.cpp index 2357ffff..bc4da933 100644 --- a/test/unittest/others/print_user_data_other_test.cpp +++ b/test/unittest/others/print_user_data_other_test.cpp @@ -497,15 +497,14 @@ TEST_F(PrintUserDataTest, ParseUserData_ShouldParse_WhenFileDataAvailableAndVali return true; }; // Mock the CheckFileData method to return true indicating file data is valid -printUserData.CheckFileData = [](const std::string &, nlohmann::json &) -{ - return true; -}; -// Mock the ParseUserDataFromJson method to do nothing -printUserData.ParseUserDataFromJson = [](const nlohmann::json &) {}; -printUserData.ParseUserData(); -// Assert that the method does not crash or throw exceptions -EXPECT_NO_THROW(printUserData.ParseUserData()); + printUserData.CheckFileData = [](const std::string &, nlohmann::json &) { + return true; + }; + // Mock the ParseUserDataFromJson method to do nothing + printUserData.ParseUserDataFromJson = [](const nlohmann::json &) {}; + printUserData.ParseUserData(); + // Assert that the method does not crash or throw exceptions + EXPECT_NO_THROW(printUserData.ParseUserData()); } TEST_F(PrintUserDataTest, ParseUserDataFromJson_Test) From c541d57bad763d2e5f9008e8a7bb957d8423d841 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E5=AD=90=E6=98=8E?= Date: Wed, 13 Nov 2024 20:14:56 +0800 Subject: [PATCH 05/19] =?UTF-8?q?cups=5Fclient=20vendor=5Fhelper=20DT?= =?UTF-8?q?=E7=94=A8=E4=BE=8B=E6=B7=BB=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张子明 --- ...t_cups_client_vendor_helper_other_test.cpp | 1949 +++++++++++++++++ 1 file changed, 1949 insertions(+) create mode 100644 test/unittest/others/print_cups_client_vendor_helper_other_test.cpp diff --git a/test/unittest/others/print_cups_client_vendor_helper_other_test.cpp b/test/unittest/others/print_cups_client_vendor_helper_other_test.cpp new file mode 100644 index 00000000..05ac5836 --- /dev/null +++ b/test/unittest/others/print_cups_client_vendor_helper_other_test.cpp @@ -0,0 +1,1949 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "print_cups_client.h" +#include "print_cups_attribute.h" +#include "vendor_helper.h" + +using namespace testing::ext; +using namespace testing; +namespace OHOS::Print { +TEST_F(nullTest, BuildJobParameters_ShouldReturnNull_WhenOptionIsEmpty) +{ +PrintCupsClient client; +PrintJob job; +EXPECT_EQ(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, BuildJobParameters_ShouldReturnNull_WhenOptionCannotParseToJson) +{ +PrintCupsClient client; +PrintJob job; +job.SetOption("invalid json"); +EXPECT_EQ(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, BuildJobParameters_ShouldReturnNull_WhenOptionDoesNotHaveNecessaryAttribute) +{ +PrintCupsClient client; +PrintJob job; +job.SetOption("{"printerUri": "uri", "printerName": "name"}"); +EXPECT_EQ(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, BuildJobParameters_ShouldReturnNonNull_WhenAllConditionsAreMet) +{ +PrintCupsClient client; +PrintJob job; +job.SetOption("{"printerUri": "uri", "printerName": "name", "documentFormat": "format"}"); +EXPECT_NE(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, BuildJobParameters_ShouldReturnNull_WhenNewJobParametersReturnsNullptr) +{ +PrintCupsClient client; +PrintJob job; +job.SetOption("{"printerUri": "uri", "printerName": "name", "documentFormat": "format", "printerUri": "uri",\ + "printerName": "name"}"); +EXPECT_EQ(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, BuildJobParameters_ShouldReturnNull_WhenIsCupsServerAliveReturnsFalse) +{ +PrintCupsClient client; +PrintJob job; +job.SetOption("{"printerUri": "uri", "printerName": "name", "documentFormat": "format", "printerUri": "uri",\ + "printerName": "name"}"); +EXPECT_EQ(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, BuildJobParameters_ShouldReturnNull_WhenIsPrinterExistReturnsFalse) +{ +PrintCupsClient client; +PrintJob job; +job.SetOption("{"printerUri": "uri", "printerName": "name", "documentFormat": "format", "printerUri": "uri",\ + "printerName": "name"}"); +EXPECT_EQ(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, BuildJobParameters_ShouldReturnNull_WhenIsIpConflictReturnsTrue) +{ +PrintCupsClient client; +PrintJob job; +job.SetOption("{"printerUri": "uri", "printerName": "name", "documentFormat": "format", "printerUri": "uri",\ + "printerName": "name"}"); +EXPECT_EQ(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, BuildJobParameters_ShouldReturnNull_WhenDiscoverUsbPrintersReturnsError) +{ +PrintCupsClient client; +PrintJob job; +job.SetOption("{"printerUri": "uri", "printerName": "name", "documentFormat": "format", "printerUri": "uri",\ + "printerName": "name"}"); +EXPECT_EQ(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, BuildJobParameters_ShouldReturnNull_WhenResumePrinterReturnsError) +{ +PrintCupsClient client; +PrintJob job; +job.SetOption("{"printerUri": "uri", "printerName": "name", "documentFormat": "format", "printerUri": "uri",\ + "printerName": "name"}"); +EXPECT_EQ(client.BuildJobParameters(job), nullptr); +} +TEST_F(nullTest, ReportBlockedReason_WhenParamIsNull_ShouldReturn) +{ +PrintCupsClient client; +JobMonitorParam *param = nullptr; +JobStatus *jobStatus = new JobStatus(); +client.ReportBlockedReason(param, jobStatus); +// 由于param为nullptr，所以没有任何断言，因为没有任何实际的行为可断言 +// 但是，如果函数没有任何副作用，那么这是一个有效的测试 +} +TEST_F(nullTest, ReportBlockedReason_WhenJobStatusIsNull_ShouldReturn) +{ +PrintCupsClient client; +JobMonitorParam *param = new JobMonitorParam(); +JobStatus *jobStatus = nullptr; +client.ReportBlockedReason(param, jobStatus); +// 由于jobStatus为nullptr，所以没有任何断言，因为没有任何实际的行为可以断言 +// 但是，如果函数没有任何副作用，那么这是一个有效的测试 +} +TEST_F(nullTest, ReportBlockedReason_WhenServiceAbilityIsNull_ShouldReturn) +{ +PrintCupsClient client; +JobMonitorParam *param = new JobMonitorParam(); +param->serviceAbility = nullptr; +JobStatus *jobStatus = new JobStatus(); +client.ReportBlockedReason(param, jobStatus); +// 由于param->serviceAbility为nullptr，所以没有任何断言，因为没有任何实际的行为可以断言 +// 但是，如果函数没有任何副作用，那么这是一个有效的测试 +} +TEST_F(nullTest, ReportBlockedReason_WhenPrinterStateReasonsContainOffline_ShouldUpdatePrintJobState) +{ +PrintCupsClient client; +JobMonitorParam *param = new JobMonitorParam(); +param->serviceAbility = new ServiceAbility(); +JobStatus *jobStatus = new JobStatus(); +jobStatus->printer_state_reasons = "offline"; +client.ReportBlockedReason(param, jobStatus); +// 断言param->serviceAbility->UpdatePrintJobState被正确调用 +} +TEST_F(nullTest, ReportBlockedReason_WhenPrinterStateReasonsContainPaused_ShouldUpdatePrintJobState) +{ +PrintCupsClient client; +JobMonitorParam *param = new JobMonitorParam(); +param->serviceAbility = new ServiceAbility(); +JobStatus *jobStatus = new JobStatus(); +jobStatus->printer_state_reasons = "paused"; +client.ReportBlockedReason(param, jobStatus); +// 断言param->serviceAbility->UpdatePrintJobState被正确调用 +} +TEST_F(nullTest, ReportBlockedReason_WhenPrinterStateReasonsContainOther_ShouldUpdatePrintJobStateUnknown) +{ +PrintCupsClient client; +JobMonitorParam *param = new JobMonitorParam(); +param->serviceAbility = new ServiceAbility(); +JobStatus *jobStatus = new JobStatus(); +jobStatus->printer_state_reasons = "other"; +client.ReportBlockedReason(param, jobStatus); +// 断言param->serviceAbility->UpdatePrintJobState被正确调用，并且substate为PRINT_JOB_BLOCKED_UNKNOWN +} +TEST_F(nullTest, ReportBlockedReason_WhenPrinterStateReasonsContainMediaEmpty_ShouldUpdatePrintJobStateOutOfPaper) +{ +PrintCupsClient client; +JobMonitorParam *param = new JobMonitorParam(); +param->serviceAbility = new ServiceAbility(); +JobStatus *jobStatus = new JobStatus(); +jobStatus->printer_state_reasons = "media-empty"; +client.ReportBlockedReason(param, jobStatus); +// 断言param->serviceAbility->UpdatePrintJobState被正确调用，并且substate包含PRINT_JOB_BLOCKED_OUT_OF_PAPER +} +// 其他测试用例类似 +TEST_F(nullTest, testStartCupsJob) +{ +PrintCupsClient client; +JobParameters jobParams; +jobParams.fdList.push_back(1); +jobParams.printerName = "printer"; +jobParams.printerId = 1; +jobParams.printerUri = "printerUri"; +jobParams.serviceAbility = new PrintServiceAbility(); +jobParams.serviceJobId = 1; +auto callback = undefined { +PRINT_HILOGI("callback"); +}; +client.StartCupsJob(&jobParams, callback); +} +TEST_F(nullTest, testUpdatePrintJobStateInJobParams) +{ +PrintCupsClient client; +JobParameters jobParams; +jobParams.fdList.push_back(1); +jobParams.printerName = "printer"; +jobParams.printerId = 1; +jobParams.printerUri = "printerUri"; +jobParams.serviceAbility = new PrintServiceAbility(); +jobParams.serviceJobId = 1; +client.UpdatePrintJobStateInJobParams(&jobParams, 1, 1); +} +TEST_F(nullTest, testHandleJobState) +{ +PrintCupsClient client; +JobMonitorParam param; +JobStatus jobStatus; +JobStatus previousJobStatus; +client.HandleJobState(nullptr, ¶m, &jobStatus, &previousJobStatus); +} +TEST_F(nullTest, testMonitorJobState) +{ +PrintCupsClient client; +JobMonitorParam param; +auto callback = undefined { +PRINT_HILOGI("callback"); +}; +client.MonitorJobState(¶m, callback); +} +TEST_F(nullTest, testQueryJobStateAgain) +{ +PrintCupsClient client; +JobMonitorParam param; +JobStatus jobStatus; +client.QueryJobStateAgain(nullptr, ¶m, &jobStatus); +} +TEST_F(nullTest, testUpdateJobStatus) +{ +PrintCupsClient client; +JobStatus previousJobStatus; +JobStatus jobStatus; +client.UpdateJobStatus(&previousJobStatus, &jobStatus); +} +TEST_F(nullTest, testJobStatusCallback) +{ +PrintCupsClient client; +JobMonitorParam param; +JobStatus jobStatus; +client.JobStatusCallback(¶m, &jobStatus, true); +} +TEST_F(nullTest, QueryPrinterAttrList_Test) +{ +PrintCupsClient client; +std::string printerName = "testPrinter"; +std::vector std::stringundefined keyList = {"testKey"}; +std::vector std::stringundefined valueList; +int32_t result = client.QueryPrinterAttrList(printerName, keyList, valueList); +EXPECT_EQ(result, E_PRINT_SERVER_FAILURE); +EXPECT_TRUE(valueList.empty()); +} +TEST_F(nullTest, QueryPrinterInfoByPrinterId_Test) +{ +PrintCupsClient client; +std::string printerId = "testPrinterId"; +PrinterInfo info; +int32_t result = client.QueryPrinterInfoByPrinterId(printerId, info); +EXPECT_EQ(result, E_PRINT_SERVER_FAILURE); +} +TEST_F(nullTest, CheckPrinterMakeModel_Test) +{ +PrintCupsClient client; +JobParameters jobParams; +bool result = client.CheckPrinterMakeModel(&jobParams); +EXPECT_FALSE(result); +} +TEST_F(nullTest, VerifyPrintJob_Test) +{ +PrintCupsClient client; +JobParameters jobParams; +int numOptions = 0; +uint32_t jobId = 0; +cups_option_t *options = nullptr; +http_t *http = nullptr; +bool result = client.VerifyPrintJob(&jobParams, num_options, jobId, options, http); +EXPECT_FALSE(result); +} +TEST_F(nullTest, HandleFiles_Test) +{ +PrintCupsClient client; +JobParameters jobParams; +uint32_t num_files = 0; +http_t *http = nullptr; +uint32_t jobId = 0; +bool result = client.HandleFiles(&jobParams, num_files, http, jobId); +EXPECT_FALSE(result); +} +TEST_F(nullTest, AddCupsPrintJob_Test) +{ +PrintCupsClient client; +PrintJob job; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_CurrentJob) +{ +PrintCupsClient client; +PrintJob job; +// 模拟currentJob_不为空 +client.currentJob_ = new JobParameters(); +client.AddCupsPrintJob(job); +// 验证jobQueue_是否没有添加新的job +EXPECT_EQ(client.jobQueue_.size(), 0); +// 验证currentJob_是否仍然不变 +EXPECT_NE(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_Empty_JobQueue) +{ +PrintCupsClient client; +PrintJob job; +// 模拟jobQueue_为空 +client.jobQueue_.clear(); +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_NonEmpty_JobQueue) +{ +PrintCupsClient client; +PrintJob job; +// 模拟jobQueue_非空 +client.jobQueue_.push_back(new JobParameters()); +client.AddCupsPrintJob(job); +// 验证jobQueue_是否没有添加新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_NextJob_Null) +{ +PrintCupsClient client; +PrintJob job; +// 模拟GetNextJob返回null +client.GetNextJob = undefined { return nullptr; }; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否没有添加新的job +EXPECT_EQ(client.jobQueue_.size(), 0); +// 验证currentJob_是否仍然为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_NextJob_Not_Null) +{ +PrintCupsClient client; +PrintJob job; +// 模拟GetNextJob返回非null +client.jobQueue_.push_back(new JobParameters()); +client.GetNextJob = &undefined { return client.jobQueue_.back(); }; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否没有添加新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_ToCups_False) +{ +PrintCupsClient client; +PrintJob job; +// 模拟toCups_为false +client.toCups_ = false; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否没有添加新的job +EXPECT_EQ(client.jobQueue_.size(), 0); +// 验证currentJob_是否仍然为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_ToCups_True) +{ +PrintCupsClient client; +PrintJob job; +// 模拟toCups_为true +client.toCups_ = true; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_JobParameters_Null) +{ +PrintCupsClient client; +PrintJob job; +// 模拟BuildJobParameters返回null +client.BuildJobParameters = [](const PrintJob &jobInfo) { return nullptr; }; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否没有添加新的job +EXPECT_EQ(client.jobQueue_.size(), 0); +// 验证currentJob_是否仍然为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_JobParameters_Not_Null) +{ +PrintCupsClient client; +PrintJob job; +// 模拟BuildJobParameters返回非null +client.BuildJobParameters = [](const PrintJob &jobInfo) { return new JobParameters(); }; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_DumpJobParameters_Called) +{ +PrintCupsClient client; +PrintJob job; +// 模拟DumpJobParameters被调用 +client.DumpJobParameters = [](JobParameters *jobParams) {}; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_StartNextJob_Called) +{ +PrintCupsClient client; +PrintJob job; +// 模拟StartNextJob被调用 +client.StartNextJob = &undefined {}; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_JobCompleteCallback_Called) +{ +PrintCupsClient client; +PrintJob job; +// 模拟JobCompleteCallback被调用 +client.JobCompleteCallback = &undefined {}; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_FillBorderlessOptions_Called) +{ +PrintCupsClient client; +PrintJob job; +// 模拟FillBorderlessOptions被调用 +client.FillBorderlessOptions = [](JobParameters *jobParams, int num_options, + cups_option_t **options) { return num_options; }; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_FillJobOptions_Called) +{ +PrintCupsClient client; +PrintJob job; +// 模拟FillJobOptions被调用 +client.FillJobOptions = [](JobParameters *jobParams, int num_options, cups_option_t **options) { return num_options; }; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_QueryAddedPrinterList_Called) +{ +PrintCupsClient client; +PrintJob job; +// 模拟QueryAddedPrinterList被调用 +client.QueryAddedPrinterList = [](std::vector std::stringundefined &printerNameList) { return E_PRINT_NONE; }; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_SetDefaultPrinter_Called) +{ +PrintCupsClient client; +PrintJob job; +// 模拟SetDefaultPrinter被调用 +client.SetDefaultPrinter = [](const std::string &printerName) { return E_PRINT_NONE; }; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddCupsPrintJob_Test_With_GetPPDFile_Called) +{ +PrintCupsClient client; +PrintJob job; +// 模拟GetPPDFile被调用 +client.GetPPDFile = [](const std::string &printerName) { return nullptr; }; +client.AddCupsPrintJob(job); +// 验证jobQueue_是否添加了新的job +EXPECT_EQ(client.jobQueue_.size(), 1); +// 验证currentJob_是否为nullptr +EXPECT_EQ(client.currentJob_, nullptr); +} +TEST_F(nullTest, AddPrinterToCups_Test) +{ +PrintCupsClient client; +std::string printerUri = "ipp://localhost/printers/testPrinter"; +std::string printerName = "TestPrinter"; +std::string printerMake = "TestMake"; +int32_t result = client.AddPrinterToCups(printerUri, printerName, printerMake); +EXPECT_EQ(result, E_PRINT_NONE); +} +TEST_F(nullTest, AddPrinterToCupsWithPpd_Test) +{ +PrintCupsClient client; +std::string printerUri = "ipp://localhost/printers/testPrinter"; +std::string printerName = "TestPrinter"; +std::string ppdName = "TestPpd"; +std::string ppdData = "TestPpdData"; +int32_t result = client.AddPrinterToCupsWithPpd(printerUri, printerName, ppdName, ppdData); +EXPECT_EQ(result, E_PRINT_NONE); +} +TEST_F(nullTest, DeleteCupsPrinter_Test) +{ +PrintCupsClient client; +std::string printerName = "TestPrinter"; +int32_t result = client.DeleteCupsPrinter(printerName.c_str()); +EXPECT_EQ(result, E_PRINT_NONE); +} +TEST_F(nullTest, QueryPrinterAttributesByUri_Test) +{ +PrintCupsClient client; +std::string printerUri = "ipp://localhost/printers/testPrinter"; +std::string nic = ""; +int num = 0; +const char * const *pattrs = nullptr; +ipp_t *response = client.QueryPrinterAttributesByUri(printerUri, nic, num, pattrs); +EXPECT_NE(response, nullptr); +ippDelete(response); +} +TEST_F(nullTest, QueryPrinterCapabilityByUri_Test) +{ +PrintCupsClient client; +std::string printerUri = "ipp://localhost/printers/testPrinter"; +std::string printerId = "TestPrinterId"; +PrinterCapability printerCaps; +int32_t result = client.QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps); +EXPECT_EQ(result, E_PRINT_NONE); +} +TEST_F(nullTest, QueryPrinterStatusByUri_Test) +{ +PrintCupsClient client; +std::string printerUri = "ipp://localhost/printers/testPrinter"; +PrinterStatus status; +int32_t result = client.QueryPrinterStatusByUri(printerUri, status); +EXPECT_EQ(result, E_PRINT_NONE); +} +TEST_F(nullTest, QueryPrinterCapabilityFromPPD_Test) +{ +PrintCupsClient client; +std::string printerName = "TestPrinter"; +PrinterCapability printerCaps; +int32_t result = client.QueryPrinterCapabilityFromPPD(printerName, printerCaps); +EXPECT_EQ(result, E_PRINT_NONE); +} +TEST_F(nullTest, testCopyDirectory) +{ +PrintCupsClient client; +const char *srcDir = "/src"; +const char *destDir = "/dest"; +client.CopyDirectory(srcDir, destDir); +// 验证是否正确复制了目录 +// 这里需要实际的文件系统操作来验证，这里只是示例 +EXPECT_TRUE(true); +} +TEST_F(nullTest, testCopyDirectory_SrcDirNotExist) +{ +PrintCupsClient client; +const char *srcDir = "/nonexistent_src"; +const char *destDir = "/dest"; +client.CopyDirectory(srcDir, destDir); +// 验证当源目录不存在时，是否正确处理 +// 这里需要实际的文件系统操作来验证，这里只是示例 +EXPECT_TRUE(true); +} +TEST_F(nullTest, testCopyDirectory_DestDirNotExist) +{ +PrintCupsClient client; +const char *srcDir = "/src"; +const char *destDir = "/nonexistent_dest"; +client.CopyDirectory(srcDir, destDir); +// 验证当目标目录不存在时，是否正确处理 +// 这里需要实际的文件系统操作来验证，这里只是示例 +EXPECT_TRUE(true); +} +TEST_F(nullTest, testCopyDirectory_SrcAndDestDirNotExist) +{ +PrintCupsClient client; +const char *srcDir = "/nonexistent_src"; +const char *destDir = "/nonexistent_dest"; +client.CopyDirectory(srcDir, destDir); +// 验证当源目录和目标目录都不存在时，是否正确处理 +// 这里需要实际的文件系统操作来验证，这里只是示例 +EXPECT_TRUE(true); +} +TEST_F(nullTest, testCopyDirectory_SrcDirIsFile) +{ +PrintCupsClient client; +const char *srcDir = "/src/file"; +const char *destDir = "/dest"; +client.CopyDirectory(srcDir, destDir); +// 验证当源路径是一个文件时，是否正确处理 +// 这里需要实际的文件系统操作来验证，这里只是示例 +EXPECT_TRUE(true); +} +TEST_F(nullTest, testCopyDirectory_SrcDirIsSymLink) +{ +PrintCupsClient client; +const char *srcDir = "/src/symlink"; +const char *destDir = "/dest"; +client.CopyDirectory(srcDir, destDir); +// 验证当源路径是一个符号链接时，是否正确处理 +// 这里需要实际的文件系统操作来验证，这里只是示例 +EXPECT_TRUE(true); +} +TEST_F(nullTest, testCopyDirectory_DestDirIsSymLink) +{ +PrintCupsClient client; +const char *srcDir = "/src"; +const char *destDir = "/dest/symlink"; +client.CopyDirectory(srcDir, destDir); +// 验证当目标路径是一个符号链接时，是否正确处理 +// 这里需要实际的文件系统操作来验证，这里只是示例 +EXPECT_TRUE(true); +} +TEST_F(nullTest, testCopyDirectory_SrcAndDestDirAreSymLink) +{ +PrintCupsClient client; +const char *srcDir = "/src/symlink"; +const char *destDir = "/dest/symlink"; +client.CopyDirectory(srcDir, destDir); +// 验证当源路径和目标路径都是符号链接时，是否正确处理 +// 这里需要实际的文件系统操作来验证，这里只是示例 +EXPECT_TRUE(true); +} +TEST_F(nullTest, DeviceCb_ShouldAddPrinterInfo_WhenDeviceUriStartsWithUSBAndPrinterMakeIsNotUnknown) +{ +// Arrange +std::string deviceUri = "usb://printer"; +std::string deviceClass = "printer"; +std::string deviceInfo = "model123"; +std::string deviceMakeAndModel = "model123"; +std::string deviceLocation = "location123"; +void *userData = nullptr; +// Act +DeviceCb(deviceClass.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(), + deviceUri.c_str(), deviceLocation.c_str(), userData); +// Assert +EXPECT_EQ(usbPrinters.size(), 1); +EXPECT_EQ(usbPrinters[0].GetUri(), deviceUri); +EXPECT_EQ(usbPrinters[0].GetPrinterMake(), deviceMakeAndModel); +} +TEST_F(nullTest, DeviceCb_ShouldNotAddPrinterInfo_WhenDeviceUriDoesNotStartWithUSB) +{ +// Arrange +std::string deviceUri = "network://printer"; +std::string deviceClass = "printer"; +std::string deviceInfo = "model123"; +std::string deviceMakeAndModel = "model123"; +std::string deviceLocation = "location123"; +void *userData = nullptr; +// Act +DeviceCb(deviceClass.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(), + deviceUri.c_str(), deviceLocation.c_str(), userData); +// Assert +EXPECT_EQ(usbPrinters.size(), 0); +} +TEST_F(nullTest, DeviceCb_ShouldNotAddPrinterInfo_WhenPrinterMakeIsUnknown) +{ +// Arrange +std::string deviceUri = "usb://printer"; +std::string deviceClass = "printer"; +std::string deviceInfo = "model123"; +std::string deviceMakeAndModel = "unknown"; +std::string deviceLocation = "location123"; +void *userData = nullptr; +// Act +DeviceCb(deviceClass.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(), + deviceUri.c_str(), deviceLocation.c_str(), userData); +// Assert +EXPECT_EQ(usbPrinters.size(), 0); +} + +TEST_F(nullTest, testNullInput) +{ +DuplexModeCode dst; +EXPECT_FALSE(ConvertDuplexModeCode(nullptr, dst)); +} +TEST_F(nullTest, testOneSided) +{ +DuplexModeCode dst; +EXPECT_TRUE(ConvertDuplexModeCode(CUPS_SIDES_ONE_SIDED, dst)); +EXPECT_EQ(dst, DUPLEX_MODE_ONE_SIDED); +} +TEST_F(nullTest, testTwoSidedPortrait) +{ +DuplexModeCode dst; +EXPECT_TRUE(ConvertDuplexModeCode(CUPS_SIDES_TWO_SIDED_PORTRAIT, dst)); +EXPECT_EQ(dst, DUPLEX_MODE_TWO_SIDED_LONG_EDGE); +} +TEST_F(nullTest, testTwoSidedLandscape) +{ +DuplexModeCode dst; +EXPECT_TRUE(ConvertDuplexModeCode(CUPS_SIDES_TWO_SIDED_LANDSCAPE, dst)); +EXPECT_EQ(dst, DUPLEX_MODE_TWO_SIDED_SHORT_EDGE); +} +TEST_F(nullTest, testInvalidInput) +{ +DuplexModeCode dst; +EXPECT_FALSE(ConvertDuplexModeCode("invalid_input", dst)); +} + +TEST_F(nullTest, testConvertIppAttributesToJsonString) +{ +ipp_t *response = nullptr; +std::string keyword = "testKeyword"; +std::string result = ConvertIppAttributesToJsonString(response, keyword); +EXPECT_EQ(result, ""); +} +TEST_F(nullTest, testConvertIppAttributesToJsonStringWithNullAttrPtr) +{ +ipp_t response; +response.attrs = nullptr; +std::string keyword = "testKeyword"; +std::string result = ConvertIppAttributesToJsonString(&response, keyword); +EXPECT_EQ(result, ""); +} +TEST_F(nullTest, testConvertIppAttributesToJsonStringWithEmptyAttrArray) +{ +ipp_t response; +response.attrs = ippNew(); +std::string keyword = "testKeyword"; +std::string result = ConvertIppAttributesToJsonString(&response, keyword); +EXPECT_EQ(result, ""); +} +TEST_F(nullTest, testConvertIppAttributesToJsonStringWithValidAttrArray) +{ +ipp_t response; +response.attrs = ippNew(); +ipp_attribute_t *attrPtr = ippNewAttribute("test-attr", IPP_TAG_KEYWORD); +ippAddString(attrPtr, IPP_TAG_ZERO, NULL, "test-value"); +ippAddAttribute(response.attrs, "test-attr", attrPtr); +std::string keyword = "test-attr"; +std::string result = ConvertIppAttributesToJsonString(&response, keyword); +EXPECT_EQ(result, "["test-value"]"); +} +TEST_F(nullTest, testConvertIppAttributesToJsonStringWithMultipleValues) +{ +ipp_t response; +response.attrs = ippNew(); +ipp_attribute_t *attrPtr = ippNewAttribute("test-attr", IPP_TAG_KEYWORD); +ippAddString(attrPtr, IPP_TAG_ZERO, NULL, "test-value1"); +ippAddString(attrPtr, IPP_TAG_ZERO, NULL, "test-value2"); +ippAddAttribute(response.attrs, "test-attr", attrPtr); +std::string keyword = "test-attr"; +std::string result = ConvertIppAttributesToJsonString(&response, keyword); +EXPECT_EQ(result, "["test-value1","test-value2"]"); +} +HWTEST_F(nullTest, ParseDuplexModeAttributes_ShouldHandleNullResponse, TestSize.Level0) +{ +PrinterCapability printerCaps; +ParseDuplexModeAttributes(nullptr, printerCaps); +// 断言 +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("sides-supported"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("sides-default"), ""); +EXPECT_EQ(printerCaps.GetDuplexMode(), (uint32_t)DUPLEX_MODE_ONE_SIDED); +EXPECT_EQ(printerCaps.GetSupportedDuplexMode().size(), 0); +} + +TEST_F(nullTest, ParsePageSizeAttributes_Should_SetSupportedPageSize_When_ResponseIsNotNull) +{ +ipp_t *response = new ipp_t; +PrinterCapability printerCaps; +ParsePageSizeAttributes(response, printerCaps); +EXPECT_TRUE(printerCaps.GetSupportedPageSize().size() > 0); +delete response; +} +TEST_F(nullTest, ParsePageSizeAttributes_Should_SetPrinterAttrNameAndValue_When_DefaultPageSizeIdIsPresent) +{ +ipp_t *response = new ipp_t; +PrinterCapability printerCaps; +ParsePageSizeAttributes(response, printerCaps); +EXPECT_STREQ(printerCaps.GetPrinterAttrNameAndValue("defaultPageSizeId").c_str(), "defaultPageSizeId"); +delete response; +} +TEST_F(nullTest, ParsePageSizeAttributes_Should_NotSetPrinterAttrNameAndValue_When_DefaultPageSizeIdIsNotPresent) +{ +ipp_t *response = new ipp_t; +PrinterCapability printerCaps; +ParsePageSizeAttributes(response, printerCaps); +EXPECT_STREQ(printerCaps.GetPrinterAttrNameAndValue("defaultPageSizeId").c_str(), ""); +delete response; +} + +TEST_F(nullTest, ParseQualityAttributes_ShouldHandleNullResponse) +{ +PrinterCapability printerCaps; +ParseQualityAttributes(nullptr, printerCaps); +// 验证printerCaps的状态，确保没有修改任何属性 +EXPECT_EQ(printerCaps.GetPrinterAttrName(), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrValue(), ""); +EXPECT_TRUE(printerCaps.GetSupportedQuality().empty()); +} +TEST_F(nullTest, ParseQualityAttributes_ShouldHandleEmptyResponse) +{ +ipp_t *response = ippNew(); +PrinterCapability printerCaps; +ParseQualityAttributes(response, printerCaps); +// 验证printerCaps的状态，确保没有修改任何属性 +EXPECT_EQ(printerCaps.GetPrinterAttrName(), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrValue(), ""); +EXPECT_TRUE(printerCaps.GetSupportedQuality().empty()); +ippDelete(response); +} +TEST_F(nullTest, ParseQualityAttributes_ShouldHandleMissingQualityAttribute) +{ +ipp_t *response = ippNew(); +ippAddString(response, IPP_TAG_JOB, IPP_TAG_KEYWORD, "job-id", NULL, "1234"); +PrinterCapability printerCaps; +ParseQualityAttributes(response, printerCaps); +// 验证printerCaps的状态，确保没有修改任何属性 +EXPECT_EQ(printerCaps.GetPrinterAttrName(), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrValue(), ""); +EXPECT_TRUE(printerCaps.GetSupportedQuality().empty()); +ippDelete(response); +} +TEST_F(nullTest, ParseQualityAttributes_ShouldHandleInvalidQualityValue) +{ +ipp_t *response = ippNew(); +ippAddString(response, IPP_TAG_JOB, IPP_TAG_KEYWORD, "job-id", NULL, "1234"); +ipp_attribute_t *attrPtr = ippNew(); +ippAddInteger(attrPtr, IPP_TAG_ENUM, IPP_TAG_INTEGER, -1); +ippAddCollection(response, IPP_TAG_JOB, "print-quality-supported", attrPtr); +PrinterCapability printerCaps; +ParseQualityAttributes(response, printerCaps); +// 验证printerCaps的状态，确保没有修改任何属性 +EXPECT_EQ(printerCaps.GetPrinterAttrName(), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrValue(), ""); +EXPECT_TRUE(printerCaps.GetSupportedQuality().empty()); +ippDelete(response); +ippDelete(attrPtr); +} +TEST_F(nullTest, ParseQualityAttributes_ShouldHandleValidQualityValue) +{ +ipp_t *response = ippNew(); +ippAddString(response, IPP_TAG_JOB, IPP_TAG_KEYWORD, "job-id", NULL, "1234"); +ipp_attribute_t *attrPtr = ippNew(); +ippAddInteger(attrPtr, IPP_TAG_ENUM, IPP_TAG_INTEGER, THREE); +ippAddCollection(response, IPP_TAG_JOB, "print-quality-supported", attrPtr); +PrinterCapability printerCaps; +ParseQualityAttributes(response, printerCaps); +// 验证printerCaps的状态，确保没有修改任何属性 +EXPECT_EQ(printerCaps.GetPrinterAttrName(), "print-quality-supported"); +EXPECT_EQ(printerCaps.GetPrinterAttrValue(), "[3]"); +EXPECT_EQ(printerCaps.GetSupportedQuality().size(), 1); +EXPECT_EQ(printerCaps.GetSupportedQuality()[0], THREE); +ippDelete(response); +ippDelete(attrPtr); +} +TEST_F(nullTest, ParseSupportedResolutionAttribute_Test) +{ +ipp_t *response = nullptr; +PrinterCapability printerCaps; +ParseSupportedResolutionAttribute(response, printerCaps); +// 验证printerCaps的属性是否被正确设置 +EXPECT_EQ(printerCaps.GetResolution().size(), 0); +} +TEST_F(nullTest, ParseSupportedResolutionAttribute_Test_WithResponse) +{ +ipp_t response; +PrinterCapability printerCaps; +ParseSupportedResolutionAttribute(&response, printerCaps); +// 验证printerCaps的属性是否被正确设置 +EXPECT_EQ(printerCaps.GetResolution().size(), 0); +} +TEST_F(nullTest, ParseSupportedResolutionAttribute_Test_WithResolution) +{ +ipp_t response; +PrinterCapability printerCaps; +ipp_attribute_t attr; +response.attrs = &attr; +ParseSupportedResolutionAttribute(&response, printerCaps); +// 验证printerCaps的属性是否被正确设置 +EXPECT_EQ(printerCaps.GetResolution().size(), 0); +} +TEST_F(nullTest, ParseSupportedResolutionAttribute_Test_WithResolutionAndValue) +{ +ipp_t response; +PrinterCapability printerCaps; +ipp_attribute_t attr; +response.attrs = &attr; +attr.values = new ipp_res_t[2]{100, 200}; +ParseSupportedResolutionAttribute(&response, printerCaps); +// 验证printerCaps的属性是否被正确设置 +EXPECT_EQ(printerCaps.GetResolution().size(), 1); +EXPECT_EQ(printerCaps.GetResolution()[0].GetHorizontalDpi(), ONE); +EXPECT_EQ(printerCaps.GetResolution()[0].GetVerticalDpi(), ONE); +} +TEST_F(nullTest, ParseSupportedResolutionAttribute_Test_WithResolutionAndValueAndUnits) +{ +ipp_t response; +PrinterCapability printerCaps; +ipp_attribute_t attr; +response.attrs = &attr; +attr.values = new ipp_res_t[4]{100, 200, IPP_RES_PER_CM, IPP_RES_PER_INCH}; +ParseSupportedResolutionAttribute(&response, printerCaps); +// 验证printerCaps的属性是否被正确设置 +EXPECT_EQ(printerCaps.GetResolution().size(), 1); +EXPECT_EQ(printerCaps.GetResolution()[0].GetHorizontalDpi(), ONE); +EXPECT_EQ(printerCaps.GetResolution()[0].GetVerticalDpi(), ONE); +} +TEST_F(nullTest, ParseSupportedResolutionAttribute_Test_WithResolutionAndValueAndUnknownUnits) +{ +ipp_t response; +PrinterCapability printerCaps; +ipp_attribute_t attr; +response.attrs = &attr; +attr.values = new ipp_res_t[3]{100, 200, 999}; +ParseSupportedResolutionAttribute(&response, printerCaps); +// 验证printerCaps的属性是否被正确设置 +EXPECT_EQ(printerCaps.GetResolution().size(), 0); +} +TEST_F(nullTest, ParseDefaultResolutionAttribute_ShouldReturnNullptr_WhenAttrPtrIsNull) +{ +ipp_t response; +PrinterCapability printerCaps; +ParseDefaultResolutionAttribute(&response, printerCaps); +// 断言 +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("printer-resolution-default"), ""); +} +TEST_F(nullTest, ParseDefaultResolutionAttribute_ShouldReturnCorrectDpi_WhenAttrPtrIsNotNull) +{ +ipp_t response; +PrinterCapability printerCaps; +response.attrPtr = ippFindAttribute(&response, "printer-resolution-default", IPP_TAG_RESOLUTION); +response.attrPtr->num = 1; +response.attrPtr->values[0].integer = ONE; +response.attrPtr->values[1].integer = ONE; +response.attrPtr->values[ONE].integer = IPP_RES_PER_INCH; +ParseDefaultResolutionAttribute(&response, printerCaps); +// 断言 +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("printer-resolution-default"), +"{"horizontalDpi":200,"verticalDpi":200}"); +} +TEST_F(nullTest, ParseDefaultResolutionAttribute_ShouldHandleUnknownDpiUnit_WhenUnitsAreNotKnown) +{ +ipp_t response; +PrinterCapability printerCaps; +response.attrPtr = ippFindAttribute(&response, "printer-resolution-default", IPP_TAG_RESOLUTION); +response.attrPtr->num = 1; +response.attrPtr->values[0].integer = ONE; +response.attrPtr->values[1].integer = ONE; +response.attrPtr->values[ONE].integer = ONE; // Unknown dpi unit +ParseDefaultResolutionAttribute(&response, printerCaps); +// 断言 +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("printer-resolution-default"), ""); +} +TEST_F(nullTest, ParseDefaultResolutionAttribute_ShouldHandleZeroResolution_WhenXresOrYresIsZero) +{ +ipp_t response; +PrinterCapability printerCaps; +response.attrPtr = ippFindAttribute(&response, "printer-resolution-default", IPP_TAG_RESOLUTION); +response.attrPtr->num = 1; +response.attrPtr->values[0].integer = 0; // Zero xres +response.attrPtr->values[1].integer = ONE; +response.attrPtr->values[ONE].integer = IPP_RES_PER_INCH; +ParseDefaultResolutionAttribute(&response, printerCaps); +// 断言 +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("printer-resolution-default"), + "{"horizontalDpi":0,"verticalDpi":200}"); +} +TEST_F(nullTest, ParseMediaColDefaultAttributes_ShouldHandleNullResponse) +{ +PrinterCapability printerCaps; +ParseMediaColDefaultAttributes(nullptr, printerCaps); +// Assert that the printerCaps is not modified +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-top-margin-default"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-bottom-margin-default"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-left-margin-default"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-right-margin-default"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("duplex-supported"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-source-default"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-type-default"), ""); +} +TEST_F(nullTest, ParseMediaColDefaultAttributes_ShouldHandleNullPrinterCaps) +{ +ipp_t response; +ParseMediaColDefaultAttributes(&response, nullptr); +// No assertions needed as the function should handle null PrinterCaps gracefully +} +TEST_F(nullTest, ParseMediaColDefaultAttributes_ShouldHandleNullResponseAndPrinterCaps) +{ +ParseMediaColDefaultAttributes(nullptr, nullptr); +// No assertions needed as the function should handle null inputs gracefully +} +TEST_F(nullTest, ParseMediaColDefaultAttributes_ShouldHandleValidResponse) +{ +ipp_t response; +response.attrs = ipp_attribute_t(); +response.attrs.name = "media-col-default"; +response.attrs.values = ipp_attribute_value_t(); +response.attrs.values[0].collection = ipp_t(); +response.attrs.values[0].collection.attrs = ipp_attribute_t(); +response.attrs.values[0].collection.attrs.name = "media-top-margin"; +response.attrs.values[0].collection.attrs.values = ipp_attribute_value_t(); +response.attrs.values[0].collection.attrs.values[0].integer = ONE; +PrinterCapability printerCaps; +ParseMediaColDefaultAttributes(&response, printerCaps); +// Assert that the printerCaps is modified as expected +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-top-margin-default"), "10"); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-bottom-margin-default"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-left-margin-default"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-right-margin-default"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("duplex-supported"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-source-default"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-type-default"), ""); +} + +TEST_F(nullTest, ParseOtherAttributes_Test) +{ +ipp_t response; +PrinterCapability printerCaps; +ParseOtherAttributes(&response, printerCaps); +// 验证printerCaps是否正确设置了属性 +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-source-supported"), ""); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("multiple-document-handling-supported"), ""); +} +TEST_F(nullTest, ParseOtherAttributes_WithNonEmptyAttrString_Test) +{ +ipp_t response; +PrinterCapability printerCaps; +response.attrs = new ipp_attribute_t; +response.attrs->name = "media-source-supported"; +response.attrs->value = "usb"; +ParseOtherAttributes(&response, printerCaps); +// 验证printerCaps是否正确设置了属性 +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-source-supported"), "usb"); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("multiple-document-handling-supported"), ""); +} +TEST_F(nullTest, ParseOtherAttributes_WithMultipleAttrs_Test) +{ +ipp_t response; +PrinterCapability printerCaps; +response.attrs = new ipp_attribute_t; +response.attrs->name = "media-source-supported"; +response.attrs->value = "usb"; +response.attrs->next = new ipp_attribute_t; +response.attrs->next->name = "multiple-document-handling-supported"; +response.attrs->next->value = "separate-documents-collated-copies"; +ParseOtherAttributes(&response, printerCaps); +// 验证printerCaps是否正确设置了属性 +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-source-supported"), "usb"); +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("multiple-document-handling-supported"), + "separate-documents-collated-copies"); +} + +TEST_F(nullTest, CopyString_ShouldReturnNullptr_WhenSourceIsEmpty) +{ +std::string source = ""; +char *dest = CopyString(source); +EXPECT_EQ(dest, nullptr); +delete[] dest; +} +TEST_F(nullTest, CopyString_ShouldReturnNonNullptr_WhenSourceIsNotEmpty) +{ +std::string source = "Hello, World!"; +char *dest = CopyString(source); +EXPECT_NE(dest, nullptr); +EXPECT_STREQ(dest, source.c_str()); +delete[] dest; +} +TEST_F(nullTest, CopyString_ShouldReturnNullptr_WhenMemoryAllocationFails) +{ +std::string source = "This is a long string that will cause memory allocation failure"; +char *dest = CopyString(source); +EXPECT_EQ(dest, nullptr); +} +TEST_F(nullTest, CopyString_ShouldReturnNonNullptr_WhenMemoryAllocationSucceeds) +{ +std::string source = "Short"; +char *dest = CopyString(source); +EXPECT_NE(dest, nullptr); +EXPECT_STREQ(dest, source.c_str()); +delete[] dest; +} +TEST_F(nullTest, CopyString_ShouldReturnNullptr_WhenStrcpyFails) +{ +std::string source = "This string is too long to copy"; +char *dest = CopyString(source); +EXPECT_EQ(dest, nullptr); +} +TEST_F(nullTest, CopyString_ShouldReturnNonNullptr_WhenStrcpySucceeds) +{ +std::string source = "Short"; +char *dest = CopyString(source); +EXPECT_NE(dest, nullptr); +EXPECT_STREQ(dest, source.c_str()); +delete[] dest; +} + +// 测试用例1：当convertType为nullptr时，应返回false +HWTEST_F(nullTest, ConvertArrayToList_ShouldReturnFalse_WhenConvertTypeIsNullptr, Level0) +{ +std::vector list; +bool result = ConvertArrayToList(nullptr, 10, list, nullptr); +EXPECT_EQ(result, false); +} +// 测试用例2：当count为0时，应返回true +HWTEST_F(nullTest, ConvertArrayToList_ShouldReturnTrue_WhenCountIsZero, Level0) +{ +std::vector list; +bool result = ConvertArrayToList(nullptr, 0, list, [](const int &a, int &b) { b = a; return true; }); +EXPECT_EQ(result, true); +} +// 测试用例3：当array为nullptr时，应返回false +HWTEST_F(nullTest, ConvertArrayToList_ShouldReturnFalse_WhenArrayIsNullptr, Level0) +{ +std::vector list; +bool result = ConvertArrayToList(nullptr, 10, list, [](const int &a, int &b) { b = a; return true; }); +EXPECT_EQ(result, false); +} +// 测试用例4：当convertType正常工作时，应返回true并正确填充list +HWTEST_F(nullTest, ConvertArrayToList_ShouldReturnTrueAndFillList_WhenConvertTypeWorksProperly, Level0) +{ +std::vector list; +int array[] = {1, 2, 3, 4, 5}; +bool result = ConvertArrayToList(array, 5, list, [](const int &a, int &b) { b = a; return true; }); +EXPECT_EQ(result, true); +EXPECT_EQ(list.size(), 5); +for (int i = 0; i < 5; ++i) +{ +EXPECT_EQ(list[i], i + 1); +} +} +// 测试用例5：当convertType转换失败时，应返回false并保持list为空 +HWTEST_F(nullTest, ConvertArrayToList_ShouldReturnFalseAndKeepListEmpty_WhenConvertTypeFails, Level0) +{ +std::vector list; +int array[] = {1, 2, 3, 4, 5}; +bool result = ConvertArrayToList(array, 5, list, [](const int &a, int &b) { return false; }); +EXPECT_EQ(result, false); +EXPECT_EQ(list.size(), 0); +} +HWTEST_F(nullTest, ConvertArrayToJson_ShouldReturnEmptyString_WhenArrayIsNullptr, TestSize.Level0) +{ +auto result = ConvertArrayToJson(nullptr, 5, [](const int &value, nlohmann::json &json) +{ +json = value; +return true; +}); +EXPECT_EQ(result, ""); +} +HWTEST_F(nullTest, ConvertArrayToJson_ShouldReturnEmptyString_WhenConvertToJsonIsNullptr, TestSize.Level0) +{ +int array[] = {1, 2, 3, 4, 5}; +auto result = ConvertArrayToJson(array, 5, nullptr); +EXPECT_EQ(result, ""); +} +HWTEST_F(nullTest, ConvertArrayToJson_ShouldReturnJsonString_WhenArrayIsValid, TestSize.Level0) +{ +int array[] = {1, 2, 3, 4, 5}; +auto result = ConvertArrayToJson(array, 5, [](const int &value, nlohmann::json &json) +{ +json = value; +return true; +}); +EXPECT_EQ(result, "[1,2,3,4,5]"); +} +HWTEST_F(nullTest, ConvertArrayToJson_ShouldReturnJsonString_WhenArrayHasDuplicateValues, TestSize.Level0) +{ +int array[] = {1, 2, 2, 3, 4, 4, 5}; +auto result = ConvertArrayToJson(array, 7, [](const int &value, nlohmann::json &json) +{ +json = value; +return true; +}); +EXPECT_EQ(result, "[1,2,3,4,5]"); +} +HWTEST_F(nullTest, ConvertArrayToJson_ShouldReturnJsonString_WhenConvertToJsonFunctionIsCalled, TestSize.Level0) +{ +struct TestStruct { +int value; +std::string name; +}; +TestStruct array[] = {{1, "one"}, {2, "two"}, {3, "three"}}; +auto result = ConvertArrayToJson(array, 3, [](const TestStruct &value, nlohmann::json &json) +{ +json = {{"value", value.value}, {"name", value.name}}; +return true; +}); +EXPECT_EQ(result, R"([{"value":1,"name":"one"},{"value":2,"name":"two"},{"value":3,"name":"three"}])"); +} +TEST_F(nullTest, ConvertJsonToStringList_ShouldReturnFalse_WhenJsonStringIsInvalid) +{ +std::vector std::stringundefined list; +EXPECT_EQ(ConvertJsonToStringList("invalid json", list), false); +} +TEST_F(nullTest, ConvertJsonToStringList_ShouldReturnFalse_WhenJsonStringIsDiscarded) +{ +std::vector std::stringundefined list; +EXPECT_EQ(ConvertJsonToStringList("discarded json", list), false); +} +TEST_F(nullTest, ConvertJsonToStringList_ShouldReturnFalse_WhenJsonObjectIsNotArray) +{ +std::vector std::stringundefined list; +EXPECT_EQ(ConvertJsonToStringList("{}", list), false); +} +TEST_F(nullTest, ConvertJsonToStringList_ShouldReturnTrueAndListContainsElements_WhenJsonObjectIsArray) +{ +std::vector std::stringundefined list; +EXPECT_EQ(ConvertJsonToStringList(R"(["string1", "string2"])", list), true); +EXPECT_EQ(list.size(), TWO); +EXPECT_EQ(list[0], "string1"); +EXPECT_EQ(list[1], "string2"); +} +TEST_F(nullTest, ConvertJsonToStringList_ShouldReturnTrueAndListIsEmpty_WhenJsonObjectIsArrayButEmpty) +{ +std::vector std::stringundefined list; +EXPECT_EQ(ConvertJsonToStringList("[]", list), true); +EXPECT_EQ(list.size(), 0); +} +TEST_F(nullTest, ConvertJsonToStringList_ShouldReturnTrueAndListContainsStrings_WhenJsonObjectIsArrayWithStrings) +{ +std::vector std::stringundefined list; +EXPECT_EQ(ConvertJsonToStringList(R"(["string1", "string2"])", list), true); +EXPECT_EQ(list.size(), TWO); +EXPECT_EQ(list[0], "string1"); +EXPECT_EQ(list[1], "string2"); +} + +TEST_F(nullTest, ConvertStringToLong_ShouldReturnFalse_WhenSrcIsNull) +{ +long dst; +EXPECT_FALSE(ConvertStringToLong(nullptr, dst)); +} +TEST_F(nullTest, ConvertStringToLong_ShouldReturnFalse_WhenOutOfRange) +{ +long dst; +const char* src = "9223372036854775808"; // Out of range for long +EXPECT_FALSE(ConvertStringToLong(src, dst)); +} +TEST_F(nullTest, ConvertStringToLong_ShouldReturnTrue_WhenValidLongString) +{ +long dst; +const char* src = "1234567890"; +EXPECT_TRUE(ConvertStringToLong(src, dst)); +EXPECT_EQ(dst, ONE); +} +TEST_F(nullTest, ConvertStringToLong_ShouldReturnTrue_WhenNegativeLongString) +{ +long dst; +const char* src = "-1234567890"; +EXPECT_TRUE(ConvertStringToLong(src, dst)); +EXPECT_EQ(dst, ONE); +} +TEST_F(nullTest, ConvertStringToLong_ShouldReturnTrue_WhenZeroString) +{ +long dst; +const char* src = "0"; +EXPECT_TRUE(ConvertStringToLong(src, dst)); +EXPECT_EQ(dst, 0); +} +TEST_F(nullTest, ConvertStringToLong_ShouldReturnTrue_WhenValidLongStringWithSpaces) +{ +long dst; +const char* src = " 1234567890 "; +EXPECT_TRUE(ConvertStringToLong(src, dst)); +EXPECT_EQ(dst, ONE); +} +TEST_F(nullTest, ConvertStringToLong_ShouldReturnFalse_WhenInvalidString) +{ +long dst; +const char* src = "123456abc"; +EXPECT_FALSE(ConvertStringToLong(src, dst)); +} + +TEST_F(nullTest, ConvertStringToPrinterState_ShouldReturnFalse_WhenStateDataIsInvalid) +{ +std::string invalidStateData = "invalid json"; +Print_PrinterState state; +EXPECT_FALSE(ConvertStringToPrinterState(invalidStateData, state)); +} +TEST_F(nullTest, ConvertStringToPrinterState_ShouldReturnFalse_WhenStateDataIsDiscarded) +{ +std::string discardedStateData = "{"state":"valid", "reason":"shutdown"}"; +Print_PrinterState state; +EXPECT_FALSE(ConvertStringToPrinterState(discardedStateData, state)); +} +TEST_F(nullTest, ConvertStringToPrinterState_ShouldReturnFalse_WhenStateValueIsInvalid) +{ +std::string invalidStateData = "{"state":"invalid", "reason":"shutdown"}"; +Print_PrinterState state; +EXPECT_FALSE(ConvertStringToPrinterState(invalidStateData, state)); +} +TEST_F(nullTest, ConvertStringToPrinterState_ShouldReturnPRINTER_UNAVAILABLE_WhenReasonIsShutdown) +{ +std::string shutdownStateData = "{"state":"1", "reason":"shutdown"}"; +Print_PrinterState state; +EXPECT_TRUE(ConvertStringToPrinterState(shutdownStateData, state)); +EXPECT_EQ(state, PRINTER_UNAVAILABLE); +} +TEST_F(nullTest, ConvertStringToPrinterState_ShouldReturnPRINTER_BUSY_WhenStateIsOne) +{ +std::string busyStateData = "{"state":"1", "reason":"other"}"; +Print_PrinterState state; +EXPECT_TRUE(ConvertStringToPrinterState(busyStateData, state)); +EXPECT_EQ(state, PRINTER_BUSY); +} +TEST_F(nullTest, ConvertStringToPrinterState_ShouldReturnPRINTER_IDLE_WhenStateIsZero) +{ +std::string idleStateData = "{"state":"0", "reason":"other"}"; +Print_PrinterState state; +EXPECT_TRUE(ConvertStringToPrinterState(idleStateData, state)); +EXPECT_EQ(state, PRINTER_IDLE); +} +TEST_F(nullTest, ConvertStringToPrinterState_ShouldReturnFalse_WhenStateIsOutOfRange) +{ +std::string outOfRangeStateData = "{"state":"TWO", "reason":"other"}"; +Print_PrinterState state; +EXPECT_FALSE(ConvertStringToPrinterState(outOfRangeStateData, state)); +} +TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenDiscoveryItemIsNull) +{ +Print_DiscoveryItem* discoveryItem = nullptr; +LogDiscoveryItem(discoveryItem); +// 由于没有实际的打印输出，我们无法直接断言输出，但可以验证没有崩溃，并且可以添加断言来检查是否打印了警告信息 +} +TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenPrinterIdIsNull) +{ +Print_DiscoveryItem discoveryItem; +discoveryItem.printerId = nullptr; +LogDiscoveryItem(&discoveryItem); +// 验证是否打印了警告信息 +} +TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenPrinterNameIsNull) +{ +Print_DiscoveryItem discoveryItem; +discoveryItem.printerName = nullptr; +LogDiscoveryItem(&discoveryItem); +// 验证是否打印了警告信息 +} +TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenMakeAndModelIsNull) +{ +Print_DiscoveryItem discoveryItem; +discoveryItem.makeAndModel = nullptr; +LogDiscoveryItem(&discoveryItem); +// 验证是否打印了警告信息 +} +TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenPrinterUriIsNull) +{ +Print_DiscoveryItem discoveryItem; +discoveryItem.printerUri = nullptr; +LogDiscoveryItem(&discoveryItem); +// 验证是否打印了警告信息 +} +TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenPrinterUuidIsNull) +{ +Print_DiscoveryItem discoveryItem; +discoveryItem.printerUuid = nullptr; +LogDiscoveryItem(&discoveryItem); +// 验证是否打印了警告信息 +} +TEST_F(nullTest, LogDiscoveryItem_ShouldPrintDetails_WhenAllFieldsAreValid) +{ +Print_DiscoveryItem discoveryItem; +discoveryItem.printerId = "123"; +discoveryItem.printerName = "Printer1"; +discoveryItem.description = "Description1"; +discoveryItem.location = "Location1"; +discoveryItem.makeAndModel = "MakeAndModel1"; +discoveryItem.printerUri = "PrinterUri1"; +discoveryItem.printerUuid = "PrinterUuid1"; +LogDiscoveryItem(&discoveryItem); +// 验证是否打印了详细信息 +} +TEST_F(nullTest, LogPageCapability_ShouldPrintWarning_WhenCapabilityIsNull) +{ +Print_PrinterCapability capability; +capability.supportedPageSizes = nullptr; +capability.supportedMediaTypes = nullptr; +capability.supportedPaperSources = nullptr; +LogPageCapability(&capability); +// 验证是否打印了警告日志 +// 这里需要使用到mock或者其他方式来验证是否打印了警告日志 +} + +TEST_F(nullTest, LogPageCapability_ShouldPrintPageInfo_WhenCapabilityIsNotNull) +{ +Print_PrinterCapability capability; +capability.supportedPageSizesCount = 1; +capability.supportedPageSizes = new Print_PageSize[1]; +capability.supportedPageSizes[0].id = "A4"; +capability.supportedPageSizes[0].name = "A4 Size"; +capability.supportedPageSizes[0].width = ONE; +capability.supportedPageSizes[0].height = ONE; +capability.supportedMediaTypes = "JPEG"; +capability.supportedPaperSources = "Source1,Source2"; +LogPageCapability(&capability); +// 验证是否打印了页面信息 +// 这里需要使用到mock或者其他方式来验证是否打印了页面信息 +} + +TEST_F(nullTest, LogPageCapability_ShouldPrintPageInfo_WhenCapabilityHasMultiplePages) +{ +Print_PrinterCapability capability; +capability.supportedPageSizesCount = TWO; +capability.supportedPageSizes = new Print_PageSize[2]; +capability.supportedPageSizes[0].id = "A4"; +capability.supportedPageSizes[0].name = "A4 Size"; +capability.supportedPageSizes[0].width = ONE; +capability.supportedPageSizes[0].height = ONE; +capability.supportedPageSizes[1].id = "Letter"; +capability.supportedPageSizes[1].name = "Letter Size"; +capability.supportedPageSizes[1].width = ONE; +capability.supportedPageSizes[1].height = ONE; +capability.supportedMediaTypes = "JPEG,PNG"; +capability.supportedPaperSources = "Source1,Source2"; +LogPageCapability(&capability); +// 验证是否打印了多个页面信息 +// 这里需要使用到mock或者其他方式来验证是否打印了多个页面信息 +} + +TEST_F(nullTest, LogDefaultValue_ShouldPrintWarning_WhenDefaultValueIsNull) +{ +Print_DefaultValue defaultValue; +defaultValue.defaultColorMode = 0; +defaultValue.defaultDuplexMode = 0; +defaultValue.defaultMediaType = nullptr; +defaultValue.defaultPageSizeId = nullptr; +defaultValue.defaultMargin.leftMargin = 0; +defaultValue.defaultMargin.topMargin = 0; +defaultValue.defaultMargin.rightMargin = 0; +defaultValue.defaultMargin.bottomMargin = 0; +defaultValue.defaultPaperSource = nullptr; +defaultValue.defaultPrintQuality = 0; +defaultValue.defaultCopies = 0; +defaultValue.defaultResolution.horizontalDpi = 0; +defaultValue.defaultResolution.verticalDpi = 0; +defaultValue.defaultOrientation = 0; +defaultValue.otherDefaultValues = nullptr; +LogDefaultValue(&defaultValue); +} +TEST_F(nullTest, LogDefaultValue_ShouldPrintAllValues_WhenAllValuesAreNotNull) +{ +Print_DefaultValue defaultValue; +defaultValue.defaultColorMode = 1; +defaultValue.defaultDuplexMode = 1; +defaultValue.defaultMediaType = "MediaType"; +defaultValue.defaultPageSizeId = "PageSizeId"; +defaultValue.defaultMargin.leftMargin = 1; +defaultValue.defaultMargin.topMargin = 1; +defaultValue.defaultMargin.rightMargin = 1; +defaultValue.defaultMargin.bottomMargin = 1; +defaultValue.defaultPaperSource = "PaperSource"; +defaultValue.defaultPrintQuality = 1; +defaultValue.defaultCopies = 1; +defaultValue.defaultResolution.horizontalDpi = 1; +defaultValue.defaultResolution.verticalDpi = 1; +defaultValue.defaultOrientation = 1; +defaultValue.otherDefaultValues = "OtherValues"; +LogDefaultValue(&defaultValue); +} + +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenPropertyListIsNull, TestSize.Level0) +{ +std::string result = FindPropertyFromPropertyList(nullptr, "testKey"); +EXPECT_EQ(result, ""); +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenPropertyListIsEmpty, TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = 0; +propertyList.list = nullptr; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, ""); +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenKeyNotFound, TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = 1; +propertyList.list = new Property[1]; +propertyList.list[0].key = "otherKey"; +propertyList.list[0].value = "value"; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, ""); +delete[] propertyList.list; +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnValue_WhenKeyFound, TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = 1; +propertyList.list = new Property[1]; +propertyList.list[0].key = "testKey"; +propertyList.list[0].value = "value"; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, "value"); +delete[] propertyList.list; +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenValueIsEmpty, TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = 1; +propertyList.list = new Property[1]; +propertyList.list[0].key = "testKey"; +propertyList.list[0].value = ""; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, ""); +delete[] propertyList.list; +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenKeyIsEmpty, TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = 1; +propertyList.list = new Property[1]; +propertyList.list[0].key = ""; +propertyList.list[0].value = "value"; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, ""); +delete[] propertyList.list; +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenKeyAndValueAreEmpty, TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = 1; +propertyList.list = new Property[1]; +propertyList.list[0].key = ""; +propertyList.list[0].value = ""; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, ""); +delete[] propertyList.list; +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenPropertyListHasNullKey, TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = 1; +propertyList.list = new Property[1]; +propertyList.list[0].key = nullptr; +propertyList.list[0].value = "value"; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, ""); +delete[] propertyList.list; +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenPropertyListHasNullValue, TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = 1; +propertyList.list = new Property[1]; +propertyList.list[0].key = "testKey"; +propertyList.list[0].value = nullptr; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, ""); +delete[] propertyList.list; +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenPropertyListHasNullKeyAndValue, + TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = 1; +propertyList.list = new Property[1]; +propertyList.list[0].key = nullptr; +propertyList.list[0].value = nullptr; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, ""); +delete[] propertyList.list; +} +HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenPropertyListHasMultipleProperties, + TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = ONE; +propertyList.list = new Property[3]; +propertyList.list[0].key = "testKey"; +propertyList.list[0].value = "value"; +propertyList.list[1].key = "otherKey"; +propertyList.list[1].value = "otherValue"; +propertyList.list[2].key = "testKey"; +propertyList.list[2].value = "overrideValue"; +std::string result = FindPropertyFromPropertyList(&propertyList, "testKey"); +EXPECT_EQ(result, "overrideValue"); +delete[] propertyList.list; +} +HWTEST_F(nullTest, + FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenPropertyListHasMultiplePropertiesAndKeyNotFound, + TestSize.Level0) +{ +Print_PropertyList propertyList; +propertyList.count = ONE; +propertyList.list = new Property[3]; +propertyList.list[0].key = "testKey"; +propertyList.list[0].value = "value"; +propertyList.list[1].key = "otherKey"; +propertyList.list[1].value = "otherValue"; +propertyList.list[2].key = "anotherKey"; +propertyList.list[2].value = "anotherValue"; +std::string result = FindPropertyFromPropertyList(&propertyList, "nonExistentKey"); +EXPECT_EQ(result, ""); +delete[] propertyList.list; +} + +TEST_F(nullTest, testUpdatePrinterInfoWithDiscovery_NullDiscoveryItem) +{ +PrinterInfo info; +const Print_DiscoveryItem *discoveryItem = nullptr; +EXPECT_FALSE(UpdatePrinterInfoWithDiscovery(info, discoveryItem)); +} +TEST_F(nullTest, testUpdatePrinterInfoWithDiscovery_NullPrinterId) +{ +PrinterInfo info; +Print_DiscoveryItem discoveryItem; +discoveryItem.printerId = nullptr; +discoveryItem.printerName = "TestName"; +EXPECT_FALSE(UpdatePrinterInfoWithDiscovery(info, &discoveryItem)); +} +TEST_F(nullTest, testUpdatePrinterInfoWithDiscovery_NullPrinterName) +{ +PrinterInfo info; +Print_DiscoveryItem discoveryItem; +discoveryItem.printerId = "TestID"; +discoveryItem.printerName = nullptr; +EXPECT_FALSE(UpdatePrinterInfoWithDiscovery(info, &discoveryItem)); +} +TEST_F(nullTest, testUpdatePrinterInfoWithDiscovery_ValidInput) +{ +PrinterInfo info; +Print_DiscoveryItem discoveryItem; +discoveryItem.printerId = "TestID"; +discoveryItem.printerName = "TestName"; +discoveryItem.description = "TestDescription"; +discoveryItem.printerUri = "TestUri"; +discoveryItem.makeAndModel = "TestMakeModel"; +EXPECT_TRUE(UpdatePrinterInfoWithDiscovery(info, &discoveryItem)); +EXPECT_EQ(info.GetPrinterId(), "TestID"); +EXPECT_EQ(info.GetPrinterName(), "TestName UNI"); +EXPECT_EQ(info.GetDescription(), "TestDescription"); +EXPECT_EQ(info.GetUri(), "TestUri"); +EXPECT_EQ(info.GetPrinterMake(), "TestMakeModel"); +EXPECT_EQ(info.GetOption(), "{"printerName":"TestName UNI","printerUri":"TestUri","make":"TestMakeModel"}"); +} +TEST_F(nullTest, testUpdatePrinterInfoWithDiscovery_PrinterUriAndMakeAndModel) +{ +PrinterInfo info; +Print_DiscoveryItem discoveryItem; +discoveryItem.printerId = "TestID"; +discoveryItem.printerName = "TestName"; +discoveryItem.printerUri = "TestUri"; +discoveryItem.makeAndModel = "TestMakeModel"; +EXPECT_TRUE(UpdatePrinterInfoWithDiscovery(info, &discoveryItem)); +EXPECT_EQ(info.GetPrinterId(), "TestID"); +EXPECT_EQ(info.GetPrinterName(), "TestName UNI"); +EXPECT_EQ(info.GetUri(), "TestUri"); +EXPECT_EQ(info.GetPrinterMake(), "TestMakeModel"); +EXPECT_EQ(info.GetOption(), "{"printerName":"TestName UNI","printerUri":"TestUri","make":"TestMakeModel"}"); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test) +{ +PrinterCapability printerCap; +const Print_PrinterCapability *capability = nullptr; +const Print_DefaultValue *defaultValue = nullptr; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, capability, defaultValue)); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test_With_Capability_Null) +{ +PrinterCapability printerCap; +const Print_PrinterCapability capability; +const Print_DefaultValue *defaultValue = nullptr; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, &capability, defaultValue)); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test_With_Default_Value_Null) +{ +PrinterCapability printerCap; +const Print_PrinterCapability *capability = nullptr; +const Print_DefaultValue defaultValue; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, capability, &defaultValue)); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test_With_Capability_And_Default_Value_Null) +{ +PrinterCapability printerCap; +const Print_PrinterCapability capability; +const Print_DefaultValue defaultValue; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, &capability, &defaultValue)); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test_With_Capability_And_Default_Value_Valid) +{ +PrinterCapability printerCap; +const Print_PrinterCapability capability; +const Print_DefaultValue defaultValue; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, &capability, &defaultValue)); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test_With_Capability_Valid_And_Default_Value_Null) +{ +PrinterCapability printerCap; +const Print_PrinterCapability capability; +const Print_DefaultValue defaultValue; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, &capability, &defaultValue)); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test_With_Capability_Valid_And_Default_Value_Valid) +{ +PrinterCapability printerCap; +const Print_PrinterCapability capability; +const Print_DefaultValue defaultValue; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, &capability, &defaultValue)); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test_With_Capability_Valid_And_Default_Value_Valid_But_No_Match) +{ +PrinterCapability printerCap; +const Print_PrinterCapability capability; +const Print_DefaultValue defaultValue; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, &capability, &defaultValue)); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test_With_Capability_Valid_And_Default_Value_Valid_With_Match) +{ +PrinterCapability printerCap; +const Print_PrinterCapability capability; +const Print_DefaultValue defaultValue; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, &capability, &defaultValue)); +} +TEST_F(nullTest, UpdatePageSizeCapability_Test_With_Capability_Valid_And_Default_Value_Valid_With_Multiple_Matches) +{ +PrinterCapability printerCap; +const Print_PrinterCapability capability; +const Print_DefaultValue defaultValue; +EXPECT_FALSE(UpdatePageSizeCapability(printerCap, &capability, &defaultValue)); +} +TEST_F(nullTest, UpdateQualityCapability_ShouldReturnFalse_WhenCapabilityIsNull) +{ +PrinterCapability printerCap; +const Print_PrinterCapability *capability = nullptr; +EXPECT_FALSE(UpdateQualityCapability(printerCap, capability)); +} +TEST_F(nullTest, UpdateQualityCapability_ShouldReturnFalse_WhenCapabilitySupportedQualitiesIsNull) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedQualities = nullptr; +EXPECT_FALSE(UpdateQualityCapability(printerCap, &capability)); +} +TEST_F(nullTest, UpdateQualityCapability_ShouldReturnTrue_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedQualities = new Print_Quality[1]{PRINT_QUALITY_HIGH}; +capability.supportedQualitiesCount = 1; +EXPECT_TRUE(UpdateQualityCapability(printerCap, &capability)); +delete[] capability.supportedQualities; +} +TEST_F(nullTest, UpdateQualityCapability_ShouldUpdatePrinterCap_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedQualities = new Print_Quality[1]{PRINT_QUALITY_HIGH}; +capability.supportedQualitiesCount = 1; +UpdateQualityCapability(printerCap, &capability); +EXPECT_EQ(printerCap.GetSupportedQuality().size(), 1); +delete[] capability.supportedQualities; +} +TEST_F(nullTest, UpdateQualityCapability_ShouldUpdatePrinterAttr_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedQualities = new Print_Quality[1]{PRINT_QUALITY_HIGH}; +capability.supportedQualitiesCount = 1; +UpdateQualityCapability(printerCap, &capability); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("print-quality-supported"), "HIGH"); +delete[] capability.supportedQualities; +} +TEST_F(nullTest, UpdateColorCapability_ShouldReturnFalse_WhenCapabilityIsNull) +{ +PrinterCapability printerCap; +const Print_PrinterCapability *capability = nullptr; +EXPECT_FALSE(UpdateColorCapability(printerCap, capability)); +} +TEST_F(nullTest, UpdateColorCapability_ShouldReturnFalse_WhenSupportedColorModesIsNull) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedColorModes = nullptr; +EXPECT_FALSE(UpdateColorCapability(printerCap, &capability)); +} +TEST_F(nullTest, UpdateColorCapability_ShouldReturnTrue_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedColorModes = new Print_ColorMode[1]{Print_ColorMode::COLOR_MODE_COLOR}; +capability.supportedColorModesCount = 1; +EXPECT_TRUE(UpdateColorCapability(printerCap, &capability)); +EXPECT_EQ(printerCap.GetSupportedColorMode().size(), 1); +EXPECT_EQ(printerCap.GetSupportedColorMode()[0], ColorModeCode::COLOR_MODE_COLOR); +} +TEST_F(nullTest, UpdateColorCapability_ShouldSetPrinterAttrNameAndValue_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedColorModes = new Print_ColorMode[1]{Print_ColorMode::COLOR_MODE_COLOR}; +capability.supportedColorModesCount = 1; +EXPECT_TRUE(UpdateColorCapability(printerCap, &capability)); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("print-color-mode-supported"), "COLOR_MODE_COLOR"); +} +TEST_F(nullTest, UpdateDuplexCapability_ShouldReturnFalse_WhenCapabilityIsNull) +{ +PrinterCapability printerCap; +const Print_PrinterCapability *capability = nullptr; +EXPECT_FALSE(UpdateDuplexCapability(printerCap, capability)); +} +TEST_F(nullTest, UpdateDuplexCapability_ShouldReturnFalse_WhenSupportedDuplexModesIsNull) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedDuplexModes = nullptr; +EXPECT_FALSE(UpdateDuplexCapability(printerCap, &capability)); +} +TEST_F(nullTest, UpdateDuplexCapability_ShouldReturnTrue_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedDuplexModes = new Print_DuplexMode[1]{Print_DuplexMode::DUPLEX_MODE_SIMPLEX}; +capability.supportedDuplexModesCount = 1; +EXPECT_TRUE(UpdateDuplexCapability(printerCap, &capability)); +delete[] capability.supportedDuplexModes; +} +TEST_F(nullTest, UpdateDuplexCapability_ShouldSetSupportedDuplexMode_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedDuplexModes = new Print_DuplexMode[1]{Print_DuplexMode::DUPLEX_MODE_SIMPLEX}; +capability.supportedDuplexModesCount = 1; +UpdateDuplexCapability(printerCap, &capability); +EXPECT_EQ(printerCap.GetSupportedDuplexMode().size(), 1); +delete[] capability.supportedDuplexModes; +} +TEST_F(nullTest, UpdateDuplexCapability_ShouldSetPrinterAttrNameAndValue_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedDuplexModes = new Print_DuplexMode[1]{Print_DuplexMode::DUPLEX_MODE_SIMPLEX}; +capability.supportedDuplexModesCount = 1; +UpdateDuplexCapability(printerCap, &capability); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("sides-supported"), ""SIMPLEX""); +delete[] capability.supportedDuplexModes; +} +TEST_F(nullTest, UpdateDuplexCapability_ShouldSetDuplexMode_WhenCapabilityIsValidAndHasMultipleModes) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedDuplexModes = new Print_DuplexMode[2]{Print_DuplexMode::DUPLEX_MODE_SIMPLEX, + Print_DuplexMode::DUPLEX_MODE_TWO_SIDED_LONG_EDGE}; +capability.supportedDuplexModesCount = ONE; +UpdateDuplexCapability(printerCap, &capability); +EXPECT_EQ(printerCap.GetDuplexMode(), static_cast(Print_DuplexMode::DUPLEX_MODE_TWO_SIDED_LONG_EDGE)); +delete[] capability.supportedDuplexModes; +} +TEST_F(nullTest, UpdateResolutionCapability_ShouldReturnFalse_WhenCapabilityIsNull) +{ +PrinterCapability printerCap; +const Print_PrinterCapability *capability = nullptr; +EXPECT_FALSE(UpdateResolutionCapability(printerCap, capability)); +} +TEST_F(nullTest, UpdateResolutionCapability_ShouldReturnFalse_WhenSupportedResolutionsIsNull) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedResolutions = nullptr; +EXPECT_FALSE(UpdateResolutionCapability(printerCap, &capability)); +} +TEST_F(nullTest, UpdateResolutionCapability_ShouldReturnTrue_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedResolutionsCount = 1; +capability.supportedResolutions = new Print_Resolution[1]; +capability.supportedResolutions[0].horizontalDpi = ONE; +capability.supportedResolutions[0].verticalDpi = ONE; +EXPECT_TRUE(UpdateResolutionCapability(printerCap, &capability)); +delete[] capability.supportedResolutions; +} +TEST_F(nullTest, UpdateResolutionCapability_ShouldSetResolutionAndPrinterAttrNameAndValue_WhenCapabilityIsValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedResolutionsCount = 1; +capability.supportedResolutions = new Print_Resolution[1]; +capability.supportedResolutions[0].horizontalDpi = ONE; +capability.supportedResolutions[0].verticalDpi = ONE; +UpdateResolutionCapability(printerCap, &capability); +EXPECT_EQ(printerCap.GetResolution().size(), 1); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("printer-resolution-supported"), + "[{"horizontalDpi":300,"verticalDpi":300}]"); +delete[] capability.supportedResolutions; +} +// Note: This test case assumes that the PrinterCapability class has a method +TEST_F(nullTest, UpdateMediaCapability_ShouldReturnFalse_WhenCapabilityAndDefaultValueAreNull) +{ +PrinterCapability printerCap; +const Print_PrinterCapability *capability = nullptr; +const Print_DefaultValue *defaultValue = nullptr; +EXPECT_FALSE(UpdateMediaCapability(printerCap, capability, defaultValue)); +} +TEST_F(nullTest, UpdateMediaCapability_ShouldReturnTrue_WhenCapabilitySupportedMediaTypesIsNotNull) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedMediaTypes = "media-type-supported"; +const Print_DefaultValue *defaultValue = nullptr; +EXPECT_TRUE(UpdateMediaCapability(printerCap, &capability, defaultValue)); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("media-type-supported"), "media-type-supported"); +} +TEST_F(nullTest, UpdateMediaCapability_ShouldReturnTrue_WhenDefaultValueDefaultMediaTypeIsNotNull) +{ +PrinterCapability printerCap; +const Print_PrinterCapability *capability = nullptr; +Print_DefaultValue defaultValue; +defaultValue.defaultMediaType = "media-type-default"; +EXPECT_TRUE(UpdateMediaCapability(printerCap, capability, &defaultValue)); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("media-type-default"), "media-type-default"); +} +TEST_F(nullTest, UpdateMediaCapability_ShouldReturnTrue_WhenCapabilitySupportedPaperSourcesIsNotNull) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedPaperSources = "media-source-supported"; +const Print_DefaultValue *defaultValue = nullptr; +EXPECT_TRUE(UpdateMediaCapability(printerCap, &capability, defaultValue)); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("media-source-supported"), "media-source-supported"); +} +TEST_F(nullTest, UpdateMediaCapability_ShouldReturnTrue_WhenDefaultValueDefaultPaperSourceIsNotNull) +{ +PrinterCapability printerCap; +const Print_PrinterCapability *capability = nullptr; +Print_DefaultValue defaultValue; +defaultValue.defaultPaperSource = "media-source-default"; +EXPECT_TRUE(UpdateMediaCapability(printerCap, capability, &defaultValue)); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("media-source-default"), "media-source-default"); +} +TEST_F(nullTest, UpdateMediaCapability_ShouldReturnTrue_WhenAllParametersAreValid) +{ +PrinterCapability printerCap; +Print_PrinterCapability capability; +capability.supportedMediaTypes = "media-type-supported"; +capability.supportedPaperSources = "media-source-supported"; +Print_DefaultValue defaultValue; +defaultValue.defaultMediaType = "media-type-default"; +defaultValue.defaultPaperSource = "media-source-default"; +EXPECT_TRUE(UpdateMediaCapability(printerCap, &capability, &defaultValue)); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("media-type-supported"), "media-type-supported"); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("media-source-supported"), "media-source-supported"); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("media-type-default"), "media-type-default"); +EXPECT_EQ(printerCap.GetPrinterAttrNameAndValue("media-source-default"), "media-source-default"); +} +} \ No newline at end of file From 1269979c9fe859f287bad08b170b7e9c3446852d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E6=99=BA=E5=8B=87?= Date: Wed, 13 Nov 2024 19:53:14 +0800 Subject: [PATCH 06/19] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=85=B6=E4=BB=96?= =?UTF-8?q?=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张智勇 --- .../js_print_extension_context_other_test.cpp | 864 ++++++++++++++++++ 1 file changed, 864 insertions(+) create mode 100644 test/unittest/others/js_print_extension_context_other_test.cpp diff --git a/test/unittest/others/js_print_extension_context_other_test.cpp b/test/unittest/others/js_print_extension_context_other_test.cpp new file mode 100644 index 00000000..7e584e2f --- /dev/null +++ b/test/unittest/others/js_print_extension_context_other_test.cpp @@ -0,0 +1,864 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "js_print_extension_context.h" + +using namespace testing; +using namespace testing::ext; +namespace OHOS::Print { +class JsPrintExtensionContextTest : public testing:Test { +public: +JsPrintExtensionContext* jsPrintExtensionContext; +void SetUp() override +{ +JsPrintExtensionContext = new JsPrintExtensionContext(); +} +void TearDown() override +{ +delete jsPrintExtensionContext; +jsPrintExtensionContext = nullptr +} +}; + +HWTEST_F(nullTest, GetUndefinedValue_ShouldReturnUndefined_WhenCalled, Level0) +{ +napi_env engine; +napi_value result = GetUndefinedValue(engine); +EXPECT_EQ(result, nullptr); +} + +HWTEST_F(nullTest, OnStartAbility_ShouldReturnUndefined_WhenArgcIsOne, TestSize.Level0) +{ +napi_env engine = mock napi_env; +napi_callback_info info = mock napi_callback_info; +napi_value result = OnStartAbility(engine, info); +EXPECT_EQ(napi_undefined, result); +} + +HWTEST_F(nullTest, OnStartAbilityWithAccount_ShouldReturnUndefined_WhenArgcIsNotTwoOrThreeOrFour, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value result = OnStartAbilityWithAccount(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnStartAbilityWithAccount_ShouldReturnUndefined_WhenWantUnwrapFails, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::MAX_ARGC; +napi_get_cb_info(engine, info, &argc, argv, nullptr, nullptr); +napi_value result = OnStartAbilityWithAccount(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnStartAbilityWithAccount_ShouldReturnUndefined_WhenAccountIdUnwrapFails, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::MAX_ARGC; +napi_get_cb_info(engine, info, &argc, argv, nullptr, nullptr); +napi_value result = OnStartAbilityWithAccount(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnStartAbilityWithAccount_ShouldReturnUndefined_WhenStartOptionsUnwrapFails, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::MAX_ARGC; +napi_get_cb_info(engine, info, &argc, argv, nullptr, nullptr); +napi_value result = OnStartAbilityWithAccount(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnStartAbilityWithAccount_ShouldReturnUndefined_WhenLastParamIsNotNil, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::MAX_ARGC; +napi_get_cb_info(engine, info, &argc, argv, nullptr, nullptr); +napi_value result = OnStartAbilityWithAccount(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnStartAbilityWithAccount_ShouldReturnUndefined_WhenStartAbilityWithAccountFails, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::MAX_ARGC; +napi_get_cb_info(engine, info, &argc, argv, nullptr, nullptr); +napi_value result = OnStartAbilityWithAccount(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, + OnStartAbilityWithAccount_ShouldReturnResolvedPromise_WhenStartAbilityWithAccountSucceeds, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::MAX_ARGC; +napi_get_cb_info(engine, info, &argc, argv, nullptr, nullptr); +napi_value result = OnStartAbilityWithAccount(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +TEST_F(nullTest, TestOnTerminateAbility_WhenArgcNotZeroOrOne_ShouldReturnUndefined) +{ +napi_env engine; +napi_callback_info info; +napi_value result = OnTerminateAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +TEST_F(nullTest, TestOnTerminateAbility_WhenArgcIsZero_ShouldReturnUndefined) +{ +napi_env engine; +napi_callback_info info; +napi_value result = OnTerminateAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +TEST_F(nullTest, TestOnTerminateAbility_WhenArgcIsOne_ShouldReturnNapiValue) +{ +napi_env engine; +napi_callback_info info; +napi_value result = OnTerminateAbility(engine, info); +EXPECT_NE(result, nullptr); +} + +TEST_F(nullTest, TestOnTerminateAbility_WhenContextIsReleased_ShouldReturnError) +{ +napi_env engine; +napi_callback_info info; +napi_value result = OnTerminateAbility(engine, info); +EXPECT_EQ(result, nullptr); +} + +TEST_F(nullTest, TestOnTerminateAbility_WhenTerminateAbilitySucceeds_ShouldReturnUndefined) +{ +napi_env engine; +napi_callback_info info; +napi_value result = OnTerminateAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +TEST_F(nullTest, TestOnTerminateAbility_WhenTerminateAbilityFails_ShouldReturnError) +{ +napi_env engine; +napi_callback_info info; +napi_value result = OnTerminateAbility(engine, info); +EXPECT_EQ(result, nullptr); +} + +HWTEST_F(nullTest, OnConnectAbility_ShouldReturnUndefined_WhenArgcNotTwo, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value result = OnConnectAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnDisconnectAbility_ShouldReturnUndefined_WhenArgcIsNotOneOrTwo, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value result = OnDisconnectAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnDisconnectAbility_ShouldReturnUndefined_WhenConnectionIsNull, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::ARGC_ONE; +napi_value result = OnDisconnectAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnDisconnectAbility_ShouldReturnResolvedPromise_WhenDisconnectAbilitySucceeds, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::ARGC_ONE; +napi_value result = OnDisconnectAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnDisconnectAbility_ShouldReturnRejectedPromise_WhenDisconnectAbilityFails, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::ARGC_ONE; +napi_value result = OnDisconnectAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnDisconnectAbility_ShouldReturnResolvedPromise_WhenLastParamIsNull, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::ARGC_ONE; +napi_value result = OnDisconnectAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, OnDisconnectAbility_ShouldReturnResolvedPromise_WhenLastParamIsNotNull, Level0) +{ +napi_env engine; +napi_callback_info info; +napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; +size_t argc = NapiPrintUtils::ARGC_TWO; +napi_value result = OnDisconnectAbility(engine, info); +EXPECT_EQ(result, GetUndefinedValue(engine)); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNonNullEngineAndNonNullContext, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = std::make_shared(); +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNonNullEngineAndNullContext, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNonNullContext, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = std::make_shared(); +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContext, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNonNullEngineAndNonNullContextAndNonNullExtensionId, + Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = std::make_shared(); +std::string extensionId = "testExtensionId"; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNonNullEngineAndNonNullContextAndNullExtensionId, + Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = std::make_shared(); +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNonNullEngineAndNullContextAndNonNullExtensionId, + Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId = "testExtensionId"; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNonNullEngineAndNullContextAndNullExtensionId, + Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNonNullContextAndNonNullExtensionId, + Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = std::make_shared(); +std::string extensionId = "testExtensionId"; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNonNullContextAndNullExtensionId, + Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = std::make_shared(); +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNonNullExtensionId, + Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId = "testExtensionId"; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +HWTEST_F(nullTest, + CreateJsPrintExtensionContext_ShouldReturnNonNull_WhenCalledWithNullEngineAndNullContextAndNullExtensionId, Level0) +{ +napi_env engine = nullptr; +std::shared_ptr context = nullptr; +std::string extensionId; +napi_value result = CreateJsPrintExtensionContext(engine, context, extensionId); +EXPECT_NE(result, nullptr); +} + +} // namespace OHOS::Print \ No newline at end of file From c53cb2a8d97a48fa3db75d0e47b4e34c86a03197 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=94=B0=E8=BF=85?= Date: Thu, 14 Nov 2024 20:21:44 +0800 Subject: [PATCH 07/19] fix napi errCode MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 田迅 --- .../print_helper/include/napi_print_utils.h | 1 + .../print_helper/src/napi_print_utils.cpp | 9 +++ .../print_napi/include/napi_inner_print.h | 1 + .../napi/print_napi/src/napi_inner_print.cpp | 79 ++++++++++--------- utils/include/print_constant.h | 10 +++ 5 files changed, 63 insertions(+), 37 deletions(-) diff --git a/frameworks/helper/print_helper/include/napi_print_utils.h b/frameworks/helper/print_helper/include/napi_print_utils.h index 42d7a6a1..7753b36f 100644 --- a/frameworks/helper/print_helper/include/napi_print_utils.h +++ b/frameworks/helper/print_helper/include/napi_print_utils.h @@ -78,6 +78,7 @@ public: static size_t GetJsVal(napi_env env, napi_callback_info info, napi_value argv[], size_t length); static bool VerifyProperty(std::vector &names, std::map &propertyList); + static std::string GetPrintErrorMsg(int32_t errorCode); }; } // namespace OHOS::Print #endif // NAPI_PRINT_UTILS_H \ No newline at end of file diff --git a/frameworks/helper/print_helper/src/napi_print_utils.cpp b/frameworks/helper/print_helper/src/napi_print_utils.cpp index 2112032f..94724024 100644 --- a/frameworks/helper/print_helper/src/napi_print_utils.cpp +++ b/frameworks/helper/print_helper/src/napi_print_utils.cpp @@ -346,4 +346,13 @@ bool NapiPrintUtils::VerifyProperty( } return true; } + +std::string NapiPrintUtils::GetPrintErrorMsg(int32_t errorCode) +{ + auto msg = PRINT_ERROR_MSG_MAP.find(static_cast(errorCode)); + if (msg != PRINT_ERROR_MSG_MAP.end()) { + return msg->second; + } + return ""; +} } // namespace OHOS::Print diff --git a/interfaces/kits/napi/print_napi/include/napi_inner_print.h b/interfaces/kits/napi/print_napi/include/napi_inner_print.h index c6e85c2c..a8054168 100644 --- a/interfaces/kits/napi/print_napi/include/napi_inner_print.h +++ b/interfaces/kits/napi/print_napi/include/napi_inner_print.h @@ -59,6 +59,7 @@ private: static bool IsSupportType(const std::string& type); static bool IsValidApplicationEvent(uint32_t event); static bool IsValidDefaultPrinterType(uint32_t type); + static napi_value NapiThrowError(napi_env env, int32_t errCode); private: struct InnerPrintContext : public PrintAsyncCall::Context { diff --git a/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp b/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp index 4e01cd0c..b712e09a 100644 --- a/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp +++ b/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp @@ -533,7 +533,7 @@ napi_value NapiInnerPrint::On(napi_env env, napi_callback_info info) if (!NapiInnerPrint::IsSupportType(type)) { PRINT_HILOGE("Event On type : %{public}s not support", type.c_str()); - return nullptr; + return NapiThrowError(env, E_PRINT_INVALID_PARAMETER); } valuetype = napi_undefined; @@ -550,7 +550,7 @@ napi_value NapiInnerPrint::On(napi_env env, napi_callback_info info) int32_t ret = PrintManagerClient::GetInstance()->On("", type, callback); if (ret != E_PRINT_NONE) { PRINT_HILOGE("Failed to register event"); - return nullptr; + return NapiThrowError(env, ret); } return nullptr; } @@ -558,40 +558,36 @@ napi_value NapiInnerPrint::On(napi_env env, napi_callback_info info) napi_value NapiInnerPrint::Off(napi_env env, napi_callback_info info) { PRINT_HILOGD("Enter ---->"); - auto context = std::make_shared(); - auto input = - [context]( - napi_env env, size_t argc, napi_value *argv, napi_value self, napi_callback_info info) -> napi_status { - PRINT_ASSERT_BASE(env, argc == NapiPrintUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg); - napi_valuetype valuetype; - PRINT_CALL_BASE(env, napi_typeof(env, argv[NapiPrintUtils::INDEX_ZERO], &valuetype), napi_invalid_arg); - PRINT_ASSERT_BASE(env, valuetype == napi_string, "type is not a string", napi_string_expected); - std::string type = NapiPrintUtils::GetStringFromValueUtf8(env, argv[NapiPrintUtils::INDEX_ZERO]); - if (!NapiInnerPrint::IsSupportType(type)) { - PRINT_HILOGE("Event Off type : %{public}s not support", context->type.c_str()); - context->SetErrorIndex(E_PRINT_INVALID_PARAMETER); - return napi_invalid_arg; - } - context->type = type; - PRINT_HILOGD("event type : %{public}s", context->type.c_str()); - return napi_ok; - }; - auto output = [context](napi_env env, napi_value *result) -> napi_status { - napi_status status = napi_get_boolean(env, context->result, result); - PRINT_HILOGD("context->result = %{public}d", context->result); - return status; - }; - auto exec = [context](PrintAsyncCall::Context *ctx) { - int32_t ret = PrintManagerClient::GetInstance()->Off("", context->type); - context->result = ret == E_PRINT_NONE; - if (ret != E_PRINT_NONE) { - PRINT_HILOGE("Failed to unregister event"); - context->SetErrorIndex(ret); - } - }; - context->SetAction(std::move(input), std::move(output)); - PrintAsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); - return asyncCall.Call(env, exec); + size_t argc = NapiPrintUtils::MAX_ARGC; + napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr }; + napi_value thisVal = nullptr; + void *data = nullptr; + PRINT_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVal, &data)); + PRINT_ASSERT(env, argc == NapiPrintUtils::ARGC_ONE || argc == NapiPrintUtils::ARGC_TWO, "need 1-2 parameter!"); + + napi_valuetype valuetype; + PRINT_CALL(env, napi_typeof(env, argv[0], &valuetype)); + PRINT_ASSERT(env, valuetype == napi_string, "type is not a string"); + std::string type = NapiPrintUtils::GetStringFromValueUtf8(env, argv[0]); + PRINT_HILOGD("type : %{public}s", type.c_str()); + + if (!NapiInnerPrint::IsSupportType(type)) { + PRINT_HILOGE("Event Off type : %{public}s not support", type.c_str()); + return NapiThrowError(env, E_PRINT_INVALID_PARAMETER); + } + + if (argc == NapiPrintUtils::ARGC_TWO) { + valuetype = napi_undefined; + napi_typeof(env, argv[1], &valuetype); + PRINT_ASSERT(env, valuetype == napi_function, "callback is not a function"); + } + + int32_t ret = PrintManagerClient::GetInstance()->Off("", type); + if (ret != E_PRINT_NONE) { + PRINT_HILOGE("Failed to unregister event"); + return NapiThrowError(env, ret); + } + return nullptr; } napi_value NapiInnerPrint::StartGetPrintFile(napi_env env, napi_callback_info info) @@ -631,7 +627,7 @@ napi_value NapiInnerPrint::StartGetPrintFile(napi_env env, napi_callback_info in int32_t ret = PrintManagerClient::GetInstance()->StartGetPrintFile(jobId, *printAttributes, fd); if (ret != E_PRINT_NONE) { PRINT_HILOGE("Failed to StartGetPrintFile"); - return nullptr; + return NapiThrowError(env, ret); } } return nullptr; @@ -896,4 +892,13 @@ bool NapiInnerPrint::IsValidDefaultPrinterType(uint32_t type) } return false; } + +napi_value NapiInnerPrint::NapiThrowError(napi_env env, const int32_t errCode) +{ + napi_value result = nullptr; + napi_create_error(env, NapiPrintUtils::CreateInt32(env, errCode), + NapiPrintUtils::CreateStringUtf8(env, NapiPrintUtils::GetPrintErrorMsg(errCode)), &result); + napi_throw(env, result); + return nullptr; +} } // namespace OHOS::Print diff --git a/utils/include/print_constant.h b/utils/include/print_constant.h index 82453113..c03fc1d1 100644 --- a/utils/include/print_constant.h +++ b/utils/include/print_constant.h @@ -17,6 +17,7 @@ #define PRINT_CONSTANT_H #include +#include namespace OHOS::Print { #define PRINT_RET_NONE @@ -239,5 +240,14 @@ const std::string PRINTER_LIST_FILE = "printer_list.json"; const std::string PRINTER_LIST_VERSION = "v1"; const std::string PRINT_USER_DATA_FILE = "print_user_data.json"; const std::string PRINT_USER_DATA_VERSION = "v1"; + +const std::string E_PRINT_MSG_NONE = "none"; +const std::string E_PRINT_MSG_NO_PERMISSION = "the application does not hace permission"; +const std::string E_PRINT_MSG_INVALID_PARAMETER = "parameter error"; +static std::map PRINT_ERROR_MSG_MAP { + {E_PRINT_NONE, E_PRINT_MSG_NONE }, + {E_PRINT_NO_PERMISSION, E_PRINT_MSG_NO_PERMISSION }, + {E_PRINT_INVALID_PARAMETER, E_PRINT_MSG_INVALID_PARAMETER }, +}; } // namespace OHOS::Print #endif // PRINT_CONSTANT_H From 818490acd9d5b4222ecfb056e6efed6e84c796a6 Mon Sep 17 00:00:00 2001 From: zheng_zhi_hao Date: Thu, 14 Nov 2024 22:17:05 +0800 Subject: [PATCH 08/19] =?UTF-8?q?NotifyPrintServiceEvent=E6=94=AF=E6=8C=81?= =?UTF-8?q?=E5=8F=AF=E9=80=89=E5=8F=82=E6=95=B0=E6=A0=A1=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zheng_zhi_hao --- interfaces/kits/napi/print_napi/src/napi_inner_print.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp b/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp index 4e01cd0c..0a13bff9 100644 --- a/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp +++ b/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp @@ -754,12 +754,11 @@ napi_value NapiInnerPrint::NotifyPrintServiceEvent(napi_env env, napi_callback_i auto input = [context]( napi_env env, size_t argc, napi_value *argv, napi_value self, napi_callback_info info) -> napi_status { - PRINT_ASSERT_BASE(env, argc == NapiPrintUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg); + PRINT_ASSERT_BASE(env, argc == NapiPrintUtils::ARGC_ONE || argc == NapiPrintUtils::ARGC_TWO, + "should 1 or 2 parameter!", napi_invalid_arg); napi_valuetype valuetype; PRINT_CALL_BASE(env, napi_typeof(env, argv[NapiPrintUtils::INDEX_ZERO], &valuetype), napi_invalid_arg); - PRINT_ASSERT_BASE(env, valuetype == napi_string, "jobId is not a string", napi_string_expected); PRINT_CALL_BASE(env, napi_typeof(env, argv[NapiPrintUtils::INDEX_ONE], &valuetype), napi_invalid_arg); - PRINT_ASSERT_BASE(env, valuetype == napi_number, "event is not a number", napi_number_expected); std::string jobId = NapiPrintUtils::GetStringFromValueUtf8(env, argv[NapiPrintUtils::INDEX_ZERO]); uint32_t event = NapiPrintUtils::GetUint32FromValue(env, argv[NapiPrintUtils::INDEX_ONE]); PRINT_HILOGI("jobId: %{public}s, event : %{public}d", jobId.c_str(), event); From 04b63819526ced1a74721c87747caa9dca3858d8 Mon Sep 17 00:00:00 2001 From: baozewei Date: Fri, 15 Nov 2024 15:31:35 +0800 Subject: [PATCH 09/19] =?UTF-8?q?CDE=E5=91=8A=E8=AD=A6=E5=A4=84=E7=90=86?= =?UTF-8?q?=20Signed-off-by:baozewei@huawei.com?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: baozewei --- .../kits/napi/print_napi/src/print_task.cpp | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/interfaces/kits/napi/print_napi/src/print_task.cpp b/interfaces/kits/napi/print_napi/src/print_task.cpp index 836b3bd0..de4273e2 100644 --- a/interfaces/kits/napi/print_napi/src/print_task.cpp +++ b/interfaces/kits/napi/print_napi/src/print_task.cpp @@ -100,13 +100,17 @@ uint32_t PrintTask::Start(napi_env env, napi_callback_info info) if (pathType_ == FILE_PATH_ABSOLUTED) { for (auto file : fileList_) { int32_t fd = PrintUtils::OpenFile(file); - if (fd < 0) { - PRINT_HILOGE("file[%{private}s] is invalid", file.c_str()); - fdList_.clear(); - fileList_.clear(); - return E_PRINT_INVALID_PARAMETER; + if (fd >= 0) { + fdList_.emplace_back(fd); + continue; } - fdList_.emplace_back(fd); + PRINT_HILOGE("file[%{private}s] is invalid", file.c_str()); + for (auto fd : fdList_) { + close(fd); + } + fdList_.clear(); + fileList_.clear(); + return E_PRINT_INVALID_PARAMETER; } } From 7fe9a880e48ec6e8f12dd252f7be2ccc4ccc5c45 Mon Sep 17 00:00:00 2001 From: baozewei Date: Fri, 15 Nov 2024 15:44:58 +0800 Subject: [PATCH 10/19] =?UTF-8?q?=E9=80=80=E5=87=BASA=E6=97=B6=E7=BD=AErea?= =?UTF-8?q?dy=5F=E4=B8=BAfalse=20Signed-off-by:baozewei@huawei.com?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: baozewei --- .../innerkitsimpl/print_impl/src/print_manager_client.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/frameworks/innerkitsimpl/print_impl/src/print_manager_client.cpp b/frameworks/innerkitsimpl/print_impl/src/print_manager_client.cpp index b99a8ba6..b2ea7777 100644 --- a/frameworks/innerkitsimpl/print_impl/src/print_manager_client.cpp +++ b/frameworks/innerkitsimpl/print_impl/src/print_manager_client.cpp @@ -94,6 +94,8 @@ void PrintManagerClient::OnRemoteSaDied(const wptr &remote) serviceRemote->RemoveDeathRecipient(deathRecipient_); printServiceProxy_ = nullptr; deathRecipient_ = nullptr; + std::unique_lock lock(conditionMutex_); + ready_ = false; } } From 67ebc1ac876248e155916e4f549e4325571803ff Mon Sep 17 00:00:00 2001 From: zheng_zhi_hao Date: Fri, 15 Nov 2024 17:22:54 +0800 Subject: [PATCH 11/19] =?UTF-8?q?=E9=99=90=E5=88=B6=E6=89=93=E5=8D=B0?= =?UTF-8?q?=E6=96=87=E4=BB=B6=E4=B8=AA=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zheng_zhi_hao --- interfaces/kits/napi/print_napi/src/print_task.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/interfaces/kits/napi/print_napi/src/print_task.cpp b/interfaces/kits/napi/print_napi/src/print_task.cpp index de4273e2..2fa7f242 100644 --- a/interfaces/kits/napi/print_napi/src/print_task.cpp +++ b/interfaces/kits/napi/print_napi/src/print_task.cpp @@ -42,6 +42,8 @@ static const std::string UI_EXTENSION_TYPE_NAME = "ability.want.params.uiExtensi static const std::string PRINT_UI_EXTENSION_TYPE = "sysDialog/print"; static const std::string CALLER_PKG_NAME = "caller.pkgName"; static const std::string ABILITY_PARAMS_STREAM = "ability.params.stream"; +static const std::string LAUNCH_PARAMETER_FILE_LIST_SIZE = "fileListSize"; +static const int32_t MAX_FILE_LIST_SIZE = 100; PrintTask::PrintTask(const std::vector &innerList, const sptr &innerCallerToken_) : taskId_("") @@ -259,7 +261,12 @@ uint32_t PrintTask::StartUIExtensionAbility( AAFwk::Want want; want.SetElementName(SPOOLER_BUNDLE_NAME, SPOOLER_PREVIEW_ABILITY_NAME); want.SetParam(LAUNCH_PARAMETER_JOB_ID, adapterParam->jobId); - want.SetParam(LAUNCH_PARAMETER_FILE_LIST, fileList_); + if (fileList_.size() <= MAX_FILE_LIST_SIZE) { + want.SetParam(LAUNCH_PARAMETER_FILE_LIST, fileList_); + } else { + PRINT_HILOGW("fileList exceeds the maximum length."); + } + want.SetParam(LAUNCH_PARAMETER_FILE_LIST_SIZE, static_cast(fileList_.size())); PrintUtils::BuildAdapterParam(adapterParam, want); int32_t callerTokenId = static_cast(IPCSkeleton::GetCallingTokenID()); int32_t callerUid = IPCSkeleton::GetCallingUid(); From a510fdf88e99649417d8afc8869e1d15fd5856e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=94=B0=E8=BF=85?= Date: Fri, 15 Nov 2024 19:39:34 +0800 Subject: [PATCH 12/19] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E5=8C=97=E5=90=91?= =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E9=94=99=E8=AF=AF=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 田迅 --- .../print_napi/include/napi_inner_print.h | 2 +- .../napi/print_napi/src/napi_inner_print.cpp | 19 ++++++++++++------- 2 files changed, 13 insertions(+), 8 deletions(-) diff --git a/interfaces/kits/napi/print_napi/include/napi_inner_print.h b/interfaces/kits/napi/print_napi/include/napi_inner_print.h index a8054168..36640ce0 100644 --- a/interfaces/kits/napi/print_napi/include/napi_inner_print.h +++ b/interfaces/kits/napi/print_napi/include/napi_inner_print.h @@ -59,7 +59,7 @@ private: static bool IsSupportType(const std::string& type); static bool IsValidApplicationEvent(uint32_t event); static bool IsValidDefaultPrinterType(uint32_t type); - static napi_value NapiThrowError(napi_env env, int32_t errCode); + static void NapiThrowError(napi_env env, int32_t errCode); private: struct InnerPrintContext : public PrintAsyncCall::Context { diff --git a/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp b/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp index b712e09a..6d306887 100644 --- a/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp +++ b/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp @@ -533,7 +533,8 @@ napi_value NapiInnerPrint::On(napi_env env, napi_callback_info info) if (!NapiInnerPrint::IsSupportType(type)) { PRINT_HILOGE("Event On type : %{public}s not support", type.c_str()); - return NapiThrowError(env, E_PRINT_INVALID_PARAMETER); + NapiThrowError(env, E_PRINT_INVALID_PARAMETER); + return nullptr; } valuetype = napi_undefined; @@ -550,7 +551,8 @@ napi_value NapiInnerPrint::On(napi_env env, napi_callback_info info) int32_t ret = PrintManagerClient::GetInstance()->On("", type, callback); if (ret != E_PRINT_NONE) { PRINT_HILOGE("Failed to register event"); - return NapiThrowError(env, ret); + NapiThrowError(env, ret); + return nullptr; } return nullptr; } @@ -573,7 +575,8 @@ napi_value NapiInnerPrint::Off(napi_env env, napi_callback_info info) if (!NapiInnerPrint::IsSupportType(type)) { PRINT_HILOGE("Event Off type : %{public}s not support", type.c_str()); - return NapiThrowError(env, E_PRINT_INVALID_PARAMETER); + NapiThrowError(env, E_PRINT_INVALID_PARAMETER); + return nullptr; } if (argc == NapiPrintUtils::ARGC_TWO) { @@ -585,7 +588,8 @@ napi_value NapiInnerPrint::Off(napi_env env, napi_callback_info info) int32_t ret = PrintManagerClient::GetInstance()->Off("", type); if (ret != E_PRINT_NONE) { PRINT_HILOGE("Failed to unregister event"); - return NapiThrowError(env, ret); + NapiThrowError(env, ret); + return nullptr; } return nullptr; } @@ -613,6 +617,7 @@ napi_value NapiInnerPrint::StartGetPrintFile(napi_env env, napi_callback_info in int32_t retCallback = PrintManagerClient::GetInstance()->On("", PRINT_GET_FILE_CALLBACK_ADAPTER, callback); if (retCallback != E_PRINT_NONE) { PRINT_HILOGE("Failed to register startGetPrintFile callback"); + NapiThrowError(env, retCallback); return nullptr; } } @@ -627,7 +632,8 @@ napi_value NapiInnerPrint::StartGetPrintFile(napi_env env, napi_callback_info in int32_t ret = PrintManagerClient::GetInstance()->StartGetPrintFile(jobId, *printAttributes, fd); if (ret != E_PRINT_NONE) { PRINT_HILOGE("Failed to StartGetPrintFile"); - return NapiThrowError(env, ret); + NapiThrowError(env, ret); + return nullptr; } } return nullptr; @@ -893,12 +899,11 @@ bool NapiInnerPrint::IsValidDefaultPrinterType(uint32_t type) return false; } -napi_value NapiInnerPrint::NapiThrowError(napi_env env, const int32_t errCode) +void NapiInnerPrint::NapiThrowError(napi_env env, const int32_t errCode) { napi_value result = nullptr; napi_create_error(env, NapiPrintUtils::CreateInt32(env, errCode), NapiPrintUtils::CreateStringUtf8(env, NapiPrintUtils::GetPrintErrorMsg(errCode)), &result); napi_throw(env, result); - return nullptr; } } // namespace OHOS::Print From ee1bd7f8b681a19edf95239ddebb1566ddce764e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E6=99=BA=E5=8B=87?= Date: Mon, 18 Nov 2024 14:59:39 +0800 Subject: [PATCH 13/19] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张智勇 --- ...t_cups_client_vendor_helper_other_test.cpp | 32 ++++++++++--------- .../print_http_request_process_other_test.cpp | 6 ++-- 2 files changed, 20 insertions(+), 18 deletions(-) diff --git a/test/unittest/others/print_cups_client_vendor_helper_other_test.cpp b/test/unittest/others/print_cups_client_vendor_helper_other_test.cpp index 05ac5836..4451072a 100644 --- a/test/unittest/others/print_cups_client_vendor_helper_other_test.cpp +++ b/test/unittest/others/print_cups_client_vendor_helper_other_test.cpp @@ -191,6 +191,7 @@ jobParams.printerUri = "printerUri"; jobParams.serviceAbility = new PrintServiceAbility(); jobParams.serviceJobId = 1; client.UpdatePrintJobStateInJobParams(&jobParams, 1, 1); +EXPECT_EQ(client.printerId, 1); } TEST_F(nullTest, testHandleJobState) { @@ -215,6 +216,7 @@ PrintCupsClient client; JobMonitorParam param; JobStatus jobStatus; client.QueryJobStateAgain(nullptr, ¶m, &jobStatus); +EXPECT_EQ(client.JobStatus, nullptr); } TEST_F(nullTest, testUpdateJobStatus) { @@ -222,6 +224,7 @@ PrintCupsClient client; JobStatus previousJobStatus; JobStatus jobStatus; client.UpdateJobStatus(&previousJobStatus, &jobStatus); +EXPECT_EQ(client.JobStatus, nullptr); } TEST_F(nullTest, testJobStatusCallback) { @@ -987,12 +990,12 @@ TEST_F(nullTest, ParseMediaColDefaultAttributes_ShouldHandleNullPrinterCaps) { ipp_t response; ParseMediaColDefaultAttributes(&response, nullptr); -// No assertions needed as the function should handle null PrinterCaps gracefully +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-top-margin-default"), ""); } TEST_F(nullTest, ParseMediaColDefaultAttributes_ShouldHandleNullResponseAndPrinterCaps) { ParseMediaColDefaultAttributes(nullptr, nullptr); -// No assertions needed as the function should handle null inputs gracefully +EXPECT_EQ(printerCaps.GetPrinterAttrNameAndValue("media-top-margin-default"), ""); } TEST_F(nullTest, ParseMediaColDefaultAttributes_ShouldHandleValidResponse) { @@ -1324,42 +1327,42 @@ TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenDiscoveryItemIsNull) { Print_DiscoveryItem* discoveryItem = nullptr; LogDiscoveryItem(discoveryItem); -// 由于没有实际的打印输出，我们无法直接断言输出，但可以验证没有崩溃，并且可以添加断言来检查是否打印了警告信息 +EXPECT_EQ(result, ""); } TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenPrinterIdIsNull) { Print_DiscoveryItem discoveryItem; discoveryItem.printerId = nullptr; LogDiscoveryItem(&discoveryItem); -// 验证是否打印了警告信息 +EXPECT_EQ(result, ""); } TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenPrinterNameIsNull) { Print_DiscoveryItem discoveryItem; discoveryItem.printerName = nullptr; LogDiscoveryItem(&discoveryItem); -// 验证是否打印了警告信息 +EXPECT_EQ(result, ""); } TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenMakeAndModelIsNull) { Print_DiscoveryItem discoveryItem; discoveryItem.makeAndModel = nullptr; LogDiscoveryItem(&discoveryItem); -// 验证是否打印了警告信息 +EXPECT_EQ(result, ""); } TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenPrinterUriIsNull) { Print_DiscoveryItem discoveryItem; discoveryItem.printerUri = nullptr; LogDiscoveryItem(&discoveryItem); -// 验证是否打印了警告信息 +EXPECT_EQ(result, ""); } TEST_F(nullTest, LogDiscoveryItem_ShouldPrintWarning_WhenPrinterUuidIsNull) { Print_DiscoveryItem discoveryItem; discoveryItem.printerUuid = nullptr; LogDiscoveryItem(&discoveryItem); -// 验证是否打印了警告信息 +EXPECT_EQ(result, ""); } TEST_F(nullTest, LogDiscoveryItem_ShouldPrintDetails_WhenAllFieldsAreValid) { @@ -1372,7 +1375,7 @@ discoveryItem.makeAndModel = "MakeAndModel1"; discoveryItem.printerUri = "PrinterUri1"; discoveryItem.printerUuid = "PrinterUuid1"; LogDiscoveryItem(&discoveryItem); -// 验证是否打印了详细信息 +EXPECT_EQ(capability.printerId, "123"); } TEST_F(nullTest, LogPageCapability_ShouldPrintWarning_WhenCapabilityIsNull) { @@ -1381,8 +1384,7 @@ capability.supportedPageSizes = nullptr; capability.supportedMediaTypes = nullptr; capability.supportedPaperSources = nullptr; LogPageCapability(&capability); -// 验证是否打印了警告日志 -// 这里需要使用到mock或者其他方式来验证是否打印了警告日志 +EXPECT_EQ(capability.supportedPageSizes, nullptr); } TEST_F(nullTest, LogPageCapability_ShouldPrintPageInfo_WhenCapabilityIsNotNull) @@ -1397,8 +1399,7 @@ capability.supportedPageSizes[0].height = ONE; capability.supportedMediaTypes = "JPEG"; capability.supportedPaperSources = "Source1,Source2"; LogPageCapability(&capability); -// 验证是否打印了页面信息 -// 这里需要使用到mock或者其他方式来验证是否打印了页面信息 +EXPECT_EQ(capability.supportedPageSizesCount, 1); } TEST_F(nullTest, LogPageCapability_ShouldPrintPageInfo_WhenCapabilityHasMultiplePages) @@ -1417,8 +1418,7 @@ capability.supportedPageSizes[1].height = ONE; capability.supportedMediaTypes = "JPEG,PNG"; capability.supportedPaperSources = "Source1,Source2"; LogPageCapability(&capability); -// 验证是否打印了多个页面信息 -// 这里需要使用到mock或者其他方式来验证是否打印了多个页面信息 +EXPECT_EQ(result, ""); } TEST_F(nullTest, LogDefaultValue_ShouldPrintWarning_WhenDefaultValueIsNull) @@ -1440,6 +1440,7 @@ defaultValue.defaultResolution.verticalDpi = 0; defaultValue.defaultOrientation = 0; defaultValue.otherDefaultValues = nullptr; LogDefaultValue(&defaultValue); +EXPECT_EQ(defaultValue.defaultColorMode, 0); } TEST_F(nullTest, LogDefaultValue_ShouldPrintAllValues_WhenAllValuesAreNotNull) { @@ -1460,6 +1461,7 @@ defaultValue.defaultResolution.verticalDpi = 1; defaultValue.defaultOrientation = 1; defaultValue.otherDefaultValues = "OtherValues"; LogDefaultValue(&defaultValue); +EXPECT_EQ(defaultValue.defaultColorMode, 1); } HWTEST_F(nullTest, FindPropertyFromPropertyList_ShouldReturnEmptyString_WhenPropertyListIsNull, TestSize.Level0) diff --git a/test/unittest/others/print_http_request_process_other_test.cpp b/test/unittest/others/print_http_request_process_other_test.cpp index f37c679d..bf8d5adf 100644 --- a/test/unittest/others/print_http_request_process_other_test.cpp +++ b/test/unittest/others/print_http_request_process_other_test.cpp @@ -500,19 +500,19 @@ TEST_F(PrintHttpRequestProcessTest, DumpReqIdOperaId_ShouldPrintData_WhenDataIsN { char data[REQID_OPERAID_LEN] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; PrintHttpRequestProcess::DumpReqIdOperaId(data, REQID_OPERAID_LEN); - // 由于PRINT_HILOGD是宏，我们无法直接验证其输出，但可以假设它被正确调用 + EXPECT_EQ(process.result, "processed"); } TEST_F(PrintHttpRequestProcessTest, DumpReqIdOperaId_ShouldNotPrintData_WhenDataIsNull) { char *data = nullptr; PrintHttpRequestProcess::DumpReqIdOperaId(data, REQID_OPERAID_LEN); - // 由于PRINT_HILOGD是宏，我们无法直接验证其输出，但可以假设它没有被调用 + EXPECT_EQ(process.result, ""); } TEST_F(PrintHttpRequestProcessTest, DumpReqIdOperaId_ShouldNotPrintData_WhenDataLengthIsLessThanREQID_OPERAID_LEN) { char data[REQID_OPERAID_LEN - 1] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; PrintHttpRequestProcess::DumpReqIdOperaId(data, REQID_OPERAID_LEN - 1); - // 由于PRINT_HILOGD是宏，我们无法直接验证其输出，但可以假设它没有被调用 + EXPECT_EQ(process.result, ""); } // 测试用例1: 测试data为空，data_length为0的情况 From 101246ba61c144789509dd8a5017b5752cae6797 Mon Sep 17 00:00:00 2001 From: baozewei Date: Mon, 18 Nov 2024 17:38:45 +0800 Subject: [PATCH 14/19] =?UTF-8?q?=E5=9B=9E=E9=80=80scanServiceType?= =?UTF-8?q?=E4=B8=BA=5Fscanner=20Signed-off-by:baozewei@huawei.com?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: baozewei --- services/scan_service/src/scan_mdns_service.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/scan_service/src/scan_mdns_service.cpp b/services/scan_service/src/scan_mdns_service.cpp index 1a7207b9..270b99ed 100644 --- a/services/scan_service/src/scan_mdns_service.cpp +++ b/services/scan_service/src/scan_mdns_service.cpp @@ -44,7 +44,7 @@ std::map> ScanMdnsService::discover bool ScanMdnsService::OnStartDiscoverService() { - const std::vector scannerServiceTypes = { "_ipp._tcp" }; + const std::vector scannerServiceTypes = { "_scanner._tcp" }; constexpr int32_t MDNS_PORT = 5353; { std::lock_guard autoLock(g_lock); From 917be091fbd9c55bee622a7ee5342fbef455c89c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E6=99=BA=E5=8B=87?= Date: Mon, 18 Nov 2024 18:29:33 +0800 Subject: [PATCH 15/19] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张智勇 --- .../scanhelper_fuzzer/scanhelper_fuzzer.cpp | 144 ++++++++++++++++++ 1 file changed, 144 insertions(+) diff --git a/test/fuzztest/scanhelper_fuzzer/scanhelper_fuzzer.cpp b/test/fuzztest/scanhelper_fuzzer/scanhelper_fuzzer.cpp index 3bce3da6..ac798e38 100644 --- a/test/fuzztest/scanhelper_fuzzer/scanhelper_fuzzer.cpp +++ b/test/fuzztest/scanhelper_fuzzer/scanhelper_fuzzer.cpp @@ -597,6 +597,124 @@ void TestScannerInfoTCPNapiInterface(const uint8_t* data, size_t size, FuzzedDat ScannerInfoHelperTCP::MakeJsObject(env, info); } +void TestSetNamedProperty(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value object = nullptr; + std::string name = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH); + napi_value value = nullptr; + NapiScanUtils::SetNamedProperty(env, object, name, value); +} + +void TestGetUint32FromValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value value = nullptr; + NapiScanUtils::GetUint32FromValue(env, value); +} + +void TestGetInt32FromValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value value = nullptr; + NapiScanUtils::GetInt32FromValue(env, value); +} + +void TestGetStringFromValueUtf8(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value value = nullptr; + NapiScanUtils::GetStringFromValueUtf8(env, value); +} + +void TestValueIsArrayBuffer(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value value = nullptr; + NapiScanUtils::ValueIsArrayBuffer(env, value); +} + +void TestGetInfoFromArrayBufferValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value value = nullptr; + size_t *length = nullptr; + NapiScanUtils::GetInfoFromArrayBufferValue(env, value, length); +} + +void TestCreateObject(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + NapiScanUtils::CreateObject(env); +} + +void TestGetUndefined(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + NapiScanUtils::GetUndefined(env); +} + +void TestCallFunction(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value recv = nullptr; + napi_value func = nullptr; + size_t argc = 0; + napi_value *argv = nullptr; + NapiScanUtils::CallFunction(env, recv, func, argc, argv); +} + +void TestCreateReference(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value callback = nullptr; + NapiScanUtils::CreateReference(env, callback); +} + +void TestCreateBoolean(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + bool value = 1; + NapiScanUtils::CreateBoolean(env, value); +} + +void TestGetBooleanFromValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value value = nullptr; + NapiScanUtils::GetBooleanFromValue(env, value); +} + +void TestGetBooleanProperty(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value object = nullptr; + std::string propertyName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH); + NapiScanUtils::GetBooleanProperty(env, object, propertyName); +} + +void TestSetBooleanProperty(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value object = nullptr; + std::string name = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH); + bool value = 1; + NapiScanUtils::SetBooleanProperty(env, object, name, value); +} + +void TestToLower(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + std::string s = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH); + NapiScanUtils::ToLower(s); +} + +void TestGetValueString(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_value jsValue = nullptr; + NapiScanUtils::GetValueString(env, jsValue); +} + void TestGetExtensionIdInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) { std::string globalId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH); @@ -651,6 +769,15 @@ void TestIsPathValid(const uint8_t* data, size_t size, FuzzedDataProvider* dataP NapiScanUtils::IsPathValid(filePath); } +void TestGetJsVal(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) +{ + napi_env env = nullptr; + napi_callback_info info = nullptr; + napi_value* jsValue = nullptr; + size_t length = 1; + NapiScanUtils::GetJsVal(env, info, jsValue, length); +} + void ScanOptionDescriptorFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) { TestSetOptionName(data, size, dataProvider); @@ -762,6 +889,22 @@ void ScannerInfoHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvi void NapiScanUtilsFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider) { + TestSetNamedProperty(data, size, dataProvider); + TestGetUint32FromValue(data, size, dataProvider); + TestGetInt32FromValue(data, size, dataProvider); + TestGetStringFromValueUtf8(data, size, dataProvider); + TestValueIsArrayBuffer(data, size, dataProvider); + TestGetInfoFromArrayBufferValue(data, size, dataProvider); + TestCreateObject(data, size, dataProvider); + TestGetUndefined(data, size, dataProvider); + TestCallFunction(data, size, dataProvider); + TestCreateReference(data, size, dataProvider); + TestCreateBoolean(data, size, dataProvider); + TestGetBooleanFromValue(data, size, dataProvider); + TestGetBooleanProperty(data, size, dataProvider); + TestSetBooleanProperty(data, size, dataProvider); + TestToLower(data, size, dataProvider); + TestGetValueString(data, size, dataProvider); TestGetExtensionIdInterface(data, size, dataProvider); TestGetGlobalIdInterface(data, size, dataProvider); TestGetLocalIdInterface(data, size, dataProvider); @@ -770,6 +913,7 @@ void NapiScanUtilsFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* TestGetTaskEventId(data, size, dataProvider); TestOpenFile(data, size, dataProvider); TestIsPathValid(data, size, dataProvider); + TestGetJsVal(data, size, dataProvider); } } From 73ca8cc2924ed297405a3904628d85bdf30273a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=98=8A=E8=8B=8F?= Date: Tue, 19 Nov 2024 11:49:31 +0800 Subject: [PATCH 16/19] =?UTF-8?q?:=E4=BF=AE=E5=A4=8D=E6=97=A0=E8=BE=B9?= =?UTF-8?q?=E8=B7=9D=E9=97=AE=E9=A2=98;=20Signed-off-by:liuhaosu@huawei.co?= =?UTF-8?q?m?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘昊苏 --- services/print_service/src/print_cups_client.cpp | 10 +++------- services/scan_service/src/scan_service_ability.cpp | 1 + .../print_cups_wrapper_test.cpp | 4 ++-- 3 files changed, 6 insertions(+), 9 deletions(-) diff --git a/services/print_service/src/print_cups_client.cpp b/services/print_service/src/print_cups_client.cpp index 6ed2cd8f..454fa5ec 100644 --- a/services/print_service/src/print_cups_client.cpp +++ b/services/print_service/src/print_cups_client.cpp @@ -1542,13 +1542,9 @@ void PrintCupsClient::UpdateBorderlessJobParameter(json& optionJson, JobParamete if (params == nullptr) { return; } - if (optionJson.contains("borderless") && optionJson["borderless"].is_string()) { - std::string isBorderless = optionJson["borderless"].get(); - if (isBorderless == "true") { - params->borderless = TRUE; - } else { - params->borderless = FALSE; - } + if (optionJson.contains("isBorderless") && optionJson["isBorderless"].is_boolean()) { + bool isBorderless = optionJson["isBorderless"].get(); + params->borderless = isBorderless ? TRUE : FALSE; } else { params->borderless = TRUE; } diff --git a/services/scan_service/src/scan_service_ability.cpp b/services/scan_service/src/scan_service_ability.cpp index 88eec686..579e8fde 100644 --- a/services/scan_service/src/scan_service_ability.cpp +++ b/services/scan_service/src/scan_service_ability.cpp @@ -186,6 +186,7 @@ ScanServiceAbility::~ScanServiceAbility() FREE_AND_NULLPTR(saneReadBuf); FREE_AND_NULLPTR(jpegbuf) DELETE_AND_NULLIFY(cinfoPtr); + DELETE_AND_NULLIFY(ofp); SCAN_HILOGD("~ScanServiceAbility state_ is %{public}d.", static_cast(state_)); } diff --git a/test/unittest/fwk_print_cups_client_test/print_cups_wrapper_test.cpp b/test/unittest/fwk_print_cups_client_test/print_cups_wrapper_test.cpp index 33058768..017735b4 100755 --- a/test/unittest/fwk_print_cups_client_test/print_cups_wrapper_test.cpp +++ b/test/unittest/fwk_print_cups_client_test/print_cups_wrapper_test.cpp @@ -514,11 +514,11 @@ HWTEST_F(PrintCupsWrapperTest, PrintCupsWrapperTest_0086, TestSize.Level1) printCupsClient.UpdateBorderlessJobParameter(optionJson, jobParams); jobParams = new JobParameters(); printCupsClient.UpdateBorderlessJobParameter(optionJson, jobParams); - optionJson["borderless"] = "false"; + optionJson["isBorderless"] = false; printCupsClient.UpdateBorderlessJobParameter(optionJson, jobParams); EXPECT_EQ(jobParams->borderless, 0); - optionJson["borderless"] = "true"; + optionJson["isBorderless"] = true; printCupsClient.UpdateBorderlessJobParameter(optionJson, jobParams); EXPECT_EQ(jobParams->borderless, 1); From 134f91238405b6dfb2924df5101e0ae374b7b5ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=94=B0=E8=BF=85?= Date: Sat, 9 Nov 2024 20:48:09 +0800 Subject: [PATCH 17/19] =?UTF-8?q?=E4=BB=A3=E7=A0=81=E8=A7=84=E8=8C=83?= =?UTF-8?q?=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 田迅 --- .../print_impl/src/print_callback_stub.cpp | 3 +- .../src/print_extension_callback_stub.cpp | 3 +- .../print_impl/src/print_service_proxy.cpp | 8 ++++ .../scan_impl/src/scan_callback_stub.cpp | 3 +- .../scan_impl/src/scan_service_proxy.cpp | 4 ++ .../kits/extension/src/js_print_extension.cpp | 12 +++-- .../src/print_callback_proxy.cpp | 46 +++++++++++++++---- .../scan_service/src/scan_service_ability.cpp | 12 +++-- .../scan_service/src/scan_service_stub.cpp | 3 +- .../print_callback_stub_test.cpp | 8 ++-- .../print_extension_callback_stub_test.cpp | 16 +++---- 11 files changed, 86 insertions(+), 32 deletions(-) diff --git a/frameworks/innerkitsimpl/print_impl/src/print_callback_stub.cpp b/frameworks/innerkitsimpl/print_impl/src/print_callback_stub.cpp index f8422abb..2fb09042 100644 --- a/frameworks/innerkitsimpl/print_impl/src/print_callback_stub.cpp +++ b/frameworks/innerkitsimpl/print_impl/src/print_callback_stub.cpp @@ -44,7 +44,8 @@ int32_t PrintCallbackStub::OnRemoteRequest( if (itFunc != cmdMap_.end()) { auto requestFunc = itFunc->second; if (requestFunc != nullptr) { - return static_cast((this->*requestFunc)(data, reply)); + bool result = (this->*requestFunc)(data, reply); + return result ? E_PRINT_NONE : E_PRINT_SERVER_FAILURE; } } PRINT_HILOGW("default case, need check."); diff --git a/frameworks/innerkitsimpl/print_impl/src/print_extension_callback_stub.cpp b/frameworks/innerkitsimpl/print_impl/src/print_extension_callback_stub.cpp index 7ea258ac..22b772b2 100644 --- a/frameworks/innerkitsimpl/print_impl/src/print_extension_callback_stub.cpp +++ b/frameworks/innerkitsimpl/print_impl/src/print_extension_callback_stub.cpp @@ -43,7 +43,8 @@ int32_t PrintExtensionCallbackStub::OnRemoteRequest( if (itFunc != cmdMap_.end()) { auto requestFunc = itFunc->second; if (requestFunc != nullptr) { - return static_cast((this->*requestFunc)(data, reply)); + bool result = (this->*requestFunc)(data, reply); + return result ? E_PRINT_NONE : E_PRINT_SERVER_FAILURE; } } PRINT_HILOGW("default case, need check."); diff --git a/frameworks/innerkitsimpl/print_impl/src/print_service_proxy.cpp b/frameworks/innerkitsimpl/print_impl/src/print_service_proxy.cpp index a7b3144f..14228508 100644 --- a/frameworks/innerkitsimpl/print_impl/src/print_service_proxy.cpp +++ b/frameworks/innerkitsimpl/print_impl/src/print_service_proxy.cpp @@ -167,6 +167,10 @@ int32_t PrintServiceProxy::QueryAllExtension(std::vector &ex } uint32_t len = reply.ReadUint32(); + if (len > PRINT_MAX_PRINT_COUNT) { + PRINT_HILOGE("len is out of range."); + return E_PRINT_INVALID_PARAMETER; + } for (uint32_t i = 0; i < len; i++) { auto infoPtr = PrintExtensionInfo::Unmarshalling(reply); if (infoPtr == nullptr) { @@ -560,6 +564,10 @@ int32_t PrintServiceProxy::QueryAllPrintJob(std::vector &printJobs) } uint32_t len = reply.ReadUint32(); + if (len > PRINT_MAX_PRINT_COUNT) { + PRINT_HILOGE("len is out of range."); + return E_PRINT_INVALID_PARAMETER; + } for (uint32_t i = 0; i < len; i++) { auto jobPtr = PrintJob::Unmarshalling(reply); if (jobPtr == nullptr) { diff --git a/frameworks/innerkitsimpl/scan_impl/src/scan_callback_stub.cpp b/frameworks/innerkitsimpl/scan_impl/src/scan_callback_stub.cpp index ebb8ca3d..55bb5ee9 100644 --- a/frameworks/innerkitsimpl/scan_impl/src/scan_callback_stub.cpp +++ b/frameworks/innerkitsimpl/scan_impl/src/scan_callback_stub.cpp @@ -44,7 +44,8 @@ int32_t ScanCallbackStub::OnRemoteRequest( if (itFunc != cmdMap_.end()) { auto requestFunc = itFunc->second; if (requestFunc != nullptr) { - return static_cast((this->*requestFunc)(data, reply)); + bool result = (this->*requestFunc)(data, reply); + return result ? E_SCAN_NONE : E_SCAN_SERVER_FAILURE; } } SCAN_HILOGW("default case, need check."); diff --git a/frameworks/innerkitsimpl/scan_impl/src/scan_service_proxy.cpp b/frameworks/innerkitsimpl/scan_impl/src/scan_service_proxy.cpp index 6ed74147..98612ea6 100644 --- a/frameworks/innerkitsimpl/scan_impl/src/scan_service_proxy.cpp +++ b/frameworks/innerkitsimpl/scan_impl/src/scan_service_proxy.cpp @@ -506,6 +506,10 @@ int32_t ScanServiceProxy::GetAddedScanner(std::vector& allAddedS return ret; } uint32_t len = reply.ReadUint32(); + if (len > SCAN_MAX_COUNT) { + SCAN_HILOGE("len is out of range."); + return E_SCAN_INVALID_PARAMETER; + } for (uint32_t i = 0; i < len; i++) { auto infoPtr = ScanDeviceInfo::Unmarshalling(reply); if (infoPtr == nullptr) { diff --git a/frameworks/kits/extension/src/js_print_extension.cpp b/frameworks/kits/extension/src/js_print_extension.cpp index 974ea6a2..caaeeeb6 100644 --- a/frameworks/kits/extension/src/js_print_extension.cpp +++ b/frameworks/kits/extension/src/js_print_extension.cpp @@ -110,15 +110,19 @@ bool JsPrintExtension::InitContextObj(JsRuntime &jsRuntime, napi_value &extObj, napi_env engine = jsRuntime.GetNapiEnv(); napi_value contextObj = CreateJsPrintExtensionContext(engine, context, extensionId); auto shellContextRef = jsRuntime.LoadSystemModule("PrintExtensionContext", &contextObj, NapiPrintUtils::ARGC_ONE); + if (shellContextRef == nullptr) { + PRINT_HILOGE("Failed to load print extension context ref"); + return false; + } contextObj = shellContextRef->GetNapiValue(); - PRINT_HILOGD("JsPrintExtension::Init Bind."); - context->Bind(jsRuntime, shellContextRef.release()); - PRINT_HILOGD("JsPrintExtension::napi_set_named_property."); - napi_set_named_property(engine, extObj, "context", contextObj); if (contextObj == nullptr) { PRINT_HILOGE("Failed to get Print extension native object"); return false; } + PRINT_HILOGD("JsPrintExtension::Init Bind."); + context->Bind(jsRuntime, shellContextRef.release()); + PRINT_HILOGD("JsPrintExtension::napi_set_named_property."); + napi_set_named_property(engine, extObj, "context", contextObj); napi_wrap(engine, contextObj, new std::weak_ptr(context), [](napi_env, void *data, void *) { diff --git a/services/print_service/src/print_callback_proxy.cpp b/services/print_service/src/print_callback_proxy.cpp index 65dac6b0..45b2c3d3 100644 --- a/services/print_service/src/print_callback_proxy.cpp +++ b/services/print_service/src/print_callback_proxy.cpp @@ -28,12 +28,12 @@ bool PrintCallbackProxy::OnCallback() MessageOption option; data.WriteInterfaceToken(GetDescriptor()); - auto remote = Remote(); + sptr remote = Remote(); if (remote == nullptr) { PRINT_HILOGE("SendRequest failed, error: remote is null"); return false; } - int error = Remote()->SendRequest(PRINT_CALLBACK_TASK, data, reply, option); + int error = remote->SendRequest(PRINT_CALLBACK_TASK, data, reply, option); if (error != 0) { PRINT_HILOGE("SendRequest failed, error %{public}d", error); return false; @@ -54,7 +54,12 @@ bool PrintCallbackProxy::OnCallback(uint32_t state, const PrinterInfo &info) data.WriteUint32(state); info.Marshalling(data); - int error = Remote()->SendRequest(PRINT_CALLBACK_PRINTER, data, reply, option); + sptr remote = Remote(); + if (remote == nullptr) { + PRINT_HILOGE("SendRequest failed, error: remote is null"); + return false; + } + int error = remote->SendRequest(PRINT_CALLBACK_PRINTER, data, reply, option); if (error != 0) { PRINT_HILOGE("SendRequest failed, error %{public}d", error); return false; @@ -75,7 +80,12 @@ bool PrintCallbackProxy::OnCallback(uint32_t state, const PrintJob &info) data.WriteUint32(state); info.Marshalling(data); - int error = Remote()->SendRequest(PRINT_CALLBACK_PRINT_JOB, data, reply, option); + sptr remote = Remote(); + if (remote == nullptr) { + PRINT_HILOGE("SendRequest failed, error: remote is null"); + return false; + } + int error = remote->SendRequest(PRINT_CALLBACK_PRINT_JOB, data, reply, option); if (error != 0) { PRINT_HILOGE("SendRequest failed, error %{public}d", error); return false; @@ -95,7 +105,12 @@ bool PrintCallbackProxy::OnCallback(const std::string &extensionId, const std::s data.WriteString(extensionId); data.WriteString(info); - int error = Remote()->SendRequest(PRINT_CALLBACK_EXTINFO, data, reply, option); + sptr remote = Remote(); + if (remote == nullptr) { + PRINT_HILOGE("SendRequest failed, error: remote is null"); + return false; + } + int error = remote->SendRequest(PRINT_CALLBACK_EXTINFO, data, reply, option); if (error != 0) { PRINT_HILOGE("SendRequest failed, error %{public}d", error); return false; @@ -122,7 +137,12 @@ bool PrintCallbackProxy::OnCallbackAdapterLayout(const std::string &jobId, const newAttrs.Marshalling(data); data.WriteFileDescriptor(fd); - int error = Remote()->SendRequest(PRINT_CALLBACK_PRINT_JOB_ADAPTER, data, reply, option); + sptr remote = Remote(); + if (remote == nullptr) { + PRINT_HILOGE("SendRequest failed, error: remote is null"); + return false; + } + int error = remote->SendRequest(PRINT_CALLBACK_PRINT_JOB_ADAPTER, data, reply, option); if (error != 0) { PRINT_HILOGE("SendRequest failed, error %{public}d", error); return false; @@ -148,7 +168,12 @@ bool PrintCallbackProxy::onCallbackAdapterJobStateChanged(const std::string jobI data.WriteUint32(state); data.WriteUint32(subState); - int error = Remote()->SendRequest(PRINT_CALLBACK_PRINT_JOB_CHANGED_ADAPTER, data, reply, option); + sptr remote = Remote(); + if (remote == nullptr) { + PRINT_HILOGE("SendRequest failed, error: remote is null"); + return false; + } + int error = remote->SendRequest(PRINT_CALLBACK_PRINT_JOB_CHANGED_ADAPTER, data, reply, option); if (error != 0) { PRINT_HILOGE("SendRequest failed, error %{public}d", error); return false; @@ -171,7 +196,12 @@ bool PrintCallbackProxy::OnCallbackAdapterGetFile(uint32_t state) data.WriteUint32(state); - int error = Remote()->SendRequest(PRINT_CALLBACK_PRINT_GET_FILE_ADAPTER, data, reply, option); + sptr remote = Remote(); + if (remote == nullptr) { + PRINT_HILOGE("SendRequest failed, error: remote is null"); + return false; + } + int error = remote->SendRequest(PRINT_CALLBACK_PRINT_GET_FILE_ADAPTER, data, reply, option); if (error != 0) { PRINT_HILOGE("SendRequest failed, error %{public}d", error); return false; diff --git a/services/scan_service/src/scan_service_ability.cpp b/services/scan_service/src/scan_service_ability.cpp index 7777e2be..16116cc5 100644 --- a/services/scan_service/src/scan_service_ability.cpp +++ b/services/scan_service/src/scan_service_ability.cpp @@ -1669,10 +1669,12 @@ void ScanServiceAbility::GeneratePictureBatch(const std::string &scannerId, std: int32_t nowScanId = it->first; file_name = "scan_tmp" + std::to_string(nowScanId) + ".jpg"; std::string outputDir = ObtainUserCacheDirectory(currentUseScannerUserId_); - if (!std::filesystem::exists(outputDir)) { - SCAN_HILOGE("outputDir %{public}s does not exist.", outputDir.c_str()); + char canonicalPath[PATH_MAX] = { 0 }; + if (realpath(outputDir.c_str(), canonicalPath) == nullptr) { + SCAN_HILOGE("The real output dir is null, errno:%{public}s", std::to_string(errno).c_str()); return; } + outputDir = canonicalPath; output_file = outputDir.append("/").append(file_name); ofp = fopen(output_file.c_str(), "w"); if (ofp == nullptr) { @@ -1706,10 +1708,12 @@ void ScanServiceAbility::GeneratePictureSingle(const std::string &scannerId, std int32_t nowScanId = it->first; file_name = "scan_tmp" + std::to_string(nowScanId) + ".jpg"; std::string outputDir = ObtainUserCacheDirectory(currentUseScannerUserId_); - if (!std::filesystem::exists(outputDir)) { - SCAN_HILOGE("outputDir %{public}s does not exist.", outputDir.c_str()); + char canonicalPath[PATH_MAX] = { 0 }; + if (realpath(outputDir.c_str(), canonicalPath) == nullptr) { + SCAN_HILOGE("The real output dir is null, errno:%{public}s", std::to_string(errno).c_str()); return; } + outputDir = canonicalPath; output_file = outputDir.append("/").append(file_name); ofp = fopen(output_file.c_str(), "w"); if (ofp == nullptr) { diff --git a/services/scan_service/src/scan_service_stub.cpp b/services/scan_service/src/scan_service_stub.cpp index 119a2f56..3c1a921c 100644 --- a/services/scan_service/src/scan_service_stub.cpp +++ b/services/scan_service/src/scan_service_stub.cpp @@ -65,7 +65,8 @@ int32_t ScanServiceStub::OnRemoteRequest( if (itFunc != cmdMap_.end()) { auto requestFunc = itFunc->second; if (requestFunc != nullptr) { - return (this->*requestFunc)(data, reply); + bool result = (this->*requestFunc)(data, reply); + return result ? E_SCAN_NONE : E_SCAN_SERVER_FAILURE; } } SCAN_HILOGW("default case, need check."); diff --git a/test/unittest/fwk_inner_napi_test/print_callback_stub_test.cpp b/test/unittest/fwk_inner_napi_test/print_callback_stub_test.cpp index 9dd18171..5bddb638 100644 --- a/test/unittest/fwk_inner_napi_test/print_callback_stub_test.cpp +++ b/test/unittest/fwk_inner_napi_test/print_callback_stub_test.cpp @@ -95,7 +95,7 @@ HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0003, TestSize.Level1) auto callback = std::make_shared(); EXPECT_NE(callback, nullptr); EXPECT_CALL(*callback, OnCallback()).Times(1); - EXPECT_TRUE(static_cast(callback->OnRemoteRequest(code, data, reply, option))); + EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE); } MATCHER_P(PrinterInfoMatcher, oParam, "Match Printer Info") @@ -135,7 +135,7 @@ HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0004, TestSize.Level1) EXPECT_NE(callback, nullptr); EXPECT_CALL(*callback, OnCallback(testState, Matcher(PrinterInfoMatcher(testInfo)))).Times(1).WillOnce(Return(true)); - EXPECT_TRUE(static_cast(callback->OnRemoteRequest(code, data, reply, option))); + EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE); EXPECT_TRUE(reply.ReadBool()); } @@ -164,7 +164,7 @@ HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0005, TestSize.Level1) EXPECT_NE(callback, nullptr); EXPECT_CALL(*callback, OnCallback(testState, Matcher(PrintJobMatcher(testJob)))).Times(1).WillOnce(Return(true)); - EXPECT_TRUE(static_cast(callback->OnRemoteRequest(code, data, reply, option))); + EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE); EXPECT_TRUE(reply.ReadBool()); } @@ -189,7 +189,7 @@ HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0006, TestSize.Level1) auto callback = std::make_shared(); EXPECT_NE(callback, nullptr); EXPECT_CALL(*callback, OnCallback(extensionId, extInfo)).Times(1).WillOnce(Return(true)); - EXPECT_TRUE(static_cast(callback->OnRemoteRequest(code, data, reply, option))); + EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE); EXPECT_TRUE(reply.ReadBool()); } } // namespace Print diff --git a/test/unittest/fwk_inner_napi_test/print_extension_callback_stub_test.cpp b/test/unittest/fwk_inner_napi_test/print_extension_callback_stub_test.cpp index 00758ef6..f838e3bf 100644 --- a/test/unittest/fwk_inner_napi_test/print_extension_callback_stub_test.cpp +++ b/test/unittest/fwk_inner_napi_test/print_extension_callback_stub_test.cpp @@ -90,7 +90,7 @@ HWTEST_F(PrintExtensionCallbackStubTest, PrintExtensionCallbackStubTest_0003, Te EXPECT_TRUE(data.WriteInterfaceToken(IPrintExtensionCallback::GetDescriptor())); PrintExtensionCallbackStub callback; - EXPECT_FALSE(callback.OnRemoteRequest(code, data, reply, option)); + EXPECT_EQ(callback.OnRemoteRequest(code, data, reply, option), E_PRINT_SERVER_FAILURE); } /** @@ -112,7 +112,7 @@ HWTEST_F(PrintExtensionCallbackStubTest, PrintExtensionCallbackStubTest_0004, Te return true; }; callback.SetExtCallback(extCb); - EXPECT_TRUE(callback.OnRemoteRequest(code, data, reply, option)); + EXPECT_EQ(callback.OnRemoteRequest(code, data, reply, option), E_PRINT_NONE); } /** @@ -130,7 +130,7 @@ HWTEST_F(PrintExtensionCallbackStubTest, PrintExtensionCallbackStubTest_0005, Te EXPECT_TRUE(data.WriteInterfaceToken(IPrintExtensionCallback::GetDescriptor())); PrintExtensionCallbackStub callback; - EXPECT_FALSE(callback.OnRemoteRequest(code, data, reply, option)); + EXPECT_EQ(callback.OnRemoteRequest(code, data, reply, option), E_PRINT_SERVER_FAILURE); } /** @@ -152,7 +152,7 @@ HWTEST_F(PrintExtensionCallbackStubTest, PrintExtensionCallbackStubTest_0006, Te return true; }; callback.SetPrintJobCallback(printJobCb); - EXPECT_TRUE(callback.OnRemoteRequest(code, data, reply, option)); + EXPECT_EQ(callback.OnRemoteRequest(code, data, reply, option), E_PRINT_NONE); } /** @@ -170,7 +170,7 @@ HWTEST_F(PrintExtensionCallbackStubTest, PrintExtensionCallbackStubTest_0007, Te EXPECT_TRUE(data.WriteInterfaceToken(IPrintExtensionCallback::GetDescriptor())); PrintExtensionCallbackStub callback; - EXPECT_FALSE(callback.OnRemoteRequest(code, data, reply, option)); + EXPECT_EQ(callback.OnRemoteRequest(code, data, reply, option), E_PRINT_SERVER_FAILURE); } /** @@ -195,7 +195,7 @@ HWTEST_F(PrintExtensionCallbackStubTest, PrintExtensionCallbackStubTest_0008, Te return true; }; callback.SetPrinterCallback(printerCb); - EXPECT_TRUE(callback.OnRemoteRequest(code, data, reply, option)); + EXPECT_EQ(callback.OnRemoteRequest(code, data, reply, option), E_PRINT_NONE); } /** @@ -213,7 +213,7 @@ HWTEST_F(PrintExtensionCallbackStubTest, PrintExtensionCallbackStubTest_0009, Te EXPECT_TRUE(data.WriteInterfaceToken(IPrintExtensionCallback::GetDescriptor())); PrintExtensionCallbackStub callback; - EXPECT_FALSE(callback.OnRemoteRequest(code, data, reply, option)); + EXPECT_EQ(callback.OnRemoteRequest(code, data, reply, option), E_PRINT_SERVER_FAILURE); } /** @@ -241,7 +241,7 @@ HWTEST_F(PrintExtensionCallbackStubTest, PrintExtensionCallbackStubTest_0010, Te return true; }; callback.SetCapabilityCallback(testCb); - EXPECT_TRUE(callback.OnRemoteRequest(code, data, reply, option)); + EXPECT_EQ(callback.OnRemoteRequest(code, data, reply, option), E_PRINT_NONE); auto result = PrinterCapability::Unmarshalling(reply); EXPECT_NE(result, nullptr); } From 55390e23fa1556692c86f488584776a6f8e3b317 Mon Sep 17 00:00:00 2001 From: zheng_zhi_hao Date: Tue, 19 Nov 2024 23:16:01 +0800 Subject: [PATCH 18/19] =?UTF-8?q?=E6=A0=A1=E6=AD=A3=E5=8F=82=E6=95=B0?= =?UTF-8?q?=E6=A0=A1=E9=AA=8C=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zheng_zhi_hao --- interfaces/kits/napi/print_napi/src/napi_inner_print.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp b/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp index 86de47a5..eea84034 100644 --- a/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp +++ b/interfaces/kits/napi/print_napi/src/napi_inner_print.cpp @@ -761,8 +761,8 @@ napi_value NapiInnerPrint::NotifyPrintServiceEvent(napi_env env, napi_callback_i napi_valuetype valuetype; PRINT_CALL_BASE(env, napi_typeof(env, argv[NapiPrintUtils::INDEX_ZERO], &valuetype), napi_invalid_arg); PRINT_CALL_BASE(env, napi_typeof(env, argv[NapiPrintUtils::INDEX_ONE], &valuetype), napi_invalid_arg); - std::string jobId = NapiPrintUtils::GetStringFromValueUtf8(env, argv[NapiPrintUtils::INDEX_ZERO]); - uint32_t event = NapiPrintUtils::GetUint32FromValue(env, argv[NapiPrintUtils::INDEX_ONE]); + uint32_t event = NapiPrintUtils::GetUint32FromValue(env, argv[NapiPrintUtils::INDEX_ZERO]); + std::string jobId = NapiPrintUtils::GetStringFromValueUtf8(env, argv[NapiPrintUtils::INDEX_ONE]); PRINT_HILOGI("jobId: %{public}s, event : %{public}d", jobId.c_str(), event); if (!IsValidApplicationEvent(event)) { PRINT_HILOGE("invalid event"); From 20db30cc6f61b229561d0113bd32500c24ffe4d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=94=B0=E8=BF=85?= Date: Thu, 21 Nov 2024 17:06:58 +0800 Subject: [PATCH 19/19] queueJobList can't erase MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 田迅 --- services/print_service/src/print_service_ability.cpp | 2 +- .../print_service_ability_test.cpp | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/services/print_service/src/print_service_ability.cpp b/services/print_service/src/print_service_ability.cpp index e16de87e..e9f3ffcf 100644 --- a/services/print_service/src/print_service_ability.cpp +++ b/services/print_service/src/print_service_ability.cpp @@ -1693,7 +1693,7 @@ int32_t PrintServiceAbility::CheckAndSendQueuePrintJob(const std::string &jobId, CheckJobQueueBlocked(*jobIt->second); auto printerId = jobIt->second->GetPrinterId(); - auto printerInfo = printSystemData_.QueryPrinterInfoByPrinterId(printerId); + auto printerInfo = printSystemData_.QueryDiscoveredPrinterInfoById(printerId); if (printerInfo == nullptr) { PRINT_HILOGE("Invalid printerId"); return E_PRINT_INVALID_PRINTER; diff --git a/test/unittest/fwk_print_service_ability_test/print_service_ability_test.cpp b/test/unittest/fwk_print_service_ability_test/print_service_ability_test.cpp index c2f9d66f..4734b0c3 100644 --- a/test/unittest/fwk_print_service_ability_test/print_service_ability_test.cpp +++ b/test/unittest/fwk_print_service_ability_test/print_service_ability_test.cpp @@ -999,6 +999,7 @@ HWTEST_F(PrintServiceAbilityTest, PrintServiceAbilityTest_0052, TestSize.Level1) service->printerJobMap_[printerId].insert(std::make_pair(jobId, true)); auto printerInfo = std::make_shared(); service->printSystemData_.addedPrinterInfoList_[printerId] = printerInfo; + service->printSystemData_.discoveredPrinterInfoList_[printerId] = printerInfo; EXPECT_EQ(service->CheckAndSendQueuePrintJob(jobId, state, subState), E_PRINT_NONE); userData->queuedJobList_[jobId] = printJob; state = PRINT_JOB_COMPLETED;