blob: d92c8bac6afa8b5d353e6d7823fa85ccfdae0948 [file] [log] [blame]
Eric Laurent3be0f002022-12-15 16:08:30 +01001/*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Chris Waddellca0dd182022-11-25 17:15:30 +000016#include "tests/UsecaseValidator-test.h"
17
18#include <gtest/gtest.h>
19
20namespace android {
21namespace media {
22
23/**
24 * Helper test functions.
25 */
26
27/**
28 * Register a mock stream.
29 */
30audio_io_handle_t UsecaseValidatorTest::testRegisterStream(bool outputFlagGame) {
31 static int streamId = 0;
32 status_t result;
33 static audio_config_base_t audioConfig = AUDIO_CONFIG_BASE_INITIALIZER;
34 audio_output_flags_t outputFlags = outputFlagGame ? GAME_OUTPUT_FLAGS : MEDIA_OUTPUT_FLAGS;
35
36 result = m_validator->registerStream(++streamId, audioConfig, outputFlags);
37
38 return result == OK ? streamId : 0;
39}
40
41/**
42 * Create a mock portId.
43 */
44audio_port_handle_t UsecaseValidatorTest::testCreatePortId(audio_io_handle_t streamId) {
45 static int portId = 0;
46
47 return (streamId << 8) | (++portId);
48}
49
50/**
51 * Add a mock portId to a stream and verify.
52 */
53error::Result<audio_attributes_t> UsecaseValidatorTest::testStartClient(audio_io_handle_t streamId,
54 audio_port_handle_t portId,
55 audio_usage_t usage) {
56 content::AttributionSourceState attributionSource;
57 audio_attributes_t attributes = AUDIO_ATTRIBUTES_INITIALIZER;
58 attributes.usage = usage;
59
60 return m_validator->startClient(streamId, portId, attributionSource, attributes, NULL);
61}
62
63/**
64 * Verify a mock stream.
65 */
66error::Result<audio_attributes_t> UsecaseValidatorTest::testVerifyAudioAttributes(
67 audio_io_handle_t streamId,
68 audio_usage_t usage) {
69 content::AttributionSourceState attributionSource;
70 audio_attributes_t attributes = AUDIO_ATTRIBUTES_INITIALIZER;
71 attributes.usage = usage;
72
73 return m_validator->verifyAudioAttributes(streamId, attributionSource, attributes);
74}
75
76/**
77 * Test functions.
78 */
79
80/**
81 * Test adding and removing streams.
82 */
83TEST_F(UsecaseLookupTest, testAddAndRemoveStream) {
84 addStream(1, false);
85 addStream(2, true);
86
87 EXPECT_NE(m_streams.find(1), m_streams.end());
88 EXPECT_NE(m_streams.find(2), m_streams.end());
89 EXPECT_EQ(m_streams.find(3), m_streams.end());
90
91 EXPECT_FALSE(isGameStream(1));
92 EXPECT_TRUE(isGameStream(2));
93 EXPECT_FALSE(isGameStream(3));
94
95 removeStream(2);
96
97 EXPECT_FALSE(isGameStream(2));
98}
99
100/**
101 * Verify attributes usage for stream.
102 */
103TEST_F(UsecaseValidatorTest, testAttributesUsage) {
104 audio_io_handle_t gameStreamId, mediaStreamId;
105
106 // Register game and media stream.
107 gameStreamId = testRegisterStream(true);
108 mediaStreamId = testRegisterStream(false);
109 EXPECT_NE(gameStreamId, 0);
110 EXPECT_NE(mediaStreamId, 0);
111 EXPECT_NE(gameStreamId, mediaStreamId);
112
113 // Verify attributes on game stream.
114 auto attr = testVerifyAudioAttributes(gameStreamId, AUDIO_USAGE_GAME);
115 EXPECT_EQ(attr.value().usage, AUDIO_USAGE_GAME);
116
117 // Verify attributes on media stream.
118 attr = testVerifyAudioAttributes(mediaStreamId, AUDIO_USAGE_MEDIA);
119 EXPECT_EQ(attr.value().usage, AUDIO_USAGE_MEDIA);
120
121 EXPECT_EQ(m_validator->unregisterStream(gameStreamId), 0);
122 EXPECT_EQ(m_validator->unregisterStream(mediaStreamId), 0);
123}
124
125/**
126 * Test hanging client.
127 */
128TEST_F(UsecaseValidatorTest, testHangingClient) {
129 audio_io_handle_t gameStreamId, mediaStreamId;
130 audio_port_handle_t gamePortId, mediaPortId;
131
132 // Register game and media stream.
133 gameStreamId = testRegisterStream(true);
134 EXPECT_NE(gameStreamId, 0);
135 mediaStreamId = testRegisterStream(false);
136 EXPECT_NE(mediaStreamId, 0);
137
138 // Assign portId.
139 gamePortId = testCreatePortId(gameStreamId);
140 EXPECT_NE(gamePortId, 0);
141 mediaPortId = testCreatePortId(mediaStreamId);
142 EXPECT_NE(mediaPortId, 0);
143
144 // Start client on game stream.
145 testStartClient(gameStreamId, gamePortId, AUDIO_USAGE_GAME);
146
147 // Start client on media stream.
148 testStartClient(mediaStreamId, mediaPortId, AUDIO_USAGE_MEDIA);
149
150 // Unregister media stream before stopClient.
151 EXPECT_EQ(m_validator->unregisterStream(gameStreamId), 0);
152 EXPECT_EQ(m_validator->unregisterStream(mediaStreamId), 0);
153}
154
155/**
156 * Verify attributes usage does not change.
157 */
158TEST_F(UsecaseValidatorTest, testAttributesUsageUnchanged) {
159 audio_io_handle_t gameStreamId, mediaStreamId;
160 audio_port_handle_t gamePortId, mediaPortId, unknownPortId, voiceCommPortId;
161
162 // Register game and media stream.
163 gameStreamId = testRegisterStream(true);
164 EXPECT_NE(gameStreamId, 0);
165 mediaStreamId = testRegisterStream(false);
166 EXPECT_NE(mediaStreamId, 0);
167
168 // Assign portId.
169 gamePortId = testCreatePortId(gameStreamId);
170 EXPECT_NE(gamePortId, 0);
171 mediaPortId = testCreatePortId(mediaStreamId);
172 EXPECT_NE(mediaPortId, 0);
173 unknownPortId = testCreatePortId(mediaStreamId);
174 EXPECT_NE(unknownPortId, 0);
175 voiceCommPortId = testCreatePortId(gameStreamId);
176 EXPECT_NE(voiceCommPortId, 0);
177
178 // Verify attributes on game stream.
179 auto attr = testStartClient(gameStreamId, gamePortId, AUDIO_USAGE_GAME);
180 EXPECT_EQ(attr.value().usage, AUDIO_USAGE_GAME);
181
182 attr = testStartClient(gameStreamId, voiceCommPortId, AUDIO_USAGE_VOICE_COMMUNICATION);
183 EXPECT_EQ(attr.value().usage, AUDIO_USAGE_VOICE_COMMUNICATION);
184
185 // Verify attributes on media stream.
186 attr = testStartClient(mediaStreamId, mediaPortId, AUDIO_USAGE_MEDIA);
187 EXPECT_EQ(attr.value().usage, AUDIO_USAGE_MEDIA);
188
189 attr = testStartClient(mediaStreamId, unknownPortId, AUDIO_USAGE_UNKNOWN);
190 EXPECT_EQ(attr.value().usage, AUDIO_USAGE_UNKNOWN);
191
192 // Stop client on game and media stream.
193 EXPECT_EQ(m_validator->stopClient(gameStreamId, gamePortId), 0);
194 EXPECT_EQ(m_validator->stopClient(mediaStreamId, mediaPortId), 0);
195
196 // Unregister game and media stream.
197 EXPECT_EQ(m_validator->unregisterStream(gameStreamId), 0);
198 EXPECT_EQ(m_validator->unregisterStream(mediaStreamId), 0);
199}
200
201/**
202 * Verify attributes usage changes.
203 */
204TEST_F(UsecaseValidatorTest, testAttributesUsageChanged) {
205 audio_io_handle_t gameStreamId;
206 audio_port_handle_t mediaPortId, unknownPortId;
207
208 // Register game and media stream.
209 gameStreamId = testRegisterStream(true);
210 EXPECT_NE(gameStreamId, 0);
211
212 // Assign portId.
213 mediaPortId = testCreatePortId(gameStreamId);
214 EXPECT_NE(mediaPortId, 0);
215 unknownPortId = testCreatePortId(gameStreamId);
216 EXPECT_NE(unknownPortId, 0);
217
218 // Verify attributes on game stream.
219 auto attr = testStartClient(gameStreamId, mediaPortId, AUDIO_USAGE_MEDIA);
220 EXPECT_EQ(attr.value().usage, AUDIO_USAGE_GAME);
221
222 attr = testStartClient(gameStreamId, unknownPortId, AUDIO_USAGE_UNKNOWN);
223 EXPECT_EQ(attr.value().usage, AUDIO_USAGE_GAME);
224
225 // Unregister game stream.
226 EXPECT_EQ(m_validator->unregisterStream(gameStreamId), 0);
227}
228
229} // namespace media
230} // namespace android