1 /* 2 * Copyright (C) 2024 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 #include "json_helper.h" 19 20 using namespace testing::ext; 21 using namespace OHOS::Media::Effect; 22 23 namespace OHOS { 24 namespace Media { 25 namespace Effect { 26 namespace Test { 27 namespace { 28 constexpr char const *IMAGE_EFFECT = "imageEffect"; 29 constexpr char const *FILTERS = "filters"; 30 constexpr char const *NAME = "name"; 31 constexpr char const *BRIGHTNESS = "Brightness"; 32 constexpr char const *VALUES = "values"; 33 constexpr char const *FILTER_INTENSITY = "FilterIntensity"; 34 constexpr char const *CONTRAST = "Contrast"; 35 constexpr char const *IMAGE_EDIT = "imageEdit"; 36 constexpr char const *FLOAT_TEST = "FloatTest"; 37 constexpr char const *INT_TEST = "IntTest"; 38 constexpr char const *UINT_TEST = "UintTest"; 39 constexpr char const *DOUBLE_TEST = "DoubleTest"; 40 constexpr char const *BOOL_TEST = "BoolTest"; 41 constexpr char const *STRING_TEST = "StringTest"; 42 constexpr char const *TEST_STR = "testStr"; 43 } // namespace 44 45 class TestJsonHelper : public testing::Test { 46 public: 47 TestJsonHelper() = default; 48 49 ~TestJsonHelper() override = default; 50 SetUpTestCase()51 static void SetUpTestCase() {} 52 TearDownTestCase()53 static void TearDownTestCase() {} 54 SetUp()55 void SetUp() override 56 { 57 root_ = JsonHelper::CreateObject(); 58 } 59 TearDown()60 void TearDown() override 61 { 62 root_ = nullptr; 63 } 64 65 EffectJsonPtr root_; 66 }; 67 68 HWTEST_F(TestJsonHelper, Parse001, TestSize.Level0) 69 { 70 std::string info = "{\"imageEffect\":{\"filters\":[{\"name\":\"Brightness\",\"values\":{\"FilterIntensity\":" 71 "100.0}},{\"name\":\"Contrast\",\"values\":{\"FilterIntensity\":50.0}}],\"name\":\"imageEdit\"}}"; 72 73 EffectJsonPtr root = JsonHelper::ParseJsonData(info); 74 ASSERT_NE(root, nullptr); 75 ASSERT_TRUE(root->HasElement(IMAGE_EFFECT)); 76 77 EffectJsonPtr imageEffect = root->GetElement(IMAGE_EFFECT); 78 ASSERT_NE(imageEffect, nullptr); 79 ASSERT_TRUE(imageEffect->HasElement(FILTERS)); 80 ASSERT_TRUE(imageEffect->HasElement(NAME)); 81 82 EffectJsonPtr filterObject = imageEffect->GetElement(FILTERS); 83 ASSERT_NE(filterObject, nullptr); 84 ASSERT_TRUE(filterObject->IsArray()); 85 std::vector<EffectJsonPtr> filters = filterObject->GetArray(); 86 ASSERT_EQ(filters.size(), 2); 87 88 filters = imageEffect->GetArray(FILTERS); 89 ASSERT_EQ(filters.size(), 2); 90 91 ASSERT_NE(filters[0], nullptr); 92 ASSERT_STREQ(filters[0]->GetString(NAME).c_str(), BRIGHTNESS); 93 EffectJsonPtr values = filters[0]->GetElement(VALUES); 94 ASSERT_NE(values, nullptr); 95 ASSERT_EQ(values->GetFloat(FILTER_INTENSITY), 100.0f); 96 97 ASSERT_NE(filters[1], nullptr); 98 ASSERT_STREQ(filters[1]->GetString(NAME).c_str(), CONTRAST); 99 values = filters[1]->GetElement(VALUES); 100 ASSERT_NE(values, nullptr); 101 ASSERT_EQ(values->GetFloat(FILTER_INTENSITY), 50.0f); 102 103 EffectJsonPtr name = imageEffect->GetElement(NAME); 104 ASSERT_NE(name, nullptr); 105 ASSERT_STREQ(name->GetString().c_str(), IMAGE_EDIT); 106 ASSERT_STREQ(imageEffect->GetString(NAME).c_str(), IMAGE_EDIT); 107 } 108 109 HWTEST_F(TestJsonHelper, Parse002, TestSize.Level0) 110 { 111 std::string info = "{\"imageEffect\":{\"filters\":[{\"name\":\"Brightness\",\"values\":{\"FloatTest\":" 112 "100.0,\"IntTest\":-10,\"UintTest\":20,\"DoubleTest\":30.5,\"BoolTest\":true,\"StringTest\":\"testStr\"}}," 113 "{\"name\":\"Contrast\",\"values\":{\"FilterIntensity\":50.0}}],\"name\":\"imageEdit\"}}"; 114 115 EffectJsonPtr root = JsonHelper::ParseJsonData(info); 116 ASSERT_NE(root, nullptr); 117 EffectJsonPtr imageEffect = root->GetElement(IMAGE_EFFECT); 118 ASSERT_NE(imageEffect, nullptr); 119 std::vector<EffectJsonPtr> filters = imageEffect->GetArray(FILTERS); 120 ASSERT_EQ(filters.size(), 2); 121 EffectJsonPtr values = filters[0]->GetElement(VALUES); 122 ASSERT_NE(values, nullptr); 123 124 ASSERT_EQ(values->GetFloat(FLOAT_TEST), 100.0f); 125 ASSERT_EQ(values->GetInt(INT_TEST), -10); 126 ASSERT_EQ(values->GetUInt(UINT_TEST), 20); 127 ASSERT_EQ(values->GetDouble(DOUBLE_TEST), 30.5f); 128 ASSERT_EQ(values->GetBool(BOOL_TEST), true); 129 ASSERT_EQ(values->GetString(STRING_TEST), TEST_STR); 130 131 EffectJsonPtr filtersObject = imageEffect->GetElement(FILTERS); 132 ASSERT_NE(filtersObject, nullptr); 133 EffectJsonPtr replaceFilters = JsonHelper::CreateObject(); 134 ASSERT_TRUE(replaceFilters->Put(NAME, TEST_STR)); 135 ASSERT_TRUE(imageEffect->Replace(FILTERS, replaceFilters)); 136 ASSERT_STREQ(replaceFilters->GetString(NAME).c_str(), TEST_STR); 137 } 138 139 HWTEST_F(TestJsonHelper, Create001, TestSize.Level0) 140 { 141 // brightness 142 EffectJsonPtr brightnessValue = JsonHelper::CreateObject(); 143 ASSERT_NE(brightnessValue, nullptr); 144 float brightnessFilterIntensity = -100.0f; 145 ASSERT_TRUE(brightnessValue->Put(FILTER_INTENSITY, brightnessFilterIntensity)); 146 147 EffectJsonPtr brightness = JsonHelper::CreateObject(); 148 ASSERT_NE(brightness, nullptr); 149 ASSERT_TRUE(brightness->Put(NAME, BRIGHTNESS)); 150 ASSERT_TRUE(brightness->Put(VALUES, brightnessValue)); 151 152 // contrast 153 EffectJsonPtr contrastValue = JsonHelper::CreateObject(); 154 ASSERT_NE(contrastValue, nullptr); 155 float contrastFilterIntensity = -50.0f; 156 ASSERT_TRUE(contrastValue->Put(FILTER_INTENSITY, contrastFilterIntensity)); 157 158 EffectJsonPtr contrast = JsonHelper::CreateObject(); 159 ASSERT_NE(contrast, nullptr); 160 ASSERT_TRUE(contrast->Put(NAME, CONTRAST)); 161 ASSERT_TRUE(contrast->Put(VALUES, contrastValue)); 162 163 // array filters 164 EffectJsonPtr filters = JsonHelper::CreateArray(); 165 ASSERT_NE(filters, nullptr); 166 ASSERT_TRUE(filters->Add(brightness)); 167 ASSERT_TRUE(filters->Add(contrast)); 168 169 // imageEffect 170 EffectJsonPtr imageEffect = JsonHelper::CreateObject(); 171 ASSERT_NE(imageEffect, nullptr); 172 ASSERT_TRUE(imageEffect->Put(FILTERS, filters)); 173 ASSERT_TRUE(imageEffect->Put(NAME, IMAGE_EDIT)); 174 175 EffectJsonPtr root = JsonHelper::CreateObject(); 176 ASSERT_NE(root, nullptr); 177 ASSERT_TRUE(root->Put(IMAGE_EFFECT, imageEffect)); 178 179 std::string info = "{\"imageEffect\":{\"filters\":[{\"name\":\"Brightness\",\"values\":{\"FilterIntensity\":" 180 "-100}},{\"name\":\"Contrast\",\"values\":{\"FilterIntensity\":-50}}],\"name\":\"imageEdit\"}}"; 181 ASSERT_STREQ(root->ToString().c_str(), info.c_str()); 182 } 183 184 HWTEST_F(TestJsonHelper, CreateObject001, TestSize.Level0) 185 { 186 EffectJsonPtr root = JsonHelper::CreateObject(); 187 ASSERT_NE(root, nullptr); 188 ASSERT_TRUE(root->IsObject()); 189 float floatValue = 50.0f; 190 ASSERT_TRUE(root->Put(FLOAT_TEST, floatValue)); 191 int32_t intValue = -10; 192 ASSERT_TRUE(root->Put(INT_TEST, intValue)); 193 uint32_t uintValue = 20; 194 ASSERT_TRUE(root->Put(UINT_TEST, uintValue)); 195 double doubleValue = 30.5; 196 ASSERT_TRUE(root->Put(DOUBLE_TEST, doubleValue)); 197 bool boolValue = true; 198 ASSERT_TRUE(root->Put(BOOL_TEST, boolValue)); 199 std::string strValue = TEST_STR; 200 ASSERT_TRUE(root->Put(STRING_TEST, strValue)); 201 ASSERT_FALSE(root->Put(STRING_TEST, (char *)nullptr)); 202 203 std::string info = "{\"FloatTest\":50,\"IntTest\":-10,\"UintTest\":20,\"DoubleTest\":30.5,\"BoolTest\":true," 204 "\"StringTest\":\"testStr\"}"; 205 206 ASSERT_STREQ(root->ToString().c_str(), info.c_str()); 207 } 208 209 HWTEST_F(TestJsonHelper, CreateArray001, TestSize.Level0) 210 { 211 // float 212 EffectJsonPtr floatRoot = JsonHelper::CreateArray(); 213 ASSERT_NE(floatRoot, nullptr); 214 float floatValue1 = 50.0f; 215 float floatValue2 = -20.0f; 216 ASSERT_TRUE(floatRoot->Add(floatValue1)); 217 ASSERT_TRUE(floatRoot->Add(floatValue2)); 218 std::vector<EffectJsonPtr> floatValues = floatRoot->GetArray(); 219 ASSERT_EQ(floatValues.size(), 2); 220 ASSERT_EQ(floatValues[0]->GetFloat(), floatValue1); 221 ASSERT_EQ(floatValues[1]->GetFloat(), floatValue2); 222 223 // int 224 EffectJsonPtr intRoot = JsonHelper::CreateArray(); 225 ASSERT_NE(intRoot, nullptr); 226 int32_t intValue1 = 50; 227 int32_t intValue2 = -20; 228 int32_t intValue3 = 10; 229 ASSERT_TRUE(intRoot->Add(intValue1)); 230 ASSERT_TRUE(intRoot->Add(intValue2)); 231 ASSERT_TRUE(intRoot->Add(intValue3)); 232 std::vector<EffectJsonPtr> intValues = intRoot->GetArray(); 233 ASSERT_EQ(intValues.size(), 3); 234 ASSERT_EQ(intValues[0]->GetInt(), intValue1); 235 ASSERT_EQ(intValues[1]->GetInt(), intValue2); 236 ASSERT_EQ(intValues[2]->GetInt(), intValue3); 237 238 // uint 239 EffectJsonPtr uintRoot = JsonHelper::CreateArray(); 240 ASSERT_NE(uintRoot, nullptr); 241 uint32_t uintValue = 50; 242 ASSERT_TRUE(uintRoot->Add(uintValue)); 243 std::vector<EffectJsonPtr> uintValues = uintRoot->GetArray(); 244 ASSERT_EQ(uintValues.size(), 1); 245 ASSERT_EQ(uintValues[0]->GetUInt(), uintValue); 246 } 247 248 HWTEST_F(TestJsonHelper, CreateArray002, TestSize.Level0) 249 { 250 // double 251 EffectJsonPtr doubleRoot = JsonHelper::CreateArray(); 252 double doubleValue = 30.5; 253 ASSERT_TRUE(doubleRoot->Add(doubleValue)); 254 std::vector<EffectJsonPtr> doubleValues = doubleRoot->GetArray(); 255 ASSERT_EQ(doubleValues.size(), 1); 256 ASSERT_DOUBLE_EQ(doubleValues[0]->GetDouble(), doubleValue); 257 258 // bool 259 EffectJsonPtr boolRoot = JsonHelper::CreateArray(); 260 bool boolValue = true; 261 ASSERT_TRUE(boolRoot->Add(boolValue)); 262 std::vector<EffectJsonPtr> boolValues = boolRoot->GetArray(); 263 ASSERT_EQ(boolValues.size(), 1); 264 ASSERT_DOUBLE_EQ(boolValues[0]->GetBool(), boolValue); 265 266 // string 267 EffectJsonPtr stringRoot = JsonHelper::CreateArray(); 268 ASSERT_TRUE(stringRoot->Add(TEST_STR)); 269 ASSERT_TRUE(stringRoot->Add(std::string(TEST_STR))); 270 std::vector<EffectJsonPtr> strValues = stringRoot->GetArray(); 271 ASSERT_EQ(strValues.size(), 2); 272 ASSERT_STREQ(strValues[0]->GetString().c_str(), TEST_STR); 273 ASSERT_STREQ(strValues[1]->GetString().c_str(), TEST_STR); 274 } 275 276 HWTEST_F(TestJsonHelper, Replace001, TestSize.Level0) 277 { 278 std::string info = "{\"imageEffect\":{\"values\":{\"FloatTest\":50.1,\"IntTest\":-10,\"UintTest\":20," 279 "\"DoubleTest\":30.5,\"BoolTest\":true,\"StringTest\":\"testStr\"}}}"; 280 281 EffectJsonPtr root = JsonHelper::ParseJsonData(info); 282 ASSERT_NE(root, nullptr); 283 EffectJsonPtr imageEffect = root->GetElement(IMAGE_EFFECT); 284 ASSERT_NE(imageEffect, nullptr); 285 EffectJsonPtr values = imageEffect->GetElement(VALUES); 286 ASSERT_NE(values, nullptr); 287 288 float floatValue = 70.0f; 289 ASSERT_TRUE(values->Replace(FLOAT_TEST, floatValue)); 290 int32_t intValue = -50; 291 ASSERT_TRUE(values->Replace(INT_TEST, intValue)); 292 uint32_t uintValue = 50; 293 ASSERT_TRUE(values->Replace(UINT_TEST, uintValue)); 294 double doubleValue = 50.4; 295 ASSERT_TRUE(values->Replace(DOUBLE_TEST, doubleValue)); 296 bool boolValue = false; 297 ASSERT_TRUE(values->Replace(BOOL_TEST, boolValue)); 298 std::string strValue = "test"; 299 ASSERT_TRUE(values->Replace(STRING_TEST, strValue)); 300 301 ASSERT_EQ(values->GetFloat(FLOAT_TEST), floatValue); 302 ASSERT_EQ(values->GetInt(INT_TEST), intValue); 303 ASSERT_EQ(values->GetUInt(UINT_TEST), uintValue); 304 ASSERT_DOUBLE_EQ(values->GetDouble(DOUBLE_TEST), doubleValue); 305 ASSERT_EQ(values->GetBool(BOOL_TEST), boolValue); 306 ASSERT_STREQ(values->GetString(STRING_TEST).c_str(), strValue.c_str()); 307 308 std::string strValue1 = "test1"; 309 const char *strValue1Ptr = strValue1.c_str(); 310 ASSERT_TRUE(values->Replace(STRING_TEST, strValue1Ptr)); 311 ASSERT_STREQ(values->GetString(STRING_TEST).c_str(), strValue1Ptr); 312 313 ASSERT_FALSE(values->Replace(std::string(STRING_TEST), (char *)nullptr)); 314 } 315 316 HWTEST_F(TestJsonHelper, Abnormal_001, TestSize.Level0) 317 { 318 EffectJsonPtr root = JsonHelper::CreateObject(false); 319 ASSERT_NE(root, nullptr); 320 ASSERT_TRUE(root->IsObject()); 321 ASSERT_TRUE(root->Put(INT_TEST, 10)); 322 ASSERT_TRUE(root->Put(STRING_TEST, TEST_STR)); 323 324 EffectJsonPtr intKeyJsonPtr = root->GetElement(INT_TEST); 325 ASSERT_NE(intKeyJsonPtr, nullptr); 326 ASSERT_TRUE(intKeyJsonPtr->GetString().empty()); 327 328 EffectJsonPtr stringKeyJsonPtr = root->GetElement(STRING_TEST); 329 ASSERT_NE(stringKeyJsonPtr, nullptr); 330 ASSERT_EQ(stringKeyJsonPtr->GetInt(), 0); 331 ASSERT_EQ(stringKeyJsonPtr->GetUInt(), 0); 332 ASSERT_EQ(stringKeyJsonPtr->GetFloat(), 0); 333 ASSERT_EQ(stringKeyJsonPtr->GetDouble(), 0); 334 ASSERT_FALSE(stringKeyJsonPtr->GetBool()); 335 ASSERT_EQ(stringKeyJsonPtr->GetArray().size(), 0); 336 337 ASSERT_EQ(root->GetUInt(STRING_TEST, UINT32_MAX), UINT32_MAX); 338 ASSERT_EQ(root->GetFloat(STRING_TEST, 0), 0); 339 ASSERT_EQ(root->GetDouble(STRING_TEST, 0), 0); 340 ASSERT_EQ(root->GetBool(STRING_TEST, true), true); 341 ASSERT_EQ(root->GetArray(STRING_TEST).size(), 0); 342 } 343 } // namespace Test 344 } // namespace Effect 345 } // namespace Media 346 } // namespace OHOS