Eric Laurent | 3be0f00 | 2022-12-15 16:08:30 +0100 | [diff] [blame^] | 1 | /* |
| 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 Waddell | ca0dd18 | 2022-11-25 17:15:30 +0000 | [diff] [blame] | 16 | #include "tests/UsecaseValidator-test.h" |
| 17 | |
| 18 | #include <gtest/gtest.h> |
| 19 | |
| 20 | namespace android { |
| 21 | namespace media { |
| 22 | |
| 23 | /** |
| 24 | * Helper test functions. |
| 25 | */ |
| 26 | |
| 27 | /** |
| 28 | * Register a mock stream. |
| 29 | */ |
| 30 | audio_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 | */ |
| 44 | audio_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 | */ |
| 53 | error::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 | */ |
| 66 | error::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 | */ |
| 83 | TEST_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 | */ |
| 103 | TEST_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 | */ |
| 128 | TEST_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 | */ |
| 158 | TEST_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 | */ |
| 204 | TEST_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 |