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
26using namespace panda::ecmascript;
27using namespace panda::ecmascript::tooling;
28
29namespace panda::test {
30// Duplicate name of panda::ecmascript::PropertyDescriptor in js_object-inl.h
31using panda::ecmascript::tooling::PropertyDescriptor;
32
33using ObjectType = RemoteObject::TypeName;
34using ObjectSubType = RemoteObject::SubTypeName;
35using ObjectClassName = RemoteObject::ClassName;
36
37class DebuggerParamsTest : public testing::Test {
38public:
39    static void SetUpTestCase()
40    {
41        GTEST_LOG_(INFO) << "SetUpTestCase";
42        Logger::InitializeStdLogging(Logger::Level::FATAL, LoggerComponentMaskAll);
43    }
44
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
63protected:
64    EcmaVM *ecmaVm {nullptr};
65    EcmaHandleScope *scope {nullptr};
66    JSThread *thread {nullptr};
67};
68
69HWTEST_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
105HWTEST_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
132HWTEST_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
158HWTEST_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
174HWTEST_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
194HWTEST_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
209HWTEST_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
227HWTEST_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
261HWTEST_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
295HWTEST_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
341HWTEST_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
383HWTEST_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
405HWTEST_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
434HWTEST_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
474HWTEST_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
510HWTEST_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
541HWTEST_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
574HWTEST_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
618HWTEST_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
652HWTEST_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
691HWTEST_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
721HWTEST_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
751HWTEST_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
781HWTEST_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
796HWTEST_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
826HWTEST_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
857HWTEST_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
894HWTEST_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
924HWTEST_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
945HWTEST_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
963HWTEST_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
978HWTEST_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
1013HWTEST_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
1063HWTEST_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