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 */ 16 17 package android.car.media; 18 19 import static android.media.AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE; 20 import static android.media.AudioAttributes.USAGE_ASSISTANT; 21 import static android.media.AudioAttributes.USAGE_MEDIA; 22 23 import static org.junit.Assert.assertThrows; 24 25 import android.car.feature.Flags; 26 import android.car.test.AbstractExpectableTestCase; 27 import android.media.AudioAttributes; 28 import android.media.AudioDeviceAttributes; 29 import android.media.AudioDeviceInfo; 30 import android.os.Parcel; 31 import android.platform.test.flag.junit.SetFlagsRule; 32 33 import org.junit.Rule; 34 import org.junit.Test; 35 36 import java.util.List; 37 38 public final class CarVolumeGroupInfoUnitTest extends AbstractExpectableTestCase { 39 40 private static final int TEST_ZONE_ID = 8; 41 private static final int TEST_PRIMARY_GROUP_ID = 7; 42 private static final String TEST_GROUP_NAME = "3"; 43 private static final int TEST_PARCEL_FLAGS = 0; 44 private static final int TEST_CURRENT_GAIN = 9_000; 45 private static final boolean TEST_DEFAULT_MUTE_STATE = false; 46 private static final boolean TEST_DEFAULT_BLOCKED_STATE = false; 47 private static final boolean TEST_DEFAULT_ATTENUATED_STATE = false; 48 private static final int TEST_MAX_GAIN_INDEX = 9_005; 49 private static final int TEST_MIN_GAIN_INDEX = 0; 50 private static final int TEST_MAX_ACTIVATION_GAIN_INDEX = 8_005; 51 private static final int TEST_MIN_ACTIVATION_GAIN_INDEX = 1_000; 52 private static final boolean TEST_MUTE_BY_SYSTEM_STATE = true; 53 private static final AudioAttributes TEST_MEDIA_AUDIO_ATTRIBUTE = 54 new AudioAttributes.Builder().setUsage(USAGE_MEDIA).build(); 55 private static final AudioAttributes TEST_NAVIGATION_AUDIO_ATTRIBUTE = 56 new AudioAttributes.Builder().setUsage(USAGE_ASSISTANCE_NAVIGATION_GUIDANCE).build(); 57 private static final AudioAttributes TEST_ASSISTANT_AUDIO_ATTRIBUTE = 58 new AudioAttributes.Builder().setUsage(USAGE_ASSISTANT).build(); 59 private static final List<AudioAttributes> TEST_AUDIO_ATTRIBUTES = List.of( 60 TEST_MEDIA_AUDIO_ATTRIBUTE, TEST_NAVIGATION_AUDIO_ATTRIBUTE, 61 TEST_ASSISTANT_AUDIO_ATTRIBUTE); 62 63 private static final CarVolumeGroupInfo TEST_VOLUME_INFO = 64 new CarVolumeGroupInfo.Builder(TEST_GROUP_NAME, TEST_ZONE_ID, TEST_PRIMARY_GROUP_ID) 65 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 66 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 67 .setAudioAttributes(TEST_AUDIO_ATTRIBUTES) 68 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 69 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 70 private static final AudioDeviceAttributes TEST_AUDIO_DEVICE_ATTRIBUTE = 71 new AudioDeviceAttributes(AudioDeviceAttributes.ROLE_OUTPUT, 72 AudioDeviceInfo.TYPE_BLUETOOTH_A2DP, "a2dp"); 73 74 private final CarVolumeGroupInfo.Builder mTestGroupInfoBuilder = 75 new CarVolumeGroupInfo.Builder(TEST_GROUP_NAME, 76 TEST_ZONE_ID, TEST_PRIMARY_GROUP_ID).setAttenuated(TEST_DEFAULT_ATTENUATED_STATE) 77 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 78 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 79 .setVolumeGainIndex(TEST_CURRENT_GAIN).setBlocked(TEST_DEFAULT_BLOCKED_STATE) 80 .setMuted(TEST_DEFAULT_MUTE_STATE) 81 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 82 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX); 83 84 @Rule 85 public final SetFlagsRule mSetFlagsRule = new SetFlagsRule(); 86 87 @Test build_buildsGroupInfo()88 public void build_buildsGroupInfo() { 89 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 90 91 CarVolumeGroupInfo info = new CarVolumeGroupInfo 92 .Builder(TEST_GROUP_NAME, TEST_ZONE_ID, TEST_PRIMARY_GROUP_ID) 93 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 94 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 95 .setVolumeGainIndex(TEST_CURRENT_GAIN) 96 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 97 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 98 99 expectWithMessage("Car volume info build info zone id") 100 .that(info.getZoneId()).isEqualTo(TEST_ZONE_ID); 101 expectWithMessage("Car volume info build info group id") 102 .that(info.getId()).isEqualTo(TEST_PRIMARY_GROUP_ID); 103 expectWithMessage("Car volume info build info group name") 104 .that(info.getName()).isEqualTo(TEST_GROUP_NAME); 105 } 106 107 @Test build_buildsGroupInfo_withoutAudioDevices_succeeds()108 public void build_buildsGroupInfo_withoutAudioDevices_succeeds() { 109 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 110 111 CarVolumeGroupInfo info = new CarVolumeGroupInfo 112 .Builder(TEST_GROUP_NAME, TEST_ZONE_ID, TEST_PRIMARY_GROUP_ID) 113 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 114 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 115 .setVolumeGainIndex(TEST_CURRENT_GAIN) 116 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 117 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 118 119 expectWithMessage("Car volume group id, for group built without audio devices") 120 .that(info.getId()).isEqualTo(TEST_PRIMARY_GROUP_ID); 121 } 122 123 @Test build_buildsGroupInfo_withAudioDevices_succeeds()124 public void build_buildsGroupInfo_withAudioDevices_succeeds() { 125 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 126 127 CarVolumeGroupInfo info = new CarVolumeGroupInfo 128 .Builder(TEST_GROUP_NAME, TEST_ZONE_ID, TEST_PRIMARY_GROUP_ID) 129 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 130 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 131 .setVolumeGainIndex(TEST_CURRENT_GAIN) 132 .setAudioDeviceAttributes(List.of(TEST_AUDIO_DEVICE_ATTRIBUTE)) 133 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 134 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 135 136 expectWithMessage("Car volume group info devices") 137 .that(info.getAudioDeviceAttributes()).containsExactly(TEST_AUDIO_DEVICE_ATTRIBUTE); 138 } 139 140 @Test build_buildsGroupInfo_withNullAudioDevices_fails()141 public void build_buildsGroupInfo_withNullAudioDevices_fails() { 142 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 143 144 NullPointerException thrown = assertThrows(NullPointerException.class, () -> 145 new CarVolumeGroupInfo.Builder(TEST_GROUP_NAME, TEST_ZONE_ID, 146 TEST_PRIMARY_GROUP_ID).setAudioDeviceAttributes(null) 147 ); 148 149 expectWithMessage("Null audio devices exception") 150 .that(thrown).hasMessageThat().contains("Audio Device Attributes"); 151 } 152 153 @Test build_buildsGroupInfo_withMinMaxActivationVolume_succeeds()154 public void build_buildsGroupInfo_withMinMaxActivationVolume_succeeds() { 155 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 156 157 CarVolumeGroupInfo info = new CarVolumeGroupInfo 158 .Builder(TEST_GROUP_NAME, TEST_ZONE_ID, TEST_PRIMARY_GROUP_ID) 159 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 160 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 161 .setVolumeGainIndex(TEST_CURRENT_GAIN) 162 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 163 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 164 165 expectWithMessage("Car volume group info max activation volume") 166 .that(info.getMaxActivationVolumeGainIndex()) 167 .isEqualTo(TEST_MAX_ACTIVATION_GAIN_INDEX); 168 expectWithMessage("Car volume group info min activation volume") 169 .that(info.getMinActivationVolumeGainIndex()) 170 .isEqualTo(TEST_MIN_ACTIVATION_GAIN_INDEX); 171 } 172 173 @Test build_buildsGroupInfo_withMinActivationVolumeOutOfMinMaxRange_fails()174 public void build_buildsGroupInfo_withMinActivationVolumeOutOfMinMaxRange_fails() { 175 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 176 CarVolumeGroupInfo.Builder infoBuilder = mTestGroupInfoBuilder 177 .setMinActivationVolumeGainIndex(TEST_MIN_GAIN_INDEX - 1); 178 179 IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, 180 infoBuilder::build); 181 182 expectWithMessage("Min activation volume out of range exception") 183 .that(thrown).hasMessageThat().contains("Min activation volume gain index"); 184 } 185 186 @Test build_buildsGroupInfo_withMaxActivationVolumeOutOfMinMaxRange_fails()187 public void build_buildsGroupInfo_withMaxActivationVolumeOutOfMinMaxRange_fails() { 188 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 189 CarVolumeGroupInfo.Builder infoBuilder = mTestGroupInfoBuilder 190 .setMaxActivationVolumeGainIndex(TEST_MAX_GAIN_INDEX + 1); 191 192 IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, 193 infoBuilder::build); 194 195 expectWithMessage("Max activation volume out of range exception") 196 .that(thrown).hasMessageThat().contains("Max activation volume gain index"); 197 } 198 199 @Test build_buildsGroupInfo_withMinLargerThanMaxActivationVolume_fails()200 public void build_buildsGroupInfo_withMinLargerThanMaxActivationVolume_fails() { 201 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 202 CarVolumeGroupInfo.Builder infoBuilder = mTestGroupInfoBuilder 203 .setMinActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 204 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX - 1); 205 206 IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, 207 infoBuilder::build); 208 209 expectWithMessage("Min activation volume gain larger than max activation exception") 210 .that(thrown).hasMessageThat().contains("must be smaller than max activation"); 211 } 212 213 @Test build_buildsGroupInfo_withMuteBySystem_succeeds()214 public void build_buildsGroupInfo_withMuteBySystem_succeeds() { 215 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MUTE_AMBIGUITY); 216 217 CarVolumeGroupInfo info = new CarVolumeGroupInfo 218 .Builder(TEST_GROUP_NAME, TEST_ZONE_ID, TEST_PRIMARY_GROUP_ID) 219 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 220 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 221 .setVolumeGainIndex(TEST_CURRENT_GAIN) 222 .setAudioDeviceAttributes(List.of(TEST_AUDIO_DEVICE_ATTRIBUTE)) 223 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 224 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX) 225 .setMutedBySystem(TEST_MUTE_BY_SYSTEM_STATE).build(); 226 227 expectWithMessage("Car volume group info system mute state") 228 .that(info.isMutedBySystem()).isEqualTo(TEST_MUTE_BY_SYSTEM_STATE); 229 } 230 231 @Test build_withNullName_fails()232 public void build_withNullName_fails() { 233 NullPointerException thrown = assertThrows(NullPointerException.class, () -> 234 new CarVolumeGroupInfo.Builder(/* name= */ null, 235 TEST_ZONE_ID, TEST_PRIMARY_GROUP_ID) 236 ); 237 238 expectWithMessage("Null volume info name exception") 239 .that(thrown).hasMessageThat().contains("Volume info name"); 240 } 241 242 @Test setVolumeGainIndex_buildsGroupInfo()243 public void setVolumeGainIndex_buildsGroupInfo() { 244 CarVolumeGroupInfo info = mTestGroupInfoBuilder.setVolumeGainIndex(9_001).build(); 245 246 expectWithMessage("Car volume info gain") 247 .that(info.getVolumeGainIndex()).isEqualTo(9_001); 248 } 249 250 @Test setMinVolumeGainIndex_buildsGroupInfo()251 public void setMinVolumeGainIndex_buildsGroupInfo() { 252 CarVolumeGroupInfo info = mTestGroupInfoBuilder.setMinVolumeGainIndex(10).build(); 253 254 expectWithMessage("Car volume info min gain") 255 .that(info.getMinVolumeGainIndex()).isEqualTo(10); 256 } 257 258 @Test setMaxVolumeGainIndex_buildsGroupInfo()259 public void setMaxVolumeGainIndex_buildsGroupInfo() { 260 CarVolumeGroupInfo info = mTestGroupInfoBuilder.setMaxVolumeGainIndex(9_002).build(); 261 262 expectWithMessage("Car volume info max gain") 263 .that(info.getMaxVolumeGainIndex()).isEqualTo(9_002); 264 } 265 266 @Test setMaxVolumeGainIndex_withMinLargerThanMax_buildFails()267 public void setMaxVolumeGainIndex_withMinLargerThanMax_buildFails() { 268 CarVolumeGroupInfo.Builder infoBuilder = 269 mTestGroupInfoBuilder.setMinVolumeGainIndex(9003) 270 .setMaxVolumeGainIndex(9_002); 271 272 IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, 273 () -> infoBuilder.build()); 274 275 expectWithMessage("Max volume gain smaller than min gain exception") 276 .that(thrown).hasMessageThat().contains("must be smaller than max"); 277 } 278 279 @Test setVolumeGainIndex_withGainOutOfMinMaxRange_buildFails()280 public void setVolumeGainIndex_withGainOutOfMinMaxRange_buildFails() { 281 CarVolumeGroupInfo.Builder infoBuilder = 282 mTestGroupInfoBuilder.setMinVolumeGainIndex(10) 283 .setMaxVolumeGainIndex(100).setVolumeGainIndex(0); 284 285 IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, 286 () -> infoBuilder.build()); 287 288 expectWithMessage("Volume gain index out of range exception") 289 .that(thrown).hasMessageThat().contains("out of range"); 290 } 291 292 @Test setMuted_buildsGroupInfo()293 public void setMuted_buildsGroupInfo() { 294 CarVolumeGroupInfo info = mTestGroupInfoBuilder.setMuted(true).build(); 295 296 expectWithMessage("Car volume info mute state") 297 .that(info.isMuted()).isTrue(); 298 } 299 300 @Test setAttenuated_buildsGroupInfo()301 public void setAttenuated_buildsGroupInfo() { 302 CarVolumeGroupInfo info = mTestGroupInfoBuilder.setAttenuated(true).build(); 303 304 expectWithMessage("Car volume info attenuated state") 305 .that(info.isAttenuated()).isTrue(); 306 } 307 308 @Test setBlocked_buildsGroupInfo()309 public void setBlocked_buildsGroupInfo() { 310 CarVolumeGroupInfo info = mTestGroupInfoBuilder.setBlocked(true).build(); 311 312 expectWithMessage("Car volume info blocked state") 313 .that(info.isBlocked()).isTrue(); 314 } 315 316 @Test setAudioAttribute_buildsGroupInfo()317 public void setAudioAttribute_buildsGroupInfo() { 318 CarVolumeGroupInfo info = mTestGroupInfoBuilder.setAudioAttributes(TEST_AUDIO_ATTRIBUTES) 319 .build(); 320 321 expectWithMessage("Audio attributes").that(info.getAudioAttributes()) 322 .containsExactlyElementsIn(TEST_AUDIO_ATTRIBUTES); 323 } 324 @Test setAudioAttribute_withNull_buildFails()325 public void setAudioAttribute_withNull_buildFails() { 326 NullPointerException thrown = assertThrows(NullPointerException.class, 327 () -> mTestGroupInfoBuilder.setAudioAttributes(null)); 328 329 expectWithMessage("Null audio attributes exception") 330 .that(thrown).hasMessageThat().contains("Audio Attributes"); 331 } 332 333 @Test builder_withReuse_fails()334 public void builder_withReuse_fails() { 335 CarVolumeGroupInfo.Builder builder = new CarVolumeGroupInfo.Builder(TEST_GROUP_NAME, 336 TEST_ZONE_ID, TEST_PRIMARY_GROUP_ID) 337 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 338 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 339 .setVolumeGainIndex(TEST_CURRENT_GAIN) 340 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 341 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX); 342 builder.build(); 343 344 IllegalStateException thrown = assertThrows(IllegalStateException.class, () -> 345 builder.build() 346 ); 347 348 expectWithMessage("Reuse builder exception") 349 .that(thrown).hasMessageThat().contains("should not be reused"); 350 } 351 352 @Test writeToParcel_withAllFlagsDisabled()353 public void writeToParcel_withAllFlagsDisabled() { 354 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 355 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 356 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_MUTE_AMBIGUITY); 357 Parcel parcel = Parcel.obtain(); 358 359 TEST_VOLUME_INFO.writeToParcel(parcel, TEST_PARCEL_FLAGS); 360 parcel.setDataPosition(/* pos= */ 0); 361 362 expectWithMessage("Car volume info from parcel with all flags disabled") 363 .that(new CarVolumeGroupInfo(parcel)).isEqualTo(TEST_VOLUME_INFO); 364 } 365 366 @Test writeToParcel_withAllFlagsEnabled()367 public void writeToParcel_withAllFlagsEnabled() { 368 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 369 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 370 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MUTE_AMBIGUITY); 371 CarVolumeGroupInfo volumeGroupInfo = new CarVolumeGroupInfo.Builder(TEST_VOLUME_INFO) 372 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 373 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 374 .setAudioAttributes(TEST_AUDIO_ATTRIBUTES) 375 .setAudioDeviceAttributes(List.of(TEST_AUDIO_DEVICE_ATTRIBUTE)) 376 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 377 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX) 378 .setMutedBySystem(TEST_MUTE_BY_SYSTEM_STATE).build(); 379 Parcel parcel = Parcel.obtain(); 380 381 volumeGroupInfo.writeToParcel(parcel, TEST_PARCEL_FLAGS); 382 parcel.setDataPosition(/* pos= */ 0); 383 384 expectWithMessage("Car volume info from parcel with all flags enabled") 385 .that(new CarVolumeGroupInfo(parcel)).isEqualTo(volumeGroupInfo); 386 } 387 388 @Test createFromParcel_withAllFlagsDisabled()389 public void createFromParcel_withAllFlagsDisabled() { 390 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 391 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 392 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_MUTE_AMBIGUITY); 393 Parcel parcel = Parcel.obtain(); 394 TEST_VOLUME_INFO.writeToParcel(parcel, TEST_PARCEL_FLAGS); 395 parcel.setDataPosition(/* pos= */ 0); 396 397 expectWithMessage("Car volume info created from parcel with all flags disabled") 398 .that(CarVolumeGroupInfo.CREATOR.createFromParcel(parcel)) 399 .isEqualTo(TEST_VOLUME_INFO); 400 } 401 402 @Test createFromParcel_withAllFlagsEnabled()403 public void createFromParcel_withAllFlagsEnabled() { 404 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 405 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 406 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MUTE_AMBIGUITY); 407 CarVolumeGroupInfo volumeGroupInfo = new CarVolumeGroupInfo.Builder(TEST_VOLUME_INFO) 408 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 409 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 410 .setAudioAttributes(TEST_AUDIO_ATTRIBUTES) 411 .setAudioDeviceAttributes(List.of(TEST_AUDIO_DEVICE_ATTRIBUTE)) 412 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 413 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX) 414 .setMutedBySystem(TEST_MUTE_BY_SYSTEM_STATE).build(); 415 Parcel parcel = Parcel.obtain(); 416 volumeGroupInfo.writeToParcel(parcel, TEST_PARCEL_FLAGS); 417 parcel.setDataPosition(/* pos= */ 0); 418 419 expectWithMessage("Car volume info created from parcel with all flags enabled") 420 .that(CarVolumeGroupInfo.CREATOR.createFromParcel(parcel)) 421 .isEqualTo(volumeGroupInfo); 422 } 423 424 @Test newArray()425 public void newArray() { 426 CarVolumeGroupInfo[] infos = CarVolumeGroupInfo.CREATOR.newArray(/* size= */ 3); 427 428 expectWithMessage("Car volume infos size").that(infos) 429 .hasLength(3); 430 } 431 432 @Test equals_forSameContent()433 public void equals_forSameContent() { 434 CarVolumeGroupInfo infoWithSameContent = 435 new CarVolumeGroupInfo.Builder(TEST_VOLUME_INFO) 436 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 437 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 438 .setAudioAttributes(TEST_AUDIO_ATTRIBUTES) 439 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 440 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 441 442 expectWithMessage("Car volume info with same content") 443 .that(infoWithSameContent).isEqualTo(TEST_VOLUME_INFO); 444 } 445 446 @Test equals_forNull()447 public void equals_forNull() { 448 CarVolumeGroupInfo info = new CarVolumeGroupInfo.Builder(TEST_GROUP_NAME, TEST_ZONE_ID, 449 TEST_PRIMARY_GROUP_ID).setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 450 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 451 .setVolumeGainIndex(TEST_CURRENT_GAIN) 452 .setAudioAttributes(TEST_AUDIO_ATTRIBUTES) 453 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 454 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 455 456 expectWithMessage("Car volume info null content") 457 .that(info.equals(null)).isFalse(); 458 } 459 460 @Test describeContents()461 public void describeContents() { 462 CarVolumeGroupInfo info = new CarVolumeGroupInfo.Builder(TEST_GROUP_NAME, TEST_ZONE_ID, 463 TEST_PRIMARY_GROUP_ID).setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 464 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 465 .setVolumeGainIndex(TEST_CURRENT_GAIN) 466 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 467 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 468 469 expectWithMessage("Car volume info contents") 470 .that(info.describeContents()).isEqualTo(0); 471 } 472 473 @Test hashCode_forSameContent_forAllFlagsDisabled()474 public void hashCode_forSameContent_forAllFlagsDisabled() { 475 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 476 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 477 mSetFlagsRule.disableFlags(Flags.FLAG_CAR_AUDIO_MUTE_AMBIGUITY); 478 CarVolumeGroupInfo infoWithSameContent = new CarVolumeGroupInfo.Builder(TEST_VOLUME_INFO) 479 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 480 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 481 .setAudioAttributes(TEST_AUDIO_ATTRIBUTES) 482 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 483 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 484 485 expectWithMessage("Car volume info hash with same content") 486 .that(infoWithSameContent.hashCode()).isEqualTo(TEST_VOLUME_INFO.hashCode()); 487 } 488 489 @Test hashCode_forSameContent_forAllFlagsEnabled()490 public void hashCode_forSameContent_forAllFlagsEnabled() { 491 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES); 492 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MIN_MAX_ACTIVATION_VOLUME); 493 mSetFlagsRule.enableFlags(Flags.FLAG_CAR_AUDIO_MUTE_AMBIGUITY); 494 CarVolumeGroupInfo originalInfo = new CarVolumeGroupInfo.Builder(TEST_VOLUME_INFO) 495 .setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 496 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 497 .setAudioAttributes(TEST_AUDIO_ATTRIBUTES) 498 .setAudioDeviceAttributes(List.of(TEST_AUDIO_DEVICE_ATTRIBUTE)) 499 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 500 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX) 501 .setMutedBySystem(TEST_MUTE_BY_SYSTEM_STATE).build(); 502 503 CarVolumeGroupInfo infoWithSameContent = 504 new CarVolumeGroupInfo.Builder(originalInfo).build(); 505 506 expectWithMessage("Car volume info hash with same content, with all flags enabled") 507 .that(infoWithSameContent.hashCode()).isEqualTo(originalInfo.hashCode()); 508 } 509 510 @Test toString_forContent()511 public void toString_forContent() { 512 CarVolumeGroupInfo info = new CarVolumeGroupInfo.Builder(TEST_GROUP_NAME, TEST_ZONE_ID, 513 TEST_PRIMARY_GROUP_ID).setMaxVolumeGainIndex(TEST_MAX_GAIN_INDEX) 514 .setMinVolumeGainIndex(TEST_MIN_GAIN_INDEX) 515 .setVolumeGainIndex(TEST_CURRENT_GAIN) 516 .setAudioAttributes(TEST_AUDIO_ATTRIBUTES) 517 .setMaxActivationVolumeGainIndex(TEST_MAX_ACTIVATION_GAIN_INDEX) 518 .setMinActivationVolumeGainIndex(TEST_MIN_ACTIVATION_GAIN_INDEX).build(); 519 520 String carVolumeGroupInfoString = info.toString(); 521 522 expectWithMessage("Car volume info name") 523 .that(carVolumeGroupInfoString).contains(TEST_GROUP_NAME); 524 expectWithMessage("Car volume info group id") 525 .that(carVolumeGroupInfoString).contains(Integer.toString(TEST_PRIMARY_GROUP_ID)); 526 expectWithMessage("Car volume info group zone") 527 .that(carVolumeGroupInfoString).contains(Integer.toString(TEST_ZONE_ID)); 528 expectWithMessage("Car volume group audio attributes") 529 .that(carVolumeGroupInfoString).contains(TEST_ASSISTANT_AUDIO_ATTRIBUTE.toString()); 530 } 531 } 532