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 <fstream> 17 18 #include <dlfcn.h> 19 #include <gtest/gtest.h> 20 21 #include "infrared_emitter_controller.h" 22 #include "mmi_log.h" 23 #include "uds_server.h" 24 25 namespace OHOS { 26 namespace MMI { 27 #ifndef OHOS_BUILD_PC_UNIT_TEST 28 namespace { 29 using namespace testing::ext; 30 const std::string IR_WRAPPER_PATH = "libinfrared_emitter_adapter.z.so"; 31 } // namespace 32 33 class InfraredEmitterControllerTest : public testing::Test { 34 public: SetUpTestCase(void)35 static void SetUpTestCase(void) {} TearDownTestCase(void)36 static void TearDownTestCase(void) {} 37 }; 38 39 /** 40 * @tc.name: InfraredEmitterControllerTest_GetInstance_001 41 * @tc.desc: Test the funcation GetInstance 42 * @tc.type: FUNC 43 * @tc.require: 44 */ 45 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_GetInstance_001, TestSize.Level1) 46 { 47 CALL_TEST_DEBUG; 48 InfraredEmitterController controller; 49 InfraredEmitterController* instance1 = controller.GetInstance(); 50 ASSERT_NE(instance1, nullptr); 51 InfraredEmitterController* instance2 = controller.GetInstance(); 52 ASSERT_EQ(instance1, instance2); 53 } 54 55 /** 56 * @tc.name: InfraredEmitterControllerTest_InitInfraredEmitter_001 57 * @tc.desc: Test the funcation InitInfraredEmitter 58 * @tc.type: FUNC 59 * @tc.require: 60 */ 61 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_InitInfraredEmitter_001, TestSize.Level1) 62 { 63 CALL_TEST_DEBUG; 64 InfraredEmitterController controller; 65 controller.irInterface_ = nullptr; 66 controller.soIrHandle_ = nullptr; 67 ASSERT_NO_FATAL_FAILURE(controller.InitInfraredEmitter()); 68 controller.soIrHandle_ = dlopen(IR_WRAPPER_PATH.c_str(), RTLD_NOW); 69 ASSERT_NO_FATAL_FAILURE(controller.InitInfraredEmitter()); 70 } 71 72 /** 73 * @tc.name: InfraredEmitterControllerTest_Transmit_001 74 * @tc.desc: Test the funcation Transmit 75 * @tc.type: FUNC 76 * @tc.require: 77 */ 78 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_Transmit_001, TestSize.Level1) 79 { 80 CALL_TEST_DEBUG; 81 InfraredEmitterController controller; 82 int64_t carrierFreq = 12; 83 std::vector<int64_t> pattern = {10, 20, 30}; 84 ASSERT_NO_FATAL_FAILURE(controller.Transmit(carrierFreq, pattern)); 85 } 86 87 /** 88 * @tc.name: InfraredEmitterControllerTest_GetFrequencies_001 89 * @tc.desc: Test the funcation GetFrequencies 90 * @tc.type: FUNC 91 * @tc.require: 92 */ 93 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_GetFrequencies_001, TestSize.Level1) 94 { 95 CALL_TEST_DEBUG; 96 InfraredEmitterController controller; 97 controller.irInterface_ = nullptr; 98 std::vector<InfraredFrequencyInfo> frequencyInfo; 99 frequencyInfo.push_back(InfraredFrequencyInfo({1, 1000})); 100 ASSERT_NO_FATAL_FAILURE(controller.GetFrequencies(frequencyInfo)); 101 } 102 103 /** 104 * @tc.name: InfraredEmitterControllerTest_InfraredEmitterController_001 105 * @tc.desc: Test the funcation GetFrequencies 106 * @tc.type: FUNC 107 * @tc.require: 108 */ 109 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_InfraredEmitterController_001, TestSize.Level1) 110 { 111 CALL_TEST_DEBUG; 112 InfraredEmitterController controller; 113 const std::string irWrapperPath = "libconsumer_ir_service_1.0.z.so"; 114 controller.soIrHandle_ = dlopen(irWrapperPath.c_str(), RTLD_NOW); 115 ASSERT_EQ(controller.irInterface_, nullptr); 116 } 117 118 /** 119 * @tc.name: InfraredEmitterControllerTest_InitInfraredEmitter_002 120 * @tc.desc: soIrHandle_ already loaded, should not dlopen again 121 * @tc.type: FUNC 122 * @tc.require: 123 */ 124 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_InitInfraredEmitter_002, TestSize.Level1) 125 { 126 CALL_TEST_DEBUG; 127 InfraredEmitterController controller; 128 controller.soIrHandle_ = dlopen(IR_WRAPPER_PATH.c_str(), RTLD_NOW); 129 controller.irInterface_ = nullptr; 130 ASSERT_NO_FATAL_FAILURE(controller.InitInfraredEmitter()); 131 if (controller.soIrHandle_ != nullptr) { 132 dlclose(controller.soIrHandle_); 133 } 134 } 135 136 /** 137 * @tc.name: InfraredEmitterControllerTest_InitInfraredEmitter_003 138 * @tc.desc: dlopen fails, should return early 139 * @tc.type: FUNC 140 * @tc.require: 141 */ 142 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_InitInfraredEmitter_003, TestSize.Level1) 143 { 144 CALL_TEST_DEBUG; 145 InfraredEmitterController controller; 146 controller.irInterface_ = nullptr; 147 controller.soIrHandle_ = nullptr; 148 ASSERT_NO_FATAL_FAILURE(controller.InitInfraredEmitter()); 149 } 150 151 /** 152 * @tc.name: InfraredEmitterControllerTest_InitInfraredEmitter_004 153 * @tc.desc: dlsym returns nullptr, should cleanup so handle 154 * @tc.type: FUNC 155 * @tc.require: 156 */ 157 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_InitInfraredEmitter_004, TestSize.Level1) 158 { 159 CALL_TEST_DEBUG; 160 InfraredEmitterController controller; 161 controller.irInterface_ = nullptr; 162 controller.soIrHandle_ = dlopen(IR_WRAPPER_PATH.c_str(), RTLD_NOW); 163 if (controller.soIrHandle_ != nullptr) { 164 dlsym(controller.soIrHandle_, "NonExistFunction"); 165 } 166 ASSERT_NO_FATAL_FAILURE(controller.InitInfraredEmitter()); 167 if (controller.soIrHandle_ != nullptr) { 168 dlclose(controller.soIrHandle_); 169 } 170 } 171 172 /** 173 * @tc.name: InfraredEmitterControllerTest_InitInfraredEmitter_005 174 * @tc.desc: fnCreate is nullptr even if dlsym success, should cleanup 175 * @tc.type: FUNC 176 * @tc.require: 177 */ 178 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_InitInfraredEmitter_005, TestSize.Level1) 179 { 180 CALL_TEST_DEBUG; 181 InfraredEmitterController controller; 182 controller.irInterface_ = nullptr; 183 controller.soIrHandle_ = dlopen(IR_WRAPPER_PATH.c_str(), RTLD_NOW); 184 ASSERT_NO_FATAL_FAILURE(controller.InitInfraredEmitter()); 185 if (controller.soIrHandle_ != nullptr) { 186 dlclose(controller.soIrHandle_); 187 } 188 } 189 190 /** 191 * @tc.name: InfraredEmitterControllerTest_Transmit_002 192 * @tc.desc: irInterface_ is nullptr，Transmit return true 193 * @tc.type: FUNC 194 * @tc.require: 195 */ 196 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_Transmit_002, TestSize.Level1) 197 { 198 CALL_TEST_DEBUG; 199 InfraredEmitterController controller; 200 controller.irInterface_ = nullptr; 201 int64_t carrierFreq = 38000; 202 std::vector<int64_t> pattern = {100, 200, 300}; 203 bool ret = controller.Transmit(carrierFreq, pattern); 204 ASSERT_FALSE(ret); 205 } 206 207 /** 208 * @tc.name: InfraredEmitterControllerTest_Transmit_003 209 * @tc.desc: irInterface_->Transmit return -1，expected return false 210 * @tc.type: FUNC 211 * @tc.require: 212 */ 213 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_Transmit_003, TestSize.Level1) 214 { 215 CALL_TEST_DEBUG; 216 struct FakeAdapter : public IInfraredEmitterAdapter { TransmitOHOS::MMI::FakeAdapter217 int32_t Transmit(int32_t, const std::vector<int32_t>&, bool& outRet) override 218 { 219 outRet = true; 220 return -1; 221 } GetCarrierFreqsOHOS::MMI::FakeAdapter222 int32_t GetCarrierFreqs(bool&, std::vector<OHOS::HDI::Consumerir::V1_0::ConsumerIrFreqRange>&) override 223 { 224 return 0; 225 } 226 }; 227 228 InfraredEmitterController controller; 229 controller.irInterface_ = new FakeAdapter(); 230 int64_t carrierFreq = 36000; 231 std::vector<int64_t> pattern = {500, 600}; 232 bool ret = controller.Transmit(carrierFreq, pattern); 233 ASSERT_FALSE(ret); 234 delete controller.irInterface_; 235 } 236 237 /** 238 * @tc.name: InfraredEmitterControllerTest_Transmit_004 239 * @tc.desc: irInterface_->Transmit success but outRet return false 240 * @tc.type: FUNC 241 * @tc.require: 242 */ 243 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_Transmit_004, TestSize.Level1) 244 { 245 CALL_TEST_DEBUG; 246 struct FakeAdapter : public IInfraredEmitterAdapter { TransmitOHOS::MMI::FakeAdapter247 int32_t Transmit(int32_t, const std::vector<int32_t>&, bool& outRet) override 248 { 249 outRet = false; 250 return 0; 251 } GetCarrierFreqsOHOS::MMI::FakeAdapter252 int32_t GetCarrierFreqs(bool&, std::vector<OHOS::HDI::Consumerir::V1_0::ConsumerIrFreqRange>&) override 253 { 254 return 0; 255 } 256 }; 257 258 InfraredEmitterController controller; 259 controller.irInterface_ = new FakeAdapter(); 260 int64_t carrierFreq = 40000; 261 std::vector<int64_t> pattern = {150, 250}; 262 bool ret = controller.Transmit(carrierFreq, pattern); 263 ASSERT_FALSE(ret); 264 delete controller.irInterface_; 265 } 266 267 /** 268 * @tc.name: InfraredEmitterControllerTest_Transmit_005 269 * @tc.desc: irInterface_->Transmit success and return true 270 * @tc.type: FUNC 271 * @tc.require: 272 */ 273 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_Transmit_005, TestSize.Level1) 274 { 275 CALL_TEST_DEBUG; 276 struct FakeAdapter : public IInfraredEmitterAdapter { TransmitOHOS::MMI::FakeAdapter277 int32_t Transmit(int32_t, const std::vector<int32_t>&, bool& outRet) override 278 { 279 outRet = true; 280 return 0; 281 } GetCarrierFreqsOHOS::MMI::FakeAdapter282 int32_t GetCarrierFreqs(bool&, std::vector<OHOS::HDI::Consumerir::V1_0::ConsumerIrFreqRange>&) override 283 { 284 return 0; 285 } 286 }; 287 288 InfraredEmitterController controller; 289 controller.irInterface_ = new FakeAdapter(); 290 int64_t carrierFreq = 39000; 291 std::vector<int64_t> pattern = {100, 100, 100, 100}; 292 bool ret = controller.Transmit(carrierFreq, pattern); 293 ASSERT_TRUE(ret); 294 delete controller.irInterface_; 295 } 296 297 /** 298 * @tc.name: InfraredEmitterControllerTest_GetFrequencies_002 299 * @tc.desc: Test GetFrequencies when interface returns ret < 0 300 * @tc.type: FUNC 301 * @tc.require: 302 */ 303 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_GetFrequencies_002, TestSize.Level1) 304 { 305 CALL_TEST_DEBUG; 306 struct FakeAdapter : public IInfraredEmitterAdapter { TransmitOHOS::MMI::FakeAdapter307 int32_t Transmit(int32_t, const std::vector<int32_t>&, bool&) override { return 0; } GetCarrierFreqsOHOS::MMI::FakeAdapter308 int32_t GetCarrierFreqs(bool& ret, std::vector<HDI::Consumerir::V1_0::ConsumerIrFreqRange>&) override 309 { 310 ret = true; 311 return -1; 312 } 313 }; 314 InfraredEmitterController controller; 315 controller.irInterface_ = new (std::nothrow) FakeAdapter(); 316 std::vector<InfraredFrequencyInfo> frequencyInfo; 317 bool result = controller.GetFrequencies(frequencyInfo); 318 ASSERT_FALSE(result); 319 } 320 321 /** 322 * @tc.name: InfraredEmitterControllerTest_GetFrequencies_003 323 * @tc.desc: Test GetFrequencies when interface returns outRet = false 324 * @tc.type: FUNC 325 * @tc.require: 326 */ 327 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_GetFrequencies_003, TestSize.Level1) 328 { 329 CALL_TEST_DEBUG; 330 struct FakeAdapter : public IInfraredEmitterAdapter { TransmitOHOS::MMI::FakeAdapter331 int32_t Transmit(int32_t, const std::vector<int32_t>&, bool&) override { return 0; } GetCarrierFreqsOHOS::MMI::FakeAdapter332 int32_t GetCarrierFreqs(bool& ret, std::vector<HDI::Consumerir::V1_0::ConsumerIrFreqRange>&) override 333 { 334 ret = false; 335 return 0; 336 } 337 }; 338 InfraredEmitterController controller; 339 controller.irInterface_ = new (std::nothrow) FakeAdapter(); 340 std::vector<InfraredFrequencyInfo> frequencyInfo; 341 bool result = controller.GetFrequencies(frequencyInfo); 342 ASSERT_FALSE(result); 343 } 344 345 /** 346 * @tc.name: InfraredEmitterControllerTest_GetFrequencies_004 347 * @tc.desc: Test GetFrequencies with valid data returned 348 * @tc.type: FUNC 349 * @tc.require: 350 */ 351 HWTEST_F(InfraredEmitterControllerTest, InfraredEmitterControllerTest_GetFrequencies_004, TestSize.Level1) 352 { 353 CALL_TEST_DEBUG; 354 struct FakeAdapter : public IInfraredEmitterAdapter { TransmitOHOS::MMI::FakeAdapter355 int32_t Transmit(int32_t, const std::vector<int32_t>&, bool&) override { return 0; } GetCarrierFreqsOHOS::MMI::FakeAdapter356 int32_t GetCarrierFreqs(bool& ret, std::vector<HDI::Consumerir::V1_0::ConsumerIrFreqRange>& range) override 357 { 358 ret = true; 359 range = { 360 { .min = 36000, .max = 40000 }, 361 { .min = 38000, .max = 42000 } 362 }; 363 return 0; 364 } 365 }; 366 InfraredEmitterController controller; 367 controller.irInterface_ = new (std::nothrow) FakeAdapter(); 368 std::vector<InfraredFrequencyInfo> frequencyInfo; 369 bool result = controller.GetFrequencies(frequencyInfo); 370 ASSERT_TRUE(result); 371 ASSERT_EQ(frequencyInfo.size(), 2); 372 ASSERT_EQ(frequencyInfo[0].min_, 36000); 373 ASSERT_EQ(frequencyInfo[0].max_, 40000); 374 ASSERT_EQ(frequencyInfo[1].min_, 38000); 375 ASSERT_EQ(frequencyInfo[1].max_, 42000); 376 } 377 #endif // OHOS_BUILD_PC_UNIT_TEST 378 } // namespace MMI 379 } // namespace OHOS