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
SetUp()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
TearDown()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,EnableParamsAccelerateLaunchModeCreateTest)227 HWTEST_F_L0(DebuggerParamsTest, EnableParamsAccelerateLaunchModeCreateTest)
228 {
229 std::string msg;
230 std::unique_ptr<EnableParams> enableParams;
231
232 // abnormal
233 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
234 enableParams = EnableParams::Create(DispatchRequest(msg).GetParams());
235 ASSERT_NE(enableParams, nullptr);
236 EXPECT_FALSE(enableParams->HasMaxScriptsCacheSize());
237
238 // normal
239 msg = std::string() + R"({"id":0,"method":"Debugger.Test",
240 "params":{"options":["enableLaunchAccelerate"], "maxScriptsCacheSize":100}})";
241 enableParams = EnableParams::Create(DispatchRequest(msg).GetParams());
242 ASSERT_NE(enableParams, nullptr);
243 EXPECT_EQ(enableParams->GetMaxScriptsCacheSize(), 100);
244 EXPECT_EQ(enableParams->GetEnableOptionsList().size(), 1);
245 }
246
HWTEST_F_L0(DebuggerParamsTest,SaveAllPossibleBreakpointsParamsCreateTest)247 HWTEST_F_L0(DebuggerParamsTest, SaveAllPossibleBreakpointsParamsCreateTest)
248 {
249 std::string msg;
250 std::unique_ptr<SaveAllPossibleBreakpointsParams> params;
251
252 // abnormal
253 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
254 params = SaveAllPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams());
255 ASSERT_EQ(params, nullptr);
256
257 // normal
258 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
259 "locations":{"actualUrl/actualFileName.ts":[{"lineNumber": 7, "columnNumber": 8}]}}})";
260 params = SaveAllPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams());
261 ASSERT_NE(params, nullptr);
262 EXPECT_TRUE(params->HasBreakpointsMap());
263 EXPECT_EQ(params->GetBreakpointsMap()->size(), 1);
264 }
265
HWTEST_F_L0(DebuggerParamsTest,StartSamplingParamsCreateTest)266 HWTEST_F_L0(DebuggerParamsTest, StartSamplingParamsCreateTest)
267 {
268 std::string msg;
269 std::unique_ptr<StartSamplingParams> startSamplingData;
270
271 // abnormal params of null params.sub-key
272 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
273 startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
274 ASSERT_NE(startSamplingData, nullptr);
275 EXPECT_EQ(startSamplingData->GetSamplingInterval(), 32768);
276
277 // abnormal params of unknown params.sub-key
278 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
279 startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
280 ASSERT_NE(startSamplingData, nullptr);
281 EXPECT_EQ(startSamplingData->GetSamplingInterval(), 32768);
282
283 // abnormal params of params.sub-key=["samplingInterval":true]
284 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":true}})";
285 startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
286 EXPECT_EQ(startSamplingData, nullptr);
287
288 // abnormal params of params.sub-key=["samplingInterval":true]
289 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":"Test"}})";
290 startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
291 EXPECT_EQ(startSamplingData, nullptr);
292
293 // abnormal params of params.sub-key = [ "size"=100,"nodeId"=1,"ordinal"=10]
294 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":1000}})";
295 startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams());
296 ASSERT_NE(startSamplingData, nullptr);
297 EXPECT_EQ(startSamplingData->GetSamplingInterval(), 1000);
298 }
299
HWTEST_F_L0(DebuggerParamsTest,StartTrackingHeapObjectsParamsCreateTest)300 HWTEST_F_L0(DebuggerParamsTest, StartTrackingHeapObjectsParamsCreateTest)
301 {
302 std::string msg;
303 std::unique_ptr<StartTrackingHeapObjectsParams> objectData;
304
305 // abnormal params of null params.sub-key
306 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
307 objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
308 ASSERT_NE(objectData, nullptr);
309 ASSERT_FALSE(objectData->GetTrackAllocations());
310
311 // abnormal params of unknown params.sub-key
312 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
313 objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
314 ASSERT_NE(objectData, nullptr);
315 ASSERT_FALSE(objectData->GetTrackAllocations());
316
317 // abnormal params of params.sub-key=["trackAllocations":10]
318 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":10}})";
319 objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
320 EXPECT_EQ(objectData, nullptr);
321
322 // abnormal params of params.sub-key=["trackAllocations":"Test"]
323 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":"Test"}})";
324 objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
325 EXPECT_EQ(objectData, nullptr);
326
327 // abnormal params of params.sub-key=["trackAllocations":true]
328 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":true}})";
329 objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
330 ASSERT_NE(objectData, nullptr);
331 ASSERT_TRUE(objectData->GetTrackAllocations());
332 }
333
HWTEST_F_L0(DebuggerParamsTest,StopTrackingHeapObjectsParamsCreateTest)334 HWTEST_F_L0(DebuggerParamsTest, StopTrackingHeapObjectsParamsCreateTest)
335 {
336 std::string msg;
337 std::unique_ptr<StopTrackingHeapObjectsParams> objectData;
338
339 // abnormal params of null params.sub-key
340 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
341 objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
342 ASSERT_NE(objectData, nullptr);
343 ASSERT_FALSE(objectData->GetReportProgress());
344 ASSERT_FALSE(objectData->GetTreatGlobalObjectsAsRoots());
345 ASSERT_FALSE(objectData->GetCaptureNumericValue());
346
347 // abnormal params of unknown params.sub-key
348 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
349 objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
350 ASSERT_NE(objectData, nullptr);
351 ASSERT_FALSE(objectData->GetReportProgress());
352 ASSERT_FALSE(objectData->GetTreatGlobalObjectsAsRoots());
353 ASSERT_FALSE(objectData->GetCaptureNumericValue());
354
355 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
356 "reportProgress":10,
357 "treatGlobalObjectsAsRoots":10,
358 "captureNumericValue":10}})";
359 objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
360 EXPECT_EQ(objectData, nullptr);
361
362 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
363 "reportProgress":"Test",
364 "treatGlobalObjectsAsRoots":"Test",
365 "captureNumericValue":"Test"}})";
366 objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
367 EXPECT_EQ(objectData, nullptr);
368
369 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
370 "reportProgress":true,
371 "treatGlobalObjectsAsRoots":true,
372 "captureNumericValue":true}})";
373 objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams());
374 ASSERT_NE(objectData, nullptr);
375 ASSERT_TRUE(objectData->GetReportProgress());
376 ASSERT_TRUE(objectData->GetTreatGlobalObjectsAsRoots());
377 ASSERT_TRUE(objectData->GetCaptureNumericValue());
378 }
379
HWTEST_F_L0(DebuggerParamsTest,AddInspectedHeapObjectParamsCreateTest)380 HWTEST_F_L0(DebuggerParamsTest, AddInspectedHeapObjectParamsCreateTest)
381 {
382 std::string msg;
383 std::unique_ptr<AddInspectedHeapObjectParams> objectData;
384
385 // abnormal params of null msg
386 msg = std::string() + R"({})";
387 objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
388 EXPECT_EQ(objectData, nullptr);
389
390 // abnormal params of unexist key params
391 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
392 objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
393 EXPECT_EQ(objectData, nullptr);
394
395 // abnormal params of null params.sub-key
396 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
397 objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
398 EXPECT_EQ(objectData, nullptr);
399
400 // abnormal params of unknown params.sub-key
401 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
402 objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
403 EXPECT_EQ(objectData, nullptr);
404
405 // abnormal params of params.sub-key=["heapObjectId":10]
406 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":10}})";
407 objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
408 EXPECT_EQ(objectData, nullptr);
409
410 // abnormal params of params.sub-key=["heapObjectId":true]
411 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":true}})";
412 objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
413 EXPECT_EQ(objectData, nullptr);
414
415 // abnormal params of params.sub-key=["heapObjectId":“10”]
416 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":"10"}})";
417 objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams());
418 ASSERT_NE(objectData, nullptr);
419 EXPECT_EQ(objectData->GetHeapObjectId(), 10);
420 }
421
HWTEST_F_L0(DebuggerParamsTest,GetHeapObjectIdParamsCreateTest)422 HWTEST_F_L0(DebuggerParamsTest, GetHeapObjectIdParamsCreateTest)
423 {
424 std::string msg;
425 std::unique_ptr<GetHeapObjectIdParams> objectData;
426
427 // abnormal params of params.sub-key=["objectId":10]
428 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10}})";
429 objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
430 EXPECT_EQ(objectData, nullptr);
431
432 // abnormal params of params.sub-key=["objectId":true]
433 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":true}})";
434 objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
435 EXPECT_EQ(objectData, nullptr);
436
437 // abnormal params of params.sub-key=["objectId":“10”]
438 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10"}})";
439 objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
440 ASSERT_NE(objectData, nullptr);
441 EXPECT_EQ((int)objectData->GetObjectId(), 10);
442 }
443
HWTEST_F_L0(DebuggerParamsTest,GetObjectByHeapObjectIdParamsCreateTest)444 HWTEST_F_L0(DebuggerParamsTest, GetObjectByHeapObjectIdParamsCreateTest)
445 {
446 std::string msg;
447 std::unique_ptr<GetObjectByHeapObjectIdParams> objectData;
448
449 // abnormal params of params.sub-key=["objectId":10]
450 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10}})";
451 objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
452 EXPECT_EQ(objectData, nullptr);
453
454 // abnormal params of params.sub-key=["objectId":true]
455 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "objectGroup":10}})";
456 objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
457 EXPECT_EQ(objectData, nullptr);
458
459 // abnormal params of params.sub-key=["objectId":“10”]
460 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10"}})";
461 objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
462 ASSERT_NE(objectData, nullptr);
463 EXPECT_EQ((int)objectData->GetObjectId(), 10);
464 ASSERT_FALSE(objectData->HasObjectGroup());
465
466 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "objectGroup":"groupname"}})";
467 objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams());
468 ASSERT_NE(objectData, nullptr);
469 EXPECT_EQ((int)objectData->GetObjectId(), 10);
470 EXPECT_EQ(objectData->GetObjectGroup(), "groupname");
471 }
472
HWTEST_F_L0(DebuggerParamsTest,StartPreciseCoverageParamCreateTest)473 HWTEST_F_L0(DebuggerParamsTest, StartPreciseCoverageParamCreateTest)
474 {
475 std::string msg;
476 std::unique_ptr<StartPreciseCoverageParams> objectData;
477
478 // abnormal params of null params.sub-key
479 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
480 objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
481 ASSERT_NE(objectData, nullptr);
482
483 // abnormal params of unknown params.sub-key
484 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
485 objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
486 ASSERT_NE(objectData, nullptr);
487
488 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
489 "callCount":8,
490 "detailed":8,
491 "allowTriggeredUpdates":8}})";
492 objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
493 EXPECT_EQ(objectData, nullptr);
494
495 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
496 "callCount":"Test",
497 "detailed":"Test",
498 "allowTriggeredUpdates":"Test"}})";
499 objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
500 EXPECT_EQ(objectData, nullptr);
501
502 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
503 "callCount":true,
504 "detailed":true,
505 "allowTriggeredUpdates":true}})";
506 objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams());
507 ASSERT_NE(objectData, nullptr);
508 ASSERT_TRUE(objectData->GetCallCount());
509 ASSERT_TRUE(objectData->GetDetailed());
510 ASSERT_TRUE(objectData->GetAllowTriggeredUpdates());
511 }
512
HWTEST_F_L0(DebuggerParamsTest,SetSamplingIntervalParamsCreateTest)513 HWTEST_F_L0(DebuggerParamsTest, SetSamplingIntervalParamsCreateTest)
514 {
515 std::string msg;
516 std::unique_ptr<SetSamplingIntervalParams> objectData;
517
518 // abnormal params of null msg
519 msg = std::string() + R"({})";
520 objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
521 EXPECT_EQ(objectData, nullptr);
522
523 // abnormal params of unexist key params
524 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
525 objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
526 EXPECT_EQ(objectData, nullptr);
527
528 // abnormal params of null params.sub-key
529 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
530 objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
531 EXPECT_EQ(objectData, nullptr);
532
533 // abnormal params of unknown params.sub-key
534 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
535 objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
536 EXPECT_EQ(objectData, nullptr);
537
538 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{
539 "interval":"500"}})";
540 objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
541 EXPECT_EQ(objectData, nullptr);
542
543 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"interval":500}})";
544 objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams());
545 ASSERT_NE(objectData, nullptr);
546 EXPECT_EQ(objectData->GetInterval(), 500);
547 }
548
HWTEST_F_L0(DebuggerParamsTest,RecordClockSyncMarkerParamsCreateTest)549 HWTEST_F_L0(DebuggerParamsTest, RecordClockSyncMarkerParamsCreateTest)
550 {
551 std::string msg;
552 std::unique_ptr<RecordClockSyncMarkerParams> objectData;
553
554 // abnormal params of null msg
555 msg = std::string() + R"({})";
556 objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
557 EXPECT_EQ(objectData, nullptr);
558
559 // abnormal params of unexist key params
560 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
561 objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
562 EXPECT_EQ(objectData, nullptr);
563
564 // abnormal params of null params.sub-key
565 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
566 objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
567 EXPECT_EQ(objectData, nullptr);
568
569 // abnormal params of unknown params.sub-key
570 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
571 objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
572 EXPECT_EQ(objectData, nullptr);
573
574 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"syncId":"101"}})";
575 objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams());
576 ASSERT_NE(objectData, nullptr);
577 EXPECT_EQ(objectData->GetSyncId(), "101");
578 }
579
HWTEST_F_L0(DebuggerParamsTest,RequestMemoryDumpParamsCreateTest)580 HWTEST_F_L0(DebuggerParamsTest, RequestMemoryDumpParamsCreateTest)
581 {
582 std::string msg;
583 std::unique_ptr<RequestMemoryDumpParams> objectData;
584
585 // abnormal params of null msg
586 msg = std::string() + R"({})";
587 objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
588 ASSERT_NE(objectData, nullptr);
589
590 // abnormal params of unexist key params
591 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
592 objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
593 ASSERT_NE(objectData, nullptr);
594
595 // abnormal params of null params.sub-key
596 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
597 objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
598 ASSERT_NE(objectData, nullptr);
599
600 // abnormal params of unknown params.sub-key
601 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
602 objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
603 ASSERT_NE(objectData, nullptr);
604
605 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"deterministic":true,
606 "levelOfDetail":"background"}})";
607 objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams());
608 ASSERT_NE(objectData, nullptr);
609 ASSERT_TRUE(objectData->GetDeterministic());
610 EXPECT_EQ(objectData->GetLevelOfDetail(), "background");
611 }
612
HWTEST_F_L0(DebuggerParamsTest,StartParamsCreateTest)613 HWTEST_F_L0(DebuggerParamsTest, StartParamsCreateTest)
614 {
615 std::string msg;
616 std::unique_ptr<StartParams> objectData;
617
618 // abnormal params of null msg
619 msg = std::string() + R"({})";
620 objectData = StartParams::Create(DispatchRequest(msg).GetParams());
621 ASSERT_NE(objectData, nullptr);
622
623 // abnormal params of unexist key params
624 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
625 objectData = StartParams::Create(DispatchRequest(msg).GetParams());
626 ASSERT_NE(objectData, nullptr);
627
628 // abnormal params of null params.sub-key
629 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
630 objectData = StartParams::Create(DispatchRequest(msg).GetParams());
631 ASSERT_NE(objectData, nullptr);
632
633 // abnormal params of unknown params.sub-key
634 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})";
635 objectData = StartParams::Create(DispatchRequest(msg).GetParams());
636 ASSERT_NE(objectData, nullptr);
637
638 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"categories":"filter1",
639 "options":"1", "bufferUsageReportingInterval":11, "transferMode":"ReportEvents", "streamFormat":"json",
640 "streamCompression":"none", "traceConfig": {"recordMode":"recordUntilFull"}, "perfettoConfig":"categories",
641 "tracingBackend":"auto"}})";
642 objectData = StartParams::Create(DispatchRequest(msg).GetParams());
643 ASSERT_NE(objectData, nullptr);
644 EXPECT_EQ(objectData->GetCategories(), "filter1");
645 EXPECT_EQ(objectData->GetOptions(), "1");
646 EXPECT_EQ(objectData->GetBufferUsageReportingInterval(), 11);
647 EXPECT_EQ(objectData->GetTransferMode(), "ReportEvents");
648 EXPECT_EQ(objectData->GetStreamFormat(), "json");
649 EXPECT_EQ(objectData->GetStreamCompression(), "none");
650 TraceConfig *traceConfig = objectData->GetTraceConfig();
651 ASSERT_NE(traceConfig, nullptr);
652 EXPECT_EQ(traceConfig->GetRecordMode(), "recordUntilFull");
653 EXPECT_EQ(objectData->GetPerfettoConfig(), "categories");
654 EXPECT_EQ(objectData->GetTracingBackend(), "auto");
655 }
656
HWTEST_F_L0(DebuggerParamsTest,EvaluateOnCallFrameParamsCreateTest)657 HWTEST_F_L0(DebuggerParamsTest, EvaluateOnCallFrameParamsCreateTest)
658 {
659 std::string msg;
660 std::unique_ptr<EvaluateOnCallFrameParams> objectData;
661
662 // abnormal params of null msg
663 msg = std::string() + R"({})";
664 objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams());
665 EXPECT_EQ(objectData, nullptr);
666
667 // abnormal params of unexist key params
668 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
669 objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams());
670 EXPECT_EQ(objectData, nullptr);
671
672 // abnormal params of null params.sub-key
673 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
674 objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams());
675 EXPECT_EQ(objectData, nullptr);
676
677 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"callFrameId":1, "expression":true,
678 "objectGroup":1, "includeCommandLineAPI":"true", "silent":"true", "returnByValue":"true",
679 "generatePreview":"true", "throwOnSideEffect":"true", "timeout":"10"}})";
680 EXPECT_EQ(objectData, nullptr);
681
682 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"callFrameId":"1", "expression":"test",
683 "objectGroup":"testGroup", "includeCommandLineAPI":true, "silent":true, "returnByValue":true,
684 "generatePreview":true, "throwOnSideEffect":true, "timeout":10}})";
685 objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams());
686 ASSERT_NE(objectData, nullptr);
687 EXPECT_EQ(objectData->GetCallFrameId(), 1);
688 EXPECT_EQ(objectData->GetExpression(), "test");
689 }
690
HWTEST_F_L0(DebuggerParamsTest,GetPossibleBreakpointsParamsCreateTest)691 HWTEST_F_L0(DebuggerParamsTest, GetPossibleBreakpointsParamsCreateTest)
692 {
693 std::string msg;
694 std::unique_ptr<GetPossibleBreakpointsParams> objectData;
695
696 // abnormal params of null msg
697 msg = std::string() + R"({})";
698 objectData = GetPossibleBreakpointsParams::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 = GetPossibleBreakpointsParams::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 = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams());
709 EXPECT_EQ(objectData, nullptr);
710
711 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"start":10, "end":10,
712 "restrictToFunction":"true"}})";
713 EXPECT_EQ(objectData, nullptr);
714
715 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"start":{"scriptId":"1", "lineNumber":1,
716 "columnNumber":10}, "end":{"scriptId":"1", "lineNumber":10, "columnNumber":10}, "restrictToFunction":true}})";
717 objectData = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams());
718 ASSERT_NE(objectData, nullptr);
719 Location *start = objectData->GetStart();
720 Location *end = objectData->GetEnd();
721 EXPECT_EQ(start->GetScriptId(), 1);
722 EXPECT_EQ(start->GetLine(), 1);
723 EXPECT_EQ(start->GetColumn(), 10);
724 EXPECT_EQ(end->GetScriptId(), 1);
725 EXPECT_EQ(end->GetLine(), 10);
726 EXPECT_EQ(end->GetColumn(), 10);
727 ASSERT_TRUE(objectData->GetRestrictToFunction());
728 }
729
HWTEST_F_L0(DebuggerParamsTest,GetScriptSourceParamsCreateTest)730 HWTEST_F_L0(DebuggerParamsTest, GetScriptSourceParamsCreateTest)
731 {
732 std::string msg;
733 std::unique_ptr<GetScriptSourceParams> objectData;
734
735 // abnormal params of null msg
736 msg = std::string() + R"({})";
737 objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
738 EXPECT_EQ(objectData, nullptr);
739
740 // abnormal params of unexist key params
741 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
742 objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
743 EXPECT_EQ(objectData, nullptr);
744
745 // abnormal params of null params.sub-key
746 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
747 objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
748 EXPECT_EQ(objectData, nullptr);
749
750 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"scriptId":10}})";
751 objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
752 EXPECT_EQ(objectData, nullptr);
753
754 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"scriptId":"10"}})";
755 objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams());
756 ASSERT_NE(objectData, nullptr);
757 EXPECT_EQ(objectData->GetScriptId(), 10);
758 }
759
HWTEST_F_L0(DebuggerParamsTest,RemoveBreakpointParamsCreateTest)760 HWTEST_F_L0(DebuggerParamsTest, RemoveBreakpointParamsCreateTest)
761 {
762 std::string msg;
763 std::unique_ptr<RemoveBreakpointParams> objectData;
764
765 // abnormal params of null msg
766 msg = std::string() + R"({})";
767 objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
768 EXPECT_EQ(objectData, nullptr);
769
770 // abnormal params of unexist key params
771 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
772 objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
773 EXPECT_EQ(objectData, nullptr);
774
775 // abnormal params of null params.sub-key
776 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
777 objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
778 EXPECT_EQ(objectData, nullptr);
779
780 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakpointId":10}})";
781 objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
782 EXPECT_EQ(objectData, nullptr);
783
784 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakpointId":"10"}})";
785 objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams());
786 ASSERT_NE(objectData, nullptr);
787 EXPECT_EQ(objectData->GetBreakpointId(), "10");
788 }
789
HWTEST_F_L0(DebuggerParamsTest,RemoveBreakpointsByUrlParamsCreateTest)790 HWTEST_F_L0(DebuggerParamsTest, RemoveBreakpointsByUrlParamsCreateTest)
791 {
792 std::string msg;
793 std::unique_ptr<RemoveBreakpointsByUrlParams> objectData;
794
795 // abnormal params of null msg
796 msg = std::string() + R"({})";
797 objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
798 EXPECT_EQ(objectData, nullptr);
799
800 // abnormal params of unexist key params
801 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
802 objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
803 EXPECT_EQ(objectData, nullptr);
804
805 // abnormal params of null params.sub-key
806 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
807 objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
808 EXPECT_EQ(objectData, nullptr);
809
810 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"url":10}})";
811 objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
812 EXPECT_EQ(objectData, nullptr);
813
814 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"url":"10"}})";
815 objectData = RemoveBreakpointsByUrlParams::Create(DispatchRequest(msg).GetParams());
816 ASSERT_NE(objectData, nullptr);
817 EXPECT_EQ(objectData->GetUrl(), "10");
818 }
819
HWTEST_F_L0(DebuggerParamsTest,ResumeParamsCreateTest)820 HWTEST_F_L0(DebuggerParamsTest, ResumeParamsCreateTest)
821 {
822 std::string msg;
823 std::unique_ptr<ResumeParams> objectData;
824
825 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"terminateOnResume":10}})";
826 objectData = ResumeParams::Create(DispatchRequest(msg).GetParams());
827 EXPECT_EQ(objectData, nullptr);
828
829 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"terminateOnResume":true}})";
830 objectData = ResumeParams::Create(DispatchRequest(msg).GetParams());
831 ASSERT_NE(objectData, nullptr);
832 ASSERT_TRUE(objectData->GetTerminateOnResume());
833 }
834
HWTEST_F_L0(DebuggerParamsTest,SetAsyncCallStackDepthParamsCreateTest)835 HWTEST_F_L0(DebuggerParamsTest, SetAsyncCallStackDepthParamsCreateTest)
836 {
837 std::string msg;
838 std::unique_ptr<SetAsyncCallStackDepthParams> objectData;
839
840 // abnormal params of null msg
841 msg = std::string() + R"({})";
842 objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
843 EXPECT_EQ(objectData, nullptr);
844
845 // abnormal params of unexist key params
846 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
847 objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
848 EXPECT_EQ(objectData, nullptr);
849
850 // abnormal params of null params.sub-key
851 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
852 objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
853 EXPECT_EQ(objectData, nullptr);
854
855 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"maxDepth":true}})";
856 objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
857 EXPECT_EQ(objectData, nullptr);
858
859 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"maxDepth":5}})";
860 objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams());
861 ASSERT_NE(objectData, nullptr);
862 EXPECT_EQ(objectData->GetMaxDepth(), 5);
863 }
864
HWTEST_F_L0(DebuggerParamsTest,SetBlackboxPatternsParamsCreateTest)865 HWTEST_F_L0(DebuggerParamsTest, SetBlackboxPatternsParamsCreateTest)
866 {
867 std::string msg;
868 std::unique_ptr<SetBlackboxPatternsParams> objectData;
869
870 // abnormal params of null msg
871 msg = std::string() + R"({})";
872 objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
873 EXPECT_EQ(objectData, nullptr);
874
875 // abnormal params of unexist key params
876 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
877 objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
878 EXPECT_EQ(objectData, nullptr);
879
880 // abnormal params of null params.sub-key
881 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
882 objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
883 EXPECT_EQ(objectData, nullptr);
884
885 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"patterns":"testpattern"}})";
886 objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
887 EXPECT_EQ(objectData, nullptr);
888
889 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"patterns":["testpattern1", "testpattern2"]}})";
890 objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams());
891 ASSERT_NE(objectData, nullptr);
892 std::list<std::string> patterns = objectData->GetPatterns();
893 EXPECT_EQ(patterns.size(), 2U);
894 }
895
HWTEST_F_L0(DebuggerParamsTest,SetBreakpointByUrlParamsCreateTest)896 HWTEST_F_L0(DebuggerParamsTest, SetBreakpointByUrlParamsCreateTest)
897 {
898 std::string msg;
899 std::unique_ptr<SetBreakpointByUrlParams> objectData;
900
901 // abnormal params of null msg
902 msg = std::string() + R"({})";
903 objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
904 EXPECT_EQ(objectData, nullptr);
905
906 // abnormal params of unexist key params
907 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
908 objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
909 EXPECT_EQ(objectData, nullptr);
910
911 // abnormal params of null params.sub-key
912 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
913 objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
914 EXPECT_EQ(objectData, nullptr);
915
916 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"lineNumber":"10", "url":10,
917 "urlRegex":true, "scriptHash":true, "columnNumber":"10", "condition":10}})";
918 objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
919 EXPECT_EQ(objectData, nullptr);
920
921 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"lineNumber":10, "url":"testURL",
922 "urlRegex":"testURLRegex", "scriptHash":"testScriptHash", "columnNumber":10, "condition":"testCondition"}})";
923 objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams());
924 ASSERT_NE(objectData, nullptr);
925 EXPECT_EQ(objectData->GetLine(), 10);
926 EXPECT_EQ(objectData->GetUrl(), "testURL");
927 EXPECT_EQ(objectData->GetUrlRegex(), "testURLRegex");
928 EXPECT_EQ(objectData->GetScriptHash(), "testScriptHash");
929 EXPECT_EQ(objectData->GetColumn(), 10);
930 EXPECT_EQ(objectData->GetCondition(), "testCondition");
931 }
932
HWTEST_F_L0(DebuggerParamsTest,SetPauseOnExceptionsParamsCreateTest)933 HWTEST_F_L0(DebuggerParamsTest, SetPauseOnExceptionsParamsCreateTest)
934 {
935 std::string msg;
936 std::unique_ptr<SetPauseOnExceptionsParams> objectData;
937
938 // abnormal params of null msg
939 msg = std::string() + R"({})";
940 objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
941 EXPECT_EQ(objectData, nullptr);
942
943 // abnormal params of unexist key params
944 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
945 objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
946 EXPECT_EQ(objectData, nullptr);
947
948 // abnormal params of null params.sub-key
949 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
950 objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
951 EXPECT_EQ(objectData, nullptr);
952
953 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"state":10}})";
954 objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
955 EXPECT_EQ(objectData, nullptr);
956
957 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"state":"none"}})";
958 objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams());
959 ASSERT_NE(objectData, nullptr);
960 EXPECT_EQ(objectData->GetState(), PauseOnExceptionsState::NONE);
961 }
962
HWTEST_F_L0(DebuggerParamsTest,StepIntoParamsCreateTest)963 HWTEST_F_L0(DebuggerParamsTest, StepIntoParamsCreateTest)
964 {
965 std::string msg;
966 std::unique_ptr<StepIntoParams> objectData;
967
968 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakOnAsyncCall":10, "skipList":true}})";
969 objectData = StepIntoParams::Create(DispatchRequest(msg).GetParams());
970 EXPECT_EQ(objectData, nullptr);
971
972 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakOnAsyncCall":true,
973 "skipList":[{"scriptId":"1", "start":{"lineNumber":1, "columnNumber":10}, "end":{"lineNumber":2,
974 "columnNumber":20}}, {"scriptId":"2", "start":{"lineNumber":3, "columnNumber":30}, "end":{"lineNumber":4,
975 "columnNumber":40}}]}})";
976 objectData = StepIntoParams::Create(DispatchRequest(msg).GetParams());
977 ASSERT_NE(objectData, nullptr);
978 ASSERT_TRUE(objectData->GetBreakOnAsyncCall());
979 const std::list<std::unique_ptr<LocationRange>> *locationRangeList = objectData->GetSkipList();
980 EXPECT_EQ(locationRangeList->size(), 2U);
981 }
982
983
HWTEST_F_L0(DebuggerParamsTest,StepOverParamsCreateTest)984 HWTEST_F_L0(DebuggerParamsTest, StepOverParamsCreateTest)
985 {
986 std::string msg;
987 std::unique_ptr<StepOverParams> objectData;
988
989 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"skipList":true}})";
990 objectData = StepOverParams::Create(DispatchRequest(msg).GetParams());
991 EXPECT_EQ(objectData, nullptr);
992
993 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"skipList":[{"scriptId":"1",
994 "start":{"lineNumber":1, "columnNumber":10}, "end":{"lineNumber":2, "columnNumber":20}}, {"scriptId":"2",
995 "start":{"lineNumber":3, "columnNumber":30}, "end":{"lineNumber":4, "columnNumber":40}}]}})";
996 objectData = StepOverParams::Create(DispatchRequest(msg).GetParams());
997 ASSERT_NE(objectData, nullptr);
998 const std::list<std::unique_ptr<LocationRange>> *locationRangeList = objectData->GetSkipList();
999 EXPECT_EQ(locationRangeList->size(), 2U);
1000 }
1001
HWTEST_F_L0(DebuggerParamsTest,ReplyNativeCallingParamsCreateTest)1002 HWTEST_F_L0(DebuggerParamsTest, ReplyNativeCallingParamsCreateTest)
1003 {
1004 std::string msg;
1005 std::unique_ptr<ReplyNativeCallingParams> objectData;
1006
1007 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"userCode":"test"}})";
1008 objectData = ReplyNativeCallingParams::Create(DispatchRequest(msg).GetParams());
1009 EXPECT_EQ(objectData, nullptr);
1010
1011 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"userCode":true}})";
1012 objectData = ReplyNativeCallingParams::Create(DispatchRequest(msg).GetParams());
1013 ASSERT_NE(objectData, nullptr);
1014 ASSERT_TRUE(objectData->GetUserCode());
1015 }
1016
HWTEST_F_L0(DebuggerParamsTest,GetPropertiesParamsCreateTest)1017 HWTEST_F_L0(DebuggerParamsTest, GetPropertiesParamsCreateTest)
1018 {
1019 std::string msg;
1020 std::unique_ptr<GetPropertiesParams> objectData;
1021
1022 // abnormal params of null msg
1023 msg = std::string() + R"({})";
1024 objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
1025 EXPECT_EQ(objectData, nullptr);
1026
1027 // abnormal params of unexist key params
1028 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
1029 objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
1030 EXPECT_EQ(objectData, nullptr);
1031
1032 // abnormal params of null params.sub-key
1033 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
1034 objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
1035 EXPECT_EQ(objectData, nullptr);
1036
1037 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10, "ownProperties":1,
1038 "accessorPropertiesOnly":2, "generatePreview":3}})";
1039 objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
1040 EXPECT_EQ(objectData, nullptr);
1041
1042 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "ownProperties":true,
1043 "accessorPropertiesOnly":true, "generatePreview":true}})";
1044 objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams());
1045 ASSERT_NE(objectData, nullptr);
1046 EXPECT_EQ(objectData->GetObjectId(), 10);
1047 ASSERT_TRUE(objectData->GetOwnProperties());
1048 ASSERT_TRUE(objectData->GetAccessPropertiesOnly());
1049 ASSERT_TRUE(objectData->GetGeneratePreview());
1050 }
1051
HWTEST_F_L0(DebuggerParamsTest,CallFunctionOnParamsCreateTest)1052 HWTEST_F_L0(DebuggerParamsTest, CallFunctionOnParamsCreateTest)
1053 {
1054 std::string msg;
1055 std::unique_ptr<CallFunctionOnParams> objectData;
1056
1057 // abnormal params of null msg
1058 msg = std::string() + R"({})";
1059 objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1060 EXPECT_EQ(objectData, nullptr);
1061
1062 // abnormal params of unexist key params
1063 msg = std::string() + R"({"id":0,"method":"Debugger.Test"})";
1064 objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1065 EXPECT_EQ(objectData, nullptr);
1066
1067 // abnormal params of null params.sub-key
1068 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})";
1069 objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1070 EXPECT_EQ(objectData, nullptr);
1071
1072 msg = std::string() + R"({"id":0, "method":"Debugger.Test", "params":{"callFrameId":0, "functionDeclaration":true,
1073 "objectId":1, "arguments":[{"unserializableValue":1, "objectId":10}, {"unserializableValue":2, "objectId":20}],
1074 "silent":"true", "returnByValue":"true", "generatePreview":"true", "userGesture":"true",
1075 "awaitPromise":"true", "executionContextId":"1", "objectGroup":2, "throwOnSideEffect":"true"}})";
1076 objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1077 EXPECT_EQ(objectData, nullptr);
1078
1079 msg = std::string() + R"({"id":0, "method":"Debugger.Test", "params":{"callFrameId":"0",
1080 "functionDeclaration":"testFunction", "objectId":"1",
1081 "arguments":[{"unserializableValue":"testValue1", "objectId":"10"},
1082 {"unserializableValue":"testValue2", "objectId":"20"}], "silent":true, "returnByValue":true,
1083 "generatePreview":true, "userGesture":true, "awaitPromise":true, "executionContextId":1,
1084 "objectGroup":"testGrp", "throwOnSideEffect":true}})";
1085 objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams());
1086 ASSERT_NE(objectData, nullptr);
1087 EXPECT_EQ(objectData->GetCallFrameId(), 0);
1088 EXPECT_EQ(objectData->GetFunctionDeclaration(), "testFunction");
1089 EXPECT_EQ(objectData->GetObjectId(), 1);
1090 const std::vector<std::unique_ptr<CallArgument>> *callArgument = objectData->GetArguments();
1091 EXPECT_EQ(callArgument->size(), 2U);
1092 ASSERT_TRUE(objectData->GetSilent());
1093 ASSERT_TRUE(objectData->GetReturnByValue());
1094 ASSERT_TRUE(objectData->GetGeneratePreview());
1095 ASSERT_TRUE(objectData->GetUserGesture());
1096 ASSERT_TRUE(objectData->GetAwaitPromise());
1097 EXPECT_EQ(objectData->GetExecutionContextId(), 1);
1098 EXPECT_EQ(objectData->GetObjectGroup(), "testGrp");
1099 ASSERT_TRUE(objectData->GetThrowOnSideEffect());
1100 }
1101
HWTEST_F_L0(DebuggerParamsTest,ResetSingleStepperParamsCreateTest)1102 HWTEST_F_L0(DebuggerParamsTest, ResetSingleStepperParamsCreateTest)
1103 {
1104 std::string msg;
1105 std::unique_ptr<ResetSingleStepperParams> objectData;
1106
1107 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"resetSingleStepper":"test"}})";
1108 objectData = ResetSingleStepperParams::Create(DispatchRequest(msg).GetParams());
1109 EXPECT_EQ(objectData, nullptr);
1110
1111 msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"resetSingleStepper":true}})";
1112 objectData = ResetSingleStepperParams::Create(DispatchRequest(msg).GetParams());
1113 ASSERT_NE(objectData, nullptr);
1114 ASSERT_TRUE(objectData->GetResetSingleStepper());
1115 }
1116 } // namespace panda::test