Home | History | Annotate | Download | only in client 
      1 /*
      2  * Copyright 2017 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 package android.support.mediacompat.client;
     17 
     18 import static org.hamcrest.core.IsEqual.equalTo;
     19 import static org.hamcrest.core.IsNot.not;
     20 import static org.junit.Assert.assertThat;
     21 
     22 import android.media.AudioAttributes;
     23 import android.media.AudioManager;
     24 import android.os.Build;
     25 import android.support.test.filters.SdkSuppress;
     26 import android.support.test.filters.SmallTest;
     27 import android.support.test.runner.AndroidJUnit4;
     28 import android.support.v4.media.AudioAttributesCompat;
     29 
     30 import org.junit.After;
     31 import org.junit.Before;
     32 import org.junit.Test;
     33 import org.junit.runner.RunWith;
     34 
     35 /** Test {@link AudioAttributesCompat}. */
     36 @SmallTest
     37 @RunWith(AndroidJUnit4.class)
     38 public class AudioAttributesCompatTest {
     39     // some macros for conciseness
     40     static final AudioAttributesCompat.Builder mkBuilder(
     41             @AudioAttributesCompat.AttributeContentType int type,
     42             @AudioAttributesCompat.AttributeUsage int usage) {
     43         return new AudioAttributesCompat.Builder().setContentType(type).setUsage(usage);
     44     }
     45 
     46     static final AudioAttributesCompat.Builder mkBuilder(int legacyStream) {
     47         return new AudioAttributesCompat.Builder().setLegacyStreamType(legacyStream);
     48     }
     49 
     50     // some objects we'll toss around
     51     Object mMediaAA;
     52     AudioAttributesCompat mMediaAAC,
     53             mMediaLegacyAAC,
     54             mMediaAACFromAA,
     55             mNotificationAAC,
     56             mNotificationLegacyAAC;
     57 
     58     @Before
     59     @SdkSuppress(minSdkVersion = 21)
     60     public void setUpApi21() {
     61         if (Build.VERSION.SDK_INT < 21) return;
     62         mMediaAA =
     63                 new AudioAttributes.Builder()
     64                         .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
     65                         .setUsage(AudioAttributes.USAGE_MEDIA)
     66                         .build();
     67         mMediaAACFromAA = AudioAttributesCompat.wrap((AudioAttributes) mMediaAA);
     68     }
     69 
     70     @Before
     71     public void setUp() {
     72         mMediaAAC =
     73                 mkBuilder(AudioAttributesCompat.CONTENT_TYPE_MUSIC,
     74                         AudioAttributesCompat.USAGE_MEDIA).build();
     75         mMediaLegacyAAC = mkBuilder(AudioManager.STREAM_MUSIC).build();
     76         mNotificationAAC =
     77                 mkBuilder(AudioAttributesCompat.CONTENT_TYPE_SONIFICATION,
     78                         AudioAttributesCompat.USAGE_NOTIFICATION)
     79                         .build();
     80         mNotificationLegacyAAC = mkBuilder(AudioManager.STREAM_NOTIFICATION).build();
     81     }
     82 
     83     @Test
     84     @SdkSuppress(minSdkVersion = 21)
     85     public void testCreateWithAudioAttributesApi21() {
     86         assertThat(mMediaAACFromAA, not(equalTo(null)));
     87         assertThat((AudioAttributes) mMediaAACFromAA.unwrap(), equalTo(mMediaAA));
     88         assertThat(
     89                 (AudioAttributes) mMediaAACFromAA.unwrap(),
     90                 equalTo(new AudioAttributes.Builder((AudioAttributes) mMediaAA).build()));
     91     }
     92 
     93     @Test
     94     @SdkSuppress(minSdkVersion = 21)
     95     public void testEqualityApi21() {
     96         assertThat("self equality", mMediaAACFromAA, equalTo(mMediaAACFromAA));
     97         assertThat("different things", mMediaAACFromAA, not(equalTo(mNotificationAAC)));
     98     }
     99 
    100     @Test
    101     public void testEquality() {
    102         assertThat("self equality", mMediaAAC, equalTo(mMediaAAC));
    103         assertThat(
    104                 "equal to clone",
    105                 mMediaAAC,
    106                 equalTo(new AudioAttributesCompat.Builder(mMediaAAC).build()));
    107         assertThat("different things are different", mMediaAAC, not(equalTo(mNotificationAAC)));
    108         assertThat("different things are different 2", mNotificationAAC, not(equalTo(mMediaAAC)));
    109         assertThat(
    110                 "equal to clone 2",
    111                 mNotificationAAC,
    112                 equalTo(new AudioAttributesCompat.Builder(mNotificationAAC).build()));
    113     }
    114 
    115     @Test
    116     public void testGetters() {
    117         assertThat(mMediaAAC.getContentType(), equalTo(AudioAttributesCompat.CONTENT_TYPE_MUSIC));
    118         assertThat(mMediaAAC.getUsage(), equalTo(AudioAttributesCompat.USAGE_MEDIA));
    119         assertThat(mMediaAAC.getFlags(), equalTo(0));
    120     }
    121 
    122     @Test
    123     public void testLegacyStreamTypeInference() {
    124         assertThat(mMediaAAC.getLegacyStreamType(), equalTo(AudioManager.STREAM_MUSIC));
    125         assertThat(mMediaLegacyAAC.getLegacyStreamType(), equalTo(AudioManager.STREAM_MUSIC));
    126         assertThat(
    127                 mNotificationAAC.getLegacyStreamType(), equalTo(AudioManager.STREAM_NOTIFICATION));
    128         assertThat(
    129                 mNotificationLegacyAAC.getLegacyStreamType(),
    130                 equalTo(AudioManager.STREAM_NOTIFICATION));
    131     }
    132 
    133     @Test
    134     @SdkSuppress(minSdkVersion = 21)
    135     public void testLegacyStreamTypeInferenceApi21() {
    136         assertThat(mMediaAACFromAA.getLegacyStreamType(), equalTo(AudioManager.STREAM_MUSIC));
    137     }
    138 
    139     @Test
    140     public void testLegacyStreamTypeInferenceInLegacyMode() {
    141         // the builders behave differently based on the value of this only-for-testing global
    142         // so we need our very own objects inside this method
    143         AudioAttributesCompat.setForceLegacyBehavior(true);
    144 
    145         AudioAttributesCompat mediaAAC =
    146                 mkBuilder(AudioAttributesCompat.CONTENT_TYPE_MUSIC,
    147                         AudioAttributesCompat.USAGE_MEDIA).build();
    148         AudioAttributesCompat mediaLegacyAAC = mkBuilder(AudioManager.STREAM_MUSIC).build();
    149 
    150         AudioAttributesCompat notificationAAC =
    151                 mkBuilder(AudioAttributesCompat.CONTENT_TYPE_SONIFICATION,
    152                         AudioAttributesCompat.USAGE_NOTIFICATION)
    153                         .build();
    154         AudioAttributesCompat notificationLegacyAAC =
    155                 mkBuilder(AudioManager.STREAM_NOTIFICATION).build();
    156 
    157         assertThat(mediaAAC.getLegacyStreamType(), equalTo(AudioManager.STREAM_MUSIC));
    158         assertThat(mediaLegacyAAC.getLegacyStreamType(), equalTo(AudioManager.STREAM_MUSIC));
    159         assertThat(
    160                 notificationAAC.getLegacyStreamType(), equalTo(AudioManager.STREAM_NOTIFICATION));
    161         assertThat(
    162                 notificationLegacyAAC.getLegacyStreamType(),
    163                 equalTo(AudioManager.STREAM_NOTIFICATION));
    164     }
    165 
    166     @After
    167     public void cleanUp() {
    168         AudioAttributesCompat.setForceLegacyBehavior(false);
    169     }
    170 }
    171