Debian Codegraph @

sdk-common/src/test/java/com/android/ide/common/build/SplitOutputMatcherTest.java

raw
1 /*
2 * Copyright (C) 2014 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.ide.common.build;
18
19 import static org.mockito.Mockito.when;
20
21 import com.android.annotations.NonNull;
22 import com.android.build.FilterData;
23 import com.android.build.OutputFile;
24 import com.android.build.VariantOutput;
25 import com.android.builder.testing.api.DeviceConfigProvider;
26 import com.android.ide.common.process.ProcessException;
27 import com.android.ide.common.process.ProcessExecutor;
28 import com.android.resources.Density;
29 import com.google.common.collect.ImmutableList;
30 import com.google.common.collect.Lists;
31 import com.google.common.collect.Sets;
32
33 import junit.framework.TestCase;
34
35 import org.mockito.Mockito;
36
37 import java.io.File;
38 import java.util.ArrayList;
39 import java.util.Arrays;
40 import java.util.Collection;
41 import java.util.List;
42 import java.util.Set;
43
44 public class SplitOutputMatcherTest extends TestCase {
45
46 /**
47 * Helper to run InstallHelper.computeMatchingOutput with variable ABI list.
48 */
49 private static List<File> computeBestOutput(
50 @NonNull List<? extends VariantOutput> outputs,
51 int deviceDensity,
52 @NonNull String... deviceAbis) throws ProcessException{
53 DeviceConfigProvider deviceConfigProvider = Mockito.mock(DeviceConfigProvider.class);
54 when(deviceConfigProvider.getDensity()).thenReturn(deviceDensity);
55 when(deviceConfigProvider.getAbis()).thenReturn(Arrays.asList(deviceAbis));
56 return SplitOutputMatcher.computeBestOutput(
57 Mockito.mock(ProcessExecutor.class),
58 null /* splitSelectExe */,
59 deviceConfigProvider,
60 outputs,
61 null /* variantAbiFilters */);
62 }
63
64 private static List<File> computeBestOutput(
65 @NonNull List<? extends VariantOutput> outputs,
66 @NonNull Set<String> deviceAbis,
67 int deviceDensity,
68 @NonNull String... variantAbiFilters) throws ProcessException {
69 DeviceConfigProvider deviceConfigProvider = Mockito.mock(DeviceConfigProvider.class);
70 when(deviceConfigProvider.getDensity()).thenReturn(deviceDensity);
71 when(deviceConfigProvider.getAbis()).thenReturn(new ArrayList<String>(deviceAbis));
72 return SplitOutputMatcher.computeBestOutput(
73 Mockito.mock(ProcessExecutor.class),
74 null /* splitSelectExec */,
75 deviceConfigProvider,
76 outputs,
77 Arrays.asList(variantAbiFilters));
78 }
79
80 /**
81 * Fake implementation of FilteredOutput
82 */
83
84 private static final class FakeSplitOutput implements OutputFile {
85
86 private final String densityFilter;
87 private final String abiFilter;
88 private final File file;
89
90 FakeSplitOutput(String densityFilter, String abiFilter) {
91 this.densityFilter = densityFilter;
92 this.abiFilter = abiFilter;
93 file = new File(densityFilter + abiFilter);
94 }
95
96 FakeSplitOutput(String densityFilter, String abiFilter, File file) {
97 this.densityFilter = densityFilter;
98 this.abiFilter = abiFilter;
99 this.file = file;
100 }
101
102 @Override
103 public String getOutputType() {
104 return OutputFile.FULL_SPLIT;
105 }
106
107 @NonNull
108 @Override
109 public Collection<String> getFilterTypes() {
110 ImmutableList.Builder<String> splitTypeBuilder = ImmutableList.builder();
111 if (densityFilter != null) {
112 splitTypeBuilder.add(OutputFile.DENSITY);
113 }
114 if (abiFilter != null) {
115 splitTypeBuilder.add(OutputFile.ABI);
116 }
117 return splitTypeBuilder.build();
118 }
119
120 @NonNull
121 @Override
122 public Collection<FilterData> getFilters() {
123 ImmutableList.Builder<FilterData> filters = ImmutableList.builder();
124 if (densityFilter != null) {
125 filters.add(FakeFilterData.Builder.build(OutputFile.DENSITY, densityFilter));
126 }
127 if (abiFilter != null) {
128 filters.add(FakeFilterData.Builder.build(OutputFile.ABI, abiFilter));
129 }
130 return filters.build();
131 }
132
133 @NonNull
134 @Override
135 public File getOutputFile() {
136 return file;
137 }
138
139 @Override
140 public String toString() {
141 return "FilteredOutput{" + densityFilter + ':' + abiFilter + '}';
142 }
143 }
144
145 private static final class FakeFilterData implements FilterData {
146 private final String filterType;
147 private final String identifier;
148
149 FakeFilterData(String filterType, String identifier) {
150 this.filterType = filterType;
151 this.identifier = identifier;
152 }
153
154 @NonNull
155 @Override
156 public String getIdentifier() {
157 return identifier;
158 }
159
160 @NonNull
161 @Override
162 public String getFilterType() {
163 return filterType;
164 }
165
166 public static class Builder {
167 public static FilterData build(final String filterType, final String identifier) {
168 return new FakeFilterData(filterType, identifier);
169 }
170 }
171 }
172
173 private static class FakeVariantOutput implements VariantOutput {
174
175 private final OutputFile mainOutputFile;
176 private final int versionCode;
177
178 private FakeVariantOutput(OutputFile mainOutputFile,
179 int versionCode) {
180 this.mainOutputFile = mainOutputFile;
181 this.versionCode = versionCode;
182 }
183
184 @NonNull
185 @Override
186 public OutputFile getMainOutputFile() {
187 return mainOutputFile;
188 }
189
190 @NonNull
191 @Override
192 public Collection<? extends OutputFile> getOutputs() {
193 return ImmutableList.of(mainOutputFile);
194 }
195
196 @Override
197 public int getVersionCode() {
198 return versionCode;
199 }
200
201 @NonNull
202 @Override
203 public File getSplitFolder() {
204 return null;
205 }
206 }
207
208 public void testSingleOutput() throws ProcessException {
209 VariantOutput match;
210 List<VariantOutput> list = Lists.newArrayList();
211
212 list.add(match = getUniversalOutput(1));
213
214 List<File> result = computeBestOutput(list, 160, "foo");
215
216 assertEquals(1, result.size());
217 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
218 }
219
220 public void testDensityOnlyWithMatch() throws ProcessException {
221 VariantOutput match;
222 List<VariantOutput> list = Lists.newArrayList();
223
224 list.add(getUniversalOutput(1));
225 list.add(match = getDensityOutput(160, 2));
226 list.add(getDensityOutput(320, 3));
227
228 List<File> result = computeBestOutput(list, 160, "foo");
229
230 assertEquals(1, result.size());
231 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
232 }
233
234 public void testDensityOnlyWithUniversalMatch() throws ProcessException {
235 VariantOutput match;
236 List<VariantOutput> list = Lists.newArrayList();
237
238 list.add(match = getUniversalOutput(3));
239 list.add(getDensityOutput(320, 2));
240 list.add(getDensityOutput(480, 1));
241
242 List<File> result = computeBestOutput(list, 160, "foo");
243
244 assertEquals(1, result.size());
245 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
246 }
247
248 public void testDensityOnlyWithNoMatch() throws ProcessException {
249 List<VariantOutput> list = Lists.newArrayList();
250
251 list.add(getDensityOutput(320, 1));
252 list.add(getDensityOutput(480, 2));
253
254 List<File> result = computeBestOutput(list, 160, "foo");
255
256 assertEquals(0, result.size());
257 }
258
259 public void testDensityOnlyWithCustomDeviceDensity() throws ProcessException {
260 VariantOutput match;
261 List<VariantOutput> list = Lists.newArrayList();
262
263 list.add(match = getUniversalOutput(1));
264 list.add(getDensityOutput(320, 2));
265 list.add(getDensityOutput(480, 3));
266
267 List<File> result = computeBestOutput(list, 1, "foo");
268
269 assertEquals(1, result.size());
270 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
271 }
272
273
274 public void testAbiOnlyWithMatch() throws ProcessException {
275 VariantOutput match;
276 List<VariantOutput> list = Lists.newArrayList();
277
278 list.add(getUniversalOutput(1));
279 list.add(match = getAbiOutput("foo", 2));
280 list.add(getAbiOutput("bar", 3));
281
282 List<File> result = computeBestOutput(list, 160, "foo");
283
284 assertEquals(1, result.size());
285 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
286 }
287
288 public void testAbiOnlyWithMultiMatch() throws ProcessException {
289 VariantOutput match;
290 List<VariantOutput> list = Lists.newArrayList();
291
292 // test where the versionCode match the abi order
293 list.add(getUniversalOutput(1));
294 list.add(getAbiOutput("foo", 2));
295 list.add(match = getAbiOutput("bar", 3));
296
297 // bar is preferred over foo
298 List<File> result = computeBestOutput(list, 160, "bar", "foo");
299
300 assertEquals(1, result.size());
301 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
302 }
303
304 public void testAbiPreference() throws ProcessException {
305 VariantOutput match;
306 List<VariantOutput> list = Lists.newArrayList();
307
308 // test where the versionCode match the abi order
309 list.add(getUniversalOutput(1));
310 list.add(getAbiOutput("foo", 1));
311 list.add(match = getAbiOutput("bar", 1, "bar1"));
312 list.add(getAbiOutput("bar", 1, "bar2"));
313
314 // bar is preferred over foo
315 List<File> result = computeBestOutput(list, 160, "bar", "foo");
316
317 assertEquals(1, result.size());
318 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
319 }
320
321 public void testAbiPreferenceForUniveralApk() throws ProcessException {
322 VariantOutput match;
323 List<VariantOutput> list = Lists.newArrayList();
324
325 // test where the versionCode match the abi order
326 list.add(match = getUniversalOutput(1));
327 list.add(getAbiOutput("foo", 1));
328 list.add(getAbiOutput("foo", 1));
329 list.add(getAbiOutput("foo", 1));
330
331 // bar is preferred over foo
332 List<File> result = computeBestOutput(list, 160, "bar", "foo");
333
334 assertEquals(1, result.size());
335 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
336 }
337
338 public void testAbiOnlyWithMultiMatch2() throws ProcessException {
339 VariantOutput match;
340 List<VariantOutput> list = Lists.newArrayList();
341
342 // test where the versionCode does not match the abi order
343 list.add(getUniversalOutput(1));
344 list.add(getAbiOutput("foo", 2));
345 list.add(match = getAbiOutput("bar", 3));
346
347 // bar is preferred over foo
348 List<File> result = computeBestOutput(list, 160, "foo", "bar");
349
350 assertEquals(1, result.size());
351 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
352 }
353
354 public void testAbiOnlyWithUniversalMatch() throws ProcessException {
355 VariantOutput match;
356 List<VariantOutput> list = Lists.newArrayList();
357
358 list.add(match = getUniversalOutput(1));
359 list.add(getAbiOutput("foo", 2));
360 list.add(getAbiOutput("bar", 3));
361
362 List<File> result = computeBestOutput(list, 160, "zzz");
363
364 assertEquals(1, result.size());
365 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
366 }
367
368 public void testAbiOnlyWithNoMatch() throws ProcessException {
369 List<VariantOutput> list = Lists.newArrayList();
370
371 list.add(getAbiOutput("foo", 1));
372 list.add(getAbiOutput("bar", 2));
373
374 List<File> result = computeBestOutput(list, 160, "zzz");
375
376 assertEquals(0, result.size());
377 }
378
379 public void testMultiFilterWithMatch() throws ProcessException {
380 VariantOutput match;
381 List<VariantOutput> list = Lists.newArrayList();
382
383 list.add(getUniversalOutput(1));
384 list.add(getOutput(160, "zzz",2));
385 list.add(match = getOutput(160, "foo", 4));
386 list.add(getOutput(320, "foo", 3));
387
388 List<File> result = computeBestOutput(list, 160, "foo");
389
390 assertEquals(1, result.size());
391 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
392 }
393
394 public void testMultiFilterWithUniversalMatch() throws ProcessException {
395 VariantOutput match;
396 List<VariantOutput> list = Lists.newArrayList();
397
398 list.add(match = getUniversalOutput(4));
399 list.add(getOutput(320, "zzz", 3));
400 list.add(getOutput(160, "bar", 2));
401 list.add(getOutput(320, "foo", 1));
402
403 List<File> result = computeBestOutput(list, 160, "zzz");
404
405 assertEquals(1, result.size());
406 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
407 }
408
409 public void testMultiFilterWithNoMatch() throws ProcessException {
410 List<VariantOutput> list = Lists.newArrayList();
411
412 list.add(getOutput(320, "zzz", 1));
413 list.add(getOutput(160, "bar", 2));
414 list.add(getOutput(320, "foo", 3));
415
416 List<File> result = computeBestOutput(list, 160, "zzz");
417
418 assertEquals(0, result.size());
419 }
420
421 public void testVariantLevelAbiFilter() throws ProcessException {
422 VariantOutput match;
423 List<VariantOutput> list = Lists.newArrayList();
424
425 list.add(match = getUniversalOutput(1));
426 List<File> result = computeBestOutput(list, Sets.newHashSet("bar", "foo"), 160, "foo",
427 "zzz");
428
429 assertEquals(1, result.size());
430 assertEquals(match.getMainOutputFile().getOutputFile(), result.get(0));
431 }
432
433 public void testWrongVariantLevelAbiFilter() throws ProcessException {
434 List<VariantOutput> list = Lists.newArrayList();
435
436 list.add(getUniversalOutput(1));
437
438 List<File> result = computeBestOutput(list, Sets.newHashSet("bar", "foo"), 160, "zzz");
439
440 assertEquals(0, result.size());
441 }
442
443 public void testDensitySplitPlugVariantLevelAbiFilter() throws ProcessException {
444 VariantOutput match;
445 List<VariantOutput> list = Lists.newArrayList();
446
447 list.add(getUniversalOutput(1));
448 list.add(getDensityOutput(240, 2));
449 list.add(match = getDensityOutput(320, 3));
450 list.add(getDensityOutput(480, 4));
451
452 List<File> result = computeBestOutput(list, Sets.newHashSet("bar", "foo"), 320, "foo", "zzz");
453
454 assertEquals(1, result.size());
455 }
456
457 public void testConfigFormatFixed() {
458 String mccMnc =
459 "310mcc-260mnc-en-rUS-ldltr-sw320dp-w320dp-h508dp-normal-long-port-"
460 + "notnight-hdpi-finger-keysexposed-nokeys-navexposed-trackball-v21:x86";
461 String expectedMccMnc = "mcc310-mnc260-en-rUS-ldltr-sw320dp-w320dp-h508dp-normal-long-port-"
462 + "notnight-hdpi-finger-keysexposed-nokeys-navexposed-trackball-v21:x86";
463 assertEquals(expectedMccMnc, SplitOutputMatcher.prepareConfigFormatMccMnc(mccMnc));
464
465 String mnc =
466 "260mnc-en-rUS-ldltr-sw320dp-w320dp-h508dp-normal-long-port-"
467 + "notnight-hdpi-finger-keysexposed-nokeys-navexposed-trackball-v21:x86";
468 String expectedMnc = "mnc260-en-rUS-ldltr-sw320dp-w320dp-h508dp-normal-long-port-"
469 + "notnight-hdpi-finger-keysexposed-nokeys-navexposed-trackball-v21:x86";
470 assertEquals(expectedMnc, SplitOutputMatcher.prepareConfigFormatMccMnc(mnc));
471
472 String mcc =
473 "310mcc-en-rUS-ldltr-sw320dp-w320dp-h508dp-normal-long-port-"
474 + "notnight-hdpi-finger-keysexposed-nokeys-navexposed-trackball-v21:x86";
475 String expectedMcc = "mcc310-en-rUS-ldltr-sw320dp-w320dp-h508dp-normal-long-port-"
476 + "notnight-hdpi-finger-keysexposed-nokeys-navexposed-trackball-v21:x86";
477 assertEquals(expectedMcc, SplitOutputMatcher.prepareConfigFormatMccMnc(mcc));
478
479 String noMccMnc =
480 "en-rUS-ldltr-sw320dp-w320dp-h508dp-normal-long-port-"
481 + "notnight-hdpi-finger-keysexposed-nokeys-navexposed-trackball-v21:x86";
482 String expectedNoMccMnc = "en-rUS-ldltr-sw320dp-w320dp-h508dp-normal-long-port-"
483 + "notnight-hdpi-finger-keysexposed-nokeys-navexposed-trackball-v21:x86";
484 assertEquals(expectedNoMccMnc, SplitOutputMatcher.prepareConfigFormatMccMnc(noMccMnc));
485 }
486
487 private static VariantOutput getUniversalOutput(int versionCode) {
488 return new FakeVariantOutput(new FakeSplitOutput(null, null), versionCode);
489 }
490
491 private static VariantOutput getDensityOutput(int densityFilter, int versionCode) {
492 Density densityEnum = Density.getEnum(densityFilter);
493 return new FakeVariantOutput(
494 new FakeSplitOutput(densityEnum.getResourceValue(), null), versionCode);
495 }
496
497 private static VariantOutput getAbiOutput(String filter, int versionCode) {
498 return new FakeVariantOutput(
499 new FakeSplitOutput( null, filter), versionCode);
500 }
501
502 private static VariantOutput getAbiOutput(String filter, int versionCode, String file) {
503 return new FakeVariantOutput(
504 new FakeSplitOutput(null, filter, new File(file)), versionCode);
505 }
506
507 private static VariantOutput getOutput(int densityFilter, String abiFilter, int versionCode) {
508 Density densityEnum = Density.getEnum(densityFilter);
509 return new FakeVariantOutput(
510 new FakeSplitOutput(densityEnum.getResourceValue(), abiFilter), versionCode);
511 }
512 }