1 /*
2 * Copyright (c) 2022 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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include "hdf_dlist.h"
19 #include "audio_proxy_common_fun_test.h"
20
21 using namespace std;
22 using namespace comfun;
23 using namespace testing::ext;
24 namespace {
25 class AudioProxyManagerTest : public testing::Test {
26 public:
27 uint32_t audioCheck = 0xAAAAAAAA;
28 struct AudioManager *manager = nullptr;
29 struct AudioManager *(*getAudioManager)(void) = NULL;
30 struct AudioAdapterDescriptor *descs = nullptr;
31 struct AudioAdapterDescriptor *desc = nullptr;
32 struct AudioAdapter *adapter = nullptr;
33 void *clientHandle = nullptr;
34 virtual void SetUp();
35 virtual void TearDown();
36 };
37
SetUp()38 void AudioProxyManagerTest::SetUp()
39 {
40 clientHandle = GetDynamicLibHandle(RESOLVED_PATH);
41 ASSERT_NE(clientHandle, nullptr);
42 getAudioManager = (struct AudioManager *(*)())(dlsym(clientHandle, FUNCTION_NAME.c_str()));
43 ASSERT_NE(getAudioManager, nullptr);
44 manager = getAudioManager();
45 ASSERT_NE(manager, nullptr);
46 int32_t size = 0;
47 ASSERT_EQ(HDF_SUCCESS, manager->GetAllAdapters(manager, &descs, &size));
48 desc = &descs[0];
49 ASSERT_EQ(HDF_SUCCESS, manager->LoadAdapter(manager, desc, &adapter));
50 }
51
TearDown()52 void AudioProxyManagerTest::TearDown()
53 {
54 if (manager != nullptr) {
55 manager->UnloadAdapter(manager, adapter);
56 adapter = nullptr;
57 manager->ReleaseAudioManagerObject(manager);
58 manager = nullptr;
59 }
60 }
61
62 HWTEST_F(AudioProxyManagerTest, ManagerGetAllAdapters_001, TestSize.Level1)
63 {
64 struct AudioManager managerFuncs;
65 struct AudioAdapterDescriptor *descs = nullptr;
66 int size = 0;
67 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->GetAllAdapters(nullptr, &descs, &size));
68 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->GetAllAdapters(&managerFuncs, nullptr, &size));
69 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->GetAllAdapters(&managerFuncs, &descs, nullptr));
70 }
71
72 HWTEST_F(AudioProxyManagerTest, ManagerGetAllAdapters_002, TestSize.Level1)
73 {
74 struct AudioProxyManager proxyMgr;
75 struct AudioManager *managerFuncs = &proxyMgr.impl;
76 struct AudioAdapterDescriptor *descs = nullptr;
77 int size = 0;
78 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->GetAllAdapters(managerFuncs, &descs, &size));
79 }
80
81 HWTEST_F(AudioProxyManagerTest, ManagerGetAllAdapters_003, TestSize.Level1)
82 {
83 ASSERT_NE(manager, nullptr);
84 int size = 0;
85 struct HdfRemoteService *remoteService = nullptr;
86 struct HdfRemoteService *usbRemoteService = nullptr;
87 struct HdfRemoteService *a2dpRemoteService = nullptr;
88 struct AudioProxyManager *proxyManager = CONTAINER_OF(manager, struct AudioProxyManager, impl);
89 remoteService = proxyManager->remote;
90 usbRemoteService = proxyManager->usbRemote;
91 a2dpRemoteService = proxyManager->a2dpRemote;
92 proxyManager->remote = nullptr;
93 proxyManager->usbRemote = nullptr;
94 proxyManager->a2dpRemote = nullptr;
95 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->GetAllAdapters(manager, &descs, &size));
96 proxyManager->remote = remoteService;
97 proxyManager->usbRemote = usbRemoteService;
98 proxyManager->a2dpRemote = a2dpRemoteService;
99
100 uint32_t audioMagic = proxyManager->audioMagic;
101 proxyManager->audioMagic = audioCheck - 1;
102 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->GetAllAdapters(manager, &descs, &size));
103 proxyManager->audioMagic = audioMagic;
104
105 remoteService = nullptr;
106 audioMagic = 0;
107 }
108
109 HWTEST_F(AudioProxyManagerTest, ManagerLoadAdapter_001, TestSize.Level1)
110 {
111 struct AudioManager managerFuncs;
112 struct AudioAdapterDescriptor descObject;
113 const struct AudioAdapterDescriptor *desc = &descObject;
114 struct AudioAdapter adapterObject;
115 struct AudioAdapter *adapter = &adapterObject;
116 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->LoadAdapter(nullptr, desc, &adapter));
117 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->LoadAdapter(&managerFuncs, nullptr, &adapter));
118 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->LoadAdapter(&managerFuncs, desc, nullptr));
119 }
120
121 HWTEST_F(AudioProxyManagerTest, ManagerLoadAdapter_002, TestSize.Level1)
122 {
123 ASSERT_NE(manager, nullptr);
124 struct AudioManager managerFuncs;
125 struct AudioAdapterDescriptor descObject;
126 const struct AudioAdapterDescriptor *desc = &descObject;
127 struct AudioAdapter adapterObject;
128 struct AudioAdapter *adapter = &adapterObject;
129
130 struct HdfRemoteService *remoteService = nullptr;
131 struct AudioProxyManager *proxyManager = CONTAINER_OF(manager, struct AudioProxyManager, impl);
132
133 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->LoadAdapter(&managerFuncs, desc, &adapter));
134
135 remoteService = proxyManager->remote;
136 proxyManager->remote = nullptr;
137 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->LoadAdapter(manager, desc, &adapter));
138 proxyManager->remote = remoteService;
139
140 uint32_t audioMagic = proxyManager->audioMagic;
141 proxyManager->audioMagic = audioCheck - 1;
142 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, manager->LoadAdapter(manager, desc, &adapter));
143 proxyManager->audioMagic = audioMagic;
144
145 remoteService = nullptr;
146 audioMagic = 0;
147 }
148 }
149
150