1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifdef IPPOVERUSB_ENABLE
17 #include <gtest/gtest.h>
18 #define private public
19 #include "print_http_request_process.h"
20 #undef private
21 #include "print_ipp_over_usb_constant.h"
22 #include "print_log.h"
23 
24 using namespace testing::ext;
25 
26 static const std::string HTTP_RESP_CONTINUE = "HTTP/1.1 100 CONTINUE\r\n\r\nContent-Length: 122\r\n";
27 static const std::string HTTP_RESP_OK = "HTTP/1.1 200 OK\r\n";
28 static const std::string HTTP_RESP_CONNECTION = "Connection:close\r\n";
29 static const std::string HTTP_RESP_DATE = "Date:Tue 20 Feb 2024 02:57:06 GMT";
30 static const std::string HTTP_RESP_CACHE_CONTROL = "Cache-Control: no-cache\r\n";
31 static const std::string HTTP_RESP_SERVER = "Server: bsa/1.2\r\n";
32 static const std::string HTTP_RESP_CONTENT_TYPE = "Content-Type: application/ipp\r\n";
33 static const std::string HTTP_RESP_CONTENT_LENGTH = "Content-Length: 11616\r\n";
34 static const std::string HTTP_RESP_IPP = "\x02\x00\x00\x00\x00\x00\x00\x01";
35 static const std::string HTTP_RESP_DATA =
36     R"(\x01G\x00\x12attributes-charset\x00\x05utf-8H\x00\x1b\x61\x74\x74\x72\x69\x62)"\
37     R"(\x75\x74\x65\x73\x2d\x6e\x61\x74\x75\x72\x61\x6c\x2d\x6c\x61\x6e\x67\x75\x61\x67)"\
38     R"(\x65\x00\x05\x65\x6e\x2d\x75\x73)";
39 static const std::string HTTP_REQ_DATA =
40     R"(\x02\x00\x00\x0b\x00\x00\x00\x01\x01G\x00\x12attributes-charset\x00\x05utf-8H\x00\x1)"\
41     R"(battributes-natural-language\x00\x05en-usE\x00\x0bprinter-uri\x00!ipp://192.168.186.1:631/ipp/printD\x00\x14)"\
42     R"(requested-attributes\x00\x15compression-supportedD\x00\x00\x00\x10copies-supportedD\x00\x00\x00\x0ccups-versi)"\
43     R"(onD\x00\x00\x00\x19document-format-supportedD\x00\x00\x00!job-password-encryption-supportedD\x00\x00\x00\x0d)"\
44     R"(marker-colorsD\x00\x00\x00\x12marker-high-levelsD\x00\x00\x00\x0dmarker-levelsD\x00\x00\x00\x11marker-low-le)"\
45     R"(velsD\x00\x00\x00\x0emarker-messageD\x00\x00\x00\x0cmarker-namesD\x00\x00\x00\x0cmarker-typesD\x00\x00\x00)"\
46     R"(\x13media-col-supportedD\x00\x00\x00$multiple-document-handling-supportedD\x00\x00\x00\x14operations-support)"\
47     R"(edD\x00\x00\x00\x1aprint-color-mode-supportedD\x00\x00\x00\x0dprinter-alertD\x00\x00\x00\x19printer-alert-d)"\
48     R"(escriptionD\x00\x00\x00\x19printer-is-accepting-jobsD\x00\x00\x00 printer-mandatory-job-attributesD\x00\x00)"\
49     R"(\x00\x0dprinter-stateD\x00\x00\x00\x15printer-state-messageD\x00\x00\x00\x15printer-state-reasons\x03")";
50 
51 namespace OHOS {
52 namespace Print {
53 class PrintHttpRequestProcessTest : public testing::Test {
54 public:
55     static void SetUpTestCase(void);
56     static void TearDownTestCase(void);
57     void SetUp();
58     void TearDown();
59 };
60 
SetUpTestCase(void)61 void PrintHttpRequestProcessTest::SetUpTestCase(void)
62 {}
63 
64 void PrintHttpRequestProcessTest::TearDownTestCase(void)
65 {}
66 
67 void PrintHttpRequestProcessTest::SetUp(void)
68 {
69     static int32_t testNo = 0;
70     PRINT_HILOGI("PrintHttpRequestProcessTest_%{public}d", ++testNo);
71 }
72 
TearDown(void)73 void PrintHttpRequestProcessTest::TearDown(void)
74 {}
75 
76 /**
77  * @tc.name: PrintHttpRequestProcessTest_001
78  * @tc.desc: Verify the PrintOperation function.
79  * @tc.type: FUNC
80  * @tc.require:
81  */
82 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_001, TestSize.Level1)
83 {
84     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
85     std::string str = printHttpRequestProcess.PrintOperation(Operation::Common);
86     EXPECT_EQ(str, HTTP_OPERATION_COMMON);
87 }
88 
89 /**
90  * @tc.name: PrintHttpRequestProcessTest_002
91  * @tc.desc: Verify the PrintOperation function.
92  * @tc.type: FUNC
93  * @tc.require:
94  */
95 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_002, TestSize.Level1)
96 {
97     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
98     std::string str = printHttpRequestProcess.PrintOperation(Operation::Get_Printer_Attributes);
99     EXPECT_EQ(str, HTTP_OPERATION_GET_ATTR);
100 }
101 /**
102  * @tc.name: PrintHttpRequestProcessTest_003
103  * @tc.desc: Verify the PrintOperation function.
104  * @tc.type: FUNC
105  * @tc.require:
106  */
107 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_003, TestSize.Level1)
108 {
109     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
110     std::string str = printHttpRequestProcess.PrintOperation(Operation::Send_Document);
111     EXPECT_EQ(str, HTTP_OPERATION_SEND_DOC);
112 }
113 
114 /**
115  * @tc.name: PrintHttpRequestProcessTest_004
116  * @tc.desc: Verify the NeedOffset function.
117  * @tc.type: FUNC
118  * @tc.require:
119  */
120 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_004, TestSize.Level1)
121 {
122     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
123     std::vector<uint8_t> readTempBuffer;
124     readTempBuffer.assign(HTTP_RESP_CONTINUE.begin(), HTTP_RESP_CONTINUE.end());
125     size_t reqindex = printHttpRequestProcess.NeedOffset(readTempBuffer);
126     size_t expect = HTTP_COMMON_CONST_VALUE_25;
127     EXPECT_EQ(reqindex, expect);
128 }
129 
130 /**
131  * @tc.name: PrintHttpRequestProcessTest_005
132  * @tc.desc: Verify the NeedOffset function.
133  * @tc.type: FUNC
134  * @tc.require:
135  */
136 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_005, TestSize.Level1)
137 {
138     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
139     std::vector<uint8_t> readTempBuffer;
140     size_t reqindex = printHttpRequestProcess.NeedOffset(readTempBuffer);
141     size_t expect = 0;
142     EXPECT_EQ(reqindex, expect);
143 }
144 
145 /**
146  * @tc.name: PrintHttpRequestProcessTest_006
147  * @tc.desc: Verify the RecordBufByOperation function.
148  * @tc.type: FUNC
149  * @tc.require:
150  */
151 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_006, TestSize.Level1)
152 {
153     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
154     size_t requestId = 1;
155     std::string tempStr = HTTP_RESP_OK;
156     tempStr += HTTP_RESP_CONNECTION;
157     tempStr += HTTP_RESP_DATE;
158     tempStr += HTTP_RESP_CACHE_CONTROL;
159     tempStr += HTTP_RESP_SERVER;
160     tempStr += HTTP_RESP_CONTENT_TYPE;
161     tempStr += HTTP_RESP_CONTENT_LENGTH;
162     tempStr += HTTP_MSG_STRING_R_AND_N;
163     tempStr += HTTP_RESP_IPP;
164     tempStr += HTTP_RESP_DATA;
165     std::vector<uint8_t> tmVector;
166     tmVector.assign(tempStr.begin(), tempStr.end());
167     printHttpRequestProcess.reqIdOperaIdMap[requestId] = HTTP_REQUEST_GET_ATTR;
168     printHttpRequestProcess.RecordBufByOperation(Operation::Get_Printer_Attributes, requestId, tmVector);
169     size_t expect = 1;
170     EXPECT_EQ(expect, printHttpRequestProcess.readGetAttrBufMap.size());
171 }
172 
173 /**
174  * @tc.name: PrintHttpRequestProcessTest_007
175  * @tc.desc: Verify the RecordBufByOperation function.
176  * @tc.type: FUNC
177  * @tc.require:
178  */
179 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_007, TestSize.Level1)
180 {
181     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
182     size_t requestId = 1;
183     std::string tempStr = HTTP_RESP_OK;
184     tempStr += HTTP_RESP_CONNECTION;
185     tempStr += HTTP_RESP_DATE;
186     tempStr += HTTP_RESP_CACHE_CONTROL;
187     tempStr += HTTP_RESP_SERVER;
188     tempStr += HTTP_RESP_CONTENT_TYPE;
189     tempStr += HTTP_RESP_CONTENT_LENGTH;
190     tempStr += HTTP_MSG_STRING_R_AND_N;
191     tempStr += HTTP_RESP_IPP;
192     tempStr += HTTP_RESP_DATA;
193     std::vector<uint8_t> tmVector;
194     tmVector.assign(tempStr.begin(), tempStr.end());
195     printHttpRequestProcess.reqIdOperaIdMap[requestId] = HTTP_REQUEST_GET_ATTR;
196     printHttpRequestProcess.readGetAttrBufMap[requestId] = tmVector;
197     printHttpRequestProcess.RecordBufByOperation(Operation::Get_Printer_Attributes, requestId, tmVector);
198     size_t expect = 1;
199     EXPECT_EQ(expect, printHttpRequestProcess.readGetAttrBufMap.size());
200 }
201 
202 /**
203  * @tc.name: PrintHttpRequestProcessTest_008
204  * @tc.desc: Verify the RecordBufByOperation function.
205  * @tc.type: FUNC
206  * @tc.require:
207  */
208 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_008, TestSize.Level1)
209 {
210     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
211     size_t requestId = 1;
212     std::string tempStr = HTTP_RESP_OK;
213     tempStr += HTTP_RESP_CONNECTION;
214     tempStr += HTTP_RESP_DATE;
215     tempStr += HTTP_RESP_CACHE_CONTROL;
216     tempStr += HTTP_RESP_SERVER;
217     tempStr += HTTP_RESP_CONTENT_TYPE;
218     tempStr += HTTP_RESP_CONTENT_LENGTH;
219     tempStr += HTTP_MSG_STRING_R_AND_N;
220     tempStr += HTTP_RESP_IPP;
221     tempStr += HTTP_RESP_DATA;
222     std::vector<uint8_t> tmVector;
223     tmVector.assign(tempStr.begin(), tempStr.end());
224     size_t expect = 1;
225     printHttpRequestProcess.RecordBufByOperation(Operation::Send_Document, requestId, tmVector);
226     EXPECT_EQ(expect, printHttpRequestProcess.readSendDocBufMap.size());
227 }
228 
229 /**
230  * @tc.name: PrintHttpRequestProcessTest_009
231  * @tc.desc: Verify the RecordBufByOperation function.
232  * @tc.type: FUNC
233  * @tc.require:
234  */
235 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_009, TestSize.Level1)
236 {
237     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
238     size_t requestId = 1;
239     std::string tempStr = HTTP_RESP_OK;
240     tempStr += HTTP_RESP_CONNECTION;
241     tempStr += HTTP_RESP_DATE;
242     tempStr += HTTP_RESP_CACHE_CONTROL;
243     tempStr += HTTP_RESP_SERVER;
244     tempStr += HTTP_RESP_CONTENT_TYPE;
245     tempStr += HTTP_RESP_CONTENT_LENGTH;
246     tempStr += HTTP_MSG_STRING_R_AND_N;
247     tempStr += HTTP_RESP_IPP;
248     tempStr += HTTP_RESP_DATA;
249     std::vector<uint8_t> tmVector;
250     tmVector.assign(tempStr.begin(), tempStr.end());
251     size_t expect = 1;
252     printHttpRequestProcess.readSendDocBufMap[requestId] = tmVector;
253     printHttpRequestProcess.RecordBufByOperation(Operation::Send_Document, requestId, tmVector);
254     EXPECT_EQ(expect, printHttpRequestProcess.readSendDocBufMap.size());
255 }
256 
257 /**
258  * @tc.name: PrintHttpRequestProcessTest_010
259  * @tc.desc: Verify the RecordBufByOperation function.
260  * @tc.type: FUNC
261  * @tc.require:
262  */
263 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_010, TestSize.Level1)
264 {
265     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
266     size_t requestId = 1;
267     std::string tempStr = HTTP_RESP_OK;
268     tempStr += HTTP_RESP_CONNECTION;
269     tempStr += HTTP_RESP_DATE;
270     tempStr += HTTP_RESP_CACHE_CONTROL;
271     tempStr += HTTP_RESP_SERVER;
272     tempStr += HTTP_RESP_CONTENT_TYPE;
273     tempStr += HTTP_RESP_CONTENT_LENGTH;
274     tempStr += HTTP_MSG_STRING_R_AND_N;
275     tempStr += HTTP_RESP_IPP;
276     tempStr += HTTP_RESP_DATA;
277     std::vector<uint8_t> tmVector;
278     tmVector.assign(tempStr.begin(), tempStr.end());
279     size_t expect = 1;
280     printHttpRequestProcess.RecordBufByOperation(Operation::Common, requestId, tmVector);
281     EXPECT_EQ(expect, printHttpRequestProcess.readBufMap.size());
282 }
283 
284 /**
285  * @tc.name: PrintHttpRequestProcessTest_011
286  * @tc.desc: Verify the RecordBufByOperation function.
287  * @tc.type: FUNC
288  * @tc.require:
289  */
290 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_011, TestSize.Level1)
291 {
292     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
293     size_t requestId = 1;
294     std::string tempStr = HTTP_RESP_OK;
295     tempStr += HTTP_RESP_CONNECTION;
296     tempStr += HTTP_RESP_DATE;
297     tempStr += HTTP_RESP_CACHE_CONTROL;
298     tempStr += HTTP_RESP_SERVER;
299     tempStr += HTTP_RESP_CONTENT_TYPE;
300     tempStr += HTTP_RESP_CONTENT_LENGTH;
301     tempStr += HTTP_MSG_STRING_R_AND_N;
302     tempStr += HTTP_RESP_IPP;
303     tempStr += HTTP_RESP_DATA;
304     std::vector<uint8_t> tmVector;
305     tmVector.assign(tempStr.begin(), tempStr.end());
306     size_t expect = 1;
307     printHttpRequestProcess.readBufMap[requestId] = tmVector;
308     printHttpRequestProcess.RecordBufByOperation(Operation::Common, requestId, tmVector);
309     EXPECT_EQ(expect, printHttpRequestProcess.readBufMap.size());
310 }
311 
312 /**
313  * @tc.name: PrintHttpRequestProcessTest_012
314  * @tc.desc: Verify the GetContentLength function.
315  * @tc.type: FUNC
316  * @tc.require:
317  */
318 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_012, TestSize.Level1)
319 {
320     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
321     std::string tempStr = HTTP_RESP_OK;
322     tempStr += HTTP_RESP_CONNECTION;
323     tempStr += HTTP_RESP_DATE;
324     tempStr += HTTP_RESP_CACHE_CONTROL;
325     tempStr += HTTP_RESP_SERVER;
326     tempStr += HTTP_RESP_CONTENT_TYPE;
327     tempStr += HTTP_RESP_CONTENT_LENGTH;
328     tempStr += HTTP_MSG_STRING_R_AND_N;
329     tempStr += HTTP_RESP_IPP;
330     tempStr += HTTP_RESP_DATA;
331     size_t index = 0;
332     bool findContentLength = false;
333     size_t contentLength = 0;
334     std::vector<uint8_t> readTempBuffer;
335     printHttpRequestProcess.GetContentLength(readTempBuffer, index, findContentLength, contentLength);
336     EXPECT_EQ(contentLength, 0);
337 }
338 
339 /**
340  * @tc.name: PrintHttpRequestProcessTest_013
341  * @tc.desc: Verify the GetContentLength function.
342  * @tc.type: FUNC
343  * @tc.require:
344  */
345 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_013, TestSize.Level1)
346 {
347     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
348     std::string tempStr = HTTP_RESP_OK;
349     tempStr += HTTP_RESP_CONNECTION;
350     tempStr += HTTP_RESP_DATE;
351     tempStr += HTTP_RESP_CACHE_CONTROL;
352     tempStr += HTTP_RESP_SERVER;
353     tempStr += HTTP_RESP_CONTENT_TYPE;
354     tempStr += HTTP_RESP_CONTENT_LENGTH;
355     tempStr += HTTP_MSG_STRING_R_AND_N;
356     tempStr += HTTP_RESP_IPP;
357     tempStr += HTTP_RESP_DATA;
358     size_t index = 0;
359     bool findContentLength = false;
360     size_t contentLength = 0;
361     std::vector<uint8_t> readTempBuffer;
362     readTempBuffer.assign(tempStr.begin(), tempStr.end());
363     printHttpRequestProcess.GetContentLength(readTempBuffer, index, findContentLength, contentLength);
364     EXPECT_EQ(contentLength, 0);
365 }
366 
367 /**
368  * @tc.name: PrintHttpRequestProcessTest_014
369  * @tc.desc: Verify the GetContentLength function.
370  * @tc.type: FUNC
371  * @tc.require:
372  */
373 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_014, TestSize.Level1)
374 {
375     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
376     std::string tempStr = HTTP_RESP_CONTENT_LENGTH;
377     tempStr += HTTP_MSG_STRING_R_AND_N;
378     tempStr += HTTP_RESP_IPP;
379     tempStr += HTTP_RESP_DATA;
380     size_t index = 0;
381     bool findContentLength = false;
382     size_t contentLength = 0;
383     std::vector<uint8_t> readTempBuffer;
384     readTempBuffer.assign(tempStr.begin(), tempStr.end());
385     printHttpRequestProcess.GetContentLength(readTempBuffer, index, findContentLength, contentLength);
386     EXPECT_EQ(contentLength, 11616);
387 }
388 
389 /**
390  * @tc.name: PrintHttpRequestProcessTest_015
391  * @tc.desc: Verify the DumpRespIdCode function.
392  * @tc.type: FUNC
393  * @tc.require:
394  */
395 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_015, TestSize.Level1)
396 {
397     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
398     std::vector<uint8_t> readTempBuffer;
399     readTempBuffer.assign(HTTP_RESP_IPP.begin(), HTTP_RESP_IPP.end());
400     size_t begin = 0;
401     size_t maxSize = 30;
402     printHttpRequestProcess.DumpRespIdCode(readTempBuffer, Operation::Get_Printer_Attributes, begin, maxSize);
403     EXPECT_EQ(printHttpRequestProcess.PrintOperation(Operation::Get_Printer_Attributes), HTTP_OPERATION_GET_ATTR);
404 }
405 
406 /**
407  * @tc.name: PrintHttpRequestProcessTest_016
408  * @tc.desc: Verify the CheckLineEnd function.
409  * @tc.type: FUNC
410  * @tc.require:
411  */
412 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_016, TestSize.Level1)
413 {
414     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
415     std::string tempStr = "\r\n\r\n";
416     tempStr += HTTP_RESP_OK;
417     tempStr += HTTP_RESP_CONNECTION;
418     tempStr += HTTP_RESP_DATE;
419     tempStr += HTTP_RESP_CACHE_CONTROL;
420     tempStr += HTTP_RESP_SERVER;
421     tempStr += HTTP_RESP_CONTENT_TYPE;
422     tempStr += HTTP_RESP_CONTENT_LENGTH;
423     tempStr += HTTP_MSG_STRING_R_AND_N;
424     tempStr += HTTP_RESP_IPP;
425     tempStr += HTTP_RESP_DATA;
426     std::vector<uint8_t> readTempBuffer;
427     readTempBuffer.assign(tempStr.begin(), tempStr.end());
428     size_t index = 0;
429     bool ret = printHttpRequestProcess.CheckLineEnd(readTempBuffer, index);
430     EXPECT_EQ(true, ret);
431 }
432 
433 /**
434  * @tc.name: PrintHttpRequestProcessTest_017
435  * @tc.desc: Verify the CheckLineEnd function.
436  * @tc.type: FUNC
437  * @tc.require:
438  */
439 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_017, TestSize.Level1)
440 {
441     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
442     std::string tempStr = "\r\n\r";
443     tempStr += HTTP_RESP_OK;
444     tempStr += HTTP_RESP_CONNECTION;
445     tempStr += HTTP_RESP_DATE;
446     tempStr += HTTP_RESP_CACHE_CONTROL;
447     tempStr += HTTP_RESP_SERVER;
448     tempStr += HTTP_RESP_CONTENT_TYPE;
449     tempStr += HTTP_RESP_CONTENT_LENGTH;
450     tempStr += HTTP_MSG_STRING_R_AND_N;
451     tempStr += HTTP_RESP_IPP;
452     tempStr += HTTP_RESP_DATA;
453     std::vector<uint8_t> readTempBuffer;
454     readTempBuffer.assign(tempStr.begin(), tempStr.end());
455     size_t index = 0;
456     bool ret = printHttpRequestProcess.CheckLineEnd(readTempBuffer, index);
457     EXPECT_EQ(false, ret);
458 }
459 
460 /**
461  * @tc.name: PrintHttpRequestProcessTest_018
462  * @tc.desc: Verify the CheckLineEnd function.
463  * @tc.type: FUNC
464  * @tc.require:
465  */
466 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_018, TestSize.Level1)
467 {
468     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
469     std::string tempStr = "\r\n";
470     tempStr += HTTP_RESP_OK;
471     tempStr += HTTP_RESP_CONNECTION;
472     tempStr += HTTP_RESP_DATE;
473     tempStr += HTTP_RESP_CACHE_CONTROL;
474     tempStr += HTTP_RESP_SERVER;
475     tempStr += HTTP_RESP_CONTENT_TYPE;
476     tempStr += HTTP_RESP_CONTENT_LENGTH;
477     tempStr += HTTP_MSG_STRING_R_AND_N;
478     tempStr += HTTP_RESP_IPP;
479     tempStr += HTTP_RESP_DATA;
480     std::vector<uint8_t> readTempBuffer;
481     readTempBuffer.assign(tempStr.begin(), tempStr.end());
482     size_t index = 0;
483     bool ret = printHttpRequestProcess.CheckLineEnd(readTempBuffer, index);
484     EXPECT_EQ(false, ret);
485 }
486 
487 /**
488  * @tc.name: PrintHttpRequestProcessTest_019
489  * @tc.desc: Verify the CheckLineEnd function.
490  * @tc.type: FUNC
491  * @tc.require:
492  */
493 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_019, TestSize.Level1)
494 {
495     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
496     std::string tempStr = "\r";
497     tempStr += HTTP_RESP_OK;
498     tempStr += HTTP_RESP_CONNECTION;
499     tempStr += HTTP_RESP_DATE;
500     tempStr += HTTP_RESP_CACHE_CONTROL;
501     tempStr += HTTP_RESP_SERVER;
502     tempStr += HTTP_RESP_CONTENT_TYPE;
503     tempStr += HTTP_RESP_CONTENT_LENGTH;
504     tempStr += HTTP_MSG_STRING_R_AND_N;
505     tempStr += HTTP_RESP_IPP;
506     tempStr += HTTP_RESP_DATA;
507     std::vector<uint8_t> readTempBuffer;
508     readTempBuffer.assign(tempStr.begin(), tempStr.end());
509     size_t index = 0;
510     bool ret = printHttpRequestProcess.CheckLineEnd(readTempBuffer, index);
511     EXPECT_EQ(false, ret);
512 }
513 
514 /**
515  * @tc.name: PrintHttpRequestProcessTest_020
516  * @tc.desc: Verify the CheckLineEnd function.
517  * @tc.type: FUNC
518  * @tc.require:
519  */
520 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_020, TestSize.Level1)
521 {
522     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
523     std::string tempStr = HTTP_RESP_OK;
524     tempStr += HTTP_RESP_CONNECTION;
525     tempStr += HTTP_RESP_DATE;
526     tempStr += HTTP_RESP_CACHE_CONTROL;
527     tempStr += HTTP_RESP_SERVER;
528     tempStr += HTTP_RESP_CONTENT_TYPE;
529     tempStr += HTTP_RESP_CONTENT_LENGTH;
530     tempStr += HTTP_MSG_STRING_R_AND_N;
531     tempStr += HTTP_RESP_IPP;
532     tempStr += HTTP_RESP_DATA;
533     std::vector<uint8_t> readTempBuffer;
534     readTempBuffer.assign(tempStr.begin(), tempStr.end());
535     size_t index = 0;
536     bool ret = printHttpRequestProcess.CheckLineEnd(readTempBuffer, index);
537     EXPECT_EQ(false, ret);
538 }
539 
540 /**
541  * @tc.name: PrintHttpRequestProcessTest_021
542  * @tc.desc: Verify the CheckLineEnd function.
543  * @tc.type: FUNC
544  * @tc.require:
545  */
546 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_021, TestSize.Level1)
547 {
548     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
549     std::string tempStr = "HTTP/1.1";
550     std::vector<uint8_t> readTempBuffer;
551     readTempBuffer.assign(tempStr.begin(), tempStr.end());
552     size_t index = 0;
553     bool ret = printHttpRequestProcess.CheckLineEnd(readTempBuffer, index);
554     EXPECT_EQ(false, ret);
555 }
556 
557 /**
558  * @tc.name: PrintHttpRequestProcessTest_022
559  * @tc.desc: Verify the CalculateRequestId function.
560  * @tc.type: FUNC
561  * @tc.require:
562  */
563 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_022, TestSize.Level1)
564 {
565     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
566     std::string tempStr = HTTP_MSG_STRING_R_AND_N;
567     tempStr += HTTP_RESP_IPP;
568     std::vector<uint8_t> readTempBuffer;
569     readTempBuffer.assign(tempStr.begin(), tempStr.end());
570     size_t index = 0;
571     size_t ret = printHttpRequestProcess.CalculateRequestId(readTempBuffer, index, Operation::Get_Printer_Attributes);
572     EXPECT_EQ(ret, 0);
573 }
574 
575 /**
576  * @tc.name: PrintHttpRequestProcessTest_023
577  * @tc.desc: Verify the CalculateFileDataBeginIndex function.
578  * @tc.type: FUNC
579  * @tc.require:
580  */
581 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_023, TestSize.Level1)
582 {
583     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
584     size_t index = 0;
585     size_t ret = printHttpRequestProcess.CalculateFileDataBeginIndex(index, Operation::Get_Printer_Attributes);
586     EXPECT_EQ(ret, index + INDEX_4);
587 }
588 
589 /**
590  * @tc.name: PrintHttpRequestProcessTest_025
591  * @tc.desc: Verify the ProcessDataFromDevice function.
592  * @tc.type: FUNC
593  * @tc.require:
594  */
595 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_025, TestSize.Level1)
596 {
597     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
598     bool ret = printHttpRequestProcess.ProcessDataFromDevice(Operation::Get_Printer_Attributes);
599     EXPECT_EQ(ret, false);
600 }
601 
602 /**
603  * @tc.name: PrintHttpRequestProcessTest_026
604  * @tc.desc: Verify the GetAttrAgain function.
605  * @tc.type: FUNC
606  * @tc.require:
607  */
608 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_026, TestSize.Level1)
609 {
610     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
611     std::vector<uint8_t> readTempBuffer;
612     printHttpRequestProcess.GetAttrAgain(Operation::Get_Printer_Attributes, readTempBuffer);
613     EXPECT_EQ(readTempBuffer, std::vector<uint8_t>{});
614 }
615 
616 /**
617  * @tc.name: PrintHttpRequestProcessTest_028
618  * @tc.desc: Verify the ProcessHttpResponse function.
619  * @tc.type: FUNC
620  * @tc.require:
621  */
622 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_028, TestSize.Level1)
623 {
624     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
625     httplib::Response responseData;
626     size_t requestId = 1;
627     printHttpRequestProcess.ProcessHttpResponse(responseData, requestId);
628 }
629 
630 /**
631  * @tc.name: PrintHttpRequestProcessTest_029
632  * @tc.desc: Verify the ProcessHttpResponse function.
633  * @tc.type: FUNC
634  * @tc.require:
635  */
636 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_029, TestSize.Level1)
637 {
638     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
639     httplib::Response responseData;
640     size_t requestId = 1;
641     std::string tempStr = HTTP_RESP_OK;
642     tempStr += HTTP_RESP_CONNECTION;
643     tempStr += HTTP_RESP_DATE;
644     tempStr += HTTP_RESP_CACHE_CONTROL;
645     tempStr += HTTP_RESP_SERVER;
646     tempStr += HTTP_RESP_CONTENT_TYPE;
647     tempStr += HTTP_RESP_CONTENT_LENGTH;
648     tempStr += HTTP_MSG_STRING_R_AND_N;
649     tempStr += HTTP_RESP_IPP;
650     tempStr += HTTP_RESP_DATA;
651     std::vector<uint8_t> readTempBuffer;
652     readTempBuffer.assign(tempStr.begin(), tempStr.end());
653     printHttpRequestProcess.readBufMap[requestId] = readTempBuffer;
654     printHttpRequestProcess.ProcessHttpResponse(responseData, requestId);
655 }
656 
657 /**
658  * @tc.name: PrintHttpRequestProcessTest_030
659  * @tc.desc: Verify the ProcessHttpResponseGetAttr function.
660  * @tc.type: FUNC
661  * @tc.require:
662  */
663 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_030, TestSize.Level1)
664 {
665     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
666     httplib::Response responseData;
667     size_t requestId = 1;
668     printHttpRequestProcess.ProcessHttpResponseGetAttr(responseData, requestId);
669 }
670 
671 /**
672  * @tc.name: PrintHttpRequestProcessTest_031
673  * @tc.desc: Verify the ProcessHttpResponseGetAttr function.
674  * @tc.type: FUNC
675  * @tc.require:
676  */
677 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_031, TestSize.Level1)
678 {
679     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
680     httplib::Response responseData;
681     size_t requestId = 1;
682     std::string tempStr = HTTP_RESP_OK;
683     tempStr += HTTP_RESP_CONNECTION;
684     tempStr += HTTP_RESP_DATE;
685     tempStr += HTTP_RESP_CACHE_CONTROL;
686     tempStr += HTTP_RESP_SERVER;
687     tempStr += HTTP_RESP_CONTENT_TYPE;
688     tempStr += HTTP_RESP_CONTENT_LENGTH;
689     tempStr += HTTP_MSG_STRING_R_AND_N;
690     tempStr += HTTP_RESP_IPP;
691     tempStr += HTTP_RESP_DATA;
692     std::vector<uint8_t> readTempBuffer;
693     readTempBuffer.assign(tempStr.begin(), tempStr.end());
694     printHttpRequestProcess.readGetAttrBufMap[requestId] = readTempBuffer;
695     printHttpRequestProcess.ProcessHttpResponseGetAttr(responseData, requestId);
696 }
697 
698 /**
699  * @tc.name: PrintHttpRequestProcessTest_032
700  * @tc.desc: Verify the ProcessHttpResponseSendDoc function.
701  * @tc.type: FUNC
702  * @tc.require:
703  */
704 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_032, TestSize.Level1)
705 {
706     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
707     httplib::Response responseData;
708     size_t requestId = 1;
709     printHttpRequestProcess.ProcessHttpResponseSendDoc(responseData, requestId);
710 }
711 
712 /**
713  * @tc.name: PrintHttpRequestProcessTest_033
714  * @tc.desc: Verify the ProcessHttpResponseSendDoc function.
715  * @tc.type: FUNC
716  * @tc.require:
717  */
718 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_033, TestSize.Level1)
719 {
720     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
721     httplib::Response responseData;
722     size_t requestId = 1;
723     std::string tempStr = HTTP_RESP_OK;
724     tempStr += HTTP_RESP_CONNECTION;
725     tempStr += HTTP_RESP_DATE;
726     tempStr += HTTP_RESP_CACHE_CONTROL;
727     tempStr += HTTP_RESP_SERVER;
728     tempStr += HTTP_RESP_CONTENT_TYPE;
729     tempStr += HTTP_RESP_CONTENT_LENGTH;
730     tempStr += HTTP_MSG_STRING_R_AND_N;
731     tempStr += HTTP_RESP_IPP;
732     tempStr += HTTP_RESP_DATA;
733     std::vector<uint8_t> readTempBuffer;
734     readTempBuffer.assign(tempStr.begin(), tempStr.end());
735     printHttpRequestProcess.readSendDocBufMap[requestId] = readTempBuffer;
736     printHttpRequestProcess.ProcessHttpResponseSendDoc(responseData, requestId);
737 }
738 
739 /**
740  * @tc.name: PrintHttpRequestProcessTest_034
741  * @tc.desc: Verify the DealRequestHeader function.
742  * @tc.type: FUNC
743  * @tc.require:
744  */
745 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_034, TestSize.Level1)
746 {
747     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
748     httplib::Request requestData;
749     requestData.set_header("Content-Length", "745");
750     requestData.set_header("Content-Type", "application/ipp");
751     requestData.set_header("Expect", "100-continue");
752     requestData.set_header("Host", "localhost:60000");
753     requestData.set_header("LOCAL_ADDR", "127.0.0.1");
754     requestData.set_header("LOCAL_PORT", "60000");
755     requestData.set_header("REMOTE_ADDR", "127.0.0.1");
756     requestData.set_header("REMOTE_PORT", "39470");
757     requestData.set_header("User-Agent", "CUPS/2.4.0 (Linux 5.10.97+; aarch64) IPP/2.0");
758     std::string str = "";
759     bool ret = printHttpRequestProcess.DealRequestHeader(requestData, str);
760     EXPECT_EQ(ret, false);
761 }
762 
763 /**
764  * @tc.name: PrintHttpRequestProcessTest_035
765  * @tc.desc: Verify the DealRequestHeader function.
766  * @tc.type: FUNC
767  * @tc.require:
768  */
769 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_035, TestSize.Level1)
770 {
771     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
772     httplib::Request requestData;
773     requestData.set_header("Content-Length", "745");
774     requestData.set_header("Content-Type", "application/ipp");
775     requestData.set_header("Transfer-Encoding", "chunked");
776     requestData.set_header("Host", "localhost:60000");
777     requestData.set_header("LOCAL_ADDR", "127.0.0.1");
778     requestData.set_header("LOCAL_PORT", "60000");
779     requestData.set_header("REMOTE_ADDR", "127.0.0.1");
780     requestData.set_header("REMOTE_PORT", "39470");
781     requestData.set_header("User-Agent", "CUPS/2.4.0 (Linux 5.10.97+; aarch64) IPP/2.0");
782     std::string str = "";
783     bool ret = printHttpRequestProcess.DealRequestHeader(requestData, str);
784     EXPECT_EQ(ret, true);
785 }
786 
787 /**
788  * @tc.name: PrintHttpRequestProcessTest_036
789  * @tc.desc: Verify the CalcReqIdOperaId function.
790  * @tc.type: FUNC
791  * @tc.require:
792  */
793 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_036, TestSize.Level1)
794 {
795     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
796     httplib::Response responseData;
797     size_t requestId = 0;
798     std::string reqData = HTTP_REQ_DATA;
799     size_t data_length = 716;
800     printHttpRequestProcess.CalcReqIdOperaId(reqData.c_str(), data_length, requestId);
801 
802     const char *data = reqData.c_str();
803     size_t expectedRequestId = (uint8_t)(*(data + INDEX_4)) * HTTP_COMMON_CONST_VALUE_1000 +
804         (uint8_t)(*(data + INDEX_5)) * HTTP_COMMON_CONST_VALUE_100 +
805             (uint8_t)(*(data + INDEX_6)) * HTTP_COMMON_CONST_VALUE_10 + (uint8_t)(*(data + INDEX_7));
806     EXPECT_EQ(requestId, expectedRequestId);
807 }
808 
809 /**
810  * @tc.name: PrintHttpRequestProcessTest_037
811  * @tc.desc: Verify the CalcReqIdOperaId function.
812  * @tc.type: FUNC
813  * @tc.require:
814  */
815 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_037, TestSize.Level1)
816 {
817     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
818     httplib::Response responseData;
819     size_t requestId = 0;
820     std::string reqData = HTTP_REQ_DATA;
821     size_t data_length = 1;
822     printHttpRequestProcess.CalcReqIdOperaId(reqData.c_str(), data_length, requestId);
823     EXPECT_EQ(requestId, 0);
824 }
825 
826 /**
827  * @tc.name: PrintHttpRequestProcessTest_038
828  * @tc.desc: Verify the CreatWriteDataTask function.
829  * @tc.type: FUNC
830  * @tc.require:
831  */
832 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_038, TestSize.Level1)
833 {
834     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
835     printHttpRequestProcess.needWriteData = true;
836     printHttpRequestProcess.CreatWriteDataTask();
837 }
838 
839 /**
840  * @tc.name: PrintHttpRequestProcessTest_040
841  * @tc.desc: Verify the ProcessOtherRequest function.
842  * @tc.type: FUNC
843  * @tc.require:
844  */
845 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_040, TestSize.Level1)
846 {
847     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
848     const char *data = "test";
849     size_t data_length = 4;
850     std::string sHeadersAndBody = "";
851     size_t requestId = 0;
852     printHttpRequestProcess.needWriteData = true;
853     printHttpRequestProcess.ProcessOtherRequest(data, data_length, sHeadersAndBody, requestId);
854 }
855 
856 /**
857  * @tc.name: PrintHttpRequestProcessTest_041
858  * @tc.desc: Verify the DumpReqIdOperaId function.
859  * @tc.type: FUNC
860  * @tc.require:
861  */
862 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_041, TestSize.Level1)
863 {
864     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
865     std::string reqData = "t";
866     size_t data_length = 1;
867     EXPECT_LT(data_length, REQID_OPERAID_LEN);
868     printHttpRequestProcess.DumpReqIdOperaId(reqData.c_str(), data_length);
869 }
870 
871 /**
872  * @tc.name: PrintHttpRequestProcessTest_042
873  * @tc.desc: Verify the DumpReqIdOperaId function.
874  * @tc.type: FUNC
875  * @tc.require:
876  */
877 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_042, TestSize.Level1)
878 {
879     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
880     std::string reqData = "test request data";
881     size_t data_length = 15;
882     EXPECT_GT(data_length, REQID_OPERAID_LEN);
883     printHttpRequestProcess.DumpReqIdOperaId(reqData.c_str(), data_length);
884 }
885 
886 /**
887  * @tc.name: PrintHttpRequestProcessTest_044
888  * @tc.desc: Verify the CreatReadSendDocTask function.
889  * @tc.type: FUNC
890  * @tc.require:
891  */
892 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_044, TestSize.Level1)
893 {
894     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
895     printHttpRequestProcess.needReadSendDoc = true;
896     printHttpRequestProcess.CreatReadSendDocTask();
897     EXPECT_EQ(true, printHttpRequestProcess.needReadSendDoc);
898 }
899 
900 /**
901  * @tc.name: PrintHttpRequestProcessTest_045
902  * @tc.desc: Verify the CreateChunk function.
903  * @tc.type: FUNC
904  * @tc.require:
905  */
906 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_045, TestSize.Level1)
907 {
908     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
909     std::string reqData = HTTP_REQ_DATA;
910     size_t data_length = 721;
911     std::string ret = printHttpRequestProcess.CreateChunk(reqData.c_str(), data_length);
912     EXPECT_EQ(ret, "2d1\r\n\\x02\\x00\\x00\\x0b\\x00\\x00\\x00\\x01\\x01G\\x00\\"
913                 "x12attributes-charset\\x00\\x05utf-8H\\x00\\x1battributes-natural-language\\x00\\"
914                 "x05en-usE\\x00\\x0bprinter-uri\\x00!ipp://192.168.186.1:631/ipp/printD\\x00\\"
915                 "x14requested-attributes\\x00\\x15compression-supportedD\\x00\\x00\\x00\\"
916                 "x10copies-supportedD\\x00\\x00\\x00\\x0ccups-versionD\\x00\\x00\\x00\\"
917                 "x19document-format-supportedD\\x00\\x00\\x00!job-password-encryption-supportedD\\"
918                 "x00\\x00\\x00\\x0dmarker-colorsD\\x00\\x00\\x00\\x12marker-high-levelsD\\x00\\x00\\"
919                 "x00\\x0dmarker-levelsD\\x00\\x00\\x00\\x11marker-low-levelsD\\x00\\x00\\x00\\"
920                 "x0emarker-messageD\\x00\\x00\\x00\\x0cmarker-namesD\\x00\\x00\\x00\\x0cmarker-typesD\\"
921                 "x00\\x00\\x00\\x13media-col-supportedD\\x00\\x00\\x00$multiple-document-handling-supportedD\\"
922                 "x00\\x00\\x00\\x14operatio\r\n");
923 }
924 
925 /**
926  * @tc.name: PrintHttpRequestProcessTest_046
927  * @tc.desc: Verify the WriteDataSync function.
928  * @tc.type: FUNC
929  * @tc.require:
930  */
931 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_046, TestSize.Level1)
932 {
933     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
934     std::string sHeadersAndBody = "test";
935     auto ret = printHttpRequestProcess.WriteDataSync(sHeadersAndBody);
936     EXPECT_EQ(INVAILD_VALUE, ret);
937 }
938 
939 /**
940  * @tc.name: PrintHttpRequestProcessTest_047
941  * @tc.desc: Verify the WriteDataSync function.
942  * @tc.type: FUNC
943  * @tc.require:
944  */
945 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_047, TestSize.Level1)
946 {
947     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
948     std::string sHeadersAndBody = "";
949     auto ret = printHttpRequestProcess.WriteDataSync(sHeadersAndBody);
950     EXPECT_EQ(0, ret);
951 }
952 
953 /**
954  * @tc.name: PrintHttpRequestProcessTest_048
955  * @tc.desc: Verify the BulkTransferWriteData function.
956  * @tc.type: FUNC
957  * @tc.require:
958  */
959 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_048, TestSize.Level1)
960 {
961     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
962     std::string name = "usb";
963     printHttpRequestProcess.SetDeviceName(name);
964     std::string reqData = HTTP_REQ_DATA;
965     size_t data_length = 716;
966     httplib::Request requestData;
967     requestData.set_header("Content-Length", "745");
968     requestData.set_header("Content-Type", "application/ipp");
969     requestData.set_header("Expect", "100-continue");
970     requestData.set_header("Host", "localhost:60000");
971     requestData.set_header("LOCAL_ADDR", "127.0.0.1");
972     requestData.set_header("LOCAL_PORT", "60000");
973     requestData.set_header("REMOTE_ADDR", "127.0.0.1");
974     requestData.set_header("REMOTE_PORT", "39470");
975     requestData.set_header("User-Agent", "CUPS/2.4.0 (Linux 5.10.97+; aarch64) IPP/2.0");
976     std::string sHeadersAndBody = "";
977     printHttpRequestProcess.DealRequestHeader(requestData, sHeadersAndBody);
978     sHeadersAndBody += printHttpRequestProcess.CreateChunk(reqData.c_str(), data_length);
979     auto ret = printHttpRequestProcess.BulkTransferWriteData(sHeadersAndBody);
980     EXPECT_EQ(INVAILD_VALUE, ret);
981 }
982 
983 /**
984  * @tc.name: PrintHttpRequestProcessTest_049
985  * @tc.desc: Verify the ProcessHttpResp function.
986  * @tc.type: FUNC
987  * @tc.require:
988  */
989 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_049, TestSize.Level1)
990 {
991     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
992     size_t requestId = 1;
993     httplib::Response responseData;
994     printHttpRequestProcess.reqIdOperaIdMap[requestId] = HTTP_REQUEST_GET_ATTR;
995     std::string sHeadersAndBody = "";
996     printHttpRequestProcess.ProcessHttpResp(requestId, responseData, sHeadersAndBody);
997 }
998 
999 /**
1000  * @tc.name: PrintHttpRequestProcessTest_050
1001  * @tc.desc: Verify the ProcessHttpResp function.
1002  * @tc.type: FUNC
1003  * @tc.require:
1004  */
1005 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_050, TestSize.Level1)
1006 {
1007     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
1008     size_t requestId = 1;
1009     httplib::Response responseData;
1010     printHttpRequestProcess.reqIdOperaIdMap[requestId] = HTTP_REQUEST_SEND_DOC;
1011     printHttpRequestProcess.deviceOpen = false;
1012     std::string sHeadersAndBody = "";
1013     printHttpRequestProcess.ProcessHttpResp(requestId, responseData, sHeadersAndBody);
1014 }
1015 
1016 /**
1017  * @tc.name: PrintHttpRequestProcessTest_051
1018  * @tc.desc: Verify the ProcessHttpResp function.
1019  * @tc.type: FUNC
1020  * @tc.require:
1021  */
1022 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_051, TestSize.Level1)
1023 {
1024     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
1025     size_t requestId = 1;
1026     httplib::Response responseData;
1027     printHttpRequestProcess.reqIdOperaIdMap[requestId] = HTTP_REQUEST_SEND_DOC;
1028     printHttpRequestProcess.deviceOpen = true;
1029     std::string sHeadersAndBody = "";
1030     printHttpRequestProcess.ProcessHttpResp(requestId, responseData, sHeadersAndBody);
1031 }
1032 
1033 /**
1034  * @tc.name: PrintHttpRequestProcessTest_052
1035  * @tc.desc: Verify the ProcessHttpResp function.
1036  * @tc.type: FUNC
1037  * @tc.require:
1038  */
1039 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_052, TestSize.Level1)
1040 {
1041     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
1042     size_t requestId = 1;
1043     httplib::Response responseData;
1044     int testOperationId = 10;
1045     printHttpRequestProcess.reqIdOperaIdMap[requestId] = testOperationId;
1046     std::string sHeadersAndBody = "";
1047     printHttpRequestProcess.ProcessHttpResp(requestId, responseData, sHeadersAndBody);
1048 }
1049 
1050 /**
1051  * @tc.name: PrintHttpRequestProcessTest_053
1052  * @tc.desc: Verify the SetDeviceName function.
1053  * @tc.type: FUNC
1054  * @tc.require:
1055  */
1056 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_053, TestSize.Level1)
1057 {
1058     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
1059     std::string name = "usb";
1060     printHttpRequestProcess.SetDeviceName(name);
1061     EXPECT_EQ("usb", printHttpRequestProcess.GetDeviceName());
1062 }
1063 
1064 /**
1065  * @tc.name: PrintHttpRequestProcessTest_054
1066  * @tc.desc: Verify the Stop function.
1067  * @tc.type: FUNC
1068  * @tc.require:
1069  */
1070 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_054, TestSize.Level1)
1071 {
1072     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
1073     printHttpRequestProcess.Stop();
1074     EXPECT_EQ(false, printHttpRequestProcess.needWriteData);
1075     EXPECT_EQ(false, printHttpRequestProcess.needReadSendDoc);
1076     EXPECT_EQ(false, printHttpRequestProcess.needWriteSendDoc);
1077 }
1078 
1079 /**
1080  * @tc.name: PrintHttpRequestProcessTest_055
1081  * @tc.desc: Verify the ProcessDataFromDevice function.
1082  * @tc.type: FUNC
1083  * @tc.require:
1084  */
1085 HWTEST_F(PrintHttpRequestProcessTest, PrintHttpRequestProcessTest_055, TestSize.Level1)
1086 {
1087     OHOS::Print::PrintHttpRequestProcess printHttpRequestProcess;
1088     printHttpRequestProcess.StartWriteDataToPrinterLooper();
1089 }
1090 
1091 }  // namespace Print
1092 }  // namespace OHOS
1093 
1094 #endif // IPPOVERUSB_ENABLE