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 #include "tooling/base/pt_types.h"
17 #include "tooling/base/pt_params.h"
18 #include "dispatcher.h"
19 
20 #include "ecmascript/js_array.h"
21 #include "ecmascript/js_object-inl.h"
22 #include "ecmascript/js_tagged_value-inl.h"
23 #include "ecmascript/object_factory.h"
24 #include "ecmascript/tests/test_helper.h"
25 
26 using namespace panda::ecmascript;
27 using namespace panda::ecmascript::tooling;
28 
29 namespace panda::test {
30 // Duplicate name of panda::ecmascript::PropertyDescriptor in js_object-inl.h
31 using panda::ecmascript::tooling::PropertyDescriptor;
32 
33 using ObjectType = RemoteObject::TypeName;
34 using ObjectSubType = RemoteObject::SubTypeName;
35 using ObjectClassName = RemoteObject::ClassName;
36 
37 class DebuggerParamsTest : public testing::Test {
38 public:
SetUpTestCase()39     static void SetUpTestCase()
40     {
41         GTEST_LOG_(INFO) << "SetUpTestCase";
42         Logger::InitializeStdLogging(Logger::Level::FATAL, LoggerComponentMaskAll);
43     }
44 
TearDownTestCase()45     static void TearDownTestCase()
46     {
47         Logger::InitializeStdLogging(Logger::Level::ERROR, LoggerComponentMaskAll);
48         GTEST_LOG_(INFO) << "TearDownCase";
49     }
50 
51     void SetUp() override
52     {
53         TestHelper::CreateEcmaVMWithScope(ecmaVm, thread, scope);
54         // Main logic is JSON parser, so not need trigger GC to decrease execute time
55         ecmaVm->SetEnableForceGC(false);
56     }
57 
58     void TearDown() override
59     {
60         TestHelper::DestroyEcmaVMWithScope(ecmaVm, scope);
61     }
62 
63 protected:
64     EcmaVM *ecmaVm {nullptr};
65     EcmaHandleScope *scope {nullptr};
66     JSThread *thread {nullptr};
67 };
68 
HWTEST_F_L0(DebuggerParamsTest, ContinueToLocationParamsCreateTest)69 HWTEST_F_L0(DebuggerParamsTest, ContinueToLocationParamsCreateTest)
70 {
71     std::string msg;
72     std::unique_ptr<ContinueToLocationParams> objectData;
73 
74     // abnormal params of null msg
75     msg = std::string() + R"({})";
76     objectData = ContinueToLocationParams::Create(DispatchRequest(msg).GetParams());
77     EXPECT_EQ(objectData, nullptr);
78 
79     // abnormal params of unexist key params
80     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
81     objectData = ContinueToLocationParams::Create(DispatchRequest(msg).GetParams());
82     EXPECT_EQ(objectData, nullptr);
83 
84     // abnormal params of null params.sub-key
85     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
86     objectData = ContinueToLocationParams::Create(DispatchRequest(msg).GetParams());
87     EXPECT_EQ(objectData, nullptr);
88 
89     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"location":10,
90         "targetCallFrames":"testTargetCallFrames"}})";
91     objectData = ContinueToLocationParams::Create(DispatchRequest(msg).GetParams());
92     EXPECT_EQ(objectData, nullptr);
93 
94     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"location":{"scriptId":"2", "lineNumber":3,
95         "columnNumber":20}, "targetCallFrames":"testTargetCallFrames"}})";
96     objectData = ContinueToLocationParams::Create(DispatchRequest(msg).GetParams());
97     ASSERT_NE(objectData, nullptr);
98     Location *location = objectData->GetLocation();
99     EXPECT_EQ(location->GetScriptId(), 2);
100     EXPECT_EQ(location->GetLine(), 3);
101     EXPECT_EQ(location->GetColumn(), 20);
102     EXPECT_EQ(objectData->GetTargetCallFrames(), "testTargetCallFrames");
103 }
104 
HWTEST_F_L0(DebuggerParamsTest, SetBreakpointsActiveParamsCreateTest)105 HWTEST_F_L0(DebuggerParamsTest, SetBreakpointsActiveParamsCreateTest)
106 {
107     std::string msg;
108     std::unique_ptr<SetBreakpointsActiveParams> objectData;
109 
110     // abnormal params of null msg
111     msg = std::string() + R"({})";
112     objectData = SetBreakpointsActiveParams::Create(DispatchRequest(msg).GetParams());
113     EXPECT_EQ(objectData, nullptr);
114 
115     // abnormal params of unexist key params
116     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
117     objectData = SetBreakpointsActiveParams::Create(DispatchRequest(msg).GetParams());
118     EXPECT_EQ(objectData, nullptr);
119 
120     // abnormal params of null params.sub-key
121     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
122     objectData = SetBreakpointsActiveParams::Create(DispatchRequest(msg).GetParams());
123     EXPECT_EQ(objectData, nullptr);
124 
125 
126     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"active":true}})";
127     objectData = SetBreakpointsActiveParams::Create(DispatchRequest(msg).GetParams());
128     ASSERT_NE(objectData, nullptr);
129     EXPECT_TRUE(objectData->GetBreakpointsState());
130 }
131 
HWTEST_F_L0(DebuggerParamsTest, SetSkipAllPausesParamsCreateTest)132 HWTEST_F_L0(DebuggerParamsTest, SetSkipAllPausesParamsCreateTest)
133 {
134     std::string msg;
135     std::unique_ptr<SetSkipAllPausesParams> objectData;
136 
137     // abnormal params of null msg
138     msg = std::string() + R"({})";
139     objectData = SetSkipAllPausesParams::Create(DispatchRequest(msg).GetParams());
140     EXPECT_EQ(objectData, nullptr);
141 
142     // abnormal params of unexist key params
143     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
144     objectData = SetSkipAllPausesParams::Create(DispatchRequest(msg).GetParams());
145     EXPECT_EQ(objectData, nullptr);
146 
147     // abnormal params of null params.sub-key
148     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
149     objectData = SetSkipAllPausesParams::Create(DispatchRequest(msg).GetParams());
150     EXPECT_EQ(objectData, nullptr);
151 
152     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"skip":true}})";
153     objectData = SetSkipAllPausesParams::Create(DispatchRequest(msg).GetParams());
154     ASSERT_NE(objectData, nullptr);
155     EXPECT_TRUE(objectData->GetSkipAllPausesState());
156 }
157 
HWTEST_F_L0(DebuggerParamsTest, SetMixedDebugParamsCreateTest)158 HWTEST_F_L0(DebuggerParamsTest, SetMixedDebugParamsCreateTest)
159 {
160     std::string msg;
161     std::unique_ptr<SetMixedDebugParams> objectData;
162 
163     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"enabled":"test", "mixedStackEnabled":true}})";
164     objectData = SetMixedDebugParams::Create(DispatchRequest(msg).GetParams());
165     EXPECT_EQ(objectData, nullptr);
166 
167     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"enabled":true, "mixedStackEnabled":true}})";
168     objectData = SetMixedDebugParams::Create(DispatchRequest(msg).GetParams());
169     ASSERT_NE(objectData, nullptr);
170     EXPECT_TRUE(objectData->GetEnabled());
171     EXPECT_TRUE(objectData->GetMixedStackEnabled());
172 }
173 
HWTEST_F_L0(DebuggerParamsTest, GetPossibleAndSetBreakpointParamsCreateTest)174 HWTEST_F_L0(DebuggerParamsTest, GetPossibleAndSetBreakpointParamsCreateTest)
175 {
176     std::string msg;
177     std::unique_ptr<GetPossibleAndSetBreakpointParams> objectData;
178 
179     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"locations":10}})";
180     objectData = GetPossibleAndSetBreakpointParams::Create(DispatchRequest(msg).GetParams());
181     EXPECT_EQ(objectData, nullptr);
182 
183     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"locations":[{"lineNumber":3,
184         "columnNumber":20, "url":"Index.ets"}]}})";
185     objectData = GetPossibleAndSetBreakpointParams::Create(DispatchRequest(msg).GetParams());
186     ASSERT_NE(objectData, nullptr);
187     auto breakpointsList = objectData->GetBreakpointsList();
188     EXPECT_EQ((*breakpointsList).size(), 1);
189     EXPECT_EQ((*breakpointsList)[0]->GetLineNumber(), 3);
190     EXPECT_EQ((*breakpointsList)[0]->GetColumnNumber(), 20);
191     EXPECT_EQ((*breakpointsList)[0]->GetUrl(), "Index.ets");
192 }
193 
HWTEST_F_L0(DebuggerParamsTest, DropFrameParamsCreateTest)194 HWTEST_F_L0(DebuggerParamsTest, DropFrameParamsCreateTest)
195 {
196     std::string msg;
197     std::unique_ptr<DropFrameParams> objectData;
198 
199     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"droppedDepth":true}})";
200     objectData = DropFrameParams::Create(DispatchRequest(msg).GetParams());
201     EXPECT_EQ(objectData, nullptr);
202 
203     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"droppedDepth":3}})";
204     objectData = DropFrameParams::Create(DispatchRequest(msg).GetParams());
205     ASSERT_NE(objectData, nullptr);
206     EXPECT_EQ(objectData->GetDroppedDepth(), 3);
207 }
208 
HWTEST_F_L0(DebuggerParamsTest, EnableParamsCreateTest)209 HWTEST_F_L0(DebuggerParamsTest, EnableParamsCreateTest)
210 {
211     std::string msg;
212     std::unique_ptr<EnableParams> enableParams;
213 
214     // abnormal
215     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
216     enableParams = EnableParams::Create(DispatchRequest(msg).GetParams());
217     ASSERT_NE(enableParams, nullptr);
218     EXPECT_FALSE(enableParams->HasMaxScriptsCacheSize());
219 
220     // normal
221     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"maxScriptsCacheSize":100}})";
222     enableParams = EnableParams::Create(DispatchRequest(msg).GetParams());
223     ASSERT_NE(enableParams, nullptr);
224     EXPECT_EQ(enableParams->GetMaxScriptsCacheSize(), 100);
225 }
226 
HWTEST_F_L0(DebuggerParamsTest, StartSamplingParamsCreateTest)227 HWTEST_F_L0(DebuggerParamsTest, StartSamplingParamsCreateTest)
228 {
229     std::string msg;
230     std::unique_ptr<StartSamplingParams> startSamplingData;
231 
232     // abnormal params of null params.sub-key
233     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
234     startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
235     ASSERT_NE(startSamplingData, nullptr);
236     EXPECT_EQ(startSamplingData->GetSamplingInterval(), 32768);
237 
238     // abnormal params of unknown params.sub-key
239     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
240     startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
241     ASSERT_NE(startSamplingData, nullptr);
242     EXPECT_EQ(startSamplingData->GetSamplingInterval(), 32768);
243 
244     // abnormal params of params.sub-key=["samplingInterval":true]
245     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":true}})";
246     startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
247     EXPECT_EQ(startSamplingData, nullptr);
248 
249     // abnormal params of params.sub-key=["samplingInterval":true]
250     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":"Test"}})";
251     startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
252     EXPECT_EQ(startSamplingData, nullptr);
253 
254     // abnormal params of params.sub-key = [ "size"=100,"nodeId"=1,"ordinal"=10]
255     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":1000}})";
256     startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
257     ASSERT_NE(startSamplingData, nullptr);
258     EXPECT_EQ(startSamplingData->GetSamplingInterval(), 1000);
259 }
260 
HWTEST_F_L0(DebuggerParamsTest, StartTrackingHeapObjectsParamsCreateTest)261 HWTEST_F_L0(DebuggerParamsTest, StartTrackingHeapObjectsParamsCreateTest)
262 {
263     std::string msg;
264     std::unique_ptr<StartTrackingHeapObjectsParams> objectData;
265 
266     // abnormal params of null params.sub-key
267     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
268     objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
269     ASSERT_NE(objectData, nullptr);
270     ASSERT_FALSE(objectData->GetTrackAllocations());
271 
272     // abnormal params of unknown params.sub-key
273     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
274     objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
275     ASSERT_NE(objectData, nullptr);
276     ASSERT_FALSE(objectData->GetTrackAllocations());
277 
278     // abnormal params of params.sub-key=["trackAllocations":10]
279     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":10}})";
280     objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
281     EXPECT_EQ(objectData, nullptr);
282 
283     // abnormal params of params.sub-key=["trackAllocations":"Test"]
284     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":"Test"}})";
285     objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
286     EXPECT_EQ(objectData, nullptr);
287 
288     // abnormal params of params.sub-key=["trackAllocations":true]
289     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":true}})";
290     objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
291     ASSERT_NE(objectData, nullptr);
292     ASSERT_TRUE(objectData->GetTrackAllocations());
293 }
294 
HWTEST_F_L0(DebuggerParamsTest, StopTrackingHeapObjectsParamsCreateTest)295 HWTEST_F_L0(DebuggerParamsTest, StopTrackingHeapObjectsParamsCreateTest)
296 {
297     std::string msg;
298     std::unique_ptr<StopTrackingHeapObjectsParams> objectData;
299 
300     // abnormal params of null params.sub-key
301     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
302     objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
303     ASSERT_NE(objectData, nullptr);
304     ASSERT_FALSE(objectData->GetReportProgress());
305     ASSERT_FALSE(objectData->GetTreatGlobalObjectsAsRoots());
306     ASSERT_FALSE(objectData->GetCaptureNumericValue());
307 
308     // abnormal params of unknown params.sub-key
309     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
310     objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
311     ASSERT_NE(objectData, nullptr);
312     ASSERT_FALSE(objectData->GetReportProgress());
313     ASSERT_FALSE(objectData->GetTreatGlobalObjectsAsRoots());
314     ASSERT_FALSE(objectData->GetCaptureNumericValue());
315 
316     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
317             "reportProgress":10,
318             "treatGlobalObjectsAsRoots":10,
319             "captureNumericValue":10}})";
320     objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
321     EXPECT_EQ(objectData, nullptr);
322 
323     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
324             "reportProgress":"Test",
325             "treatGlobalObjectsAsRoots":"Test",
326             "captureNumericValue":"Test"}})";
327     objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
328     EXPECT_EQ(objectData, nullptr);
329 
330     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
331             "reportProgress":true,
332             "treatGlobalObjectsAsRoots":true,
333             "captureNumericValue":true}})";
334     objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
335     ASSERT_NE(objectData, nullptr);
336     ASSERT_TRUE(objectData->GetReportProgress());
337     ASSERT_TRUE(objectData->GetTreatGlobalObjectsAsRoots());
338     ASSERT_TRUE(objectData->GetCaptureNumericValue());
339 }
340 
HWTEST_F_L0(DebuggerParamsTest, AddInspectedHeapObjectParamsCreateTest)341 HWTEST_F_L0(DebuggerParamsTest, AddInspectedHeapObjectParamsCreateTest)
342 {
343     std::string msg;
344     std::unique_ptr<AddInspectedHeapObjectParams> objectData;
345 
346     //  abnormal params of null msg
347     msg = std::string() + R"({})";
348     objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
349     EXPECT_EQ(objectData, nullptr);
350 
351     // abnormal params of unexist key params
352     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
353     objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
354     EXPECT_EQ(objectData, nullptr);
355 
356     // abnormal params of null params.sub-key
357     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
358     objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
359     EXPECT_EQ(objectData, nullptr);
360 
361     // abnormal params of unknown params.sub-key
362     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
363     objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
364     EXPECT_EQ(objectData, nullptr);
365 
366     // abnormal params of params.sub-key=["heapObjectId":10]
367     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":10}})";
368     objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
369     EXPECT_EQ(objectData, nullptr);
370 
371     // abnormal params of params.sub-key=["heapObjectId":true]
372     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":true}})";
373     objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
374     EXPECT_EQ(objectData, nullptr);
375 
376     // abnormal params of params.sub-key=["heapObjectId":“10”]
377     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":"10"}})";
378     objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
379     ASSERT_NE(objectData, nullptr);
380     EXPECT_EQ(objectData->GetHeapObjectId(), 10);
381 }
382 
HWTEST_F_L0(DebuggerParamsTest, GetHeapObjectIdParamsCreateTest)383 HWTEST_F_L0(DebuggerParamsTest, GetHeapObjectIdParamsCreateTest)
384 {
385     std::string msg;
386     std::unique_ptr<GetHeapObjectIdParams> objectData;
387 
388     // abnormal params of params.sub-key=["objectId":10]
389     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10}})";
390     objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
391     EXPECT_EQ(objectData, nullptr);
392 
393     // abnormal params of params.sub-key=["objectId":true]
394     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":true}})";
395     objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
396     EXPECT_EQ(objectData, nullptr);
397 
398     // abnormal params of params.sub-key=["objectId":“10”]
399     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10"}})";
400     objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
401     ASSERT_NE(objectData, nullptr);
402     EXPECT_EQ((int)objectData->GetObjectId(), 10);
403 }
404 
HWTEST_F_L0(DebuggerParamsTest, GetObjectByHeapObjectIdParamsCreateTest)405 HWTEST_F_L0(DebuggerParamsTest, GetObjectByHeapObjectIdParamsCreateTest)
406 {
407     std::string msg;
408     std::unique_ptr<GetObjectByHeapObjectIdParams> objectData;
409 
410     // abnormal params of params.sub-key=["objectId":10]
411     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10}})";
412     objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
413     EXPECT_EQ(objectData, nullptr);
414 
415     // abnormal params of params.sub-key=["objectId":true]
416     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "objectGroup":10}})";
417     objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
418     EXPECT_EQ(objectData, nullptr);
419 
420     // abnormal params of params.sub-key=["objectId":“10”]
421     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10"}})";
422     objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
423     ASSERT_NE(objectData, nullptr);
424     EXPECT_EQ((int)objectData->GetObjectId(), 10);
425     ASSERT_FALSE(objectData->HasObjectGroup());
426 
427     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "objectGroup":"groupname"}})";
428     objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
429     ASSERT_NE(objectData, nullptr);
430     EXPECT_EQ((int)objectData->GetObjectId(), 10);
431     EXPECT_EQ(objectData->GetObjectGroup(), "groupname");
432 }
433 
HWTEST_F_L0(DebuggerParamsTest, StartPreciseCoverageParamCreateTest)434 HWTEST_F_L0(DebuggerParamsTest, StartPreciseCoverageParamCreateTest)
435 {
436     std::string msg;
437     std::unique_ptr<StartPreciseCoverageParams> objectData;
438 
439     // abnormal params of null params.sub-key
440     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
441     objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
442     ASSERT_NE(objectData, nullptr);
443 
444     // abnormal params of unknown params.sub-key
445     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
446     objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
447     ASSERT_NE(objectData, nullptr);
448 
449     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
450             "callCount":8,
451             "detailed":8,
452             "allowTriggeredUpdates":8}})";
453     objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
454     EXPECT_EQ(objectData, nullptr);
455 
456     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
457             "callCount":"Test",
458             "detailed":"Test",
459             "allowTriggeredUpdates":"Test"}})";
460     objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
461     EXPECT_EQ(objectData, nullptr);
462 
463     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
464             "callCount":true,
465             "detailed":true,
466             "allowTriggeredUpdates":true}})";
467     objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
468     ASSERT_NE(objectData, nullptr);
469     ASSERT_TRUE(objectData->GetCallCount());
470     ASSERT_TRUE(objectData->GetDetailed());
471     ASSERT_TRUE(objectData->GetAllowTriggeredUpdates());
472 }
473 
HWTEST_F_L0(DebuggerParamsTest, SetSamplingIntervalParamsCreateTest)474 HWTEST_F_L0(DebuggerParamsTest, SetSamplingIntervalParamsCreateTest)
475 {
476     std::string msg;
477     std::unique_ptr<SetSamplingIntervalParams> objectData;
478 
479     //  abnormal params of null msg
480     msg = std::string() + R"({})";
481     objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
482     EXPECT_EQ(objectData, nullptr);
483 
484     // abnormal params of unexist key params
485     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
486     objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
487     EXPECT_EQ(objectData, nullptr);
488 
489     // abnormal params of null params.sub-key
490     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
491     objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
492     EXPECT_EQ(objectData, nullptr);
493 
494     // abnormal params of unknown params.sub-key
495     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
496     objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
497     EXPECT_EQ(objectData, nullptr);
498 
499     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
500             "interval":"500"}})";
501     objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
502     EXPECT_EQ(objectData, nullptr);
503 
504     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"interval":500}})";
505     objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
506     ASSERT_NE(objectData, nullptr);
507     EXPECT_EQ(objectData->GetInterval(), 500);
508 }
509 
HWTEST_F_L0(DebuggerParamsTest, RecordClockSyncMarkerParamsCreateTest)510 HWTEST_F_L0(DebuggerParamsTest, RecordClockSyncMarkerParamsCreateTest)
511 {
512     std::string msg;
513     std::unique_ptr<RecordClockSyncMarkerParams> objectData;
514 
515     //  abnormal params of null msg
516     msg = std::string() + R"({})";
517     objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
518     EXPECT_EQ(objectData, nullptr);
519 
520     // abnormal params of unexist key params
521     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
522     objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
523     EXPECT_EQ(objectData, nullptr);
524 
525     // abnormal params of null params.sub-key
526     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
527     objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
528     EXPECT_EQ(objectData, nullptr);
529 
530     // abnormal params of unknown params.sub-key
531     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
532     objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
533     EXPECT_EQ(objectData, nullptr);
534 
535     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"syncId":"101"}})";
536     objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
537     ASSERT_NE(objectData, nullptr);
538     EXPECT_EQ(objectData->GetSyncId(), "101");
539 }
540 
HWTEST_F_L0(DebuggerParamsTest, RequestMemoryDumpParamsCreateTest)541 HWTEST_F_L0(DebuggerParamsTest, RequestMemoryDumpParamsCreateTest)
542 {
543     std::string msg;
544     std::unique_ptr<RequestMemoryDumpParams> objectData;
545 
546     //  abnormal params of null msg
547     msg = std::string() + R"({})";
548     objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
549     ASSERT_NE(objectData, nullptr);
550 
551     // abnormal params of unexist key params
552     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
553     objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
554     ASSERT_NE(objectData, nullptr);
555 
556     // abnormal params of null params.sub-key
557     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
558     objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
559     ASSERT_NE(objectData, nullptr);
560 
561     // abnormal params of unknown params.sub-key
562     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
563     objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
564     ASSERT_NE(objectData, nullptr);
565 
566     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"deterministic":true,
567             "levelOfDetail":"background"}})";
568     objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
569     ASSERT_NE(objectData, nullptr);
570     ASSERT_TRUE(objectData->GetDeterministic());
571     EXPECT_EQ(objectData->GetLevelOfDetail(), "background");
572 }
573 
HWTEST_F_L0(DebuggerParamsTest, StartParamsCreateTest)574 HWTEST_F_L0(DebuggerParamsTest, StartParamsCreateTest)
575 {
576     std::string msg;
577     std::unique_ptr<StartParams> objectData;
578 
579     //  abnormal params of null msg
580     msg = std::string() + R"({})";
581     objectData = StartParams::Create(DispatchRequest(msg).GetParams());
582     ASSERT_NE(objectData, nullptr);
583 
584     // abnormal params of unexist key params
585     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
586     objectData = StartParams::Create(DispatchRequest(msg).GetParams());
587     ASSERT_NE(objectData, nullptr);
588 
589     // abnormal params of null params.sub-key
590     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
591     objectData = StartParams::Create(DispatchRequest(msg).GetParams());
592     ASSERT_NE(objectData, nullptr);
593 
594     // abnormal params of unknown params.sub-key
595     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
596     objectData = StartParams::Create(DispatchRequest(msg).GetParams());
597     ASSERT_NE(objectData, nullptr);
598 
599     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"categories":"filter1",
600             "options":"1", "bufferUsageReportingInterval":11, "transferMode":"ReportEvents", "streamFormat":"json",
601             "streamCompression":"none", "traceConfig": {"recordMode":"recordUntilFull"}, "perfettoConfig":"categories",
602             "tracingBackend":"auto"}})";
603     objectData = StartParams::Create(DispatchRequest(msg).GetParams());
604     ASSERT_NE(objectData, nullptr);
605     EXPECT_EQ(objectData->GetCategories(), "filter1");
606     EXPECT_EQ(objectData->GetOptions(), "1");
607     EXPECT_EQ(objectData->GetBufferUsageReportingInterval(), 11);
608     EXPECT_EQ(objectData->GetTransferMode(), "ReportEvents");
609     EXPECT_EQ(objectData->GetStreamFormat(), "json");
610     EXPECT_EQ(objectData->GetStreamCompression(), "none");
611     TraceConfig *traceConfig = objectData->GetTraceConfig();
612     ASSERT_NE(traceConfig, nullptr);
613     EXPECT_EQ(traceConfig->GetRecordMode(), "recordUntilFull");
614     EXPECT_EQ(objectData->GetPerfettoConfig(), "categories");
615     EXPECT_EQ(objectData->GetTracingBackend(), "auto");
616 }
617 
HWTEST_F_L0(DebuggerParamsTest, EvaluateOnCallFrameParamsCreateTest)618 HWTEST_F_L0(DebuggerParamsTest, EvaluateOnCallFrameParamsCreateTest)
619 {
620     std::string msg;
621     std::unique_ptr<EvaluateOnCallFrameParams> objectData;
622 
623     // abnormal params of null msg
624     msg = std::string() + R"({})";
625     objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams());
626     EXPECT_EQ(objectData, nullptr);
627 
628     // abnormal params of unexist key params
629     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
630     objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams());
631     EXPECT_EQ(objectData, nullptr);
632 
633     // abnormal params of null params.sub-key
634     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
635     objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams());
636     EXPECT_EQ(objectData, nullptr);
637 
638     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"callFrameId":1, "expression":true,
639         "objectGroup":1, "includeCommandLineAPI":"true", "silent":"true", "returnByValue":"true",
640         "generatePreview":"true", "throwOnSideEffect":"true", "timeout":"10"}})";
641     EXPECT_EQ(objectData, nullptr);
642 
643     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"callFrameId":"1", "expression":"test",
644         "objectGroup":"testGroup", "includeCommandLineAPI":true, "silent":true, "returnByValue":true,
645         "generatePreview":true, "throwOnSideEffect":true, "timeout":10}})";
646     objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams());
647     ASSERT_NE(objectData, nullptr);
648     EXPECT_EQ(objectData->GetCallFrameId(), 1);
649     EXPECT_EQ(objectData->GetExpression(), "test");
650 }
651 
HWTEST_F_L0(DebuggerParamsTest, GetPossibleBreakpointsParamsCreateTest)652 HWTEST_F_L0(DebuggerParamsTest, GetPossibleBreakpointsParamsCreateTest)
653 {
654     std::string msg;
655     std::unique_ptr<GetPossibleBreakpointsParams> objectData;
656 
657     // abnormal params of null msg
658     msg = std::string() + R"({})";
659     objectData = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams());
660     EXPECT_EQ(objectData, nullptr);
661 
662     // abnormal params of unexist key params
663     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
664     objectData = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams());
665     EXPECT_EQ(objectData, nullptr);
666 
667     // abnormal params of null params.sub-key
668     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
669     objectData = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams());
670     EXPECT_EQ(objectData, nullptr);
671 
672     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"start":10, "end":10,
673         "restrictToFunction":"true"}})";
674     EXPECT_EQ(objectData, nullptr);
675 
676     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"start":{"scriptId":"1", "lineNumber":1,
677         "columnNumber":10}, "end":{"scriptId":"1", "lineNumber":10, "columnNumber":10}, "restrictToFunction":true}})";
678     objectData = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams());
679     ASSERT_NE(objectData, nullptr);
680     Location *start = objectData->GetStart();
681     Location *end = objectData->GetEnd();
682     EXPECT_EQ(start->GetScriptId(), 1);
683     EXPECT_EQ(start->GetLine(), 1);
684     EXPECT_EQ(start->GetColumn(), 10);
685     EXPECT_EQ(end->GetScriptId(), 1);
686     EXPECT_EQ(end->GetLine(), 10);
687     EXPECT_EQ(end->GetColumn(), 10);
688     ASSERT_TRUE(objectData->GetRestrictToFunction());
689 }
690 
HWTEST_F_L0(DebuggerParamsTest, GetScriptSourceParamsCreateTest)691 HWTEST_F_L0(DebuggerParamsTest, GetScriptSourceParamsCreateTest)
692 {
693     std::string msg;
694     std::unique_ptr<GetScriptSourceParams> objectData;
695 
696     // abnormal params of null msg
697     msg = std::string() + R"({})";
698     objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
699     EXPECT_EQ(objectData, nullptr);
700 
701     // abnormal params of unexist key params
702     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
703     objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
704     EXPECT_EQ(objectData, nullptr);
705 
706     // abnormal params of null params.sub-key
707     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
708     objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
709     EXPECT_EQ(objectData, nullptr);
710 
711     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"scriptId":10}})";
712     objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
713     EXPECT_EQ(objectData, nullptr);
714 
715     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"scriptId":"10"}})";
716     objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
717     ASSERT_NE(objectData, nullptr);
718     EXPECT_EQ(objectData->GetScriptId(), 10);
719 }
720 
HWTEST_F_L0(DebuggerParamsTest, RemoveBreakpointParamsCreateTest)721 HWTEST_F_L0(DebuggerParamsTest, RemoveBreakpointParamsCreateTest)
722 {
723     std::string msg;
724     std::unique_ptr<RemoveBreakpointParams> objectData;
725 
726     // abnormal params of null msg
727     msg = std::string() + R"({})";
728     objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
729     EXPECT_EQ(objectData, nullptr);
730 
731     // abnormal params of unexist key params
732     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
733     objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
734     EXPECT_EQ(objectData, nullptr);
735 
736     // abnormal params of null params.sub-key
737     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
738     objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
739     EXPECT_EQ(objectData, nullptr);
740 
741     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakpointId":10}})";
742     objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
743     EXPECT_EQ(objectData, nullptr);
744 
745     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakpointId":"10"}})";
746     objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
747     ASSERT_NE(objectData, nullptr);
748     EXPECT_EQ(objectData->GetBreakpointId(), "10");
749 }
750 
HWTEST_F_L0(DebuggerParamsTest, RemoveBreakpointsByUrlParamsCreateTest)751 HWTEST_F_L0(DebuggerParamsTest, RemoveBreakpointsByUrlParamsCreateTest)
752 {
753     std::string msg;
754     std::unique_ptr<RemoveBreakpointsByUrlParams> objectData;
755 
756     // abnormal params of null msg
757     msg = std::string() + R"({})";
758     objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
759     EXPECT_EQ(objectData, nullptr);
760 
761     // abnormal params of unexist key params
762     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
763     objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
764     EXPECT_EQ(objectData, nullptr);
765 
766     // abnormal params of null params.sub-key
767     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
768     objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
769     EXPECT_EQ(objectData, nullptr);
770 
771     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"url":10}})";
772     objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
773     EXPECT_EQ(objectData, nullptr);
774 
775     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"url":"10"}})";
776     objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
777     ASSERT_NE(objectData, nullptr);
778     EXPECT_EQ(objectData->GetUrl(), "10");
779 }
780 
HWTEST_F_L0(DebuggerParamsTest, ResumeParamsCreateTest)781 HWTEST_F_L0(DebuggerParamsTest, ResumeParamsCreateTest)
782 {
783     std::string msg;
784     std::unique_ptr<ResumeParams> objectData;
785 
786     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"terminateOnResume":10}})";
787     objectData = ResumeParams::Create(DispatchRequest(msg).GetParams());
788     EXPECT_EQ(objectData, nullptr);
789 
790     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"terminateOnResume":true}})";
791     objectData = ResumeParams::Create(DispatchRequest(msg).GetParams());
792     ASSERT_NE(objectData, nullptr);
793     ASSERT_TRUE(objectData->GetTerminateOnResume());
794 }
795 
HWTEST_F_L0(DebuggerParamsTest, SetAsyncCallStackDepthParamsCreateTest)796 HWTEST_F_L0(DebuggerParamsTest, SetAsyncCallStackDepthParamsCreateTest)
797 {
798     std::string msg;
799     std::unique_ptr<SetAsyncCallStackDepthParams> objectData;
800 
801     // abnormal params of null msg
802     msg = std::string() + R"({})";
803     objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
804     EXPECT_EQ(objectData, nullptr);
805 
806     // abnormal params of unexist key params
807     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
808     objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
809     EXPECT_EQ(objectData, nullptr);
810 
811     // abnormal params of null params.sub-key
812     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
813     objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
814     EXPECT_EQ(objectData, nullptr);
815 
816     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"maxDepth":true}})";
817     objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
818     EXPECT_EQ(objectData, nullptr);
819 
820     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"maxDepth":5}})";
821     objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
822     ASSERT_NE(objectData, nullptr);
823     EXPECT_EQ(objectData->GetMaxDepth(), 5);
824 }
825 
HWTEST_F_L0(DebuggerParamsTest, SetBlackboxPatternsParamsCreateTest)826 HWTEST_F_L0(DebuggerParamsTest, SetBlackboxPatternsParamsCreateTest)
827 {
828     std::string msg;
829     std::unique_ptr<SetBlackboxPatternsParams> objectData;
830 
831     // abnormal params of null msg
832     msg = std::string() + R"({})";
833     objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
834     EXPECT_EQ(objectData, nullptr);
835 
836     // abnormal params of unexist key params
837     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
838     objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
839     EXPECT_EQ(objectData, nullptr);
840 
841     // abnormal params of null params.sub-key
842     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
843     objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
844     EXPECT_EQ(objectData, nullptr);
845 
846     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"patterns":"testpattern"}})";
847     objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
848     EXPECT_EQ(objectData, nullptr);
849 
850     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"patterns":["testpattern1", "testpattern2"]}})";
851     objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
852     ASSERT_NE(objectData, nullptr);
853     std::list<std::string> patterns = objectData->GetPatterns();
854     EXPECT_EQ(patterns.size(), 2U);
855 }
856 
HWTEST_F_L0(DebuggerParamsTest, SetBreakpointByUrlParamsCreateTest)857 HWTEST_F_L0(DebuggerParamsTest, SetBreakpointByUrlParamsCreateTest)
858 {
859     std::string msg;
860     std::unique_ptr<SetBreakpointByUrlParams> objectData;
861 
862     // abnormal params of null msg
863     msg = std::string() + R"({})";
864     objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
865     EXPECT_EQ(objectData, nullptr);
866 
867     // abnormal params of unexist key params
868     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
869     objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
870     EXPECT_EQ(objectData, nullptr);
871 
872     // abnormal params of null params.sub-key
873     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
874     objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
875     EXPECT_EQ(objectData, nullptr);
876 
877     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"lineNumber":"10", "url":10,
878         "urlRegex":true, "scriptHash":true, "columnNumber":"10", "condition":10}})";
879     objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
880     EXPECT_EQ(objectData, nullptr);
881 
882     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"lineNumber":10, "url":"testURL",
883         "urlRegex":"testURLRegex", "scriptHash":"testScriptHash", "columnNumber":10, "condition":"testCondition"}})";
884     objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
885     ASSERT_NE(objectData, nullptr);
886     EXPECT_EQ(objectData->GetLine(), 10);
887     EXPECT_EQ(objectData->GetUrl(), "testURL");
888     EXPECT_EQ(objectData->GetUrlRegex(), "testURLRegex");
889     EXPECT_EQ(objectData->GetScriptHash(), "testScriptHash");
890     EXPECT_EQ(objectData->GetColumn(), 10);
891     EXPECT_EQ(objectData->GetCondition(), "testCondition");
892 }
893 
HWTEST_F_L0(DebuggerParamsTest, SetPauseOnExceptionsParamsCreateTest)894 HWTEST_F_L0(DebuggerParamsTest, SetPauseOnExceptionsParamsCreateTest)
895 {
896     std::string msg;
897     std::unique_ptr<SetPauseOnExceptionsParams> objectData;
898 
899     // abnormal params of null msg
900     msg = std::string() + R"({})";
901     objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
902     EXPECT_EQ(objectData, nullptr);
903 
904     // abnormal params of unexist key params
905     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
906     objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
907     EXPECT_EQ(objectData, nullptr);
908 
909     // abnormal params of null params.sub-key
910     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
911     objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
912     EXPECT_EQ(objectData, nullptr);
913 
914     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"state":10}})";
915     objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
916     EXPECT_EQ(objectData, nullptr);
917 
918     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"state":"none"}})";
919     objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
920     ASSERT_NE(objectData, nullptr);
921     EXPECT_EQ(objectData->GetState(), PauseOnExceptionsState::NONE);
922 }
923 
HWTEST_F_L0(DebuggerParamsTest, StepIntoParamsCreateTest)924 HWTEST_F_L0(DebuggerParamsTest, StepIntoParamsCreateTest)
925 {
926     std::string msg;
927     std::unique_ptr<StepIntoParams> objectData;
928 
929     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakOnAsyncCall":10, "skipList":true}})";
930     objectData = StepIntoParams::Create(DispatchRequest(msg).GetParams());
931     EXPECT_EQ(objectData, nullptr);
932 
933     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakOnAsyncCall":true,
934         "skipList":[{"scriptId":"1", "start":{"lineNumber":1, "columnNumber":10}, "end":{"lineNumber":2,
935         "columnNumber":20}}, {"scriptId":"2", "start":{"lineNumber":3, "columnNumber":30}, "end":{"lineNumber":4,
936         "columnNumber":40}}]}})";
937     objectData = StepIntoParams::Create(DispatchRequest(msg).GetParams());
938     ASSERT_NE(objectData, nullptr);
939     ASSERT_TRUE(objectData->GetBreakOnAsyncCall());
940     const std::list<std::unique_ptr<LocationRange>> *locationRangeList = objectData->GetSkipList();
941     EXPECT_EQ(locationRangeList->size(), 2U);
942 }
943 
944 
HWTEST_F_L0(DebuggerParamsTest, StepOverParamsCreateTest)945 HWTEST_F_L0(DebuggerParamsTest, StepOverParamsCreateTest)
946 {
947     std::string msg;
948     std::unique_ptr<StepOverParams> objectData;
949 
950     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"skipList":true}})";
951     objectData = StepOverParams::Create(DispatchRequest(msg).GetParams());
952     EXPECT_EQ(objectData, nullptr);
953 
954     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"skipList":[{"scriptId":"1",
955         "start":{"lineNumber":1, "columnNumber":10}, "end":{"lineNumber":2, "columnNumber":20}}, {"scriptId":"2",
956         "start":{"lineNumber":3, "columnNumber":30}, "end":{"lineNumber":4, "columnNumber":40}}]}})";
957     objectData = StepOverParams::Create(DispatchRequest(msg).GetParams());
958     ASSERT_NE(objectData, nullptr);
959     const std::list<std::unique_ptr<LocationRange>> *locationRangeList = objectData->GetSkipList();
960     EXPECT_EQ(locationRangeList->size(), 2U);
961 }
962 
HWTEST_F_L0(DebuggerParamsTest, ReplyNativeCallingParamsCreateTest)963 HWTEST_F_L0(DebuggerParamsTest, ReplyNativeCallingParamsCreateTest)
964 {
965     std::string msg;
966     std::unique_ptr<ReplyNativeCallingParams> objectData;
967 
968     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"userCode":"test"}})";
969     objectData = ReplyNativeCallingParams::Create(DispatchRequest(msg).GetParams());
970     EXPECT_EQ(objectData, nullptr);
971 
972     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"userCode":true}})";
973     objectData = ReplyNativeCallingParams::Create(DispatchRequest(msg).GetParams());
974     ASSERT_NE(objectData, nullptr);
975     ASSERT_TRUE(objectData->GetUserCode());
976 }
977 
HWTEST_F_L0(DebuggerParamsTest, GetPropertiesParamsCreateTest)978 HWTEST_F_L0(DebuggerParamsTest, GetPropertiesParamsCreateTest)
979 {
980     std::string msg;
981     std::unique_ptr<GetPropertiesParams> objectData;
982 
983     // abnormal params of null msg
984     msg = std::string() + R"({})";
985     objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
986     EXPECT_EQ(objectData, nullptr);
987 
988     // abnormal params of unexist key params
989     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
990     objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
991     EXPECT_EQ(objectData, nullptr);
992 
993     // abnormal params of null params.sub-key
994     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
995     objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
996     EXPECT_EQ(objectData, nullptr);
997 
998     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10, "ownProperties":1,
999         "accessorPropertiesOnly":2, "generatePreview":3}})";
1000     objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
1001     EXPECT_EQ(objectData, nullptr);
1002 
1003     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "ownProperties":true,
1004         "accessorPropertiesOnly":true, "generatePreview":true}})";
1005     objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
1006     ASSERT_NE(objectData, nullptr);
1007     EXPECT_EQ(objectData->GetObjectId(), 10);
1008     ASSERT_TRUE(objectData->GetOwnProperties());
1009     ASSERT_TRUE(objectData->GetAccessPropertiesOnly());
1010     ASSERT_TRUE(objectData->GetGeneratePreview());
1011 }
1012 
HWTEST_F_L0(DebuggerParamsTest, CallFunctionOnParamsCreateTest)1013 HWTEST_F_L0(DebuggerParamsTest, CallFunctionOnParamsCreateTest)
1014 {
1015     std::string msg;
1016     std::unique_ptr<CallFunctionOnParams> objectData;
1017 
1018     // abnormal params of null msg
1019     msg = std::string() + R"({})";
1020     objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1021     EXPECT_EQ(objectData, nullptr);
1022 
1023     // abnormal params of unexist key params
1024     msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
1025     objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1026     EXPECT_EQ(objectData, nullptr);
1027 
1028     // abnormal params of null params.sub-key
1029     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
1030     objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1031     EXPECT_EQ(objectData, nullptr);
1032 
1033     msg = std::string() + R"({"id":0, "method":"Debugger.Test", "params":{"callFrameId":0, "functionDeclaration":true,
1034         "objectId":1, "arguments":[{"unserializableValue":1, "objectId":10}, {"unserializableValue":2, "objectId":20}],
1035         "silent":"true", "returnByValue":"true", "generatePreview":"true", "userGesture":"true",
1036         "awaitPromise":"true", "executionContextId":"1", "objectGroup":2, "throwOnSideEffect":"true"}})";
1037     objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1038     EXPECT_EQ(objectData, nullptr);
1039 
1040     msg = std::string() + R"({"id":0, "method":"Debugger.Test", "params":{"callFrameId":"0",
1041         "functionDeclaration":"testFunction", "objectId":"1",
1042         "arguments":[{"unserializableValue":"testValue1", "objectId":"10"},
1043         {"unserializableValue":"testValue2", "objectId":"20"}], "silent":true, "returnByValue":true,
1044         "generatePreview":true, "userGesture":true, "awaitPromise":true, "executionContextId":1,
1045         "objectGroup":"testGrp", "throwOnSideEffect":true}})";
1046     objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1047     ASSERT_NE(objectData, nullptr);
1048     EXPECT_EQ(objectData->GetCallFrameId(), 0);
1049     EXPECT_EQ(objectData->GetFunctionDeclaration(), "testFunction");
1050     EXPECT_EQ(objectData->GetObjectId(), 1);
1051     const std::vector<std::unique_ptr<CallArgument>> *callArgument = objectData->GetArguments();
1052     EXPECT_EQ(callArgument->size(), 2U);
1053     ASSERT_TRUE(objectData->GetSilent());
1054     ASSERT_TRUE(objectData->GetReturnByValue());
1055     ASSERT_TRUE(objectData->GetGeneratePreview());
1056     ASSERT_TRUE(objectData->GetUserGesture());
1057     ASSERT_TRUE(objectData->GetAwaitPromise());
1058     EXPECT_EQ(objectData->GetExecutionContextId(), 1);
1059     EXPECT_EQ(objectData->GetObjectGroup(), "testGrp");
1060     ASSERT_TRUE(objectData->GetThrowOnSideEffect());
1061 }
1062 
HWTEST_F_L0(DebuggerParamsTest, ResetSingleStepperParamsCreateTest)1063 HWTEST_F_L0(DebuggerParamsTest, ResetSingleStepperParamsCreateTest)
1064 {
1065     std::string msg;
1066     std::unique_ptr<ResetSingleStepperParams> objectData;
1067 
1068     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"resetSingleStepper":"test"}})";
1069     objectData = ResetSingleStepperParams::Create(DispatchRequest(msg).GetParams());
1070     EXPECT_EQ(objectData, nullptr);
1071 
1072     msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"resetSingleStepper":true}})";
1073     objectData = ResetSingleStepperParams::Create(DispatchRequest(msg).GetParams());
1074     ASSERT_NE(objectData, nullptr);
1075     ASSERT_TRUE(objectData->GetResetSingleStepper());
1076 }
1077 }  // namespace panda::test