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
20using namespace panda::ecmascript;
21using namespace panda::ecmascript::tooling;
22
23namespace panda::test {
24class PtParamsTest : public testing::Test {
25public:
26    static void SetUpTestCase()
27    {
28        GTEST_LOG_(INFO) << "SetUpTestCase";
29    }
30
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
46protected:
47    EcmaVM *ecmaVm {nullptr};
48    EcmaHandleScope *scope {nullptr};
49    JSThread *thread {nullptr};
50};
51
52HWTEST_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
61HWTEST_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
75HWTEST_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
92HWTEST_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
104HWTEST_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
117HWTEST_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
136HWTEST_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
155HWTEST_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
167HWTEST_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
179HWTEST_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
188HWTEST_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
197HWTEST_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
206HWTEST_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
220HWTEST_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
248HWTEST_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
258HWTEST_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