Home | History | Annotate | Download | only in util
      1 /*
      2  * Copyright (C) 2015 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 com.android.tv.util;
     18 
     19 import static android.support.test.InstrumentationRegistry.getContext;
     20 
     21 import android.content.pm.ResolveInfo;
     22 import android.media.tv.TvInputInfo;
     23 import android.support.test.filters.SmallTest;
     24 import android.support.test.runner.AndroidJUnit4;
     25 import com.android.tv.testing.ComparatorTester;
     26 import com.android.tv.testing.utils.TestUtils;
     27 import java.util.ArrayList;
     28 import java.util.HashMap;
     29 import java.util.List;
     30 import org.junit.Test;
     31 import org.junit.runner.RunWith;
     32 import org.mockito.Mockito;
     33 import org.mockito.invocation.InvocationOnMock;
     34 import org.mockito.stubbing.Answer;
     35 
     36 /** Test for {@link TvInputManagerHelper} */
     37 @SmallTest
     38 @RunWith(AndroidJUnit4.class)
     39 public class TvInputManagerHelperTest {
     40     final HashMap<String, TvInputInfoWrapper> TEST_INPUT_MAP = new HashMap<>();
     41 
     42     @Test
     43     public void testComparatorInternal() {
     44         ResolveInfo resolveInfo = TestUtils.createResolveInfo("test", "test");
     45 
     46         List<TvInputInfo> inputs = new ArrayList<>();
     47         inputs.add(
     48                 createTvInputInfo(
     49                         resolveInfo,
     50                         "2_partner_input",
     51                         null,
     52                         0,
     53                         false,
     54                         "2_partner_input",
     55                         null,
     56                         true));
     57         inputs.add(
     58                 createTvInputInfo(
     59                         resolveInfo,
     60                         "3_partner_input",
     61                         null,
     62                         0,
     63                         false,
     64                         "3_partner_input",
     65                         null,
     66                         true));
     67         inputs.add(
     68                 createTvInputInfo(
     69                         resolveInfo,
     70                         "1_3rd_party_input",
     71                         null,
     72                         0,
     73                         false,
     74                         "1_3rd_party_input",
     75                         null,
     76                         false));
     77         inputs.add(
     78                 createTvInputInfo(
     79                         resolveInfo,
     80                         "4_3rd_party_input",
     81                         null,
     82                         0,
     83                         false,
     84                         "4_3rd_party_input",
     85                         null,
     86                         false));
     87 
     88         TvInputManagerHelper manager = createMockTvInputManager();
     89 
     90         ComparatorTester<TvInputInfo> comparatorTester =
     91                 ComparatorTester.withoutEqualsTest(
     92                         new TvInputManagerHelper.InputComparatorInternal(manager));
     93         for (TvInputInfo input : inputs) {
     94             comparatorTester.addComparableGroup(input);
     95         }
     96         comparatorTester.test();
     97     }
     98 
     99     @Test
    100     public void testHardwareInputComparatorHdmi() {
    101         ResolveInfo resolveInfo = TestUtils.createResolveInfo("test", "test");
    102 
    103         TvInputInfo hdmi1 =
    104                 createTvInputInfo(
    105                         resolveInfo,
    106                         "HDMI1",
    107                         null,
    108                         TvInputInfo.TYPE_HDMI,
    109                         true,
    110                         "HDMI1",
    111                         null,
    112                         false);
    113         TvInputInfo hdmi2 =
    114                 createTvInputInfo(
    115                         resolveInfo,
    116                         "HDMI2",
    117                         null,
    118                         TvInputInfo.TYPE_HDMI,
    119                         true,
    120                         "HDMI2",
    121                         "DVD",
    122                         false);
    123         TvInputInfo hdmi3 =
    124                 createTvInputInfo(
    125                         resolveInfo,
    126                         "HDMI3",
    127                         null,
    128                         TvInputInfo.TYPE_HDMI,
    129                         true,
    130                         "HDMI3",
    131                         "Cable",
    132                         false);
    133         TvInputInfo hdmi4 =
    134                 createTvInputInfo(
    135                         resolveInfo,
    136                         "HDMI4",
    137                         null,
    138                         TvInputInfo.TYPE_HDMI,
    139                         true,
    140                         "HDMI4",
    141                         null,
    142                         false);
    143 
    144         TvInputManagerHelper manager = createMockTvInputManager();
    145 
    146         ComparatorTester<TvInputInfo> comparatorTester =
    147                 ComparatorTester.withoutEqualsTest(
    148                         new TvInputManagerHelper.HardwareInputComparator(getContext(), manager));
    149         comparatorTester
    150                 .addComparableGroup(hdmi3)
    151                 .addComparableGroup(hdmi2)
    152                 .addComparableGroup(hdmi1)
    153                 .addComparableGroup(hdmi4)
    154                 .test();
    155     }
    156 
    157     @Test
    158     public void testHardwareInputComparatorCec() {
    159         ResolveInfo resolveInfo = TestUtils.createResolveInfo("test", "test");
    160 
    161         TvInputInfo hdmi1 =
    162                 createTvInputInfo(
    163                         resolveInfo,
    164                         "HDMI1",
    165                         null,
    166                         TvInputInfo.TYPE_HDMI,
    167                         true,
    168                         "HDMI1",
    169                         null,
    170                         false);
    171         TvInputInfo hdmi2 =
    172                 createTvInputInfo(
    173                         resolveInfo,
    174                         "HDMI2",
    175                         null,
    176                         TvInputInfo.TYPE_HDMI,
    177                         true,
    178                         "HDMI2",
    179                         null,
    180                         false);
    181 
    182         TvInputInfo cec1 =
    183                 createTvInputInfo(
    184                         resolveInfo,
    185                         "2_cec",
    186                         "HDMI1",
    187                         TvInputInfo.TYPE_HDMI,
    188                         true,
    189                         "2_cec",
    190                         null,
    191                         false);
    192         TvInputInfo cec2 =
    193                 createTvInputInfo(
    194                         resolveInfo,
    195                         "1_cec",
    196                         "HDMI2",
    197                         TvInputInfo.TYPE_HDMI,
    198                         true,
    199                         "1_cec",
    200                         null,
    201                         false);
    202 
    203         TvInputManagerHelper manager = createMockTvInputManager();
    204 
    205         ComparatorTester<TvInputInfo> comparatorTester =
    206                 ComparatorTester.withoutEqualsTest(
    207                         new TvInputManagerHelper.HardwareInputComparator(getContext(), manager));
    208         comparatorTester.addComparableGroup(cec1).addComparableGroup(cec2).test();
    209     }
    210 
    211     private TvInputManagerHelper createMockTvInputManager() {
    212         TvInputManagerHelper manager = Mockito.mock(TvInputManagerHelper.class);
    213         Mockito.doAnswer(
    214                         new Answer<Boolean>() {
    215                             @Override
    216                             public Boolean answer(InvocationOnMock invocation) throws Throwable {
    217                                 TvInputInfo info = (TvInputInfo) invocation.getArguments()[0];
    218                                 return TEST_INPUT_MAP.get(info.getId()).mIsPartnerInput;
    219                             }
    220                         })
    221                 .when(manager)
    222                 .isPartnerInput(Mockito.<TvInputInfo>any());
    223         Mockito.doAnswer(
    224                         new Answer<String>() {
    225                             @Override
    226                             public String answer(InvocationOnMock invocation) throws Throwable {
    227                                 TvInputInfo info = (TvInputInfo) invocation.getArguments()[0];
    228                                 return TEST_INPUT_MAP.get(info.getId()).mLabel;
    229                             }
    230                         })
    231                 .when(manager)
    232                 .loadLabel(Mockito.<TvInputInfo>any());
    233         Mockito.doAnswer(
    234                         new Answer<String>() {
    235                             @Override
    236                             public String answer(InvocationOnMock invocation) throws Throwable {
    237                                 TvInputInfo info = (TvInputInfo) invocation.getArguments()[0];
    238                                 return TEST_INPUT_MAP.get(info.getId()).mCustomLabel;
    239                             }
    240                         })
    241                 .when(manager)
    242                 .loadCustomLabel(Mockito.<TvInputInfo>any());
    243         Mockito.doAnswer(
    244                         new Answer<TvInputInfo>() {
    245                             @Override
    246                             public TvInputInfo answer(InvocationOnMock invocation)
    247                                     throws Throwable {
    248                                 String inputId = (String) invocation.getArguments()[0];
    249                                 TvInputInfoWrapper inputWrapper = TEST_INPUT_MAP.get(inputId);
    250                                 return inputWrapper == null ? null : inputWrapper.mInput;
    251                             }
    252                         })
    253                 .when(manager)
    254                 .getTvInputInfo(Mockito.<String>any());
    255         return manager;
    256     }
    257 
    258     private TvInputInfo createTvInputInfo(
    259             ResolveInfo service,
    260             String id,
    261             String parentId,
    262             int type,
    263             boolean isHardwareInput,
    264             String label,
    265             String customLabel,
    266             boolean isPartnerInput) {
    267         TvInputInfoWrapper inputWrapper = new TvInputInfoWrapper();
    268         try {
    269             inputWrapper.mInput =
    270                     TestUtils.createTvInputInfo(service, id, parentId, type, isHardwareInput);
    271         } catch (Exception e) {
    272         }
    273         inputWrapper.mLabel = label;
    274         inputWrapper.mIsPartnerInput = isPartnerInput;
    275         inputWrapper.mCustomLabel = customLabel;
    276         TEST_INPUT_MAP.put(id, inputWrapper);
    277         return inputWrapper.mInput;
    278     }
    279 
    280     private static class TvInputInfoWrapper {
    281         TvInputInfo mInput;
    282         String mLabel;
    283         String mCustomLabel;
    284         boolean mIsPartnerInput;
    285     }
    286 }
    287