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 if (clientHandle != nullptr) {
61 dlclose(clientHandle);
62 clientHandle = nullptr;
63 }
64 }
65
66 HWTEST_F(AudioProxyManagerTest, ManagerGetAllAdapters_001, TestSize.Level1)
67 {
68 struct AudioManager managerFuncs;
69 struct AudioAdapterDescriptor *descs = nullptr;
70 int size = 0;
71 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(nullptr, &descs, &size));
72 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(&managerFuncs, nullptr, &size));
73 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(&managerFuncs, &descs, nullptr));
74 }
75
76 HWTEST_F(AudioProxyManagerTest, ManagerGetAllAdapters_002, TestSize.Level1)
77 {
78 struct AudioProxyManager proxyMgr;
79 struct AudioManager *managerFuncs = &proxyMgr.impl;
80 struct AudioAdapterDescriptor *descs = nullptr;
81 int size = 0;
82 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(managerFuncs, &descs, &size));
83 }
84
85 HWTEST_F(AudioProxyManagerTest, ManagerGetAllAdapters_003, TestSize.Level1)
86 {
87 ASSERT_NE(manager, nullptr);
88 int size = 0;
89 struct HdfRemoteService *remoteService = nullptr;
90 struct HdfRemoteService *usbRemoteService = nullptr;
91 struct HdfRemoteService *a2dpRemoteService = nullptr;
92 struct AudioProxyManager *proxyManager = CONTAINER_OF(manager, struct AudioProxyManager, impl);
93 remoteService = proxyManager->remote;
94 usbRemoteService = proxyManager->usbRemote;
95 a2dpRemoteService = proxyManager->a2dpRemote;
96 proxyManager->remote = nullptr;
97 proxyManager->usbRemote = nullptr;
98 proxyManager->a2dpRemote = nullptr;
99 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(manager, &descs, &size));
100 proxyManager->remote = remoteService;
101 proxyManager->usbRemote = usbRemoteService;
102 proxyManager->a2dpRemote = a2dpRemoteService;
103
104 uint32_t audioMagic = proxyManager->audioMagic;
105 proxyManager->audioMagic = audioCheck - 1;
106 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerGetAllAdapters(manager, &descs, &size));
107 proxyManager->audioMagic = audioMagic;
108
109 remoteService = nullptr;
110 audioMagic = 0;
111 }
112
113 HWTEST_F(AudioProxyManagerTest, ManagerLoadAdapter_001, TestSize.Level1)
114 {
115 struct AudioManager managerFuncs;
116 struct AudioAdapterDescriptor descObject;
117 const struct AudioAdapterDescriptor *desc = &descObject;
118 struct AudioAdapter adapterObject;
119 struct AudioAdapter *adapter = &adapterObject;
120 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(nullptr, desc, &adapter));
121 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(&managerFuncs, nullptr, &adapter));
122 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(&managerFuncs, desc, nullptr));
123 }
124
125 HWTEST_F(AudioProxyManagerTest, ManagerLoadAdapter_002, TestSize.Level1)
126 {
127 ASSERT_NE(manager, nullptr);
128 struct AudioManager managerFuncs;
129 struct AudioAdapterDescriptor descObject;
130 const struct AudioAdapterDescriptor *desc = &descObject;
131 struct AudioAdapter adapterObject;
132 struct AudioAdapter *adapter = &adapterObject;
133
134 struct HdfRemoteService *remoteService = nullptr;
135 struct AudioProxyManager *proxyManager = CONTAINER_OF(manager, struct AudioProxyManager, impl);
136
137 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(&managerFuncs, desc, &adapter));
138
139 remoteService = proxyManager->remote;
140 proxyManager->remote = nullptr;
141 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(manager, desc, &adapter));
142 proxyManager->remote = remoteService;
143
144 uint32_t audioMagic = proxyManager->audioMagic;
145 proxyManager->audioMagic = audioCheck - 1;
146 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyManagerLoadAdapter(manager, desc, &adapter));
147 proxyManager->audioMagic = audioMagic;
148
149 remoteService = nullptr;
150 audioMagic = 0;
151 }
152 }
153
154