1 /* 2 * Copyright (c) 2021-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 "gtest/gtest.h" 17 18 #define private public 19 #define protected public 20 #include "base/json/uobject.h" 21 22 using namespace testing; 23 using namespace testing::ext; 24 25 namespace OHOS::Ace { 26 namespace {} // namespace 27 28 class UObjectTest : public testing::Test {}; 29 30 /** 31 * @tc.name: UObjectTest001 32 * @tc.desc: AddItemToObject() 33 * @tc.type: FUNC 34 */ 35 HWTEST_F(UObjectTest, UObjectTest001, TestSize.Level1) 36 { 37 /** 38 * @tc.steps: step1. Create a UOObject. 39 */ 40 UObject uObject; 41 42 /** 43 * @tc.steps: step2. Save value through AdditemToObject. 44 * @tc.expected: step2. Asserting values through the get method. 45 */ 46 char* value = nullptr; 47 uObject.AddItemToObject("char", value); 48 EXPECT_EQ(uObject.stringItems_.size(), 0); 49 std::string stringValue = "test"; 50 uObject.AddItemToObject("char", const_cast<char*>(stringValue.c_str())); 51 EXPECT_EQ(uObject.GetString("char"), "test"); 52 53 stringValue = "test1"; 54 uObject.AddItemToObject("string", stringValue); 55 EXPECT_EQ(uObject.GetString("invalidKey"), ""); 56 EXPECT_EQ(uObject.GetString("string"), "test1"); 57 58 double doubleValue = 1.0; 59 uObject.AddItemToObject("double", doubleValue); 60 EXPECT_EQ(uObject.GetDouble("invalidKey"), 0); 61 EXPECT_EQ(uObject.GetDouble("double"), 1.0); 62 63 size_t sizeValue = 10; 64 uObject.AddItemToObject("size_t", sizeValue); 65 EXPECT_EQ(uObject.GetSizeT("invalidKey"), 0); 66 EXPECT_EQ(uObject.GetSizeT("size_t"), 10); 67 EXPECT_EQ(uObject.GetSizeT("double"), 1); 68 69 int32_t int32Value = 5; 70 uObject.AddItemToObject("int32_t", int32Value); 71 EXPECT_EQ(uObject.GetInt32("invalidKey"), 0); 72 EXPECT_EQ(uObject.GetInt32("int32_t"), 5); 73 EXPECT_EQ(uObject.GetInt32("double"), 1); 74 75 int64_t int64Value = 1; 76 uObject.AddItemToObject("int64_t", int64Value); 77 EXPECT_EQ(uObject.GetInt64("invalidKey"), 0); 78 EXPECT_EQ(uObject.GetInt64("int64_t"), 1); 79 EXPECT_EQ(uObject.GetInt64("double"), 1); 80 81 bool boolValue = false; 82 uObject.AddItemToObject("bool", boolValue); 83 EXPECT_EQ(uObject.GetBool("invalidKey"), false); 84 EXPECT_EQ(uObject.GetBool("bool"), false); 85 86 std::shared_ptr<UObject> sharedUObject = std::make_shared<UObject>(); 87 uObject.AddItemToObject("shared_ptr", sharedUObject); 88 EXPECT_TRUE(uObject.GetObject("invalidKey")); 89 EXPECT_TRUE(uObject.GetObject("shared_ptr")); 90 91 /** 92 * @tc.steps: step3. Contains() test. 93 * @tc.expected: step3. Asserting return bool. 94 */ 95 EXPECT_FALSE(uObject.Contains("invalidKey")); 96 EXPECT_TRUE(uObject.Contains("string")); 97 EXPECT_TRUE(uObject.Contains("double")); 98 EXPECT_TRUE(uObject.Contains("size_t")); 99 EXPECT_TRUE(uObject.Contains("int32_t")); 100 EXPECT_TRUE(uObject.Contains("int64_t")); 101 EXPECT_TRUE(uObject.Contains("bool")); 102 EXPECT_TRUE(uObject.Contains("shared_ptr")); 103 } 104 105 /** 106 * @tc.name: UObjectTest002 107 * @tc.desc: Serialize() 108 * @tc.type: FUNC 109 */ 110 HWTEST_F(UObjectTest, UObjectTest002, TestSize.Level1) 111 { 112 /** 113 * @tc.steps: step1. Create a UOObject. 114 */ 115 UObject uObject; 116 std::string stringValue = "test"; 117 uObject.AddItemToObject("char", const_cast<char*>(stringValue.c_str())); 118 stringValue = "test1"; 119 uObject.AddItemToObject("string", stringValue); 120 double doubleValue = 1.0; 121 uObject.AddItemToObject("double", doubleValue); 122 size_t sizeValue = 10; 123 uObject.AddItemToObject("size_t", sizeValue); 124 int32_t int32Value = 5; 125 uObject.AddItemToObject("int32_t", int32Value); 126 int64_t int64Value = 1; 127 uObject.AddItemToObject("int64_t", int64Value); 128 bool boolValue = false; 129 uObject.AddItemToObject("bool", boolValue); 130 std::shared_ptr<UObject> sharedUObject = std::make_shared<UObject>(); 131 uObject.AddItemToObject("shared_ptr", sharedUObject); 132 133 /** 134 * @tc.steps: step2. Serialize() 135 * @tc.expected: step2. Asserting values through the get method. 136 */ 137 uObject.Hash(); 138 139 char* buffer = nullptr; 140 uObject.Serialize(buffer, 0); 141 EXPECT_EQ(uObject.offset_, 0); 142 buffer = new char[136]; 143 uObject.Serialize(buffer, 136); 144 EXPECT_EQ(uObject.offset_, 136); 145 146 /** 147 * @tc.steps: step3. Deserialize() test. 148 * @tc.expected: step3. Asserting offset_. 149 */ 150 uObject.Deserialize(buffer, 136); 151 EXPECT_EQ(uObject.offset_, 136); 152 153 /** 154 * @tc.steps: step4. delete buffer. 155 */ 156 delete[] buffer; 157 buffer = nullptr; 158 } 159 160 /** 161 * @tc.name: UObjectTest003 162 * @tc.desc: Serialize() 163 * @tc.type: FUNC 164 */ 165 HWTEST_F(UObjectTest, UObjectTest003, TestSize.Level1) 166 { 167 UObject uObject; 168 std::string value = ""; 169 uObject.WriteString(value); 170 const char* buffer = nullptr; 171 int32_t bufferLen = 100; 172 uObject.Deserialize(buffer, bufferLen); 173 EXPECT_EQ(uObject.offset_, 0); 174 } 175 176 /** 177 * @tc.name: EstimateBufferSizeTest001 178 * @tc.desc: test empty UObject 179 * @tc.type: FUNC 180 */ 181 HWTEST_F(UObjectTest, EstimateBufferSizeTest001, TestSize.Level1) 182 { 183 UObject uObject; 184 int32_t ret = uObject.EstimateBufferSize(); 185 EXPECT_EQ(ret, static_cast<int32_t>(0)); 186 } 187 188 /** 189 * @tc.name: EstimateBufferSizeTest002 190 * @tc.desc: test string items 191 * @tc.type: FUNC 192 */ 193 HWTEST_F(UObjectTest, EstimateBufferSizeTest002, TestSize.Level1) 194 { 195 UObject uObject; 196 uObject.stringItems_["key"] = "value"; 197 size_t expectedSize = sizeof(uint8_t) + sizeof(int32_t) + strlen("key") + sizeof(int32_t) + strlen("value"); 198 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 199 uObject.stringItems_["key2"] = "value222"; 200 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("key2") + sizeof(int32_t) + strlen("value222"); 201 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 202 } 203 204 /** 205 * @tc.name: EstimateBufferSizeTest003 206 * @tc.desc: test sizet items 207 * @tc.type: FUNC 208 */ 209 HWTEST_F(UObjectTest, EstimateBufferSizeTest003, TestSize.Level1) 210 { 211 UObject uObject; 212 uObject.sizetItems_["size"] = 100; 213 size_t expectedSize = sizeof(uint8_t) + sizeof(int32_t) + strlen("size") + sizeof(size_t); 214 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 215 uObject.sizetItems_["sizeItem"] = 101; 216 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("sizeItem") + sizeof(size_t); 217 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 218 } 219 220 /** 221 * @tc.name: EstimateBufferSizeTest004 222 * @tc.desc: test int32 items 223 * @tc.type: FUNC 224 */ 225 HWTEST_F(UObjectTest, EstimateBufferSizeTest004, TestSize.Level1) 226 { 227 UObject uObject; 228 uObject.int32Items_["int32"] = -42; 229 size_t expectedSize = sizeof(uint8_t) + sizeof(int32_t) + strlen("int32") + sizeof(int32_t); 230 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 231 uObject.int32Items_["int32Item"] = -43; 232 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("int32Item") + sizeof(int32_t); 233 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 234 } 235 236 /** 237 * @tc.name: EstimateBufferSizeTest005 238 * @tc.desc: test int64 items 239 * @tc.type: FUNC 240 */ 241 HWTEST_F(UObjectTest, EstimateBufferSizeTest005, TestSize.Level1) 242 { 243 UObject uObject; 244 uObject.int64Items_["int64"] = 1LL << 40; 245 size_t expectedSize = sizeof(uint8_t) + sizeof(int32_t) + strlen("int64") + sizeof(int64_t); 246 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 247 uObject.int64Items_["int64Item"] = 1LL << 41; 248 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("int64Item") + sizeof(int64_t); 249 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 250 } 251 252 /** 253 * @tc.name: EstimateBufferSizeTest006 254 * @tc.desc: test double items 255 * @tc.type: FUNC 256 */ 257 HWTEST_F(UObjectTest, EstimateBufferSizeTest006, TestSize.Level1) 258 { 259 UObject uObject; 260 uObject.doubleItems_["pi"] = 3.14159; 261 size_t expectedSize = sizeof(uint8_t) + sizeof(int32_t) + strlen("pi") + sizeof(double); 262 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 263 uObject.doubleItems_["e"] = 2.71828; 264 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("e") + sizeof(double); 265 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 266 } 267 268 /** 269 * @tc.name: EstimateBufferSizeTest007 270 * @tc.desc: test bool items 271 * @tc.type: FUNC 272 */ 273 HWTEST_F(UObjectTest, EstimateBufferSizeTest007, TestSize.Level1) 274 { 275 UObject uObject; 276 uObject.boolItems_["flagTrue"] = true; 277 size_t expectedSize = sizeof(uint8_t) + sizeof(int32_t) + strlen("flagTrue") + sizeof(bool); 278 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 279 uObject.boolItems_["flagFalse"] = false; 280 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("flagFalse") + sizeof(bool); 281 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 282 } 283 284 /** 285 * @tc.name: EstimateBufferSizeTest008 286 * @tc.desc: test child 287 * @tc.type: FUNC 288 */ 289 HWTEST_F(UObjectTest, EstimateBufferSizeTest008, TestSize.Level1) 290 { 291 /** 292 * @tc.steps: step1. init UObject, child and expected size 293 * @tc.expected: step1. children not empty 294 */ 295 UObject uObject; 296 auto childUObject1 = std::make_shared<UObject>(); 297 EXPECT_NE(childUObject1, nullptr); 298 auto childUObject2 = std::make_shared<UObject>(); 299 EXPECT_NE(childUObject2, nullptr); 300 301 /** 302 * @tc.steps: step2. test children themselves 303 */ 304 childUObject1->int32Items_["c"] = 30; 305 size_t expectedChildSize1 = sizeof(uint8_t) + sizeof(int32_t) + strlen("c") + sizeof(int32_t); 306 EXPECT_EQ(childUObject1->EstimateBufferSize(), static_cast<int32_t>(expectedChildSize1)); 307 childUObject1->int32Items_["de"] = 31; 308 expectedChildSize1 += sizeof(uint8_t) + sizeof(int32_t) + strlen("de") + sizeof(int32_t); 309 EXPECT_EQ(childUObject1->EstimateBufferSize(), static_cast<int32_t>(expectedChildSize1)); 310 childUObject1->int32Items_["fgh"] = 32; 311 expectedChildSize1 += sizeof(uint8_t) + sizeof(int32_t) + strlen("fgh") + sizeof(int32_t); 312 EXPECT_EQ(childUObject1->EstimateBufferSize(), static_cast<int32_t>(expectedChildSize1)); 313 314 childUObject2->doubleItems_["e"] = 2.71828; 315 size_t expectedChildSize2 = sizeof(uint8_t) + sizeof(int32_t) + strlen("e") + sizeof(double); 316 EXPECT_EQ(childUObject2->EstimateBufferSize(), static_cast<int32_t>(expectedChildSize2)); 317 318 /** 319 * @tc.steps: step3. test children 320 */ 321 uObject.children_["obj01"] = childUObject1; 322 size_t expectedSize = sizeof(uint8_t) + sizeof(int32_t) + strlen("obj01") + sizeof(int32_t) + expectedChildSize1; 323 uObject.children_["obj2"] = childUObject2; 324 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("obj2") + sizeof(int32_t) + expectedChildSize2; 325 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 326 } 327 328 /** 329 * @tc.name: EstimateBufferSizeTest009 330 * @tc.desc: test different data types 331 * @tc.type: FUNC 332 */ 333 HWTEST_F(UObjectTest, EstimateBufferSizeTest009, TestSize.Level1) 334 { 335 /** 336 * @tc.steps: step1. init UObject and expected size 337 */ 338 UObject uObject; 339 size_t expectedSize = 0; 340 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 341 342 /** 343 * @tc.steps: step2. test string 344 */ 345 uObject.stringItems_["name"] = "Alice"; 346 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("name") + sizeof(int32_t) + strlen("Alice"); 347 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 348 349 /** 350 * @tc.steps: step3. test number 351 */ 352 uObject.sizetItems_["size"] = 100; 353 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("size") + sizeof(size_t); 354 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 355 uObject.int32Items_["int32"] = -42; 356 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("int32") + sizeof(int32_t); 357 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 358 uObject.int64Items_["int64"] = 1LL << 40; 359 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("int64") + sizeof(int64_t); 360 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 361 uObject.doubleItems_["pi"] = 3.14159; 362 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("pi") + sizeof(double); 363 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 364 365 /** 366 * @tc.steps: step4. test bool 367 */ 368 uObject.boolItems_["flag"] = true; 369 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("flag") + sizeof(bool); 370 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 371 372 /** 373 * @tc.steps: step5. test child 374 */ 375 auto childUObject = std::make_shared<UObject>(); 376 EXPECT_NE(childUObject, nullptr); 377 childUObject->int32Items_["c"] = 30; 378 size_t expectedChildSize = sizeof(uint8_t) + sizeof(int32_t) + strlen("c") + sizeof(int32_t); 379 EXPECT_EQ(childUObject->EstimateBufferSize(), static_cast<int32_t>(expectedChildSize)); 380 uObject.children_["obj"] = childUObject; 381 expectedSize += sizeof(uint8_t) + sizeof(int32_t) + strlen("obj") + sizeof(int32_t) + expectedChildSize; 382 EXPECT_EQ(uObject.EstimateBufferSize(), static_cast<int32_t>(expectedSize)); 383 } 384 } // namespace OHOS::Ace