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 #define private public 17 #define protected public 18 19 #include <gtest/gtest.h> 20 21 #include "mock/mock_sim_manager.h" 22 #include "core_manager_inner.h" 23 #include "cellular_data_handler.h" 24 #include "cellular_data_incall_observer.h" 25 #include "cellular_data_setting_observer.h" 26 #include "cellular_data_rdb_observer.h" 27 #include "cellular_data_roaming_observer.h" 28 #include "cellular_data_settings_rdb_helper.h" 29 #include "cellular_data_airplane_observer.h" 30 31 namespace OHOS { 32 namespace Telephony { 33 using namespace testing::ext; 34 using ::testing::_; 35 using ::testing::Mock; 36 using ::testing::Return; 37 38 class CellularDataObserverTest : public testing::Test { 39 public: 40 CellularDataObserverTest() = default; 41 ~CellularDataObserverTest() = default; 42 TearDownTestCase()43 static void TearDownTestCase() 44 { 45 if (CoreManagerInner::GetInstance().simManager_ != nullptr) { 46 CoreManagerInner::GetInstance().simManager_ = nullptr; 47 std::cout << "CellularDataObserverTest set simManager_ nullptr" << std::endl; 48 } 49 } 50 createCellularDataHandler()51 static std::shared_ptr<CellularDataHandler> createCellularDataHandler() 52 { 53 EventFwk::CommonEventSubscribeInfo subscriberInfo; 54 subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON); 55 std::shared_ptr<CellularDataHandler> cellularDataHandler = 56 std::make_shared<CellularDataHandler>(subscriberInfo, 0); 57 return cellularDataHandler; 58 } 59 }; 60 61 HWTEST_F(CellularDataObserverTest, CellularDataIncallObserver_01, Function | MediumTest | Level1) 62 { 63 std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr; 64 auto cellularDataIncallObserver = std::make_shared<CellularDataIncallObserver>(cellularDataHandler); 65 cellularDataIncallObserver->OnChange(); 66 ASSERT_TRUE(cellularDataHandler == nullptr); 67 68 // GetValue success, cellularDataHandler is nullptr 69 std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance(); 70 Uri uri(CELLULAR_DATA_SETTING_DATA_INCALL_URI); 71 ASSERT_TRUE(settingHelper->PutValue(uri, CELLULAR_DATA_COLUMN_INCALL, 1) == TELEPHONY_ERR_SUCCESS); 72 cellularDataIncallObserver->OnChange(); 73 ASSERT_TRUE(cellularDataHandler == nullptr); 74 75 // GetValue success, cellularDataHandler is not nullptr 76 cellularDataHandler = CellularDataObserverTest::createCellularDataHandler(); 77 cellularDataIncallObserver = std::make_shared<CellularDataIncallObserver>(cellularDataHandler); 78 cellularDataIncallObserver->OnChange(); 79 ASSERT_FALSE(cellularDataHandler == nullptr); 80 } 81 82 HWTEST_F(CellularDataObserverTest, CellularDataRdbObserver_02, Function | MediumTest | Level1) 83 { 84 std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr; 85 auto cellularDataRdbObserver = std::make_shared<CellularDataRdbObserver>(cellularDataHandler); 86 cellularDataRdbObserver->OnChange(); 87 ASSERT_TRUE(cellularDataHandler == nullptr); 88 89 // cellularDataHandler is not nullptr 90 cellularDataHandler = CellularDataObserverTest::createCellularDataHandler(); 91 cellularDataRdbObserver = std::make_shared<CellularDataRdbObserver>(cellularDataHandler); 92 cellularDataRdbObserver->OnChange(); 93 ASSERT_FALSE(cellularDataHandler == nullptr); 94 } 95 96 HWTEST_F(CellularDataObserverTest, CellularDataRoamingObserver_03, Function | MediumTest | Level1) 97 { 98 // mock sim manager 99 ASSERT_TRUE(CoreManagerInner::GetInstance().simManager_ == nullptr); 100 MockSimManager *mockSimManager = new MockSimManager(); 101 std::shared_ptr<MockSimManager> mockSimManagerPtr(mockSimManager); 102 CoreManagerInner::GetInstance().OnInit(nullptr, mockSimManagerPtr, nullptr); 103 ASSERT_FALSE(CoreManagerInner::GetInstance().simManager_ == nullptr); 104 ASSERT_EQ(CoreManagerInner::GetInstance().simManager_, mockSimManagerPtr); 105 106 // get sim id failed 107 EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(-1)); 108 std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr; 109 auto cellularDataRoamingObserver = std::make_shared<CellularDataRoamingObserver>(cellularDataHandler, 0); 110 cellularDataRoamingObserver->OnChange(); 111 ASSERT_TRUE(cellularDataHandler == nullptr); 112 113 // get sim id success, GetValue failed 114 EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1)); 115 cellularDataRoamingObserver->OnChange(); 116 ASSERT_TRUE(cellularDataHandler == nullptr); 117 118 // get sim id success, GetValue success, cellularDataHandler is nullptr 119 EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1)); 120 std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance(); 121 Uri uri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(1)); 122 std::string col = std::string(CELLULAR_DATA_COLUMN_ROAMING) + std::to_string(1); 123 ASSERT_TRUE(settingHelper->PutValue(uri, col, 1) == TELEPHONY_ERR_SUCCESS); 124 cellularDataRoamingObserver->OnChange(); 125 ASSERT_TRUE(cellularDataHandler == nullptr); 126 127 // get sim id success, GetValue success, cellularDataHandler is nullptr 128 EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1)); 129 cellularDataHandler = CellularDataObserverTest::createCellularDataHandler(); 130 cellularDataRoamingObserver = std::make_shared<CellularDataRoamingObserver>(cellularDataHandler, 0); 131 cellularDataRoamingObserver->OnChange(); 132 ASSERT_FALSE(cellularDataHandler == nullptr); 133 134 Mock::VerifyAndClearExpectations(mockSimManager); 135 } 136 137 HWTEST_F(CellularDataObserverTest, CellularDataSettingObserver_04, Function | MediumTest | Level1) 138 { 139 std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr; 140 auto cellularDataSettingObserver = std::make_shared<CellularDataSettingObserver>(cellularDataHandler); 141 cellularDataSettingObserver->OnChange(); 142 ASSERT_TRUE(cellularDataHandler == nullptr); 143 144 // GetValue success, cellularDataHandler is nullptr 145 std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance(); 146 Uri uri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI); 147 ASSERT_TRUE(settingHelper->PutValue(uri, CELLULAR_DATA_COLUMN_ENABLE, 1) == TELEPHONY_ERR_SUCCESS); 148 cellularDataSettingObserver->OnChange(); 149 ASSERT_TRUE(cellularDataHandler == nullptr); 150 151 // GetValue success, cellularDataHandler is not nullptr 152 cellularDataHandler = CellularDataObserverTest::createCellularDataHandler(); 153 cellularDataSettingObserver = std::make_shared<CellularDataSettingObserver>(cellularDataHandler); 154 cellularDataSettingObserver->OnChange(); 155 ASSERT_FALSE(cellularDataHandler == nullptr); 156 } 157 158 HWTEST_F(CellularDataObserverTest, CellularDataAirplaneObserver_05, Function | MediumTest | Level1) 159 { 160 auto cellularDataAirplaneObserver = std::make_shared<CellularDataAirplaneObserver>(); 161 162 std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance(); 163 Uri uri(CELLULAR_DATA_AIRPLANE_MODE_URI); 164 EXPECT_TRUE(settingHelper->PutValue(uri, CELLULAR_DATA_COLUMN_AIRPLANE, 1) == TELEPHONY_ERR_SUCCESS); 165 cellularDataAirplaneObserver->OnChange(); 166 167 EXPECT_TRUE(settingHelper->PutValue(uri, CELLULAR_DATA_COLUMN_AIRPLANE, 0) == TELEPHONY_ERR_SUCCESS); 168 cellularDataAirplaneObserver->OnChange(); 169 EXPECT_FALSE(cellularDataAirplaneObserver->IsAirplaneModeOn()); 170 171 settingHelper->NotifyChange(uri); 172 } 173 174 } // namespace Telephony 175 } // namespace OHOS