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 sinkDev_ 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 "daudio_sink_service_test.h"
17
18 #include "audio_event.h"
19 #include "daudio_constants.h"
20 #include "daudio_errorcode.h"
21 #include "iservice_registry.h"
22 #include "daudio_sink_ipc_callback_proxy.h"
23 #include "daudio_sink_load_callback.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace DistributedHardware {
SetUpTestCase(void)29 void DAudioSinkServiceTest::SetUpTestCase(void) {}
30
TearDownTestCase(void)31 void DAudioSinkServiceTest::TearDownTestCase(void) {}
32
SetUp()33 void DAudioSinkServiceTest::SetUp()
34 {
35 uint32_t saId = 6666;
36 bool runOnCreate = true;
37 std::string params = "params";
38 samgr_ = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
39 if (samgr_ == nullptr) {
40 return;
41 }
42 sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
43 samgr_->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
44 remoteObject_ = samgr_->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
45 if (remoteObject_ == nullptr) {
46 return;
47 }
48
49 sinkSrv_ = std::make_shared<DAudioSinkService>(saId, runOnCreate);
50 }
51
TearDown()52 void DAudioSinkServiceTest::TearDown()
53 {
54 if (samgr_ != nullptr) {
55 samgr_->UnloadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
56 }
57 sinkSrv_ = nullptr;
58 }
59
60 /**
61 * @tc.name: OnStart_001
62 * @tc.desc: Verify the OnStart function.
63 * @tc.type: FUNC
64 * @tc.require: AR000H0E5F
65 */
66 HWTEST_F(DAudioSinkServiceTest, OnStart_001, TestSize.Level1)
67 {
68 sinkSrv_->isServiceStarted_ = true;
69 sinkSrv_->OnStart();
70
71 std::string dhId = "oh123";
72 std::string pram = "test";
73 EXPECT_EQ(DH_SUCCESS, sinkSrv_->SubscribeLocalHardware(dhId, pram));
74 }
75
76 /**
77 * @tc.name: Init_001
78 * @tc.desc: Verify the Init function.
79 * @tc.type: FUNC
80 * @tc.require: AR000H0E5F
81 */
82 HWTEST_F(DAudioSinkServiceTest, Init_001, TestSize.Level1)
83 {
84 sinkSrv_->isServiceStarted_ = true;
85 EXPECT_EQ(true, sinkSrv_->Init());
86 }
87
88 /**
89 * @tc.name: InitSink_001
90 * @tc.desc: Verify the InitSink function.
91 * @tc.type: FUNC
92 * @tc.require: AR000H0E5F
93 */
94 HWTEST_F(DAudioSinkServiceTest, InitSink_001, TestSize.Level1)
95 {
96 std::string param = "sink";
97 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
98 EXPECT_EQ(DH_SUCCESS, sinkSrv_->InitSink(param, dAudioSinkIpcCallbackProxy));
99 }
100
101 /**
102 * @tc.name: SubscribeLocalHardware_001
103 * @tc.desc: Verify the SubscribeLocalHardware function.
104 * @tc.type: FUNC
105 * @tc.require: AR000H0E5F
106 */
107 HWTEST_F(DAudioSinkServiceTest, SubscribeLocalHardware_001, TestSize.Level1)
108 {
109 std::string dhId = "oh123";
110 std::string pram = "test";
111
112 sinkSrv_->isServiceStarted_ = true;
113 sinkSrv_->OnStop();
114 EXPECT_EQ(DH_SUCCESS, sinkSrv_->SubscribeLocalHardware(dhId, pram));
115 }
116
117 /**
118 * @tc.name: UnsubscribeLocalHardware_001
119 * @tc.desc: Verify the UnsubscribeLocalHardware function.
120 * @tc.type: FUNC
121 * @tc.require: AR000H0E5F
122 */
123 HWTEST_F(DAudioSinkServiceTest, UnsubscribeLocalHardware_001, TestSize.Level1)
124 {
125 std::string devId = "efwewf";
126 std::string dhId = "oh123";
127 int32_t eventType = 2;
128 std::string eventContent = "OPEN_MIC";
129 std::string param = "sink";
130 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
131
132 sinkSrv_->InitSink(param, dAudioSinkIpcCallbackProxy);
133 sinkSrv_->DAudioNotify(devId, dhId, eventType, eventContent);
134 EXPECT_EQ(DH_SUCCESS, sinkSrv_->UnsubscribeLocalHardware(dhId));
135 sinkSrv_->ReleaseSink();
136 }
137
138 /**
139 * @tc.name: Dump_001
140 * @tc.desc: Verify the Dump function.
141 * @tc.type: FUNC
142 * @tc.require: AR000H0E5F
143 */
144 HWTEST_F(DAudioSinkServiceTest, Dump_001, TestSize.Level1)
145 {
146 int32_t fd = 1;
147 std::vector<std::u16string> args;
148 EXPECT_EQ(DH_SUCCESS, sinkSrv_->Dump(fd, args));
149 std::u16string order = u"-h";
150 args.push_back(order);
151 EXPECT_EQ(DH_SUCCESS, sinkSrv_->Dump(fd, args));
152 args.pop_back();
153 order = u"--stopDump";
154 args.push_back(order);
155 EXPECT_EQ(DH_SUCCESS, sinkSrv_->Dump(fd, args));
156 order = u"--illegal";
157 args.push_back(order);
158 EXPECT_EQ(DH_SUCCESS, sinkSrv_->Dump(fd, args));
159 }
160
161 /**
162 * @tc.name: PauseDistributedHardware_001
163 * @tc.desc: Verify the PauseDistributedHardware function.
164 * @tc.type: FUNC
165 * @tc.require: AR000H0E5F
166 */
167 HWTEST_F(DAudioSinkServiceTest, PauseDistributedHardware_001, TestSize.Level1)
168 {
169 std::string networkId = "1";
170 EXPECT_EQ(DH_SUCCESS, sinkSrv_->PauseDistributedHardware(networkId));
171 EXPECT_EQ(DH_SUCCESS, sinkSrv_->ResumeDistributedHardware(networkId));
172 EXPECT_EQ(DH_SUCCESS, sinkSrv_->StopDistributedHardware(networkId));
173 }
174 } // DistributedHardware
175 } // OHOS
176