1 /* 2 * Copyright (c) 2025 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 <gtest/gtest.h> 17 #include <string> 18 19 #include "json_parser.h" 20 #include "util.h" 21 22 namespace OHOS { 23 namespace MMI { 24 namespace { 25 using namespace testing::ext; 26 using namespace OHOS; 27 } // namespace 28 29 class JsonParserTest : public testing::Test { 30 public: SetUpTestCase(void)31 static void SetUpTestCase(void) {} TearDownTestCase(void)32 static void TearDownTestCase(void) {} 33 }; 34 35 /** 36 * @tc.name:IsIntegerTest_001 37 * @tc.desc:Verify JsonParser 38 * @tc.type: FUNC 39 * @tc.require: 40 */ 41 HWTEST_F(JsonParserTest, IsInteger_001, TestSize.Level1) 42 { 43 JsonParser parser(nullptr); 44 EXPECT_FALSE(JsonParser::IsInteger(parser.Get())); 45 } 46 47 /** 48 * @tc.name:JsonParserTest_001 49 * @tc.desc:Verify JsonParser 50 * @tc.type: FUNC 51 * @tc.require: 52 */ 53 HWTEST_F(JsonParserTest, JsonParser_001, TestSize.Level1) 54 { 55 JsonParser parser(R"({"Hello": 1})"); 56 JsonParser parser1(R"({"Hello": 2})"); 57 parser1 = std::move(parser); 58 auto json = parser1.Get(); 59 EXPECT_NE(json, nullptr); 60 } 61 62 /** 63 * @tc.name:JsonParserTest_002 64 * @tc.desc:Verify JsonParser 65 * @tc.type: FUNC 66 * @tc.require: 67 */ 68 HWTEST_F(JsonParserTest, JsonParser_002, TestSize.Level1) 69 { 70 JsonParser parser(R"({"Hello": 1})"); 71 JsonParser parser1 = std::move(parser); 72 auto json = parser1.Get(); 73 EXPECT_NE(json, nullptr); 74 } 75 76 /** 77 * @tc.name:ParseInt_001 78 * @tc.desc:Verify ParseInt 79 * @tc.type: FUNC 80 * @tc.require: 81 */ 82 HWTEST_F(JsonParserTest, ParseInt_001, TestSize.Level1) 83 { 84 std::string jsonData = R"({"Hello": 1})"; 85 JsonParser parser(jsonData.c_str()); 86 int32_t value; 87 EXPECT_EQ(JsonParser::ParseInt32(parser.Get(), "Hello", value), RET_OK); 88 } 89 90 /** 91 * @tc.name:ParseInt_002 92 * @tc.desc:Verify ParseInt 93 * @tc.type: FUNC 94 * @tc.require: 95 */ 96 HWTEST_F(JsonParserTest, ParseInt_002, TestSize.Level1) 97 { 98 std::string jsonData = R"({"Hello": "world"})"; 99 JsonParser parser(jsonData.c_str()); 100 int32_t value; 101 EXPECT_NE(JsonParser::ParseInt32(parser.Get(), "Hello", value), RET_OK); 102 } 103 104 /** 105 * @tc.name:ParseInt_003 106 * @tc.desc:Verify ParseInt 107 * @tc.type: FUNC 108 * @tc.require: 109 */ 110 HWTEST_F(JsonParserTest, ParseInt_003, TestSize.Level1) 111 { 112 std::string jsonData = R"({"integer": 42.13})"; 113 JsonParser parser(jsonData.c_str()); 114 int32_t value; 115 EXPECT_NE(JsonParser::ParseInt32(parser.Get(), "integer", value), RET_OK); 116 } 117 118 /** 119 * @tc.name:ParseInt_004 120 * @tc.desc:Verify ParseInt 121 * @tc.type: FUNC 122 * @tc.require: 123 */ 124 HWTEST_F(JsonParserTest, ParseInt_004, TestSize.Level1) 125 { 126 std::string jsonData = R"({"integer": 21474836480})"; 127 JsonParser parser(jsonData.c_str()); 128 int32_t value; 129 EXPECT_EQ(JsonParser::ParseInt32(parser.Get(), "integer", value), RET_OK); 130 } 131 132 /** 133 * @tc.name:ParseString_001 134 * @tc.desc:Verify ParseString 135 * @tc.type: FUNC 136 * @tc.require: 137 */ 138 HWTEST_F(JsonParserTest, ParseString_001, TestSize.Level1) 139 { 140 std::string jsonData = R"({"Hello": "Hello World"})"; 141 JsonParser parser(jsonData.c_str()); 142 std::string value; 143 EXPECT_EQ(JsonParser::ParseString(parser.Get(), "Hello", value), RET_OK); 144 } 145 146 /** 147 * @tc.name:ParseString_002 148 * @tc.desc:Verify ParseString 149 * @tc.type: FUNC 150 * @tc.require: 151 */ 152 HWTEST_F(JsonParserTest, ParseString_002, TestSize.Level1) 153 { 154 std::string jsonData = R"({"Hello": 1})"; 155 JsonParser parser(jsonData.c_str()); 156 std::string value; 157 EXPECT_NE(JsonParser::ParseString(parser.Get(), "Hello", value), RET_OK); 158 } 159 160 /** 161 * @tc.name:ParseStringArray_001 162 * @tc.desc:Verify ParseStringArray 163 * @tc.type: FUNC 164 * @tc.require: 165 */ 166 HWTEST_F(JsonParserTest, ParseStringArray_001, TestSize.Level1) 167 { 168 std::string jsonData = R"({"Hello": ["a", "b", "c"]})"; 169 JsonParser parser(jsonData.c_str()); 170 std::vector<std::string> value; 171 EXPECT_EQ(JsonParser::ParseStringArray(parser.Get(), "Hello", value, 10), RET_OK); 172 } 173 174 /** 175 * @tc.name:ParseStringArray_002 176 * @tc.desc:Verify ParseStringArray 177 * @tc.type: FUNC 178 * @tc.require: 179 */ 180 HWTEST_F(JsonParserTest, ParseStringArray_002, TestSize.Level1) 181 { 182 std::string jsonData = R"({"Hello": "World"})"; 183 JsonParser parser(jsonData.c_str()); 184 std::vector<std::string> value; 185 EXPECT_NE(JsonParser::ParseStringArray(parser.Get(), "Hello", value, 10), RET_OK); 186 } 187 188 /** 189 * @tc.name:ParseStringArray_003 190 * @tc.desc:Verify ParseStringArray 191 * @tc.type: FUNC 192 * @tc.require: 193 */ 194 HWTEST_F(JsonParserTest, ParseStringArray_003, TestSize.Level1) 195 { 196 std::string jsonData = R"({"Hello": [1, 2, 3]})"; 197 JsonParser parser(jsonData.c_str()); 198 std::vector<std::string> value; 199 EXPECT_NE(JsonParser::ParseStringArray(parser.Get(), "Hello", value, 10), RET_OK); 200 } 201 202 /** 203 * @tc.name:ParseStringArray_004 204 * @tc.desc:Verify ParseStringArray 205 * @tc.type: FUNC 206 * @tc.require: 207 */ 208 HWTEST_F(JsonParserTest, ParseStringArray_004, TestSize.Level1) 209 { 210 std::string jsonData = R"({"Hello": ["a", "b", "c", "d"]})"; 211 JsonParser parser(jsonData.c_str()); 212 std::vector<std::string> value; 213 EXPECT_EQ(JsonParser::ParseStringArray(parser.Get(), "Hello", value, 2), RET_OK); 214 } 215 216 /** 217 * @tc.name:ParseBool_001 218 * @tc.desc:Verify ParseBool 219 * @tc.type: FUNC 220 * @tc.require: 221 */ 222 HWTEST_F(JsonParserTest, ParseBool_001, TestSize.Level1) 223 { 224 std::string jsonData = R"({"Boolean": true})"; 225 JsonParser parser(jsonData.c_str()); 226 bool value; 227 EXPECT_EQ(JsonParser::ParseBool(parser.Get(), "Boolean", value), RET_OK); 228 } 229 230 /** 231 * @tc.name:ParseBool_002 232 * @tc.desc:Verify ParseBool 233 * @tc.type: FUNC 234 * @tc.require: 235 */ 236 HWTEST_F(JsonParserTest, ParseBool_002, TestSize.Level1) 237 { 238 std::string jsonData = R"({"Boolean": "true"})"; 239 JsonParser parser(jsonData.c_str()); 240 bool value; 241 EXPECT_NE(JsonParser::ParseBool(parser.Get(), "Boolean", value), RET_OK); 242 } 243 244 } // namespace MMI 245 } // namespace OHOS