1 /* 2 * Copyright (c) 2021 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 #include <cstdio> 16 #include <cstring> 17 #include <gmock/gmock.h> 18 #include <gtest/gtest.h> 19 20 #include "if_system_ability_manager.h" 21 #include "init_unittest.h" 22 #include "iservice_registry.h" 23 #include "iwatcher.h" 24 #include "iwatcher_manager.h" 25 #include "message_parcel.h" 26 #include "param_message.h" 27 #include "param_request.h" 28 #include "param_utils.h" 29 #include "parcel.h" 30 #include "securec.h" 31 #include "system_ability_definition.h" 32 #include "watcher.h" 33 #include "watcher_manager.h" 34 #include "watcher_proxy.h" 35 #include "watcher_utils.h" 36 37 using namespace testing::ext; 38 using namespace std; 39 using namespace OHOS; 40 using namespace OHOS::init_param; 41 42 class TestWatcher final : public Watcher { 43 public: TestWatcher()44 TestWatcher() {} 45 ~TestWatcher() = default; 46 OnParamerterChange(const std::string & name,const std::string & value)47 void OnParamerterChange(const std::string &name, const std::string &value) override 48 { 49 printf("TestWatcher::OnParamerterChange name %s %s \n", name.c_str(), value.c_str()); 50 } 51 }; 52 53 using WatcherManagerPtr = WatcherManager *; 54 class WatcherProxyUnitTest : public ::testing::Test { 55 public: WatcherProxyUnitTest()56 WatcherProxyUnitTest() {} ~WatcherProxyUnitTest()57 virtual ~WatcherProxyUnitTest() {} 58 SetUp()59 void SetUp() {} TearDown()60 void TearDown() {} TestBody()61 void TestBody() {} 62 TestAddWatcher(const std::string & keyPrefix,uint32_t & watcherId)63 int TestAddWatcher(const std::string &keyPrefix, uint32_t &watcherId) 64 { 65 WatcherManagerPtr watcherManager = GetWatcherManager(); 66 WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager"); 67 MessageParcel data; 68 MessageParcel reply; 69 MessageOption option; 70 71 data.WriteInterfaceToken(IWatcherManager::GetDescriptor()); 72 data.WriteString(keyPrefix); 73 sptr<IWatcher> watcher = new TestWatcher(); 74 bool ret = data.WriteRemoteObject(watcher->AsObject()); 75 WATCHER_CHECK(ret, return 0, "Can not get remote"); 76 watcherManager->OnRemoteRequest(IWatcherManager::ADD_WATCHER, data, reply, option); 77 watcherId = reply.ReadUint32(); 78 EXPECT_NE(watcherId, 0); 79 EXPECT_EQ(watcherManager->GetWatcherGroup(1000) != NULL, 0); // 1000 test group id 80 EXPECT_EQ(watcherManager->GetWatcherGroup("TestAddWatcher") != NULL, 0); // test key not exist 81 return 0; 82 } 83 TestDelWatcher(const std::string & keyPrefix,uint32_t & watcherId)84 int TestDelWatcher(const std::string &keyPrefix, uint32_t &watcherId) 85 { 86 WatcherManagerPtr watcherManager = GetWatcherManager(); 87 WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager"); 88 MessageParcel data; 89 MessageParcel reply; 90 MessageOption option; 91 data.WriteInterfaceToken(IWatcherManager::GetDescriptor()); 92 data.WriteString(keyPrefix); 93 data.WriteUint32(watcherId); 94 watcherManager->OnRemoteRequest(IWatcherManager::DEL_WATCHER, data, reply, option); 95 EXPECT_EQ(reply.ReadInt32(), 0); 96 printf("TestDelWatcher %s watcherId %d %p \n", keyPrefix.c_str(), watcherId, watcherManager); 97 return 0; 98 } 99 TestProcessWatcherMessage(const std::string & name,uint32_t watcherId)100 int TestProcessWatcherMessage(const std::string &name, uint32_t watcherId) 101 { 102 WatcherManagerPtr watcherManager = GetWatcherManager(); 103 WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager"); 104 const std::string value("test.value"); 105 uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + value.size(); 106 msgSize = PARAM_ALIGN(msgSize); // align 107 std::vector<char> buffer(msgSize, 0); 108 ParamMessage *msg = (ParamMessage *)buffer.data(); 109 WATCHER_CHECK(msg != NULL, return -1, "Invalid msg"); 110 msg->type = MSG_NOTIFY_PARAM; 111 msg->msgSize = msgSize; 112 msg->id.watcherId = watcherId; 113 int ret = memcpy_s(msg->key, sizeof(msg->key), name.c_str(), name.size()); 114 WATCHER_CHECK(ret == 0, return -1, "Failed to fill value"); 115 uint32_t offset = 0; 116 ret = FillParamMsgContent(msg, &offset, PARAM_VALUE, value.c_str(), value.size()); 117 WATCHER_CHECK(ret == 0, return -1, "Failed to fill value"); 118 watcherManager->ProcessWatcherMessage(buffer, msgSize); 119 return 0; 120 } 121 TestWatchProxy(const std::string & name,const std::string & value)122 int TestWatchProxy(const std::string &name, const std::string &value) 123 { 124 sptr<ISystemAbilityManager> systemMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 125 EXPECT_NE(systemMgr, nullptr); 126 sptr<IRemoteObject> remoteObj = systemMgr->GetSystemAbility(PARAM_WATCHER_DISTRIBUTED_SERVICE_ID); 127 EXPECT_NE(remoteObj, nullptr); 128 WatcherProxy *watcher = new WatcherProxy(remoteObj); 129 if (watcher != nullptr) { 130 watcher->OnParamerterChange(name, value); 131 delete watcher; 132 } 133 return 0; 134 } 135 TestWatchAgentDel(const std::string & keyPrefix)136 int TestWatchAgentDel(const std::string &keyPrefix) 137 { 138 WatcherManagerPtr watcherManager = GetWatcherManager(); 139 WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager"); 140 MessageParcel data; 141 MessageParcel reply; 142 MessageOption option; 143 144 data.WriteInterfaceToken(IWatcherManager::GetDescriptor()); 145 data.WriteString(keyPrefix); 146 sptr<IWatcher> watcher = new TestWatcher(); 147 bool ret = data.WriteRemoteObject(watcher->AsObject()); 148 WATCHER_CHECK(ret, return 0, "Can not get remote"); 149 watcherManager->OnRemoteRequest(IWatcherManager::ADD_WATCHER, data, reply, option); 150 uint32_t watcherId = reply.ReadUint32(); 151 EXPECT_NE(watcherId, 0); 152 if (watcherManager->GetDeathRecipient() != nullptr) { 153 watcherManager->GetDeathRecipient()->OnRemoteDied(watcher->AsObject()); 154 } 155 printf("TestWatchAgentDel %s success \n", keyPrefix.c_str()); 156 EXPECT_EQ(watcherManager->GetWatcher(watcherId) == nullptr, 1); 157 return 0; 158 } 159 TestInvalid(const std::string & keyPrefix)160 int TestInvalid(const std::string &keyPrefix) 161 { 162 WatcherManagerPtr watcherManager = GetWatcherManager(); 163 WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager"); 164 MessageParcel data; 165 MessageParcel reply; 166 MessageOption option; 167 data.WriteString(keyPrefix); 168 sptr<IWatcher> watcher = new TestWatcher(); 169 bool ret = data.WriteRemoteObject(watcher->AsObject()); 170 WATCHER_CHECK(ret, return 0, "Can not get remote"); 171 watcherManager->OnRemoteRequest(IWatcherManager::ADD_WATCHER + 1, data, reply, option); 172 173 if (watcherManager->GetDeathRecipient() != nullptr) { 174 watcherManager->GetDeathRecipient()->OnRemoteDied(watcher->AsObject()); 175 } 176 return 0; 177 } 178 TestStop()179 int TestStop() 180 { 181 WatcherManagerPtr watcherManager = GetWatcherManager(); 182 WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager"); 183 watcherManager->OnStop(); 184 return 0; 185 } 186 GetWatcherManager()187 WatcherManagerPtr GetWatcherManager() 188 { 189 static WatcherManagerPtr watcherManager = nullptr; 190 if (watcherManager == nullptr) { 191 watcherManager = new WatcherManager(0, true); 192 if (watcherManager == nullptr) { 193 return nullptr; 194 } 195 watcherManager->OnStart(); 196 } 197 return watcherManager; 198 } 199 }; 200 201 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher, TestSize.Level0) 202 { 203 WatcherProxyUnitTest test; 204 uint32_t watcherId = 0; 205 test.TestAddWatcher("test.permission.watcher.test1", watcherId); 206 test.TestProcessWatcherMessage("test.permission.watcher.test1", watcherId); 207 } 208 209 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher2, TestSize.Level0) 210 { 211 WatcherProxyUnitTest test; 212 uint32_t watcherId = 0; 213 test.TestAddWatcher("test.permission.watcher.test2", watcherId); 214 test.TestAddWatcher("test.permission.watcher.test2", watcherId); 215 test.TestAddWatcher("test.permission.watcher.test2", watcherId); 216 } 217 218 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher3, TestSize.Level0) 219 { 220 WatcherProxyUnitTest test; 221 uint32_t watcherId = 0; 222 test.TestAddWatcher("test.permission.watcher.test3", watcherId); 223 } 224 225 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher4, TestSize.Level0) 226 { 227 WatcherProxyUnitTest test; 228 uint32_t watcherId = 0; 229 SystemSetParameter("test.watcher.test4", "1101"); 230 SystemSetParameter("test.watcher.test4.test", "1102"); 231 test.TestAddWatcher("test.watcher.test4*", watcherId); 232 } 233 234 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher5, TestSize.Level0) 235 { 236 WatcherProxyUnitTest test; 237 uint32_t watcherId = 0; 238 test.TestAddWatcher("test.permission.watcher.test5", watcherId); 239 SystemSetParameter("test.permission.watcher.test5", "1101"); 240 } 241 242 HWTEST_F(WatcherProxyUnitTest, TestDelWatcher, TestSize.Level0) 243 { 244 WatcherProxyUnitTest test; 245 uint32_t watcherId = 0; 246 test.TestAddWatcher("test.permission.watcher.testDel", watcherId); 247 test.TestDelWatcher("test.permission.watcher.testDel", watcherId); 248 } 249 250 HWTEST_F(WatcherProxyUnitTest, TestWatchProxy, TestSize.Level0) 251 { 252 WatcherProxyUnitTest test; 253 test.TestWatchProxy("test.permission.watcher.test1", "watcherId"); 254 } 255 256 HWTEST_F(WatcherProxyUnitTest, TestWatchAgentDel, TestSize.Level0) 257 { 258 WatcherProxyUnitTest test; 259 test.TestWatchAgentDel("test.permission.watcher.test1"); 260 } 261 262 HWTEST_F(WatcherProxyUnitTest, TestInvalid, TestSize.Level0) 263 { 264 WatcherProxyUnitTest test; 265 test.TestInvalid("test.permission.watcher.test1"); 266 } 267 268 HWTEST_F(WatcherProxyUnitTest, TestStop, TestSize.Level0) 269 { 270 WatcherProxyUnitTest test; 271 test.TestStop(); 272 }