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 "effect_json_helper.h"
19
20using namespace testing::ext;
21using namespace OHOS::Media::Effect;
22
23namespace OHOS {
24namespace Media {
25namespace Effect {
26namespace Test {
27namespace {
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
45class TestJsonHelper : public testing::Test {
46public:
47    TestJsonHelper() = default;
48
49    ~TestJsonHelper() override = default;
50
51    static void SetUpTestCase() {}
52
53    static void TearDownTestCase() {}
54
55    void SetUp() override
56    {
57        root_ = EFFECTJsonHelper::CreateObject();
58    }
59
60    void TearDown() override
61    {
62        root_ = nullptr;
63    }
64
65    EffectJsonPtr root_;
66};
67
68HWTEST_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 = EFFECTJsonHelper::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
109HWTEST_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 = EFFECTJsonHelper::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 = EFFECTJsonHelper::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
139HWTEST_F(TestJsonHelper, Create001, TestSize.Level0)
140{
141    // brightness
142    EffectJsonPtr brightnessValue = EFFECTJsonHelper::CreateObject();
143    ASSERT_NE(brightnessValue, nullptr);
144    float brightnessFilterIntensity = -100.0f;
145    ASSERT_TRUE(brightnessValue->Put(FILTER_INTENSITY, brightnessFilterIntensity));
146
147    EffectJsonPtr brightness = EFFECTJsonHelper::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 = EFFECTJsonHelper::CreateObject();
154    ASSERT_NE(contrastValue, nullptr);
155    float contrastFilterIntensity = -50.0f;
156    ASSERT_TRUE(contrastValue->Put(FILTER_INTENSITY, contrastFilterIntensity));
157
158    EffectJsonPtr contrast = EFFECTJsonHelper::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 = EFFECTJsonHelper::CreateArray();
165    ASSERT_NE(filters, nullptr);
166    ASSERT_TRUE(filters->Add(brightness));
167    ASSERT_TRUE(filters->Add(contrast));
168
169    // imageEffect
170    EffectJsonPtr imageEffect = EFFECTJsonHelper::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 = EFFECTJsonHelper::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
184HWTEST_F(TestJsonHelper, CreateObject001, TestSize.Level0)
185{
186    EffectJsonPtr root = EFFECTJsonHelper::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
209HWTEST_F(TestJsonHelper, CreateArray001, TestSize.Level0)
210{
211    // float
212    EffectJsonPtr floatRoot = EFFECTJsonHelper::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 = EFFECTJsonHelper::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 = EFFECTJsonHelper::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
248HWTEST_F(TestJsonHelper, CreateArray002, TestSize.Level0)
249{
250    // double
251    EffectJsonPtr doubleRoot = EFFECTJsonHelper::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 = EFFECTJsonHelper::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 = EFFECTJsonHelper::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
276HWTEST_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 = EFFECTJsonHelper::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
316HWTEST_F(TestJsonHelper, Abnormal_001, TestSize.Level0)
317{
318    EffectJsonPtr root = EFFECTJsonHelper::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->GetInt(INT_TEST, INT32_MAX), INT32_MAX);
332    ASSERT_EQ(stringKeyJsonPtr->GetUInt(), 0);
333    ASSERT_EQ(stringKeyJsonPtr->GetUInt(INT_TEST, UINT32_MAX), UINT32_MAX);
334    ASSERT_EQ(stringKeyJsonPtr->GetFloat(), 0);
335    ASSERT_EQ(stringKeyJsonPtr->GetFloat(INT_TEST, 0), 0);
336    ASSERT_EQ(stringKeyJsonPtr->GetDouble(), 0);
337    ASSERT_EQ(stringKeyJsonPtr->GetDouble(INT_TEST, 0), 0);
338    ASSERT_FALSE(stringKeyJsonPtr->GetBool());
339    ASSERT_EQ(stringKeyJsonPtr->GetBool(INT_TEST, true), true);
340    ASSERT_EQ(stringKeyJsonPtr->GetArray().size(), 0);
341    ASSERT_EQ(stringKeyJsonPtr->GetArray(INT_TEST).size(), 0);
342
343    ASSERT_EQ(root->GetUInt(STRING_TEST, UINT32_MAX), UINT32_MAX);
344    ASSERT_EQ(root->GetFloat(STRING_TEST, 0), 0);
345    ASSERT_EQ(root->GetDouble(STRING_TEST, 0), 0);
346    ASSERT_EQ(root->GetBool(STRING_TEST, true), true);
347    ASSERT_EQ(root->GetArray(STRING_TEST).size(), 0);
348
349    EffectJsonPtr boolKeyJsonPtr = root->GetElement(BOOL_TEST);
350    ASSERT_EQ(boolKeyJsonPtr, nullptr);
351}
352} // namespace Test
353} // namespace Effect
354} // namespace Media
355} // namespace OHOS