Debian Codegraph @

sdk-common/src/test/java/com/android/ide/common/res2/ResourceRepositoryTest.java

raw
1 /*
2 * Copyright (C) 2013 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.res2;
18
19 import static org.junit.Assert.assertEquals;
20 import static org.junit.Assert.assertFalse;
21 import static org.junit.Assert.assertNotNull;
22 import static org.junit.Assert.assertTrue;
23 import static org.junit.Assert.fail;
24
25 import com.android.ide.common.rendering.api.AttrResourceValue;
26 import com.android.ide.common.rendering.api.ItemResourceValue;
27 import com.android.ide.common.rendering.api.ResourceValue;
28 import com.android.ide.common.rendering.api.StyleResourceValue;
29 import com.android.resources.ResourceFolderType;
30 import com.android.resources.ResourceType;
31 import com.android.testutils.TestUtils;
32 import com.google.common.collect.ListMultimap;
33 import com.google.common.collect.Multimap;
34
35 import org.junit.Test;
36
37 import java.io.File;
38 import java.io.IOException;
39 import java.util.ArrayList;
40 import java.util.Collection;
41 import java.util.Collections;
42 import java.util.Comparator;
43 import java.util.List;
44 import java.util.Map;
45
46 public class ResourceRepositoryTest extends BaseTestCase {
47
48 @Test
49 public void testMergeByCount() throws Exception {
50 ResourceRepository repo = getResourceRepository();
51
52 Map<ResourceType, ListMultimap<String, ResourceItem>> items = repo.getItems();
53
54 assertEquals(6, items.get(ResourceType.DRAWABLE).size());
55 assertEquals(1, items.get(ResourceType.RAW).size());
56 assertEquals(4, items.get(ResourceType.LAYOUT).size());
57 assertEquals(1, items.get(ResourceType.COLOR).size());
58 assertEquals(6, items.get(ResourceType.STRING).size());
59 assertEquals(1, items.get(ResourceType.STYLE).size());
60 assertEquals(3, items.get(ResourceType.ARRAY).size());
61 assertEquals(7, items.get(ResourceType.ATTR).size());
62 assertEquals(1, items.get(ResourceType.DECLARE_STYLEABLE).size());
63 assertEquals(2, items.get(ResourceType.DIMEN).size());
64 assertEquals(1, items.get(ResourceType.ID).size());
65 assertEquals(1, items.get(ResourceType.INTEGER).size());
66 assertEquals(2, items.get(ResourceType.PLURALS).size());
67 }
68
69 @Test
70 public void testMergedResourcesByName() throws Exception {
71 ResourceRepository repo = getResourceRepository();
72
73 // use ? between type and qualifier because of declare-styleable
74 verifyResourceExists(repo,
75 "drawable/icon",
76 "drawable?ldpi-v4/icon",
77 "drawable/icon2",
78 "drawable/patch",
79 "drawable/color_drawable",
80 "drawable/drawable_ref",
81 "raw/foo",
82 "layout/main",
83 "layout/layout_ref",
84 "layout/alias_replaced_by_file",
85 "layout/file_replaced_by_alias",
86 "color/color",
87 "string/basic_string",
88 "string/xliff_string",
89 "string/styled_string",
90 "string/two",
91 "string/many",
92 "style/style",
93 "array/string_array",
94 "array/integer_array",
95 "array/my_colors",
96 "attr/dimen_attr",
97 "attr/string_attr",
98 "attr/enum_attr",
99 "attr/flag_attr",
100 "attr/blah",
101 "attr/blah2",
102 "attr/flagAttr",
103 "declare-styleable/declare_styleable",
104 "dimen/dimen",
105 "dimen?sw600dp-v13/offset",
106 "id/item_id",
107 "integer/integer",
108 "plurals/plurals",
109 "plurals/plurals_with_bad_quantity"
110 );
111 }
112
113 @Test
114 public void testBaseStringValue() throws Exception {
115 ResourceRepository repo = getResourceRepository();
116
117 List<ResourceItem> itemList = repo.getResourceItem(ResourceType.STRING, "basic_string");
118 assertNotNull(itemList);
119 assertEquals(1, itemList.size());
120
121 ResourceValue value = itemList.get(0).getResourceValue(false);
122 assertNotNull(value);
123
124 assertEquals("overlay_string", value.getValue());
125 }
126
127 @Test
128 public void testBaseStyledStringValue() throws Exception {
129 ResourceRepository repo = getResourceRepository();
130
131 List<ResourceItem> itemList = repo.getResourceItem(ResourceType.STRING, "styled_string");
132 assertNotNull(itemList);
133 assertEquals(1, itemList.size());
134
135 ResourceValue value = itemList.get(0).getResourceValue(false);
136 assertNotNull(value);
137
138 assertEquals("Forgot your username or password?\nVisit google.com/accounts/recovery.",
139 value.getValue());
140 }
141
142 @Test
143 public void testBaseColorValue() throws Exception {
144 ResourceRepository repo = getResourceRepository();
145
146 List<ResourceItem> itemList = repo.getResourceItem(ResourceType.COLOR, "color");
147 assertNotNull(itemList);
148 assertEquals(1, itemList.size());
149
150 ResourceValue value = itemList.get(0).getResourceValue(false);
151 assertNotNull(value);
152
153 assertEquals("#FFFFFFFF", value.getValue());
154 }
155
156 @Test
157 public void testBaseLayoutAliasValue() throws Exception {
158 ResourceRepository repo = getResourceRepository();
159
160 List<ResourceItem> itemList = repo.getResourceItem(ResourceType.LAYOUT, "layout_ref");
161 assertNotNull(itemList);
162 assertEquals(1, itemList.size());
163
164 ResourceValue value = itemList.get(0).getResourceValue(false);
165 assertNotNull(value);
166
167 assertEquals("@layout/ref", value.getValue());
168 }
169
170 @Test
171 public void testBaseAttrValue() throws Exception {
172 ResourceRepository repo = getResourceRepository();
173
174 List<ResourceItem> itemList = repo.getResourceItem(ResourceType.ATTR, "flag_attr");
175 assertNotNull(itemList);
176 assertEquals(1, itemList.size());
177
178 ResourceValue value = itemList.get(0).getResourceValue(false);
179 assertNotNull(value);
180 assertTrue(value instanceof AttrResourceValue);
181 AttrResourceValue attrValue = (AttrResourceValue) value;
182
183 Map<String, Integer> attrValues = attrValue.getAttributeValues();
184 assertNotNull(attrValues);
185 assertEquals(3, attrValues.size());
186
187 Integer i = attrValues.get("normal");
188 assertNotNull(i);
189 assertEquals(Integer.valueOf(0), i);
190
191 i = attrValues.get("bold");
192 assertNotNull(i);
193 assertEquals(Integer.valueOf(1), i);
194
195 i = attrValues.get("italic");
196 assertNotNull(i);
197 assertEquals(Integer.valueOf(2), i);
198 }
199
200 @Test
201 public void testBaseStyleValue() throws Exception {
202 ResourceRepository repo = getResourceRepository();
203
204 List<ResourceItem> itemList = repo.getResourceItem(ResourceType.STYLE, "style");
205 assertNotNull(itemList);
206 assertEquals(1, itemList.size());
207
208 ResourceValue value = itemList.get(0).getResourceValue(false);
209 assertNotNull(value);
210 assertTrue(value instanceof StyleResourceValue);
211 StyleResourceValue styleResourceValue = (StyleResourceValue) value;
212
213 assertEquals("@android:style/Holo.Light", styleResourceValue.getParentStyle());
214
215 ItemResourceValue styleValue = styleResourceValue.getItem("singleLine", true /*framework*/);
216 assertNotNull(styleValue);
217 assertEquals("true", styleValue.getValue());
218
219 styleValue = styleResourceValue.getItem("textAppearance", true /*framework*/);
220 assertNotNull(styleValue);
221 assertEquals("@style/TextAppearance.WindowTitle", styleValue.getValue());
222
223 styleValue = styleResourceValue.getItem("shadowColor", true /*framework*/);
224 assertNotNull(styleValue);
225 assertEquals("#BB000000", styleValue.getValue());
226
227 styleValue = styleResourceValue.getItem("shadowRadius", true /*framework*/);
228 assertNotNull(styleValue);
229 assertEquals("2.75", styleValue.getValue());
230
231 styleValue = styleResourceValue.getItem("foo", false /*framework*/);
232 assertNotNull(styleValue);
233 assertEquals("foo", styleValue.getValue());
234 }
235
236 @Test
237 public void testUpdateWithBasicFiles() throws Exception {
238 File root = getIncMergeRoot("basicFiles");
239 File fakeRoot = getMergedBlobFolder(root);
240 ResourceMerger resourceMerger = new ResourceMerger(0);
241 resourceMerger.loadFromBlob(fakeRoot, false /*incrementalState*/);
242 checkSourceFolders(resourceMerger);
243
244 List<ResourceSet> sets = resourceMerger.getDataSets();
245 assertEquals(2, sets.size());
246
247 // write the content in a repo.
248 ResourceRepository repo = new ResourceRepository(false);
249 resourceMerger.mergeData(repo.createMergeConsumer(), true /*doCleanUp*/);
250
251 // checks the initial state of the repo
252 Map<ResourceType, ListMultimap<String, ResourceItem>> items = repo.getItems();
253 ListMultimap<String, ResourceItem> drawables = items.get(ResourceType.DRAWABLE);
254 assertNotNull("Drawable null check", drawables);
255 assertEquals("Drawable size check", 6, drawables.size());
256 verifyResourceExists(repo,
257 "drawable/new_overlay",
258 "drawable/removed",
259 "drawable?ldpi/removed",
260 "drawable/touched",
261 "drawable/removed_overlay",
262 "drawable/untouched");
263
264 // Apply updates
265 RecordingLogger logger = new RecordingLogger();
266
267 // ----------------
268 // first set is the main one, no change here
269 ResourceSet mainSet = sets.get(0);
270 File mainBase = new File(root, "main");
271 File mainDrawable = new File(mainBase, "drawable");
272 File mainDrawableLdpi = new File(mainBase, "drawable-ldpi");
273
274 // touched/removed files:
275 File mainDrawableTouched = new File(mainDrawable, "touched.png");
276 mainSet.updateWith(mainBase, mainDrawableTouched, FileStatus.CHANGED, logger);
277 checkLogger(logger);
278
279 File mainDrawableRemoved = new File(mainDrawable, "removed.png");
280 mainSet.updateWith(mainBase, mainDrawableRemoved, FileStatus.REMOVED, logger);
281 checkLogger(logger);
282
283 File mainDrawableLdpiRemoved = new File(mainDrawableLdpi, "removed.png");
284 mainSet.updateWith(mainBase, mainDrawableLdpiRemoved, FileStatus.REMOVED, logger);
285 checkLogger(logger);
286
287 // ----------------
288 // second set is the overlay one
289 ResourceSet overlaySet = sets.get(1);
290 File overlayBase = new File(root, "overlay");
291 File overlayDrawable = new File(overlayBase, "drawable");
292 File overlayDrawableHdpi = new File(overlayBase, "drawable-hdpi");
293
294 // new/removed files:
295 File overlayDrawableNewOverlay = new File(overlayDrawable, "new_overlay.png");
296 overlaySet.updateWith(overlayBase, overlayDrawableNewOverlay, FileStatus.NEW, logger);
297 checkLogger(logger);
298
299 File overlayDrawableRemovedOverlay = new File(overlayDrawable, "removed_overlay.png");
300 overlaySet.updateWith(overlayBase, overlayDrawableRemovedOverlay, FileStatus.REMOVED,
301 logger);
302 checkLogger(logger);
303
304 File overlayDrawableHdpiNewAlternate = new File(overlayDrawableHdpi, "new_alternate.png");
305 overlaySet.updateWith(overlayBase, overlayDrawableHdpiNewAlternate, FileStatus.NEW, logger);
306 checkLogger(logger);
307
308 // validate for duplicates
309 resourceMerger.validateDataSets();
310
311 // check the new content.
312 resourceMerger.mergeData(repo.createMergeConsumer(), true /*doCleanUp*/);
313
314 drawables = items.get(ResourceType.DRAWABLE);
315 assertNotNull("Drawable null check", drawables);
316 assertEquals("Drawable size check", 5, drawables.size());
317 verifyResourceExists(repo,
318 "drawable/new_overlay",
319 "drawable/touched",
320 "drawable/removed_overlay",
321 "drawable/untouched",
322 "drawable?hdpi-v4/new_alternate");
323 checkRemovedItems(resourceMerger);
324 }
325
326 @Test
327 public void testUpdateWithBasicValues() throws Exception {
328 File root = getIncMergeRoot("basicValues");
329 File fakeRoot = getMergedBlobFolder(root);
330 ResourceMerger resourceMerger = new ResourceMerger(0);
331 resourceMerger.loadFromBlob(fakeRoot, false /*incrementalState*/);
332 checkSourceFolders(resourceMerger);
333
334 List<ResourceSet> sets = resourceMerger.getDataSets();
335 assertEquals(2, sets.size());
336
337 // write the content in a repo.
338 ResourceRepository repo = new ResourceRepository(false);
339 resourceMerger.mergeData(repo.createMergeConsumer(), true /*doCleanUp*/);
340
341 // checks the initial state of the repo
342 Map<ResourceType, ListMultimap<String, ResourceItem>> items = repo.getItems();
343 ListMultimap<String, ResourceItem> strings = items.get(ResourceType.STRING);
344 assertNotNull("String null check", strings);
345 assertEquals("String size check", 5, strings.size());
346 verifyResourceExists(repo,
347 "string/untouched",
348 "string/touched",
349 "string/removed",
350 "string?en/removed",
351 "string/new_overlay");
352
353 // apply updates
354 RecordingLogger logger = new RecordingLogger();
355
356 // ----------------
357 // first set is the main one, no change here
358 ResourceSet mainSet = sets.get(0);
359 File mainBase = new File(root, "main");
360 File mainValues = new File(mainBase, "values");
361 File mainValuesEn = new File(mainBase, "values-en");
362
363 // touched file:
364 File mainValuesTouched = new File(mainValues, "values.xml");
365 mainSet.updateWith(mainBase, mainValuesTouched, FileStatus.CHANGED, logger);
366 checkLogger(logger);
367
368 // removed files
369 File mainValuesEnRemoved = new File(mainValuesEn, "values.xml");
370 mainSet.updateWith(mainBase, mainValuesEnRemoved, FileStatus.REMOVED, logger);
371 checkLogger(logger);
372
373 // ----------------
374 // second set is the overlay one
375 ResourceSet overlaySet = sets.get(1);
376 File overlayBase = new File(root, "overlay");
377 File overlayValues = new File(overlayBase, "values");
378 File overlayValuesFr = new File(overlayBase, "values-fr");
379
380 // new files:
381 File overlayValuesNew = new File(overlayValues, "values.xml");
382 overlaySet.updateWith(overlayBase, overlayValuesNew, FileStatus.NEW, logger);
383 checkLogger(logger);
384
385 File overlayValuesFrNew = new File(overlayValuesFr, "values.xml");
386 overlaySet.updateWith(overlayBase, overlayValuesFrNew, FileStatus.NEW, logger);
387 checkLogger(logger);
388
389 // validate for duplicates
390 resourceMerger.validateDataSets();
391
392 // check the new content.
393 resourceMerger.mergeData(repo.createMergeConsumer(), true /*doCleanUp*/);
394
395 strings = items.get(ResourceType.STRING);
396 assertNotNull("String null check", strings);
397 assertEquals("String size check", 4, strings.size());
398 verifyResourceExists(repo,
399 "string/untouched",
400 "string/touched",
401 "string/new_overlay",
402 "string?fr/new_alternate");
403 checkRemovedItems(resourceMerger);
404 }
405
406 @Test
407 public void testUpdateWithBasicValues2() throws Exception {
408 File root = getIncMergeRoot("basicValues2");
409 File fakeRoot = getMergedBlobFolder(root);
410 ResourceMerger resourceMerger = new ResourceMerger(0);
411 resourceMerger.loadFromBlob(fakeRoot, false /*incrementalState*/);
412 checkSourceFolders(resourceMerger);
413
414 List<ResourceSet> sets = resourceMerger.getDataSets();
415 assertEquals(2, sets.size());
416
417 // write the content in a repo.
418 ResourceRepository repo = new ResourceRepository(false);
419 resourceMerger.mergeData(repo.createMergeConsumer(), true /*doCleanUp*/);
420
421 // checks the initial state of the repo
422 Map<ResourceType, ListMultimap<String, ResourceItem>> items = repo.getItems();
423 ListMultimap<String, ResourceItem> strings = items.get(ResourceType.STRING);
424 assertNotNull("String null check", strings);
425 assertEquals("String size check", 2, strings.size());
426 verifyResourceExists(repo,
427 "string/untouched",
428 "string/removed_overlay");
429
430 // apply updates
431 RecordingLogger logger = new RecordingLogger();
432
433 // ----------------
434 // first set is the main one, no change here
435
436 // ----------------
437 // second set is the overlay one
438 ResourceSet overlaySet = sets.get(1);
439 File overlayBase = new File(root, "overlay");
440 File overlayValues = new File(overlayBase, "values");
441
442 // new files:
443 File overlayValuesNew = new File(overlayValues, "values.xml");
444 overlaySet.updateWith(overlayBase, overlayValuesNew, FileStatus.REMOVED, logger);
445 checkLogger(logger);
446
447 // validate for duplicates
448 resourceMerger.validateDataSets();
449
450 // check the new content.
451 resourceMerger.mergeData(repo.createMergeConsumer(), true /*doCleanUp*/);
452
453 strings = items.get(ResourceType.STRING);
454 assertNotNull("String null check", strings);
455 assertEquals("String size check", 2, strings.size());
456 verifyResourceExists(repo,
457 "string/untouched",
458 "string/removed_overlay");
459 checkRemovedItems(resourceMerger);
460 }
461
462 @Test
463 public void testUpdateWithFilesVsValues() throws Exception {
464 File root = getIncMergeRoot("filesVsValues");
465 File fakeRoot = getMergedBlobFolder(root);
466 ResourceMerger resourceMerger = new ResourceMerger(0);
467 resourceMerger.loadFromBlob(fakeRoot, false /*incrementalState*/);
468 checkSourceFolders(resourceMerger);
469
470 List<ResourceSet> sets = resourceMerger.getDataSets();
471 assertEquals(1, sets.size());
472
473 // write the content in a repo.
474 ResourceRepository repo = new ResourceRepository(false);
475 resourceMerger.mergeData(repo.createMergeConsumer(), true /*doCleanUp*/);
476
477 // checks the initial state of the repo
478 Map<ResourceType, ListMultimap<String, ResourceItem>> items = repo.getItems();
479 ListMultimap<String, ResourceItem> layouts = items.get(ResourceType.LAYOUT);
480 assertNotNull("String null check", layouts);
481 assertEquals("String size check", 3, layouts.size());
482 verifyResourceExists(repo,
483 "layout/main",
484 "layout/file_replaced_by_alias",
485 "layout/alias_replaced_by_file");
486
487 // apply updates
488 RecordingLogger logger = new RecordingLogger();
489
490 // ----------------
491 // Load the main set
492 ResourceSet mainSet = sets.get(0);
493 File mainBase = new File(root, "main");
494 File mainValues = new File(mainBase, ResourceFolderType.VALUES.getName());
495 File mainLayout = new File(mainBase, ResourceFolderType.LAYOUT.getName());
496
497 // touched file:
498 File mainValuesTouched = new File(mainValues, "values.xml");
499 mainSet.updateWith(mainBase, mainValuesTouched, FileStatus.CHANGED, logger);
500 checkLogger(logger);
501
502 // new file:
503 File mainLayoutNew = new File(mainLayout, "alias_replaced_by_file.xml");
504 mainSet.updateWith(mainBase, mainLayoutNew, FileStatus.NEW, logger);
505 checkLogger(logger);
506
507 // removed file
508 File mainLayoutRemoved = new File(mainLayout, "file_replaced_by_alias.xml");
509 mainSet.updateWith(mainBase, mainLayoutRemoved, FileStatus.REMOVED, logger);
510 checkLogger(logger);
511
512 // validate for duplicates
513 resourceMerger.validateDataSets();
514
515 // check the new content.
516 resourceMerger.mergeData(repo.createMergeConsumer(), true /*doCleanUp*/);
517
518 layouts = items.get(ResourceType.LAYOUT);
519 assertNotNull("String null check", layouts);
520 assertEquals("String size check", 3, layouts.size());
521 verifyResourceExists(repo,
522 "layout/main",
523 "layout/file_replaced_by_alias",
524 "layout/alias_replaced_by_file");
525 checkRemovedItems(resourceMerger);
526 }
527
528 @Test
529 public void testUpdateFromOldFile() throws Exception {
530 File root = getIncMergeRoot("oldMerge");
531 File fakeRoot = getMergedBlobFolder(root);
532 ResourceMerger resourceMerger = new ResourceMerger(0);
533 assertFalse(resourceMerger.loadFromBlob(fakeRoot, false /*incrementalState*/));
534 }
535
536 private static void checkRemovedItems(DataMap<? extends DataItem> dataMap) {
537 for (DataItem item : dataMap.getDataMap().values()) {
538 if (item.isRemoved()) {
539 fail("Removed item found: " + item);
540 }
541 }
542 }
543
544 /**
545 * Creates a fake merge with given sets.
546 *
547 * the data is an array of sets.
548 *
549 * Each set is [ setName, folder1, folder2, ...]
550 *
551 */
552 private static ResourceMerger createMerger(String[][] data) {
553 ResourceMerger merger = new ResourceMerger(0);
554 for (String[] setData : data) {
555 ResourceSet set = new ResourceSet(setData[0], null);
556 merger.addDataSet(set);
557 for (int i = 1, n = setData.length; i < n; i++) {
558 set.addSource(new File(setData[i]));
559 }
560 }
561
562 return merger;
563 }
564
565 /**
566 * Returns a merger with the baseSet and baseMerge content.
567 */
568 private static ResourceMerger getBaseResourceMerger()
569 throws MergingException, IOException {
570 File root = TestUtils.getRoot("resources", "baseMerge");
571
572 ResourceSet res = ResourceSetTest.getBaseResourceSet();
573
574 RecordingLogger logger = new RecordingLogger();
575
576 ResourceSet overlay = new ResourceSet("overlay", null);
577 overlay.addSource(new File(root, "overlay"));
578 overlay.loadFromFiles(logger);
579
580 checkLogger(logger);
581
582 ResourceMerger resourceMerger = new ResourceMerger(0);
583 resourceMerger.addDataSet(res);
584 resourceMerger.addDataSet(overlay);
585
586 return resourceMerger;
587 }
588
589 /**
590 * Returns a merger from incMergeData initialized from the files, not from the merger
591 * state blog.
592 */
593 private static ResourceMerger getIncResourceMerger(String rootName, String... sets)
594 throws MergingException, IOException {
595
596 File root = getIncMergeRoot(rootName);
597 RecordingLogger logger = new RecordingLogger();
598
599 ResourceMerger resourceMerger = new ResourceMerger(0);
600
601 for (String setName : sets) {
602 ResourceSet resourceSet = new ResourceSet(setName, null);
603 resourceSet.addSource(new File(root, setName));
604 resourceSet.loadFromFiles(logger);
605 checkLogger(logger);
606
607 resourceMerger.addDataSet(resourceSet);
608 }
609
610 return resourceMerger;
611 }
612
613 private static ResourceRepository getResourceRepository()
614 throws MergingException, IOException {
615 ResourceMerger merger = getBaseResourceMerger();
616
617 ResourceRepository repo = new ResourceRepository(false);
618
619 merger.mergeData(repo.createMergeConsumer(), true /*doCleanUp*/);
620 return repo;
621 }
622
623 private static File getIncMergeRoot(String name) throws IOException {
624 File root = TestUtils.getCanonicalRoot("resources", "incMergeData");
625 return new File(root, name);
626 }
627
628 private static void verifyResourceExists(ResourceRepository repository,
629 String... dataItemKeys) {
630 Map<ResourceType, ListMultimap<String, ResourceItem>> items = repository.getItems();
631
632 for (String resKey : dataItemKeys) {
633 String type, name, qualifier = "";
634
635 int pos = resKey.indexOf('/');
636 if (pos != -1) {
637 name = resKey.substring(pos + 1);
638 type = resKey.substring(0, pos);
639 } else {
640 throw new IllegalArgumentException("Invalid key " + resKey);
641 }
642
643 // use ? as a qualifier delimiter because of
644 // declare-styleable
645 pos = type.indexOf('?');
646 if (pos != -1) {
647 qualifier = type.substring(pos + 1);
648 type = type.substring(0, pos);
649 }
650
651 ResourceType resourceType = ResourceType.getEnum(type);
652 assertNotNull("Type check for " + resKey, resourceType);
653
654 Multimap<String, ResourceItem> map = items.get(resourceType);
655 assertNotNull("Map check for " + resKey, map);
656
657 Collection<ResourceItem> list = map.get(name);
658 int found = 0;
659 for (ResourceItem resourceItem : list) {
660 if (resourceItem.getName().equals(name)) {
661 String fileQualifier = resourceItem.getSource() != null ?
662 resourceItem.getSource().getQualifiers() : "";
663
664 if (qualifier.equals(fileQualifier)) {
665 found++;
666 }
667 }
668 }
669
670 assertEquals("Match for " + resKey, 1, found);
671 }
672 }
673
674 // This utility method has been pretty handy in tracking down resource repository bugs
675 // so keeping it for future potential use, but in unit test code so no runtime overhead
676 @SuppressWarnings({"deprecation", "ConstantConditions"})
677 public static String dumpRepository(ResourceRepository repository) {
678 Map<ResourceType, ListMultimap<String, ResourceItem>> mItems = repository.getMap();
679 Comparator<ResourceItem> comparator = new Comparator<ResourceItem>() {
680 @Override
681 public int compare(ResourceItem item1, ResourceItem item2) {
682 assert item1.getType() == item2.getType();
683 String qualifiers = item2.getSource().getQualifiers();
684 return item1.getSource().getQualifiers().compareTo(qualifiers);
685 }
686 };
687
688 StringBuilder sb = new StringBuilder(5000);
689 sb.append("Resource Map Dump For Repository ").append(repository)
690 .append("\n------------------------------------------------\n");
691 for (ResourceType type : ResourceType.values()) {
692 ListMultimap<String, ResourceItem> map = mItems.get(type);
693 if (map == null) {
694 continue;
695 }
696 sb.append(type.getName()).append(':').append('\n');
697
698 List<String> keys = new ArrayList<String>(map.keySet());
699 Collections.sort(keys);
700 for (String key : keys) {
701 List<ResourceItem> items = map.get(key);
702 List<ResourceItem> sorted = new ArrayList<ResourceItem>(items);
703 Collections.sort(sorted, comparator);
704 sb.append(" ").append(type.getName()).append(" ").append(key).append(": ");
705 boolean first = true;
706 for (ResourceItem item : sorted) {
707 if (first) {
708 first = false;
709 } else {
710 sb.append(", ");
711 }
712 String qualifiers = item.getSource().getQualifiers();
713 if (qualifiers.isEmpty()) {
714 qualifiers = "default";
715 }
716 sb.append(qualifiers);
717 }
718
719 if (!sorted.isEmpty()) {
720 ResourceItem item = sorted.get(0);
721 ResourceValue resourceValue = item.getResourceValue(repository.isFramework());
722 if (resourceValue == null) {
723 sb.append(" <no value found>");
724 } else {
725 String value = resourceValue.getValue();
726 if (value == null || value.isEmpty()) {
727 if (resourceValue instanceof StyleResourceValue) {
728 StyleResourceValue srv = (StyleResourceValue) resourceValue;
729 sb.append(" parentStyle=").append(srv.getParentStyle())
730 .append("\n");
731 for (String name : srv.getNames()) {
732 ItemResourceValue value1 = srv.getItem(name, false);
733 ItemResourceValue value2 = srv.getItem(name, true);
734 if (value1 != null) {
735 Boolean framework = false;
736 sb.append(" ");
737 sb.append(name).append(" ").append(framework).append(" ");
738 sb.append(" = ");
739 sb.append('"');
740 String strValue = value1.getValue();
741 if (strValue != null) {
742 sb.append(strValue.replace("\n", "\\n"));
743 } else {
744 sb.append("???");
745 }
746 sb.append('"');
747 }
748 if (value2 != null) {
749 Boolean framework = true;
750 sb.append(" ");
751 sb.append(name).append(" ").append(framework).append(" ");
752 sb.append(" = ");
753 sb.append('"');
754 String strValue = value2.getValue();
755 if (strValue != null) {
756 sb.append(strValue.replace("\n", "\\n"));
757 } else {
758 sb.append("???");
759 }
760 sb.append('"');
761 }
762 }
763 } else {
764 sb.append(" = \"\"");
765 }
766 } else {
767 sb.append(" = ");
768 sb.append('"');
769 sb.append(value.replace("\n", "\\n"));
770 sb.append('"');
771 }
772 }
773 }
774
775 sb.append("\n");
776 }
777
778 sb.append("\n\n");
779 }
780
781 return sb.toString();
782 }
783 }