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