1 /*
2  * Copyright (c) 2022 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_params.h"
17 #include "ecmascript/tests/test_helper.h"
18 #include "protocol_handler.h"
19 
20 using namespace panda::ecmascript;
21 using namespace panda::ecmascript::tooling;
22 
23 namespace panda::test {
24 class PtParamsTest : public testing::Test {
25 public:
SetUpTestCase()26     static void SetUpTestCase()
27     {
28         GTEST_LOG_(INFO) << "SetUpTestCase";
29     }
30 
TearDownTestCase()31     static void TearDownTestCase()
32     {
33         GTEST_LOG_(INFO) << "TearDownCase";
34     }
35 
36     void SetUp() override
37     {
38         TestHelper::CreateEcmaVMWithScope(ecmaVm, thread, scope);
39     }
40 
41     void TearDown() override
42     {
43         TestHelper::DestroyEcmaVMWithScope(ecmaVm, scope);
44     }
45 
46 protected:
47     EcmaVM *ecmaVm {nullptr};
48     EcmaHandleScope *scope {nullptr};
49     JSThread *thread {nullptr};
50 };
51 
HWTEST_F_L0(PtParamsTest, EnableParamsCreateTest)52 HWTEST_F_L0(PtParamsTest, EnableParamsCreateTest)
53 {
54     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
55     std::string attribute = "test";
56     ptJson->Add("maxScriptsCacheSize", attribute.c_str());
57     std::unique_ptr<EnableParams> result = EnableParams::Create(*ptJson);
58     ASSERT_TRUE(result == nullptr);
59 }
60 
HWTEST_F_L0(PtParamsTest, EvaluateOnCallFrameParamsCreateTest)61 HWTEST_F_L0(PtParamsTest, EvaluateOnCallFrameParamsCreateTest)
62 {
63     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
64     std::string attribute = "test";
65     ptJson->Add("objectGroup", 0);
66     ptJson->Add("includeCommandLineAPI", attribute.c_str());
67     ptJson->Add("silent", attribute.c_str());
68     ptJson->Add("returnByValue", attribute.c_str());
69     ptJson->Add("generatePreview", attribute.c_str());
70     ptJson->Add("throwOnSideEffect", attribute.c_str());
71     std::unique_ptr<EvaluateOnCallFrameParams> result = EvaluateOnCallFrameParams::Create(*ptJson);
72     ASSERT_TRUE(result == nullptr);
73 }
74 
HWTEST_F_L0(PtParamsTest, GetPossibleBreakpointsParamsCreateTest)75 HWTEST_F_L0(PtParamsTest, GetPossibleBreakpointsParamsCreateTest)
76 {
77     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
78     std::unique_ptr<PtJson>  start = PtJson::CreateObject();
79     std::unique_ptr<PtJson> ptJson1 = PtJson::CreateObject();
80     std::unique_ptr<PtJson>  end = PtJson::CreateObject();
81     std::string attribute = "test";
82     ptJson->Add("start", start);
83     ptJson->Add("end", end);
84     std::unique_ptr<GetPossibleBreakpointsParams> result = GetPossibleBreakpointsParams::Create(*ptJson);
85     ASSERT_TRUE(result == nullptr);
86     ptJson1->Add("end", attribute.c_str());
87     ptJson1->Add("restrictToFunction", attribute.c_str());
88     std::unique_ptr<GetPossibleBreakpointsParams> result1 = GetPossibleBreakpointsParams::Create(*ptJson1);
89     ASSERT_TRUE(result1 == nullptr);
90 }
91 
HWTEST_F_L0(PtParamsTest, ResumeParamsCreateTest)92 HWTEST_F_L0(PtParamsTest, ResumeParamsCreateTest)
93 {
94     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
95     std::unique_ptr<PtJson> ptJson1 = PtJson::CreateObject();
96     std::string attribute = "test";
97     ptJson->Add("terminateOnResume", attribute.c_str());
98     std::unique_ptr<ResumeParams> result = ResumeParams::Create(*ptJson);
99     ASSERT_TRUE(result == nullptr);
100     std::unique_ptr<ResumeParams> result1 = ResumeParams::Create(*ptJson1);
101     ASSERT_TRUE(result == nullptr);
102 }
103 
HWTEST_F_L0(PtParamsTest, SetBlackboxPatternsParamsCreateTest)104 HWTEST_F_L0(PtParamsTest, SetBlackboxPatternsParamsCreateTest)
105 {
106     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
107     std::unique_ptr<PtJson> array = PtJson::CreateArray();
108     std::string attribute = "test";
109     array->Push(128);
110     array->Push(true);
111     array->Push(attribute.c_str());
112     ptJson->Add("patterns", array);
113     std::unique_ptr<SetBlackboxPatternsParams> result = SetBlackboxPatternsParams::Create(*ptJson);
114     ASSERT_TRUE(result == nullptr);
115 }
116 
HWTEST_F_L0(PtParamsTest, StepIntoParamsCreateTest)117 HWTEST_F_L0(PtParamsTest, StepIntoParamsCreateTest)
118 {
119     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
120     std::unique_ptr<PtJson> ptJson1 = PtJson::CreateObject();
121     std::unique_ptr<PtJson> array = PtJson::CreateArray();
122     std::unique_ptr<PtJson> scriptId = PtJson::CreateObject();
123     std::unique_ptr<PtJson> end = PtJson::CreateObject();
124     std::string attribute = "test";
125     scriptId->Add("scriptId", 123);
126     end->Add("end", 123);
127     array->Push(scriptId);
128     array->Push(end);
129     ptJson->Add("skipList", array);
130     std::unique_ptr<StepIntoParams> result = StepIntoParams::Create(*ptJson);
131     ASSERT_TRUE(result == nullptr);
132     std::unique_ptr<StepIntoParams> result1 = StepIntoParams::Create(*ptJson1);
133     ASSERT_TRUE(result1 != nullptr);
134 }
135 
HWTEST_F_L0(PtParamsTest, StepOverParamsCreateTest)136 HWTEST_F_L0(PtParamsTest, StepOverParamsCreateTest)
137 {
138     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
139     std::unique_ptr<PtJson> ptJson1 = PtJson::CreateObject();
140     std::unique_ptr<PtJson> array = PtJson::CreateArray();
141     std::unique_ptr<PtJson> scriptId = PtJson::CreateObject();
142     std::unique_ptr<PtJson> end = PtJson::CreateObject();
143     std::string attribute = "test";
144     scriptId->Add("scriptId", 123);
145     end->Add("end", 123);
146     array->Push(scriptId);
147     array->Push(end);
148     ptJson->Add("skipList", array);
149     std::unique_ptr<StepOverParams> result = StepOverParams::Create(*ptJson);
150     ASSERT_TRUE(result == nullptr);
151     std::unique_ptr<StepOverParams> result1 = StepOverParams::Create(*ptJson1);
152     ASSERT_TRUE(result1 != nullptr);
153 }
154 
HWTEST_F_L0(PtParamsTest, SetMixedDebugParamsCreateTest)155 HWTEST_F_L0(PtParamsTest, SetMixedDebugParamsCreateTest)
156 {
157     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
158     std::unique_ptr<PtJson> ptJson1 = PtJson::CreateObject();
159     std::string attribute = "test";
160     ptJson->Add("enabled", attribute.c_str());
161     std::unique_ptr<SetMixedDebugParams> result = SetMixedDebugParams::Create(*ptJson);
162     ASSERT_TRUE(result == nullptr);
163     std::unique_ptr<SetMixedDebugParams> result1 = SetMixedDebugParams::Create(*ptJson1);
164     ASSERT_TRUE(result == nullptr);
165 }
166 
HWTEST_F_L0(PtParamsTest, ReplyNativeCallingParamsCreateTest)167 HWTEST_F_L0(PtParamsTest, ReplyNativeCallingParamsCreateTest)
168 {
169     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
170     std::unique_ptr<PtJson> ptJson1 = PtJson::CreateObject();
171     std::string attribute = "test";
172     ptJson->Add("userCode", attribute.c_str());
173     std::unique_ptr<ReplyNativeCallingParams> result = ReplyNativeCallingParams::Create(*ptJson);
174     ASSERT_TRUE(result == nullptr);
175     std::unique_ptr<ReplyNativeCallingParams> result1 = ReplyNativeCallingParams::Create(*ptJson1);
176     ASSERT_TRUE(result == nullptr);
177 }
178 
HWTEST_F_L0(PtParamsTest, CallFunctionOnParamsCreateTest)179 HWTEST_F_L0(PtParamsTest, CallFunctionOnParamsCreateTest)
180 {
181     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
182     std::string attribute = "test";
183     ptJson->Add("arguments", attribute.c_str());
184     std::unique_ptr<CallFunctionOnParams> result = CallFunctionOnParams::Create(*ptJson);
185     ASSERT_TRUE(result == nullptr);
186 }
187 
HWTEST_F_L0(PtParamsTest, GetHeapObjectIdParamsCreateTest)188 HWTEST_F_L0(PtParamsTest, GetHeapObjectIdParamsCreateTest)
189 {
190     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
191     std::string attribute = "test";
192     ptJson->Add("arguments", attribute.c_str());
193     std::unique_ptr<GetHeapObjectIdParams> result = GetHeapObjectIdParams::Create(*ptJson);
194     ASSERT_TRUE(result != nullptr);
195 }
196 
HWTEST_F_L0(PtParamsTest, GetObjectByHeapObjectIdParamsCreateTest)197 HWTEST_F_L0(PtParamsTest, GetObjectByHeapObjectIdParamsCreateTest)
198 {
199     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
200     std::string attribute = "test";
201     ptJson->Add("arguments", attribute.c_str());
202     std::unique_ptr<GetObjectByHeapObjectIdParams> result = GetObjectByHeapObjectIdParams::Create(*ptJson);
203     ASSERT_TRUE(result != nullptr);
204 }
205 
HWTEST_F_L0(PtParamsTest, RequestMemoryDumpParamsCreateTest)206 HWTEST_F_L0(PtParamsTest, RequestMemoryDumpParamsCreateTest)
207 {
208     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
209     std::unique_ptr<PtJson> ptJson1 = PtJson::CreateObject();
210     std::string attribute = "test";
211     ptJson->Add("deterministic", attribute.c_str());
212     ptJson->Add("levelOfDetail", attribute.c_str());
213     std::unique_ptr<RequestMemoryDumpParams> result = RequestMemoryDumpParams::Create(*ptJson);
214     ASSERT_TRUE(result == nullptr);
215     ptJson1->Add("levelOfDetail", 0);
216     std::unique_ptr<RequestMemoryDumpParams> result1 = RequestMemoryDumpParams::Create(*ptJson1);
217     ASSERT_TRUE(result1 == nullptr);
218 }
219 
HWTEST_F_L0(PtParamsTest, StartParamsCreateTest)220 HWTEST_F_L0(PtParamsTest, StartParamsCreateTest)
221 {
222     std::unique_ptr<PtJson> ptJson = PtJson::CreateObject();
223     std::unique_ptr<PtJson> ptJson1 = PtJson::CreateObject();
224     std::unique_ptr<PtJson> traceConfig = PtJson::CreateObject();
225     std::string attribute = "test";
226     ptJson->Add("categories", 0);
227     ptJson->Add("options", 0);
228     ptJson->Add("bufferUsageReportingInterval", attribute.c_str());
229     ptJson->Add("transferMode", 0);
230     ptJson->Add("streamFormat", 0);
231     ptJson->Add("streamCompression", 0);
232     ptJson->Add("traceConfig", 0);
233     ptJson->Add("perfettoConfig", 0);
234     ptJson->Add("tracingBackend", 0);
235     std::unique_ptr<StartParams> result = StartParams::Create(*ptJson);
236     ASSERT_TRUE(result == nullptr);
237     ptJson1->Add("transferMode", attribute.c_str());
238     ptJson1->Add("streamFormat", attribute.c_str());
239     ptJson1->Add("streamCompression", attribute.c_str());
240     traceConfig->Add("recordMode", 0);
241     ptJson1->Add("traceConfig", traceConfig);
242     ptJson1->Add("tracingBackend", attribute.c_str());
243 
244     std::unique_ptr<StartParams> result1 = StartParams::Create(*ptJson1);
245     ASSERT_TRUE(result1 == nullptr);
246 }
247 
HWTEST_F_L0(PtParamsTest, AddRequireParamsTest)248 HWTEST_F_L0(PtParamsTest, AddRequireParamsTest)
249 {
250     std::string msg;
251     std::unique_ptr<SmartStepIntoParams> smartStepIntoParams;
252 
253     msg = std::string() + R"({})";
254     smartStepIntoParams = SmartStepIntoParams::Create(DispatchRequest(msg).GetParams());
255     EXPECT_EQ(smartStepIntoParams, nullptr);
256 }
257 
HWTEST_F_L0(PtParamsTest, SeriliazationTimeoutCheckEnableParamsCreateTest)258 HWTEST_F_L0(PtParamsTest, SeriliazationTimeoutCheckEnableParamsCreateTest)
259 {
260     std::string msg;
261     std::unique_ptr<SeriliazationTimeoutCheckEnableParams> seriliazationParams;
262 
263     msg = std::string() + R"({})";
264     seriliazationParams = SeriliazationTimeoutCheckEnableParams::Create(DispatchRequest(msg).GetParams());
265     EXPECT_EQ(seriliazationParams, nullptr);
266 
267     msg = std::string() + R"({"id":0,"method":"PtParams.Test","params":{"threshold":2}})";
268     seriliazationParams = SeriliazationTimeoutCheckEnableParams::Create(DispatchRequest(msg).GetParams());
269     ASSERT_TRUE(seriliazationParams != nullptr);
270 }
271 }  // namespace panda::test