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 "ecmascript/tests/test_helper.h"
17 #include "tooling/base/pt_json.h"
18
19 using namespace panda::ecmascript::tooling;
20
21 namespace panda::test {
22 class PtJsonTest : public testing::Test {
23 public:
SetUpTestCase()24 static void SetUpTestCase()
25 {
26 GTEST_LOG_(INFO) << "SetUpTestCase";
27 }
28
TearDownTestCase()29 static void TearDownTestCase()
30 {
31 GTEST_LOG_(INFO) << "TearDownCase";
32 }
33
SetUp()34 void SetUp() override
35 {
36 }
37
TearDown()38 void TearDown() override
39 {
40 }
41 };
42
HWTEST_F_L0(PtJsonTest,FalseTest)43 HWTEST_F_L0(PtJsonTest, FalseTest)
44 {
45 std::string str = "false";
46 std::unique_ptr<PtJson> json = PtJson::Parse(str.c_str());
47 ASSERT_TRUE(json->IsBool());
48 EXPECT_FALSE(json->GetBool());
49 EXPECT_EQ(json->Stringify(), str);
50 json->ReleaseRoot();
51 }
52
HWTEST_F_L0(PtJsonTest,TrueTest)53 HWTEST_F_L0(PtJsonTest, TrueTest)
54 {
55 std::string str = "true";
56 std::unique_ptr<PtJson> json = PtJson::Parse(str.c_str());
57 ASSERT_TRUE(json->IsBool());
58 EXPECT_TRUE(json->GetBool());
59 EXPECT_EQ(json->Stringify(), str);
60 json->ReleaseRoot();
61 }
62
HWTEST_F_L0(PtJsonTest,IntTest)63 HWTEST_F_L0(PtJsonTest, IntTest)
64 {
65 std::string str = "100";
66 std::unique_ptr<PtJson> json = PtJson::Parse(str.c_str());
67 ASSERT_TRUE(json->IsNumber());
68 EXPECT_EQ(json->GetInt(), 100);
69 EXPECT_EQ(json->Stringify(), str);
70 json->ReleaseRoot();
71 }
72
HWTEST_F_L0(PtJsonTest,Int64Test)73 HWTEST_F_L0(PtJsonTest, Int64Test)
74 {
75 std::string str = "123456789012345";
76 std::unique_ptr<PtJson> json = PtJson::Parse(str.c_str());
77 ASSERT_TRUE(json->IsNumber());
78 EXPECT_EQ(json->GetInt64(), 123456789012345);
79 EXPECT_EQ(json->Stringify(), str);
80 json->ReleaseRoot();
81 }
82
HWTEST_F_L0(PtJsonTest,DoubleTest)83 HWTEST_F_L0(PtJsonTest, DoubleTest)
84 {
85 std::string str = "12345.6789";
86 std::unique_ptr<PtJson> json = PtJson::Parse(str.c_str());
87 ASSERT_TRUE(json->IsNumber());
88 EXPECT_EQ(json->GetDouble(), 12345.6789);
89 EXPECT_EQ(json->Stringify(), str);
90 json->ReleaseRoot();
91 }
92
HWTEST_F_L0(PtJsonTest,StringTest)93 HWTEST_F_L0(PtJsonTest, StringTest)
94 {
95 std::string str = "\"abcdefg\"";
96 std::unique_ptr<PtJson> json = PtJson::Parse(str.c_str());
97 ASSERT_TRUE(json->IsString());
98 EXPECT_EQ(json->GetString(), "abcdefg");
99 EXPECT_EQ(json->Stringify(), str);
100 json->ReleaseRoot();
101 }
102
HWTEST_F_L0(PtJsonTest,ArrayTest1)103 HWTEST_F_L0(PtJsonTest, ArrayTest1)
104 {
105 std::string str = "[\"a\",\"b\",200]";
106 std::unique_ptr<PtJson> json = PtJson::Parse(str.c_str());
107 ASSERT_TRUE(json->IsArray());
108 EXPECT_EQ(json->GetSize(), 3);
109 EXPECT_EQ(json->Get(0)->GetString(), "a");
110 EXPECT_EQ(json->Get(1)->GetString(), "b");
111 EXPECT_EQ(json->Get(2)->GetInt(), 200);
112 EXPECT_EQ(json->Stringify(), str);
113 json->ReleaseRoot();
114 }
115
HWTEST_F_L0(PtJsonTest,ArrayTest2)116 HWTEST_F_L0(PtJsonTest, ArrayTest2)
117 {
118 std::string str = "[\"a\",\"b\",200,10.5,{}]";
119 std::unique_ptr<PtJson> json = PtJson::Parse(str.c_str());
120 ASSERT_TRUE(json->IsArray());
121 EXPECT_EQ(json->GetSize(), 5);
122 EXPECT_EQ(json->Get(0)->GetString(), "a");
123 EXPECT_EQ(json->Get(1)->GetString(), "b");
124 EXPECT_EQ(json->Get(2)->GetInt(), 200);
125 EXPECT_EQ(json->Get(3)->GetDouble(), 10.5);
126 EXPECT_TRUE(json->Get(4)->IsObject());
127 EXPECT_EQ(json->Stringify(), str);
128 json->ReleaseRoot();
129 }
130
HWTEST_F_L0(PtJsonTest,ObjectTest)131 HWTEST_F_L0(PtJsonTest, ObjectTest)
132 {
133 auto child1 = PtJson::CreateObject();
134 child1->Add("ch", "child_1");
135 ASSERT_TRUE(child1->Contains("ch"));
136
137 auto child2 = PtJson::CreateObject();
138 child2->Add("ch", "child_2");
139 ASSERT_TRUE(child2->Contains("ch"));
140
141 auto arr = PtJson::CreateArray();
142 arr->Push(100);
143 EXPECT_EQ(arr->GetSize(), 1);
144
145 auto root = PtJson::CreateObject();
146 root->Add("a", false);
147 root->Add("b", 100);
148 root->Add("c", 100.2);
149 root->Add("d", static_cast<int64_t>(200));
150 root->Add("e", "abc");
151 root->Add("f", child2);
152 root->Add("g", arr);
153
154 bool b;
155 int32_t i32;
156 int64_t i64;
157 double d;
158 std::string str;
159 std::unique_ptr<PtJson> json;
160 ASSERT_EQ(root->GetBool("a", &b), Result::SUCCESS);
161 EXPECT_FALSE(b);
162 ASSERT_EQ(root->GetInt("b", &i32), Result::SUCCESS);
163 EXPECT_EQ(i32, 100);
164 ASSERT_EQ(root->GetDouble("c", &d), Result::SUCCESS);
165 EXPECT_EQ(d, 100.2);
166 ASSERT_EQ(root->GetInt64("d", &i64), Result::SUCCESS);
167 EXPECT_EQ(i64, static_cast<int64_t>(200));
168 ASSERT_EQ(root->GetString("e", &str), Result::SUCCESS);
169 EXPECT_EQ(str, "abc");
170 ASSERT_EQ(root->GetObject("f", &json), Result::SUCCESS);
171 ASSERT_EQ(json->GetString("ch", &str), Result::SUCCESS);
172 EXPECT_EQ(str, "child_2");
173 ASSERT_EQ(root->GetArray("g", &json), Result::SUCCESS);
174 ASSERT_TRUE(json->IsArray());
175 EXPECT_EQ(json->Get(0)->GetInt(), 100);
176
177 EXPECT_EQ(root->Stringify(),
178 "{\"a\":false,\"b\":100,\"c\":100.2,\"d\":200,\"e\":\"abc\",\"f\":{\"ch\":\"child_2\"},\"g\":[100]}");
179 root->ReleaseRoot();
180 }
181
HWTEST_F_L0(PtJsonTest,StringifyTest)182 HWTEST_F_L0(PtJsonTest, StringifyTest)
183 {
184 PtJson ptJson;
185 std::string result = ptJson.Stringify();
186 ASSERT_EQ(result, "");
187 }
188
HWTEST_F_L0(PtJsonTest,GetKeyTest)189 HWTEST_F_L0(PtJsonTest, GetKeyTest)
190 {
191 PtJson ptJson;
192 std::string result = ptJson.GetKey();
193 ASSERT_EQ(result, "");
194 cJSON temp;
195 char test[] = "test";
196 temp.string = test;
197 PtJson ptJson1(&temp);
198 result = ptJson1.GetKey();
199 ASSERT_EQ(result, "test");
200 cJSON temp1;
201 temp1.string = nullptr;
202 PtJson ptJson2(&temp1);
203 result = ptJson2.GetKey();
204 ASSERT_EQ(result, "");
205 std::unique_ptr<PtJson> ptr = std::make_unique<PtJson>();
206 Result result1 = ptJson.GetAny(test, &ptr);
207 ASSERT_EQ(result1, Result::NOT_EXIST);
208 cJSON json;
209 cJSON son;
210 son.string = test;
211 json.string = test;
212 json.child = &son;
213 PtJson ptJson3(&json);
214 std::unique_ptr<PtJson> ptr1 = std::make_unique<PtJson>();
215 result1 = ptJson3.GetAny(test, &ptr1);
216 ASSERT_EQ(result1, Result::SUCCESS);
217 }
218
HWTEST_F_L0(PtJsonTest,GetTypeTest)219 HWTEST_F_L0(PtJsonTest, GetTypeTest)
220 {
221 cJSON *node = cJSON_CreateNumber(0);
222 PtJson num(node);
223 cJSON *node1 = cJSON_CreateString("test");
224 PtJson str(node1);
225 bool result = str.GetBool(false);
226 ASSERT_EQ(result, false);
227 int32_t result1 = str.GetInt(int32_t(0));
228 ASSERT_EQ(result1, 0);
229 int64_t result2 = str.GetInt64(int64_t(0));
230 ASSERT_EQ(result2, 0);
231 double result3 = str.GetDouble(0.1); // 0.1:num
232 ASSERT_EQ(result3, 0.1); // 0.1:num
233 std::string result4 = num.GetString();
234 ASSERT_EQ(result4, "");
235 }
236
HWTEST_F_L0(PtJsonTest,PushTest)237 HWTEST_F_L0(PtJsonTest, PushTest)
238 {
239 char *ptr = nullptr;
240 PtJson ptJson;
241 bool result = ptJson.Push(ptr);
242 ASSERT_EQ(result, false);
243 char cPtr[] = "value";
244 result = ptJson.Push(cPtr);
245 ASSERT_EQ(result, false);
246 bool value = true;
247 result = ptJson.Push(value);
248 ASSERT_EQ(result, false);
249 double value1 = 0.1; // 0.1:value
250 result = ptJson.Push(value1);
251 ASSERT_EQ(result, false);
252 std::unique_ptr<PtJson> ptr1;
253 result = ptJson.Push(std::move(ptr1));
254 ASSERT_EQ(result, false);
255 std::unique_ptr<PtJson> ptr2 = std::make_unique<PtJson>();
256 result = ptJson.Push(std::move(ptr2));
257 ASSERT_EQ(result, false);
258 cJSON json;
259 std::unique_ptr<PtJson> ptr3 = std::make_unique<PtJson>(&json);
260 result = ptJson.Push(std::move(ptr3));
261 ASSERT_EQ(result, false);
262 }
263
HWTEST_F_L0(PtJsonTest,AddTest)264 HWTEST_F_L0(PtJsonTest, AddTest)
265 {
266 char key[] = "key";
267 double value = 0.1; // 0.1:value
268 PtJson ptJson;
269 bool result = ptJson.Add(key, value);
270 ASSERT_EQ(result, false);
271 char value1[] = "value";
272 result = ptJson.Add(key, value1);
273 ASSERT_EQ(result, false);
274 std::unique_ptr<PtJson> ptr = std::make_unique<PtJson>();
275 result = ptJson.Add(key, std::move(ptr));
276 ASSERT_EQ(result, false);
277 cJSON json;
278 std::unique_ptr<PtJson> ptr1 = std::make_unique<PtJson>(&json);
279 result = ptJson.Add(key, std::move(ptr1));
280 ASSERT_EQ(result, false);
281 bool value2 = true;
282 result = ptJson.Add(key, value2);
283 ASSERT_EQ(result, false);
284 }
285 }