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
17package com.android.tv.util;
18
19import static android.support.test.InstrumentationRegistry.getContext;
20
21import android.content.pm.ResolveInfo;
22import android.media.tv.TvInputInfo;
23import android.support.test.filters.SmallTest;
24import android.support.test.runner.AndroidJUnit4;
25import com.android.tv.testing.ComparatorTester;
26import com.android.tv.testing.utils.TestUtils;
27import java.util.ArrayList;
28import java.util.HashMap;
29import java.util.List;
30import org.junit.Test;
31import org.junit.runner.RunWith;
32import org.mockito.Mockito;
33import org.mockito.invocation.InvocationOnMock;
34import org.mockito.stubbing.Answer;
35
36/** Test for {@link TvInputManagerHelper} */
37@SmallTest
38@RunWith(AndroidJUnit4.class)
39public 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