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 "native_common_utils.h" 19 #include "json_helper.h" 20 #include "common_utils.h" 21 #include "string_helper.h" 22 23 using namespace testing::ext; 24 25 namespace OHOS { 26 namespace Media { 27 namespace Effect { 28 namespace Test { 29 30 class TestUtils : public testing::Test { 31 public: 32 TestUtils() = default; 33 34 ~TestUtils() override = default; SetUpTestCase()35 static void SetUpTestCase() {} 36 TearDownTestCase()37 static void TearDownTestCase() {} 38 SetUp()39 void SetUp() override{} 40 TearDown()41 void TearDown() override{} 42 }; 43 44 HWTEST_F(TestUtils, NativeCommonUtilsParseOHAny001, TestSize.Level1) { 45 ImageEffect_Any value; 46 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 47 value.dataValue.int32Value = 123; 48 Plugin::Any any; 49 ErrorCode result = NativeCommonUtils::ParseOHAny(&value, any); 50 ASSERT_EQ(result, ErrorCode::SUCCESS); 51 int actualValue = Plugin::AnyCast<int>(any); 52 ASSERT_EQ(actualValue, 123); 53 } 54 55 HWTEST_F(TestUtils, NativeCommonUtilsParseOHAny002, TestSize.Level1) { 56 ImageEffect_Any value; 57 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 58 value.dataValue.floatValue = 123.45f; 59 Plugin::Any any; 60 ErrorCode result = NativeCommonUtils::ParseOHAny(&value, any); 61 ASSERT_EQ(result, ErrorCode::SUCCESS); 62 float actualValue = Plugin::AnyCast<float>(any); 63 ASSERT_EQ(actualValue, 123.45f); 64 } 65 66 HWTEST_F(TestUtils, NativeCommonUtilsParseOHAny003, TestSize.Level1) { 67 ImageEffect_Any value; 68 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_DOUBLE; 69 value.dataValue.doubleValue = 123.45; 70 Plugin::Any any; 71 ErrorCode result = NativeCommonUtils::ParseOHAny(&value, any); 72 ASSERT_EQ(result, ErrorCode::SUCCESS); 73 double actualValue = Plugin::AnyCast<double>(any); 74 ASSERT_EQ(actualValue, 123.45); 75 } 76 77 HWTEST_F(TestUtils, NativeCommonUtilsParseOHAny004, TestSize.Level1) { 78 ImageEffect_Any value; 79 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_CHAR; 80 value.dataValue.charValue = 'A'; 81 Plugin::Any any; 82 ErrorCode result = NativeCommonUtils::ParseOHAny(&value, any); 83 ASSERT_EQ(result, ErrorCode::SUCCESS); 84 ASSERT_EQ(Plugin::AnyCast<char>(any), 'A'); 85 } 86 87 HWTEST_F(TestUtils, NativeCommonUtilsParseOHAny005, TestSize.Level1) { 88 ImageEffect_Any value; 89 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_LONG; 90 value.dataValue.longValue = 123456789L; 91 Plugin::Any any; 92 ErrorCode result = NativeCommonUtils::ParseOHAny(&value, any); 93 ASSERT_EQ(result, ErrorCode::SUCCESS); 94 ASSERT_EQ(Plugin::AnyCast<long>(any), 123456789L); 95 } 96 97 HWTEST_F(TestUtils, NativeCommonUtilsParseOHAny006, TestSize.Level1) { 98 ImageEffect_Any value; 99 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_PTR; 100 value.dataValue.ptrValue = (void*)0x12345678; 101 Plugin::Any any; 102 ErrorCode result = NativeCommonUtils::ParseOHAny(&value, any); 103 ASSERT_EQ(result, ErrorCode::SUCCESS); 104 ASSERT_EQ(Plugin::AnyCast<void*>(any), reinterpret_cast<void*>(0x12345678)); 105 } 106 107 HWTEST_F(TestUtils, NativeCommonUtilsParseOHAny007, TestSize.Level1) { 108 ImageEffect_Any value; 109 Plugin::Any any; 110 ErrorCode result = NativeCommonUtils::ParseOHAny(&value, any); 111 ASSERT_NE(result, ErrorCode::SUCCESS); 112 } 113 114 HWTEST_F(TestUtils, NativeCommonUtilsParseOHAny008, TestSize.Level1) { 115 ImageEffect_Any value; 116 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_BOOL; 117 value.dataValue.boolValue = true; 118 Plugin::Any any; 119 EXPECT_EQ(NativeCommonUtils::ParseOHAny(&value, any), ErrorCode::SUCCESS); 120 } 121 122 HWTEST_F(TestUtils, NativeCommonUtilsSwitchToOHAny001, TestSize.Level1) { 123 Plugin::Any any = 10.0; 124 ImageEffect_Any value; 125 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_DOUBLE; 126 ErrorCode result = NativeCommonUtils::SwitchToOHAny(any, &value); 127 EXPECT_EQ(result, ErrorCode::SUCCESS); 128 EXPECT_DOUBLE_EQ(value.dataValue.doubleValue, 10.0); 129 130 Plugin::Any anyChar = 'a'; 131 ImageEffect_Any valueChar; 132 valueChar.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_CHAR; 133 result = NativeCommonUtils::SwitchToOHAny(anyChar, &valueChar); 134 EXPECT_EQ(result, ErrorCode::SUCCESS); 135 EXPECT_EQ(valueChar.dataValue.charValue, 'a'); 136 137 Plugin::Any anyLong = 10L; 138 ImageEffect_Any valueLong; 139 valueLong.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_LONG; 140 result = NativeCommonUtils::SwitchToOHAny(anyLong, &valueLong); 141 EXPECT_EQ(result, ErrorCode::SUCCESS); 142 EXPECT_EQ(valueLong.dataValue.longValue, 10L); 143 144 Plugin::Any anyPtr = (void*)10; 145 ImageEffect_Any valuePtr; 146 valuePtr.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_PTR; 147 result = NativeCommonUtils::SwitchToOHAny(anyPtr, &valuePtr); 148 EXPECT_EQ(result, ErrorCode::SUCCESS); 149 EXPECT_EQ(valuePtr.dataValue.ptrValue, (void*)10); 150 151 Plugin::Any anyBool = true; 152 ImageEffect_Any valueBool; 153 valueBool.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_BOOL; 154 result = NativeCommonUtils::SwitchToOHAny(anyBool, &valueBool); 155 EXPECT_EQ(result, ErrorCode::SUCCESS); 156 EXPECT_EQ(valueBool.dataValue.boolValue, true); 157 158 Plugin::Any anyUnknown = std::string("Unsupported"); 159 ImageEffect_Any valueUnknown; 160 valueUnknown.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_UNKNOWN; 161 result = NativeCommonUtils::SwitchToOHAny(anyUnknown, &valueUnknown); 162 EXPECT_EQ(result, ErrorCode::ERR_NOT_SUPPORT_SWITCH_TO_OHANY); 163 } 164 165 HWTEST_F(TestUtils, JsonHelper001, TestSize.Level1) { 166 EffectJsonPtr root = JsonHelper::CreateObject(); 167 ASSERT_NE(root, nullptr); 168 ASSERT_TRUE(root->IsObject()); 169 ASSERT_TRUE(root->Put("stringKey", "testString")); 170 ASSERT_TRUE(root->Put("floatKey", 1.23f)); 171 ASSERT_TRUE(root->Put("intKey", 123)); 172 EffectJsonPtr intRoot = JsonHelper::CreateArray(); 173 ASSERT_TRUE(intRoot->Add(1)); 174 ASSERT_TRUE(intRoot->Add(2)); 175 ASSERT_TRUE(intRoot->Add(3)); 176 ASSERT_TRUE(root->Put("arrayKey", intRoot)); 177 178 ASSERT_TRUE(root->HasElement("stringKey")); 179 EffectJsonPtr stringKeyJsonPtr = root->GetElement("stringKey"); 180 ASSERT_NE(stringKeyJsonPtr, nullptr); 181 ASSERT_TRUE(stringKeyJsonPtr->IsString()); 182 ASSERT_FALSE(stringKeyJsonPtr->IsNumber()); 183 ASSERT_EQ(stringKeyJsonPtr->GetInt(), 0); 184 ASSERT_EQ(stringKeyJsonPtr->GetUInt(), 0); 185 ASSERT_EQ(stringKeyJsonPtr->GetFloat(), 0); 186 ASSERT_EQ(stringKeyJsonPtr->GetDouble(), 0); 187 ASSERT_FALSE(stringKeyJsonPtr->GetBool()); 188 std::string stringValue = stringKeyJsonPtr->GetString(); 189 ASSERT_STREQ(stringValue.c_str(), "testString"); 190 191 ASSERT_TRUE(root->HasElement("floatKey")); 192 EffectJsonPtr floatKeyJsonPtr = root->GetElement("floatKey"); 193 ASSERT_NE(floatKeyJsonPtr, nullptr); 194 ASSERT_TRUE(floatKeyJsonPtr->IsNumber()); 195 ASSERT_TRUE(floatKeyJsonPtr->GetString().empty()); 196 ASSERT_FALSE(floatKeyJsonPtr->IsString()); 197 float floatValue = floatKeyJsonPtr->GetFloat(); 198 ASSERT_EQ(floatValue, 1.23f); 199 200 ASSERT_FALSE(root->HasElement("nonExistKey")); 201 202 ASSERT_TRUE(root->HasElement("arrayKey")); 203 EffectJsonPtr arrayKeyJsonPtr = root->GetElement("arrayKey"); 204 ASSERT_NE(arrayKeyJsonPtr, nullptr); 205 ASSERT_TRUE(arrayKeyJsonPtr->IsArray()); 206 std::vector<EffectJsonPtr> arrayJsonPtr = arrayKeyJsonPtr->GetArray(); 207 ASSERT_EQ(arrayJsonPtr.size(), 3); 208 ASSERT_EQ(arrayJsonPtr[0]->GetInt(), 1); 209 ASSERT_EQ(arrayJsonPtr[1]->GetInt(), 2); 210 ASSERT_EQ(arrayJsonPtr[2]->GetInt(), 3); 211 } 212 213 HWTEST_F(TestUtils, NativeCommonUtilsParseJson001, TestSize.Level1) { 214 std::string key = "test_key"; 215 Plugin::Any any = nullptr; 216 Json *json = nullptr; 217 EffectJsonPtr result = std::make_shared<EffectJson>(json); 218 ErrorCode ret = CommonUtils::ParseAnyAndAddToJson(key, any, result); 219 ASSERT_EQ(ret, ErrorCode::ERR_ANY_CAST_TYPE_NOT_MATCH); 220 } 221 HWTEST_F(TestUtils, NativeCommonUtilsParseNativeWindowData001, TestSize.Level1) { 222 std::shared_ptr<BufferInfo> bufferinfo = std::make_unique<BufferInfo>(); 223 void *addr = nullptr; 224 std::shared_ptr<ExtraInfo> extrainfo = std::make_unique<ExtraInfo>(); 225 std::shared_ptr<EffectBuffer> effectBuffer = std::make_unique<EffectBuffer>(bufferinfo, addr, extrainfo); 226 DataType datatype = DataType::UNKNOWN; 227 ErrorCode result = CommonUtils::ParseNativeWindowData(effectBuffer, datatype); 228 ASSERT_EQ(result, ErrorCode::SUCCESS); 229 } 230 HWTEST_F(TestUtils, NativeCommonUtilsModifyPixelMapProperty001, TestSize.Level1) { 231 PixelMap pixelMap; 232 std::shared_ptr<BufferInfo> bufferinfo = std::make_unique<BufferInfo>(); 233 void *addr = nullptr; 234 std::shared_ptr<ExtraInfo> extrainfo = std::make_unique<ExtraInfo>(); 235 std::shared_ptr<EffectBuffer> buffer = std::make_unique<EffectBuffer>(bufferinfo, addr, extrainfo); 236 std::shared_ptr<EffectMemoryManager> memoryManager = std::make_unique<EffectMemoryManager>(); 237 ErrorCode result = CommonUtils::ModifyPixelMapProperty(&pixelMap, buffer, memoryManager); 238 EXPECT_EQ(result, ErrorCode::ERR_ALLOC_MEMORY_FAIL); 239 } 240 HWTEST_F(TestUtils, StringHelper001, TestSize.Level1) { 241 std::string input = "abc"; 242 std::string suffix = "abcd"; 243 std::string srcStr = "abcdef"; 244 std::string endStr = "def"; 245 std::shared_ptr<StringHelp> stringHelp = std::make_shared<StringHelp>(); 246 EXPECT_FALSE(stringHelp->EndsWith(input, suffix)); 247 EXPECT_FALSE(stringHelp->EndsWithIgnoreCase(input, suffix)); 248 bool result = stringHelp->EndsWith(srcStr, endStr); 249 EXPECT_TRUE(result); 250 } 251 } 252 } 253 } 254 }