Debian Codegraph @

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

raw
1 /*
2 * Copyright (C) 2012 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 com.android.SdkConstants.ATTR_NAME;
20 import static com.android.SdkConstants.TAG_ATTR;
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertFalse;
23 import static org.junit.Assert.assertNotNull;
24 import static org.junit.Assert.assertNull;
25 import static org.junit.Assert.assertTrue;
26 import static org.junit.Assert.fail;
27
28 import com.android.SdkConstants;
29 import com.android.annotations.NonNull;
30 import com.android.annotations.Nullable;
31 import com.android.ide.common.blame.MergingLog;
32 import com.android.ide.common.blame.SourceFile;
33 import com.android.ide.common.blame.SourceFilePosition;
34 import com.android.ide.common.blame.SourcePosition;
35 import com.android.ide.common.rendering.api.ResourceValue;
36 import com.android.resources.ResourceFolderType;
37 import com.android.resources.ResourceType;
38 import com.android.testutils.TestUtils;
39 import com.android.utils.FileUtils;
40 import com.android.utils.Pair;
41 import com.google.common.base.Charsets;
42 import com.google.common.base.Predicate;
43 import com.google.common.base.Strings;
44 import com.google.common.collect.*;
45 import com.google.common.io.Files;
46
47 import org.junit.Before;
48 import org.junit.Rule;
49 import org.junit.Test;
50 import org.junit.rules.TemporaryFolder;
51 import org.mockito.Mock;
52 import org.mockito.MockitoAnnotations;
53 import org.w3c.dom.Attr;
54 import org.w3c.dom.Document;
55 import org.w3c.dom.Node;
56 import org.w3c.dom.NodeList;
57
58 import java.io.File;
59 import java.io.IOException;
60 import java.nio.charset.Charset;
61 import java.util.Collection;
62 import java.util.Collections;
63 import java.util.List;
64 import java.util.Map;
65
66 import javax.xml.parsers.DocumentBuilderFactory;
67
68 public class ResourceMergerTest extends BaseTestCase {
69
70 @Mock
71 ResourcePreprocessor mPreprocessor;
72
73 @Rule
74 public TemporaryFolder mTemporaryFolder = new TemporaryFolder();
75
76 @Before
77 public void setUp() throws Exception {
78 MockitoAnnotations.initMocks(this);
79 }
80
81 @Test
82 public void testMergeWithNormalizationByCount() throws Exception {
83 ResourceMerger merger = getResourceMerger();
84
85 assertEquals(36, merger.size());
86 }
87
88 @Test
89 public void testMergedResourcesWithNormalizationByName() throws Exception {
90 ResourceMerger merger = getResourceMerger();
91
92 verifyResourceExists(merger,
93 "drawable/icon",
94 "drawable-ldpi-v4/icon",
95 "drawable/icon2",
96 "drawable/patch",
97 "raw/foo",
98 "layout/main",
99 "layout/layout_ref",
100 "layout/alias_replaced_by_file",
101 "layout/file_replaced_by_alias",
102 "drawable/color_drawable",
103 "drawable/drawable_ref",
104 "color/color",
105 "string/basic_string",
106 "string/xliff_string",
107 "string/xliff_with_carriage_return",
108 "string/styled_string",
109 "string/two",
110 "string/many",
111 "style/style",
112 "array/string_array",
113 "array/integer_array",
114 "array/my_colors",
115 "attr/dimen_attr",
116 "attr/string_attr",
117 "attr/enum_attr",
118 "attr/flag_attr",
119 "attr/blah",
120 "attr/blah2",
121 "attr/flagAttr",
122 "declare-styleable/declare_styleable",
123 "dimen/dimen",
124 "dimen-sw600dp-v13/offset",
125 "id/item_id",
126 "integer/integer",
127 "plurals/plurals",
128 "plurals/plurals_with_bad_quantity"
129 );
130 }
131
132 private static String getPlatformPath(String path) {
133 return path.replace('/', File.separatorChar);
134 }
135
136 @Test
137 public void testReplacedLayout() throws Exception {
138 ResourceMerger merger = getResourceMerger();
139 ListMultimap<String, ResourceItem> mergedMap = merger.getDataMap();
140
141 List<ResourceItem> values = mergedMap.get("layout/main");
142
143 // the overlay means there's 2 versions of this resource.
144 assertEquals(2, values.size());
145 ResourceItem mainLayout = values.get(1);
146
147 ResourceFile sourceFile = mainLayout.getSource();
148 assertTrue(sourceFile.getFile().getAbsolutePath()
149 .endsWith(getPlatformPath("overlay/layout/main.xml")));
150 }
151
152 @Test
153 public void testReplacedAlias() throws Exception {
154 ResourceMerger merger = getResourceMerger();
155 ListMultimap<String, ResourceItem> mergedMap = merger.getDataMap();
156
157 List<ResourceItem> values = mergedMap.get("layout/alias_replaced_by_file");
158
159 // the overlay means there's 2 versions of this resource.
160 assertEquals(2, values.size());
161 ResourceItem layout = values.get(1);
162
163 // since it's replaced by a file, there's no node.
164 assertNull(layout.getValue());
165 }
166
167 @Test
168 public void testReplacedFile() throws Exception {
169 ResourceMerger merger = getResourceMerger();
170 ListMultimap<String, ResourceItem> mergedMap = merger.getDataMap();
171
172 List<ResourceItem> values = mergedMap.get("layout/file_replaced_by_alias");
173
174 // the overlay means there's 2 versions of this resource.
175 assertEquals(2, values.size());
176 ResourceItem layout = values.get(1);
177
178 // since it's replaced by an alias, there's a node
179 assertNotNull(layout.getValue());
180 }
181
182 @Test
183 public void testMergeWrite() throws Exception {
184 ResourceMerger merger = getResourceMerger();
185 RecordingLogger logger = new RecordingLogger();
186
187 File folder = getWrittenResources();
188
189 ResourceSet writtenSet = new ResourceSet("unused", null);
190 writtenSet.addSource(folder);
191 writtenSet.loadFromFiles(logger);
192
193 // compare the two maps, but not using the full map as the set loaded from the output
194 // won't contains all versions of each ResourceItem item.
195 compareResourceMaps(merger, writtenSet, false /*full compare*/);
196 checkLogger(logger);
197 }
198
199 @Test
200 public void testXliffString() throws Exception {
201 ResourceMerger merger = getResourceMerger();
202
203 // check the result of the load
204 List<ResourceItem> values = merger.getDataMap().get("string/xliff_string");
205
206 assertEquals(1, values.size());
207 ResourceItem string = values.get(0);
208
209 // Even though the content is
210 // <xliff:g id="firstName">%1$s</xliff:g> <xliff:g id="lastName">%2$s</xliff:g>
211 // The valueText is going to skip the <g> node so we skip them from the comparison.
212 // What matters here is that the whitespaces are kept.
213 assertEquals("Loaded String in merger",
214 "%1$s %2$s",
215 string.getValueText());
216
217 File folder = getWrittenResources();
218
219 RecordingLogger logger = new RecordingLogger();
220 ResourceSet writtenSet = new ResourceSet("unused", null);
221 writtenSet.addSource(folder);
222 writtenSet.loadFromFiles(logger);
223
224 values = writtenSet.getDataMap().get("string/xliff_string");
225
226 assertEquals(1, values.size());
227 string = values.get(0);
228
229 // Even though the content is
230 // <xliff:g id="firstName">%1$s</xliff:g> <xliff:g id="lastName">%2$s</xliff:g>
231 // The valueText is going to skip the <g> node so we skip them from the comparison.
232 // What matters here is that the whitespaces are kept.
233 assertEquals("Rewritten String through merger",
234 "%1$s %2$s",
235 string.getValueText());
236 }
237
238 @Test
239 public void testXliffStringWithCarriageReturn() throws Exception {
240 ResourceMerger merger = getResourceMerger();
241
242 // check the result of the load
243 List<ResourceItem> values = merger.getDataMap().get("string/xliff_with_carriage_return");
244
245 assertEquals(1, values.size());
246 ResourceItem string = values.get(0);
247
248 // Even though the content has xliff nodes
249 // The valueText is going to skip the <g> node so we skip them from the comparison.
250 // What matters here is that the whitespaces are kept.
251 String value = string.getValueText();
252 assertEquals("Loaded String in merger",
253 "This is should be followed by whitespace:\n %1$s",
254 value);
255
256 File folder = getWrittenResources();
257
258 RecordingLogger logger = new RecordingLogger();
259 ResourceSet writtenSet = new ResourceSet("unused", null);
260 writtenSet.addSource(folder);
261 writtenSet.loadFromFiles(logger);
262
263 values = writtenSet.getDataMap().get("string/xliff_with_carriage_return");
264
265 assertEquals(1, values.size());
266 string = values.get(0);
267
268 // Even though the content has xliff nodes
269 // The valueText is going to skip the <g> node so we skip them from the comparison.
270 // What matters here is that the whitespaces are kept.
271 String newValue = string.getValueText();
272 assertEquals("Rewritten String through merger",
273 value,
274 newValue);
275 }
276
277 @Test
278 public void testNotMergedAttr() throws Exception {
279 RecordingLogger logger = new RecordingLogger();
280
281 File folder = getWrittenResources();
282
283 ResourceSet writtenSet = new ResourceSet("unused", null);
284 writtenSet.addSource(folder);
285 writtenSet.loadFromFiles(logger);
286
287 List<ResourceItem> items = writtenSet.getDataMap().get("attr/blah");
288 assertEquals(1, items.size());
289 assertTrue(items.get(0).getIgnoredFromDiskMerge());
290
291 checkLogger(logger);
292 }
293
294 @Test
295 public void testMergedAttr() throws Exception {
296 RecordingLogger logger = new RecordingLogger();
297
298 File folder = getWrittenResources();
299
300 ResourceSet writtenSet = new ResourceSet("unused", null);
301 writtenSet.addSource(folder);
302 writtenSet.loadFromFiles(logger);
303
304 List<ResourceItem> items = writtenSet.getDataMap().get("attr/blah2");
305 assertEquals(1, items.size());
306 assertFalse(items.get(0).getIgnoredFromDiskMerge());
307
308 checkLogger(logger);
309 }
310
311 @Test
312 public void testNotMergedAttrFromMerge() throws Exception {
313 ResourceMerger merger = getResourceMerger();
314
315 File folder = TestUtils.createTempDirDeletedOnExit();
316 merger.writeBlobTo(folder, getConsumer(), false);
317
318 ResourceMerger loadedMerger = new ResourceMerger(0);
319 assertTrue(loadedMerger.loadFromBlob(folder, true /*incrementalState*/));
320
321 // check that attr/blah is ignoredFromDiskMerge.
322 List<ResourceItem> items = loadedMerger.getDataSets().get(0).getDataMap().get("attr/blah");
323 assertEquals(1, items.size());
324 assertTrue(items.get(0).getIgnoredFromDiskMerge());
325 }
326
327 @Test
328 public void testNotMergedSingleFileItem() throws Exception {
329 ResourceMerger merger = getResourceMerger();
330
331 List<ResourceItem> items = merger.getDataSets().get(0).getDataMap().get("drawable/patch");
332 assertEquals(1, items.size());
333 assertFalse(items.get(0).getIgnoredFromDiskMerge());
334
335 File folder = TestUtils.createTempDirDeletedOnExit();
336 merger.writeBlobTo(folder, getConsumer(), false);
337
338 ResourceMerger loadedMerger = new ResourceMerger(0);
339 assertTrue(loadedMerger.loadFromBlob(folder, true /*incrementalState*/));
340
341 // drawable/patch should survive blob writing / loading
342 List<ResourceItem> loadedItems = loadedMerger.getDataSets().get(0).getDataMap().get("drawable/patch");
343 assertEquals(1, loadedItems.size());
344
345 // Now mark the item ignored and try write + load again
346 loadedItems.get(0).setIgnoredFromDiskMerge(true);
347 folder = TestUtils.createTempDirDeletedOnExit();
348 loadedMerger.writeBlobTo(folder, getConsumer(), false);
349
350 ResourceMerger loadedMerger2 = new ResourceMerger(0);
351 assertTrue(loadedMerger2.loadFromBlob(folder, true /*incrementalState*/));
352
353 List<ResourceItem> loadedItems2 = loadedMerger2.getDataSets().get(0).getDataMap().get("drawable/patch");
354 assertEquals(0, loadedItems2.size());
355 }
356
357 @Test
358 public void testWrittenDeclareStyleable() throws Exception {
359 RecordingLogger logger = new RecordingLogger();
360
361 File folder = getWrittenResources();
362
363 ResourceSet writtenSet = new ResourceSet("unused", null);
364 writtenSet.addSource(folder);
365 writtenSet.loadFromFiles(logger);
366
367 List<ResourceItem> items = writtenSet.getDataMap().get("declare-styleable/declare_styleable");
368 assertEquals(1, items.size());
369
370 Node styleableNode = items.get(0).getValue();
371 assertNotNull(styleableNode);
372
373 // inspect the node
374 NodeList nodes = styleableNode.getChildNodes();
375
376 boolean foundBlah = false;
377 boolean foundAndroidColorForegroundInverse = false;
378 boolean foundBlah2 = false;
379
380 for (int i = 0, n = nodes.getLength(); i < n; i++) {
381 Node node = nodes.item(i);
382
383 if (node.getNodeType() != Node.ELEMENT_NODE) {
384 continue;
385 }
386
387 String nodeName = node.getLocalName();
388 if (ResourceType.ATTR.getName().equals(nodeName)) {
389 Attr attribute = (Attr) node.getAttributes().getNamedItemNS(null, ATTR_NAME);
390
391 if (attribute != null) {
392 String name = attribute.getValue();
393 if ("blah".equals(name)) {
394 foundBlah = true;
395 } else if ("android:colorForegroundInverse".equals(name)) {
396 foundAndroidColorForegroundInverse = true;
397 } else if ("blah2".equals(name)) {
398 foundBlah2 = true;
399 }
400 }
401
402 }
403 }
404
405 assertTrue(foundBlah);
406 assertTrue(foundAndroidColorForegroundInverse);
407 assertTrue(foundBlah2);
408
409 checkLogger(logger);
410 }
411
412 @Test
413 public void testMergeBlob() throws Exception {
414 ResourceMerger merger = getResourceMerger();
415
416 File folder = TestUtils.createTempDirDeletedOnExit();
417 merger.writeBlobTo(folder, getConsumer(), false);
418
419 ResourceMerger loadedMerger = new ResourceMerger(0);
420 assertTrue(loadedMerger.loadFromBlob(folder, true /*incrementalState*/));
421
422 compareResourceMaps(merger, loadedMerger, true /*full compare*/);
423
424 // Also check that some of the node values are preserved.
425 List<ResourceItem> fromOrigValue = merger.getDataMap().get("string/xliff_with_carriage_return");
426 assertEquals(1, fromOrigValue.size());
427 ResourceItem fromOrigString = fromOrigValue.get(0);
428 assertEquals("Original String in merger",
429 "This is should be followed by whitespace:\n %1$s",
430 fromOrigString.getValueText());
431
432 List<ResourceItem> fromLoadedValues = loadedMerger.getDataMap().get("string/xliff_with_carriage_return");
433 assertEquals(1, fromLoadedValues.size());
434 ResourceItem fromLoadedString = fromLoadedValues.get(0);
435 assertEquals("Loaded String in merger",
436 "This is should be followed by whitespace:\n %1$s",
437 fromLoadedString.getValueText());
438 }
439
440 @Test
441 public void testMergeIdGeneratingResources() throws Exception {
442 // Test loading and writing Id resources. Test loading a single file instead of all.
443 File root = TestUtils.getRoot("resources", "idGenerating");
444 ResourceSet resourceSet = new ResourceSet("idResources", null);
445 resourceSet.addSource(root);
446 ResourceMerger merger = new ResourceMerger(0);
447 merger.addDataSet(resourceSet);
448
449 RecordingLogger logger = new RecordingLogger();
450
451 File layoutDir = new File(root, "layout");
452 File layoutFile = new File(layoutDir, "layout_for_id_scan.xml");
453 resourceSet.setShouldParseResourceIds(true);
454 final ResourceFile parsedFile = resourceSet.loadFile(root, layoutFile, logger);
455 assertNotNull(parsedFile);
456 assertTrue(parsedFile.getFile().equals(layoutFile));
457 assertEquals("", parsedFile.getQualifiers());
458 assertEquals(12, parsedFile.getItems().size());
459 Collection<ResourceItem> layoutItems = Collections2.filter(parsedFile.getItems(), new Predicate<ResourceItem>() {
460 @Override
461 public boolean apply(ResourceItem input) {
462 return input.getType() == ResourceType.LAYOUT &&
463 input.getName().equals("layout_for_id_scan") &&
464 input.getSource() != null &&
465 input.getSource().equals(parsedFile);
466 }
467 });
468 assertEquals(1, layoutItems.size());
469 // Also check that the layout item's ResourceValue makes sense.
470 ResourceItem layoutItem = Iterables.getFirst(layoutItems, null);
471 assertNotNull(layoutItem);
472 ResourceValue layoutValue = layoutItem.getResourceValue(false);
473 assertNotNull(layoutValue);
474 assertEquals(layoutFile.getAbsolutePath(), layoutValue.getValue());
475 Collection<ResourceItem> idItems = Collections2.filter(parsedFile.getItems(), new Predicate<ResourceItem>() {
476 @Override
477 public boolean apply(ResourceItem input) {
478 return input.getType() == ResourceType.ID &&
479 input.getSource() != null &&
480 input.getSource().equals(parsedFile);
481 }
482 });
483 assertEquals(11, idItems.size());
484
485 File folder = TestUtils.createTempDirDeletedOnExit();
486 folder.deleteOnExit();
487 merger.writeBlobTo(folder, getConsumer(), false);
488
489 // reload it
490 ResourceMerger loadedMerger = new ResourceMerger(0);
491 assertTrue(loadedMerger.loadFromBlob(folder, true /*incrementalState*/));
492
493 compareResourceMaps(merger, loadedMerger, true /*full compare*/);
494 // Also check that the layout item's ResourceValue makes sense after reload.
495 List<ResourceItem> loadedLayoutItems = loadedMerger.getDataMap().get("layout/layout_for_id_scan");
496 assertEquals(1, loadedLayoutItems.size());
497 layoutItem = Iterables.getFirst(loadedLayoutItems, null);
498 assertNotNull(layoutItem);
499 layoutValue = layoutItem.getResourceValue(false);
500 assertNotNull(layoutValue);
501 assertEquals(layoutFile.getAbsolutePath(), layoutValue.getValue());
502
503 // Check that the ID item's ResourceValue is nothing of consequence.
504 List<ResourceItem> loadedIdItems = loadedMerger.getDataMap().get("id/title_refresh_progress");
505 assertEquals(1, loadedIdItems.size());
506 ResourceItem idItem = Iterables.getFirst(loadedIdItems, null);
507 assertNotNull(idItem);
508 ResourceValue idValue = idItem.getResourceValue(false);
509 assertNotNull(idValue);
510 assertTrue(Strings.isNullOrEmpty(idValue.getValue()));
511
512 checkLogger(logger);
513 }
514
515 @Test
516 public void testScanForIdDrawableXmlMixedWithBinary() throws Exception {
517 // Test that in a drawable directory with both XML and PNG, we can pick up IDs
518 // without being confused about the PNG.
519 File srcDrawables = FileUtils.join(TestUtils.getRoot("resources", "idGenerating"), "drawable-v21");
520 File copiedRoot = TestUtils.createTempDirDeletedOnExit();
521 copiedRoot.deleteOnExit();
522 File copiedDrawables = FileUtils.join(copiedRoot, "drawable-v21");
523 copyFolder(srcDrawables, copiedDrawables);
524
525 File srcPng = FileUtils.join(TestUtils.getRoot("resources", "baseSet"), "drawable", "icon.png");
526 FileUtils.copyFileToDirectory(srcPng, copiedDrawables);
527 assertTrue(FileUtils.join(copiedDrawables, "drawable_for_id_scan.xml").exists());
528
529 ResourceSet resourceSet = new ResourceSet("idResources", null);
530 resourceSet.addSource(copiedRoot);
531 resourceSet.setShouldParseResourceIds(true);
532
533 RecordingLogger logger = new RecordingLogger();
534 resourceSet.loadFromFiles(logger);
535 List<ResourceItem> iconRes = resourceSet.getDataMap().get("drawable-v21/icon");
536 assertEquals(1, iconRes.size());
537 List<ResourceItem> drawableRes = resourceSet.getDataMap().get("drawable-v21/drawable_for_id_scan");
538 assertEquals(1, drawableRes.size());
539 List<ResourceItem> focusedId= resourceSet.getDataMap().get("id-v21/focused");
540 assertEquals(1, focusedId.size());
541
542 checkLogger(logger);
543 }
544
545 @Test
546 public void testDontNormalizeQualifiers() throws Exception {
547 File root = TestUtils.getRoot("resources", "idGenerating");
548 File copiedRoot = getFolderCopy(root);
549 copiedRoot.deleteOnExit();
550 // Add some qualifiers to directory before loading.
551 File layoutDirWithQualifiers = new File(copiedRoot, "layout-xlarge-land");
552 FileUtils.renameTo(new File(copiedRoot, "layout"), layoutDirWithQualifiers);
553 File layoutFile = new File(layoutDirWithQualifiers, "layout_for_id_scan.xml");
554
555 ResourceSet resourceSet = new ResourceSet("idResources", null);
556 resourceSet.addSource(copiedRoot);
557 RecordingLogger logger = new RecordingLogger();
558
559 // Try first with normalization, which tacks on a -v4 qualifier.
560 ResourceFile parsedFile = resourceSet.loadFile(copiedRoot, layoutFile, logger);
561 assertNotNull(parsedFile);
562 assertEquals("xlarge-land-v4", parsedFile.getQualifiers());
563
564 // Now try without normalization.
565 resourceSet.setDontNormalizeQualifiers(true);
566 parsedFile = resourceSet.loadFile(copiedRoot, layoutFile, logger);
567 assertNotNull(parsedFile);
568 assertEquals("xlarge-land", parsedFile.getQualifiers());
569
570 checkLogger(logger);
571 }
572
573 @Test
574 public void testWriteAndReadBlobWithTimestamps() throws Exception {
575 ResourceMerger merger = getResourceMerger();
576
577 File folder = TestUtils.createTempDirDeletedOnExit();
578 folder.deleteOnExit();
579 merger.writeBlobToWithTimestamps(folder, getConsumer());
580
581 // new merger to read the blob
582 ResourceMerger loadedMerger = new ResourceMerger(0);
583 assertTrue(loadedMerger.loadFromBlob(folder, true /*incrementalState*/));
584
585 compareResourceMaps(merger, loadedMerger, true /*full compare*/);
586 }
587
588 @Test
589 public void testWriteEditAndReadBlobWithTimestamps() throws Exception {
590 Pair<ResourceMerger, File> pair = getResourceMergerBackedByTempFiles();
591 ResourceMerger merger = pair.getFirst();
592 File tempDir = pair.getSecond();
593
594 // Check existence of a values resource.
595 String stringKey = "string/basic_string";
596 assertNotNull(merger.getDataMap().get(stringKey));
597 assertFalse(merger.getDataMap().get(stringKey).isEmpty());
598 ResourceFile resourceFile = merger.getDataMap().get(stringKey).get(0).getSource();
599 assertNotNull(resourceFile);
600 assertTrue(resourceFile.getFile().getName().equals("values.xml"));
601
602 // Write blobs with and without timestamps.
603 File folderWithTimestamps = TestUtils.createTempDirDeletedOnExit();
604 merger.writeBlobToWithTimestamps(folderWithTimestamps, getConsumer());
605
606 File folderWithoutTimestamps = TestUtils.createTempDirDeletedOnExit();
607 merger.writeBlobTo(folderWithoutTimestamps, getConsumer(), false);
608
609 // Simply touch the values file with a sufficiently later timestamp.
610 File subFile = new File(tempDir, FileUtils.join("values", "values.xml"));
611 long oldLastModified = subFile.lastModified();
612 long twoSeconds = 2000;
613 if (!subFile.setLastModified(oldLastModified + twoSeconds)) {
614 // Not supported on this platform
615 return;
616 }
617
618 // Load with and without timestamps to see values omitted due to modification (or not omitted).
619 ResourceMerger loadedWithTimestamps = new ResourceMerger(0);
620 assertTrue(loadedWithTimestamps.loadFromBlob(folderWithTimestamps, true /*incrementalState*/));
621
622 // omitted
623 assertNotNull(loadedWithTimestamps.getDataMap().get(stringKey));
624 assertTrue(loadedWithTimestamps.getDataMap().get(stringKey).isEmpty());
625
626 ResourceMerger loadedWithoutTimestamps = new ResourceMerger(0);
627 assertTrue(loadedWithoutTimestamps.loadFromBlob(folderWithoutTimestamps, true /*incrementalState*/));
628
629 // not omitted
630 assertNotNull(loadedWithoutTimestamps.getDataMap().get(stringKey));
631 assertFalse(loadedWithoutTimestamps.getDataMap().get(stringKey).isEmpty());
632 resourceFile = loadedWithoutTimestamps.getDataMap().get(stringKey).get(0).getSource();
633 assertNotNull(resourceFile);
634 assertTrue(resourceFile.getFile().getName().equals("values.xml"));
635 }
636
637 @Test
638 public void testWriteDeleteAndReadBlobWithTimestamps() throws Exception {
639 Pair<ResourceMerger, File> pair = getResourceMergerBackedByTempFiles();
640 ResourceMerger merger = pair.getFirst();
641 File tempDir = pair.getSecond();
642
643 File folder = TestUtils.createTempDirDeletedOnExit();
644 merger.writeBlobToWithTimestamps(folder, getConsumer());
645
646 String stringKey = "string/basic_string";
647 assertNotNull(merger.getDataMap().get(stringKey));
648 assertFalse(merger.getDataMap().get(stringKey).isEmpty());
649 ResourceFile resourceFile = merger.getDataMap().get(stringKey).get(0).getSource();
650 assertNotNull(resourceFile);
651 assertTrue(resourceFile.getFile().getName().equals("values.xml"));
652
653 File subFile = new File(tempDir, FileUtils.join("values", "values.xml"));
654 assertTrue(subFile.delete());
655
656 // new merger to read the blob
657 ResourceMerger loadedMerger = new ResourceMerger(0);
658 assertTrue(loadedMerger.loadFromBlob(folder, true /*incrementalState*/));
659
660 assertNotNull(loadedMerger.getDataMap().get(stringKey));
661 assertTrue(loadedMerger.getDataMap().get(stringKey).isEmpty());
662 }
663
664 /**
665 * Tests the path replacement in the merger.xml file loaded from testData/
666 * @throws Exception
667 */
668 @Test
669 public void testLoadingTestPathReplacement() throws Exception {
670 File root = TestUtils.getRoot("resources", "baseMerge");
671 File fakeRoot = getMergedBlobFolder(root);
672
673 ResourceMerger resourceMerger = new ResourceMerger(0);
674 assertTrue(resourceMerger.loadFromBlob(fakeRoot, true /*incrementalState*/));
675 checkSourceFolders(resourceMerger);
676
677 List<ResourceSet> sets = resourceMerger.getDataSets();
678 for (ResourceSet set : sets) {
679 List<File> sourceFiles = set.getSourceFiles();
680
681 // there should only be one
682 assertEquals(1, sourceFiles.size());
683
684 File sourceFile = sourceFiles.get(0);
685 assertTrue(String.format("File %s is located in %s", sourceFile, root),
686 sourceFile.getAbsolutePath().startsWith(root.getAbsolutePath()));
687 }
688 }
689
690 @Test
691 public void testUpdateWithBasicFiles() throws Exception {
692 File root = getIncMergeRoot("basicFiles");
693 File fakeRoot = getMergedBlobFolder(root);
694 ResourceMerger resourceMerger = new ResourceMerger(0);
695 assertTrue(resourceMerger.loadFromBlob(fakeRoot, true /*incrementalState*/));
696 checkSourceFolders(resourceMerger);
697
698 List<ResourceSet> sets = resourceMerger.getDataSets();
699 assertEquals(2, sets.size());
700
701 RecordingLogger logger = new RecordingLogger();
702
703 // ----------------
704 // first set is the main one, no change here
705 ResourceSet mainSet = sets.get(0);
706 File mainBase = new File(root, "main");
707 File mainDrawable = new File(mainBase, "drawable");
708 File mainDrawableLdpi = new File(mainBase, "drawable-ldpi");
709
710 // touched/removed files:
711 File mainDrawableTouched = new File(mainDrawable, "touched.png");
712 mainSet.updateWith(mainBase, mainDrawableTouched, FileStatus.CHANGED, logger);
713 checkLogger(logger);
714
715 File mainDrawableRemoved = new File(mainDrawable, "removed.png");
716 mainSet.updateWith(mainBase, mainDrawableRemoved, FileStatus.REMOVED, logger);
717 checkLogger(logger);
718
719 File mainDrawableLdpiRemoved = new File(mainDrawableLdpi, "removed.png");
720 mainSet.updateWith(mainBase, mainDrawableLdpiRemoved, FileStatus.REMOVED, logger);
721 checkLogger(logger);
722
723 // ----------------
724 // second set is the overlay one
725 ResourceSet overlaySet = sets.get(1);
726 File overlayBase = new File(root, "overlay");
727 File overlayDrawable = new File(overlayBase, "drawable");
728 File overlayDrawableHdpi = new File(overlayBase, "drawable-hdpi");
729
730 // new/removed files:
731 File overlayDrawableNewOverlay = new File(overlayDrawable, "new_overlay.png");
732 overlaySet.updateWith(overlayBase, overlayDrawableNewOverlay, FileStatus.NEW, logger);
733 checkLogger(logger);
734
735 File overlayDrawableRemovedOverlay = new File(overlayDrawable, "removed_overlay.png");
736 overlaySet.updateWith(overlayBase, overlayDrawableRemovedOverlay, FileStatus.REMOVED,
737 logger);
738 checkLogger(logger);
739
740 File overlayDrawableHdpiNewAlternate = new File(overlayDrawableHdpi, "new_alternate.png");
741 overlaySet.updateWith(overlayBase, overlayDrawableHdpiNewAlternate, FileStatus.NEW, logger);
742 checkLogger(logger);
743
744 // validate for duplicates
745 resourceMerger.validateDataSets();
746
747 // check the content.
748 ListMultimap<String, ResourceItem> mergedMap = resourceMerger.getDataMap();
749
750 // check unchanged file is WRITTEN
751 List<ResourceItem> drawableUntouched = mergedMap.get("drawable/untouched");
752 assertEquals(1, drawableUntouched.size());
753 assertTrue(drawableUntouched.get(0).isWritten());
754 assertFalse(drawableUntouched.get(0).isTouched());
755 assertFalse(drawableUntouched.get(0).isRemoved());
756
757 // check replaced file is TOUCHED
758 List<ResourceItem> drawableTouched = mergedMap.get("drawable/touched");
759 assertEquals(1, drawableTouched.size());
760 assertTrue(drawableTouched.get(0).isWritten());
761 assertTrue(drawableTouched.get(0).isTouched());
762 assertFalse(drawableTouched.get(0).isRemoved());
763
764 // check removed file is REMOVED
765 List<ResourceItem> drawableRemoved = mergedMap.get("drawable/removed");
766 assertEquals(1, drawableRemoved.size());
767 assertTrue(drawableRemoved.get(0).isWritten());
768 assertTrue(drawableRemoved.get(0).isRemoved());
769
770 // check new overlay: two objects, last one is TOUCHED
771 List<ResourceItem> drawableNewOverlay = mergedMap.get("drawable/new_overlay");
772 assertEquals(2, drawableNewOverlay.size());
773 ResourceItem newOverlay = drawableNewOverlay.get(1);
774 assertEquals(overlayDrawableNewOverlay, newOverlay.getSource().getFile());
775 assertFalse(newOverlay.isWritten());
776 assertTrue(newOverlay.isTouched());
777
778 // check new alternate: one objects, last one is TOUCHED
779 List<ResourceItem> drawableHdpiNewAlternate = mergedMap.get("drawable-hdpi-v4/new_alternate");
780 assertEquals(1, drawableHdpiNewAlternate.size());
781 ResourceItem newAlternate = drawableHdpiNewAlternate.get(0);
782 assertEquals(overlayDrawableHdpiNewAlternate, newAlternate.getSource().getFile());
783 assertFalse(newAlternate.isWritten());
784 assertTrue(newAlternate.isTouched());
785
786 // write and check the result of writeResourceFolder
787 // copy the current resOut which serves as pre incremental update state.
788 File resFolder = getFolderCopy(new File(root, "resOut"));
789 resFolder.deleteOnExit();
790
791 File mergeLogFolder = TestUtils.createTempDirDeletedOnExit();
792 mergeLogFolder.deleteOnExit();
793
794 // write the content of the resource merger.
795 MergedResourceWriter writer = MergedResourceWriter.createWriterWithoutPngCruncher(
796 resFolder,
797 null /*publicFile*/,
798 mergeLogFolder,
799 mPreprocessor,
800 mTemporaryFolder.getRoot());
801 resourceMerger.mergeData(writer, false /*doCleanUp*/);
802
803 // Check the content.
804 checkImageColor(new File(resFolder, "drawable" + File.separator + "touched.png"),
805 (int) 0xFF00FF00);
806 checkImageColor(new File(resFolder, "drawable" + File.separator + "untouched.png"),
807 (int) 0xFF00FF00);
808 checkImageColor(new File(resFolder, "drawable" + File.separator + "new_overlay.png"),
809 (int) 0xFF00FF00);
810 checkImageColor(new File(resFolder, "drawable" + File.separator + "removed_overlay.png"),
811 (int) 0xFF00FF00);
812 checkImageColor(new File(resFolder, "drawable-hdpi-v4" + File.separator + "new_alternate.png"),
813 (int) 0xFF00FF00);
814 assertFalse(new File(resFolder, "drawable-ldpi-v4" + File.separator + "removed.png").isFile());
815
816 // Blame log sanity check
817 MergingLog mergingLog = new MergingLog(mergeLogFolder);
818
819 SourceFile original = mergingLog.find(
820 new SourceFile(new File(resFolder, "drawable" + File.separator + "touched.png")));
821 assertTrue(original.getSourceFile().getAbsolutePath().endsWith(
822 "basicFiles/main/drawable/touched.png".replace('/', File.separatorChar)));
823 }
824
825 @Test
826 public void testUpdateWithBasicValues() throws Exception {
827 File root = getIncMergeRoot("basicValues");
828 File fakeRoot = getMergedBlobFolder(root);
829 ResourceMerger resourceMerger = new ResourceMerger(0);
830 assertTrue(resourceMerger.loadFromBlob(fakeRoot, true /*incrementalState*/));
831 checkSourceFolders(resourceMerger);
832
833 List<ResourceSet> sets = resourceMerger.getDataSets();
834 assertEquals(2, sets.size());
835
836 RecordingLogger logger = new RecordingLogger();
837
838 // ----------------
839 // first set is the main one, no change here
840 ResourceSet mainSet = sets.get(0);
841 File mainBase = new File(root, "main");
842 File mainValues = new File(mainBase, "values");
843 File mainValuesEn = new File(mainBase, "values-en");
844
845 // touched file:
846 File mainValuesTouched = new File(mainValues, "values.xml");
847 mainSet.updateWith(mainBase, mainValuesTouched, FileStatus.CHANGED, logger);
848 checkLogger(logger);
849
850
851 // removed files
852 File mainValuesEnRemoved = new File(mainValuesEn, "values.xml");
853 mainSet.updateWith(mainBase, mainValuesEnRemoved, FileStatus.REMOVED, logger);
854 checkLogger(logger);
855
856
857 // ----------------
858 // second set is the overlay one
859 ResourceSet overlaySet = sets.get(1);
860 File overlayBase = new File(root, "overlay");
861 File overlayValues = new File(overlayBase, "values");
862 File overlayValuesFr = new File(overlayBase, "values-fr");
863
864 // new files:
865 File overlayValuesNew = new File(overlayValues, "values.xml");
866 overlaySet.updateWith(overlayBase, overlayValuesNew, FileStatus.NEW, logger);
867 checkLogger(logger);
868
869 File overlayValuesFrNew = new File(overlayValuesFr, "values.xml");
870 overlaySet.updateWith(overlayBase, overlayValuesFrNew, FileStatus.NEW, logger);
871 checkLogger(logger);
872
873 // validate for duplicates
874 resourceMerger.validateDataSets();
875
876 // check the content.
877 ListMultimap<String, ResourceItem> mergedMap = resourceMerger.getDataMap();
878
879 // check unchanged string is WRITTEN
880 List<ResourceItem> valuesUntouched = mergedMap.get("string/untouched");
881 assertEquals(1, valuesUntouched.size());
882 assertTrue(valuesUntouched.get(0).isWritten());
883 assertFalse(valuesUntouched.get(0).isTouched());
884 assertFalse(valuesUntouched.get(0).isRemoved());
885
886 // check replaced file is TOUCHED
887 List<ResourceItem> valuesTouched = mergedMap.get("string/touched");
888 assertEquals(1, valuesTouched.size());
889 assertTrue(valuesTouched.get(0).isWritten());
890 assertTrue(valuesTouched.get(0).isTouched());
891 assertFalse(valuesTouched.get(0).isRemoved());
892
893 // check removed file is REMOVED
894 List<ResourceItem> valuesRemoved = mergedMap.get("string/removed");
895 assertEquals(1, valuesRemoved.size());
896 assertTrue(valuesRemoved.get(0).isWritten());
897 assertTrue(valuesRemoved.get(0).isRemoved());
898
899 valuesRemoved = mergedMap.get("string-en/removed");
900 assertEquals(1, valuesRemoved.size());
901 assertTrue(valuesRemoved.get(0).isWritten());
902 assertTrue(valuesRemoved.get(0).isRemoved());
903
904 // check new overlay: two objects, last one is TOUCHED
905 List<ResourceItem> valuesNewOverlay = mergedMap.get("string/new_overlay");
906 assertEquals(2, valuesNewOverlay.size());
907 ResourceItem newOverlay = valuesNewOverlay.get(1);
908 assertFalse(newOverlay.isWritten());
909 assertTrue(newOverlay.isTouched());
910
911 // check new alternate: one objects, last one is TOUCHED
912 List<ResourceItem> valuesFrNewAlternate = mergedMap.get("string-fr/new_alternate");
913 assertEquals(1, valuesFrNewAlternate.size());
914 ResourceItem newAlternate = valuesFrNewAlternate.get(0);
915 assertFalse(newAlternate.isWritten());
916 assertTrue(newAlternate.isTouched());
917
918 // write and check the result of writeResourceFolder
919 // copy the current resOut which serves as pre incremental update state.
920 File resFolder = getFolderCopy(new File(root, "resOut"));
921
922
923 File mergeLogFolder = TestUtils.createTempDirDeletedOnExit();
924 mergeLogFolder.deleteOnExit();
925
926 // write the content of the resource merger.
927 MergedResourceWriter writer = MergedResourceWriter.createWriterWithoutPngCruncher(
928 resFolder,
929 null /*publicFile*/,
930 mergeLogFolder,
931 mPreprocessor,
932 mTemporaryFolder.getRoot());
933 resourceMerger.mergeData(writer, false /*doCleanUp*/);
934
935 // Check the content.
936 // values/values.xml
937 Map<String, String> map = quickStringOnlyValueFileParser(
938 new File(resFolder, "values" + File.separator + "values.xml"));
939 assertEquals("untouched", map.get("untouched"));
940 assertEquals("touched", map.get("touched"));
941 assertEquals("new_overlay", map.get("new_overlay"));
942
943 // values-fr/values-fr.xml
944 map = quickStringOnlyValueFileParser(
945 new File(resFolder, "values-fr" + File.separator + "values-fr.xml"));
946 assertEquals("new_alternate", map.get("new_alternate"));
947
948 // deleted values-en/values-en.xml
949 assertFalse(new File(resFolder, "values-en" + File.separator + "values-en.xml").isFile());
950
951 // Blame log sanity check.
952 MergingLog mergingLog = new MergingLog(mergeLogFolder);
953
954 SourceFile destFile =
955 mergingLog.destinationFor(
956 new SourceFile(overlayValuesNew));
957
958 SourceFilePosition original =
959 mergingLog.find(
960 new SourceFilePosition(destFile, new SourcePosition(2,5,-1)));
961
962 assertEquals(new SourcePosition(2, 4, 55, 2, 51, 102), original.getPosition());
963 assertTrue(original.getFile().getSourceFile().getAbsolutePath().endsWith(
964 "basicValues/overlay/values/values.xml".replace('/', File.separatorChar)));
965
966 }
967
968 @Test
969 public void testUpdateWithBasicValues2() throws Exception {
970 File root = getIncMergeRoot("basicValues2");
971 File fakeRoot = getMergedBlobFolder(root);
972 ResourceMerger resourceMerger = new ResourceMerger(0);
973 assertTrue(resourceMerger.loadFromBlob(fakeRoot, true /*incrementalState*/));
974 checkSourceFolders(resourceMerger);
975
976 List<ResourceSet> sets = resourceMerger.getDataSets();
977 assertEquals(2, sets.size());
978
979 RecordingLogger logger = new RecordingLogger();
980
981 // ----------------
982 // first set is the main one, no change here
983
984 // ----------------
985 // second set is the overlay one
986 ResourceSet overlaySet = sets.get(1);
987 File overlayBase = new File(root, "overlay");
988 File overlayValues = new File(overlayBase, "values");
989
990 // new files:
991 File overlayValuesNew = new File(overlayValues, "values.xml");
992 overlaySet.updateWith(overlayBase, overlayValuesNew, FileStatus.REMOVED, logger);
993 checkLogger(logger);
994
995
996 // validate for duplicates
997 resourceMerger.validateDataSets();
998
999 // check the content.
1000 ListMultimap<String, ResourceItem> mergedMap = resourceMerger.getDataMap();
1001
1002 // check unchanged string is WRITTEN
1003 List<ResourceItem> valuesUntouched = mergedMap.get("string/untouched");
1004 assertEquals(1, valuesUntouched.size());
1005 assertTrue(valuesUntouched.get(0).isWritten());
1006 assertFalse(valuesUntouched.get(0).isTouched());
1007 assertFalse(valuesUntouched.get(0).isRemoved());
1008
1009 // check removed_overlay is present twice.
1010 List<ResourceItem> valuesRemovedOverlay = mergedMap.get("string/removed_overlay");
1011 assertEquals(2, valuesRemovedOverlay.size());
1012 // first is untouched
1013 assertFalse(valuesRemovedOverlay.get(0).isWritten());
1014 assertFalse(valuesRemovedOverlay.get(0).isTouched());
1015 assertFalse(valuesRemovedOverlay.get(0).isRemoved());
1016 // other is removed
1017 assertTrue(valuesRemovedOverlay.get(1).isWritten());
1018 assertFalse(valuesRemovedOverlay.get(1).isTouched());
1019 assertTrue(valuesRemovedOverlay.get(1).isRemoved());
1020
1021 // write and check the result of writeResourceFolder
1022 // copy the current resOut which serves as pre incremental update state.
1023 File resFolder = getFolderCopy(new File(root, "resOut"));
1024
1025 // write the content of the resource merger.
1026 MergedResourceWriter writer = getConsumer(resFolder);
1027 resourceMerger.mergeData(writer, false /*doCleanUp*/);
1028
1029 // Check the content.
1030 // values/values.xml
1031 Map<String, String> map = quickStringOnlyValueFileParser(
1032 new File(resFolder, "values" + File.separator + "values.xml"));
1033 assertEquals("untouched", map.get("untouched"));
1034 assertEquals("untouched", map.get("removed_overlay"));
1035 }
1036
1037 @Test
1038 public void testUpdateWithFilesVsValues() throws Exception {
1039 File root = getIncMergeRoot("filesVsValues");
1040 File fakeRoot = getMergedBlobFolder(root);
1041 ResourceMerger resourceMerger = new ResourceMerger(0);
1042 assertTrue(resourceMerger.loadFromBlob(fakeRoot, true /*incrementalState*/));
1043 checkSourceFolders(resourceMerger);
1044
1045 List<ResourceSet> sets = resourceMerger.getDataSets();
1046 assertEquals(1, sets.size());
1047
1048 RecordingLogger logger = new RecordingLogger();
1049
1050 // ----------------
1051 // Load the main set
1052 ResourceSet mainSet = sets.get(0);
1053 File mainBase = new File(root, "main");
1054 File mainValues = new File(mainBase, ResourceFolderType.VALUES.getName());
1055 File mainLayout = new File(mainBase, ResourceFolderType.LAYOUT.getName());
1056
1057 // touched file:
1058 File mainValuesTouched = new File(mainValues, "values.xml");
1059 mainSet.updateWith(mainBase, mainValuesTouched, FileStatus.CHANGED, logger);
1060 checkLogger(logger);
1061
1062 // new file:
1063 File mainLayoutNew = new File(mainLayout, "alias_replaced_by_file.xml");
1064 mainSet.updateWith(mainBase, mainLayoutNew, FileStatus.NEW, logger);
1065 checkLogger(logger);
1066
1067 // removed file
1068 File mainLayoutRemoved = new File(mainLayout, "file_replaced_by_alias.xml");
1069 mainSet.updateWith(mainBase, mainLayoutRemoved, FileStatus.REMOVED, logger);
1070 checkLogger(logger);
1071
1072 // validate for duplicates
1073 resourceMerger.validateDataSets();
1074
1075 // check the content.
1076 ListMultimap<String, ResourceItem> mergedMap = resourceMerger.getDataMap();
1077
1078 // check layout/main is unchanged
1079 List<ResourceItem> layoutMain = mergedMap.get("layout/main");
1080 assertEquals(1, layoutMain.size());
1081 assertTrue(layoutMain.get(0).isWritten());
1082 assertFalse(layoutMain.get(0).isTouched());
1083 assertFalse(layoutMain.get(0).isRemoved());
1084
1085 // check file_replaced_by_alias has 2 version, 2nd is TOUCHED, and contains a Node
1086 List<ResourceItem> layoutReplacedByAlias = mergedMap.get("layout/file_replaced_by_alias");
1087 assertEquals(2, layoutReplacedByAlias.size());
1088 // 1st one is removed version, as it already existed in the item multimap
1089 ResourceItem replacedByAlias = layoutReplacedByAlias.get(0);
1090 assertTrue(replacedByAlias.isWritten());
1091 assertFalse(replacedByAlias.isTouched());
1092 assertTrue(replacedByAlias.isRemoved());
1093 assertNull(replacedByAlias.getValue());
1094 assertEquals("file_replaced_by_alias.xml", replacedByAlias.getSource().getFile().getName());
1095 // 2nd version is the new one
1096 replacedByAlias = layoutReplacedByAlias.get(1);
1097 assertFalse(replacedByAlias.isWritten());
1098 assertTrue(replacedByAlias.isTouched());
1099 assertFalse(replacedByAlias.isRemoved());
1100 assertNotNull(replacedByAlias.getValue());
1101 assertEquals("values.xml", replacedByAlias.getSource().getFile().getName());
1102
1103 // check alias_replaced_by_file has 2 version, 2nd is TOUCHED, and contains a Node
1104 List<ResourceItem> layoutReplacedByFile = mergedMap.get("layout/alias_replaced_by_file");
1105 // 1st one is removed version, as it already existed in the item multimap
1106 assertEquals(2, layoutReplacedByFile.size());
1107 ResourceItem replacedByFile = layoutReplacedByFile.get(0);
1108 assertTrue(replacedByFile.isWritten());
1109 assertFalse(replacedByFile.isTouched());
1110 assertTrue(replacedByFile.isRemoved());
1111 assertNotNull(replacedByFile.getValue());
1112 assertEquals("values.xml", replacedByFile.getSource().getFile().getName());
1113 // 2nd version is the new one
1114 replacedByFile = layoutReplacedByFile.get(1);
1115 assertFalse(replacedByFile.isWritten());
1116 assertTrue(replacedByFile.isTouched());
1117 assertFalse(replacedByFile.isRemoved());
1118 assertNull(replacedByFile.getValue());
1119 assertEquals("alias_replaced_by_file.xml", replacedByFile.getSource().getFile().getName());
1120
1121 // write and check the result of writeResourceFolder
1122 // copy the current resOut which serves as pre incremental update state.
1123 File resFolder = getFolderCopy(new File(root, "resOut"));
1124
1125 // write the content of the resource merger.
1126 MergedResourceWriter writer = getConsumer(resFolder);
1127 resourceMerger.mergeData(writer, false /*doCleanUp*/);
1128
1129 // deleted layout/file_replaced_by_alias.xml
1130 assertFalse(new File(resFolder, "layout" + File.separator + "file_replaced_by_alias.xml")
1131 .isFile());
1132 // new file layout/alias_replaced_by_file.xml
1133 assertTrue(new File(resFolder, "layout" + File.separator + "alias_replaced_by_file.xml")
1134 .isFile());
1135
1136 // quick load of the values file
1137 File valuesFile = new File(resFolder, "values" + File.separator + "values.xml");
1138 assertTrue(valuesFile.isFile());
1139 String content = Files.toString(valuesFile, Charsets.UTF_8);
1140 assertTrue(content.contains("name=\"file_replaced_by_alias\""));
1141 assertFalse(content.contains("name=\"alias_replaced_by_file\""));
1142 }
1143
1144 @Test
1145 public void testCheckValidUpdate() throws Exception {
1146 // first merger
1147 ResourceMerger merger1 = createMerger(new String[][] {
1148 new String[] { "main", ("/main/res1"), ("/main/res2") },
1149 new String[] { "overlay", ("/overlay/res1"), ("/overlay/res2") },
1150 });
1151
1152 // 2nd merger with different order source files in sets.
1153 ResourceMerger merger2 = createMerger(new String[][] {
1154 new String[] { "main", ("/main/res2"), ("/main/res1") },
1155 new String[] { "overlay", ("/overlay/res1"), ("/overlay/res2") },
1156 });
1157
1158 assertTrue(merger1.checkValidUpdate(merger2.getDataSets()));
1159
1160 // write merger1 on disk to test writing empty ResourceSets.
1161 File folder = TestUtils.createTempDirDeletedOnExit();
1162 merger1.writeBlobTo(folder, getConsumer(), false);
1163
1164 // reload it
1165 ResourceMerger loadedMerger = new ResourceMerger(0);
1166 assertTrue(loadedMerger.loadFromBlob(folder, true /*incrementalState*/));
1167
1168 String expected = merger1.toString();
1169 String actual = loadedMerger.toString();
1170 if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_WINDOWS) {
1171 expected = expected.replace(File.separatorChar, '/').
1172 replaceAll("[A-Z]:/", "/");
1173 actual = actual.replace(File.separatorChar, '/').
1174 replaceAll("[A-Z]:/", "/");
1175 assertEquals("Actual: " + actual + "\nExpected: " + expected, expected, actual);
1176 } else {
1177 assertTrue("Actual: " + actual + "\nExpected: " + expected,
1178 loadedMerger.checkValidUpdate(merger1.getDataSets()));
1179 }
1180 }
1181
1182 @Test
1183 public void testUpdateWithRemovedOverlay() throws Exception {
1184 // Test with removed overlay
1185 ResourceMerger merger1 = createMerger(new String[][] {
1186 new String[] { "main", "/main/res1", "/main/res2" },
1187 new String[] { "overlay", "/overlay/res1", "/overlay/res2" },
1188 });
1189
1190 // 2nd merger with different order source files in sets.
1191 ResourceMerger merger2 = createMerger(new String[][]{
1192 new String[]{"main", "/main/res2", "/main/res1"},
1193 });
1194
1195 assertFalse(merger1.checkValidUpdate(merger2.getDataSets()));
1196 }
1197
1198 @Test
1199 public void testUpdateWithReplacedOverlays() throws Exception {
1200 // Test with different overlays
1201 ResourceMerger merger1 = createMerger(new String[][] {
1202 new String[] { "main", "/main/res1", "/main/res2" },
1203 new String[] { "overlay", "/overlay/res1", "/overlay/res2" },
1204 });
1205
1206 // 2nd merger with different order source files in sets.
1207 ResourceMerger merger2 = createMerger(new String[][] {
1208 new String[] { "main", "/main/res2", "/main/res1" },
1209 new String[] { "overlay2", "/overlay2/res1", "/overlay2/res2" },
1210 });
1211
1212 assertFalse(merger1.checkValidUpdate(merger2.getDataSets()));
1213 }
1214
1215 @Test
1216 public void testUpdateWithReorderedOverlays() throws Exception {
1217 // Test with different overlays
1218 ResourceMerger merger1 = createMerger(new String[][] {
1219 new String[] { "main", "/main/res1", "/main/res2" },
1220 new String[] { "overlay1", "/overlay1/res1", "/overlay1/res2" },
1221 new String[] { "overlay2", "/overlay2/res1", "/overlay2/res2" },
1222 });
1223
1224 // 2nd merger with different order source files in sets.
1225 ResourceMerger merger2 = createMerger(new String[][] {
1226 new String[] { "main", "/main/res2", "/main/res1" },
1227 new String[] { "overlay2", "/overlay2/res1", "/overlay2/res2" },
1228 new String[] { "overlay1", "/overlay1/res1", "/overlay1/res2" },
1229 });
1230
1231 assertFalse(merger1.checkValidUpdate(merger2.getDataSets()));
1232 }
1233
1234 @Test
1235 public void testUpdateWithRemovedSourceFile() throws Exception {
1236 // Test with different source files
1237 ResourceMerger merger1 = createMerger(new String[][] {
1238 new String[] { "main", "/main/res1", "/main/res2" },
1239 });
1240
1241 // 2nd merger with different order source files in sets.
1242 ResourceMerger merger2 = createMerger(new String[][]{
1243 new String[]{"main", "/main/res1"},
1244 });
1245
1246 assertFalse(merger1.checkValidUpdate(merger2.getDataSets()));
1247 }
1248
1249 @Test
1250 public void testChangedIgnoredFile() throws Exception {
1251 ResourceSet res = ResourceSetTest.getBaseResourceSet();
1252
1253 ResourceMerger resourceMerger = new ResourceMerger(0);
1254 resourceMerger.addDataSet(res);
1255
1256 File root = TestUtils.getRoot("resources", "baseSet");
1257 File changedCVSFoo = new File(root, "CVS/foo.txt");
1258 FileValidity<ResourceSet> fileValidity = resourceMerger.findDataSetContaining(
1259 changedCVSFoo);
1260
1261 assertEquals(FileValidity.FileStatus.IGNORED_FILE, fileValidity.status);
1262 }
1263
1264 @Test
1265 public void testIncDataForRemovedFile() throws Exception {
1266 File root = TestUtils.getCanonicalRoot("resources", "removedFile");
1267 File fakeBlobRoot = getMergedBlobFolder(root);
1268
1269 ResourceMerger resourceMerger = new ResourceMerger(0);
1270 assertTrue(resourceMerger.loadFromBlob(fakeBlobRoot, true /*incrementalState*/));
1271 checkSourceFolders(resourceMerger);
1272
1273 List<ResourceSet> sets = resourceMerger.getDataSets();
1274 assertEquals(1, sets.size());
1275
1276 RecordingLogger logger = new RecordingLogger();
1277
1278 // ----------------
1279 // Load the main set
1280 ResourceSet mainSet = sets.get(0);
1281 File resBase = new File(root, "res");
1282 File resDrawable = new File(resBase, ResourceFolderType.DRAWABLE.getName());
1283
1284 // removed file
1285 File resIconRemoved = new File(resDrawable, "removed.png");
1286 mainSet.updateWith(resBase, resIconRemoved, FileStatus.REMOVED, logger);
1287 checkLogger(logger);
1288
1289 // validate for duplicates
1290 resourceMerger.validateDataSets();
1291
1292 // check the content.
1293 ListMultimap<String, ResourceItem> mergedMap = resourceMerger.getDataMap();
1294
1295 // check layout/main is unchanged
1296 List<ResourceItem> removedIcon = mergedMap.get("drawable/removed");
1297 assertEquals(1, removedIcon.size());
1298 assertTrue(removedIcon.get(0).isRemoved());
1299 assertTrue(removedIcon.get(0).isWritten());
1300 assertFalse(removedIcon.get(0).isTouched());
1301
1302 // write and check the result of writeResourceFolder
1303 // copy the current resOut which serves as pre incremental update state.
1304 File outFolder = getFolderCopy(new File(root, "out"));
1305
1306 // write the content of the resource merger.
1307 MergedResourceWriter writer = getConsumer(outFolder);
1308 resourceMerger.mergeData(writer, false /*doCleanUp*/);
1309
1310 File outDrawableFolder = new File(outFolder, ResourceFolderType.DRAWABLE.getName());
1311
1312 // check the files are correct
1313 assertFalse(new File(outDrawableFolder, "removed.png").isFile());
1314 assertTrue(new File(outDrawableFolder, "icon.png").isFile());
1315
1316 // now write the blob
1317 File outBlobFolder = TestUtils.createTempDirDeletedOnExit();
1318 resourceMerger.writeBlobTo(outBlobFolder, writer, false);
1319
1320 // check the removed icon is not present.
1321 ResourceMerger resourceMerger2 = new ResourceMerger(0);
1322 assertTrue(resourceMerger2.loadFromBlob(outBlobFolder, true /*incrementalState*/));
1323
1324 mergedMap = resourceMerger2.getDataMap();
1325 removedIcon = mergedMap.get("drawable/removed");
1326 assertTrue(removedIcon.isEmpty());
1327 }
1328
1329 @Test
1330 public void testMergedDeclareStyleable() throws Exception {
1331 File root = TestUtils.getRoot("resources", "declareStyleable");
1332
1333 // load both base and overlay set
1334 File baseRoot = new File(root, "base");
1335 ResourceSet baseSet = new ResourceSet("main", null);
1336 baseSet.addSource(baseRoot);
1337 RecordingLogger logger = new RecordingLogger();
1338 baseSet.loadFromFiles(logger);
1339 checkLogger(logger);
1340
1341 File overlayRoot = new File(root, "overlay");
1342 ResourceSet overlaySet = new ResourceSet("overlay", null);
1343 overlaySet.addSource(overlayRoot);
1344 logger = new RecordingLogger();
1345 overlaySet.loadFromFiles(logger);
1346 checkLogger(logger);
1347
1348 // create a merger
1349 ResourceMerger resourceMerger = new ResourceMerger(0);
1350 resourceMerger.addDataSet(baseSet);
1351 resourceMerger.addDataSet(overlaySet);
1352
1353 // write the merge result.
1354 File folder = TestUtils.createTempDirDeletedOnExit();
1355 folder.deleteOnExit();
1356
1357 MergedResourceWriter writer = getConsumer(folder);
1358 resourceMerger.mergeData(writer, false /*doCleanUp*/);
1359
1360 // load the result as a set.
1361 ResourceSet mergedSet = new ResourceSet("merged", null);
1362 mergedSet.addSource(folder);
1363 logger = new RecordingLogger();
1364 mergedSet.loadFromFiles(logger);
1365 checkLogger(logger);
1366
1367 ListMultimap<String, ResourceItem> map = mergedSet.getDataMap();
1368 assertEquals(4, map.size());
1369
1370 List<ResourceItem> items = map.get("declare-styleable/foo");
1371 assertNotNull(items);
1372 assertEquals(1, items.size());
1373
1374 ResourceItem item = items.get(0);
1375 assertNotNull(item);
1376
1377 // now we need to look at the item's value (which is the XML).
1378 // We're looking for 3 attributes.
1379 List<String> expectedAttrs = Lists.newArrayList("bar", "bar1", "boo");
1380 Node rootNode = item.getValue();
1381 assertNotNull(rootNode);
1382 NodeList sourceNodes = rootNode.getChildNodes();
1383 for (int i = 0, n = sourceNodes.getLength(); i < n; i++) {
1384 Node sourceNode = sourceNodes.item(i);
1385
1386 if (sourceNode.getNodeType() != Node.ELEMENT_NODE ||
1387 !TAG_ATTR.equals(sourceNode.getLocalName())) {
1388 continue;
1389 }
1390
1391 Attr attr = (Attr) sourceNode.getAttributes().getNamedItem(ATTR_NAME);
1392 if (attr == null) {
1393 continue;
1394 }
1395
1396 String attrName = attr.getValue();
1397
1398 assertTrue("Check expected " + attrName, expectedAttrs.contains(attrName));
1399 expectedAttrs.remove(attrName);
1400 }
1401
1402 assertTrue("Check emptiness of " + expectedAttrs.toString(), expectedAttrs.isEmpty());
1403 }
1404
1405 @Test
1406 public void testUnchangedMergedItem() throws Exception {
1407 // locate the merger file that contains exactly the result of the source folders.
1408 File root = TestUtils.getRoot("resources", "declareStyleable");
1409 File fakeBlobRoot = getMergedBlobFolder(root, new File(root, "unchanged_merger.xml"));
1410
1411 // load a resource merger based on it.
1412 ResourceMerger resourceMerger = new ResourceMerger(0);
1413 assertTrue(resourceMerger.loadFromBlob(fakeBlobRoot, true /*incrementalState*/));
1414 checkSourceFolders(resourceMerger);
1415
1416 // create a fake consumer
1417 FakeMergeConsumer consumer = new FakeMergeConsumer();
1418
1419 // do the merge
1420 resourceMerger.mergeData(consumer, false /*doCleanUp*/);
1421
1422 // test result of merger.
1423 assertTrue(consumer.touchedItems.isEmpty());
1424 assertTrue(consumer.removedItems.isEmpty());
1425 }
1426
1427 @Test
1428 public void testRemovedMergedItem() throws Exception {
1429 // locate the merger file that contains exactly the result of the source folders.
1430 File root = TestUtils.getCanonicalRoot("resources", "declareStyleable");
1431 File fakeBlobRoot = getMergedBlobFolder(root, new File(root, "removed_merger.xml"));
1432
1433 // load a resource merger based on it.
1434 ResourceMerger resourceMerger = new ResourceMerger(0);
1435 assertTrue(resourceMerger.loadFromBlob(fakeBlobRoot, true /*incrementalState*/));
1436 checkSourceFolders(resourceMerger);
1437
1438 // we know have to tell the merger that the values files have been touched
1439 // to trigger the removal detection based on the original merger blob.
1440
1441 List<ResourceSet> sets = resourceMerger.getDataSets();
1442 assertEquals(2, sets.size());
1443
1444 RecordingLogger logger = new RecordingLogger();
1445
1446 // ----------------
1447 // Load the main set
1448 ResourceSet mainSet = sets.get(0);
1449 File mainRoot = new File(root, "base");
1450 File mainValues = new File(mainRoot, ResourceFolderType.VALUES.getName());
1451
1452 // trigger changed file event
1453 File touchedValueFile = new File(mainValues, "values.xml");
1454 mainSet.updateWith(mainRoot, touchedValueFile, FileStatus.CHANGED, logger);
1455 checkLogger(logger);
1456
1457 // same with overlay set.
1458 ResourceSet overlaySet = sets.get(1);
1459 File overlayRoot = new File(root, "overlay");
1460 File overlayValues = new File(overlayRoot, ResourceFolderType.VALUES.getName());
1461
1462 // trigger changed file event
1463 touchedValueFile = new File(overlayValues, "values.xml");
1464 overlaySet.updateWith(overlayRoot, touchedValueFile, FileStatus.CHANGED, logger);
1465 checkLogger(logger);
1466
1467 // create a fake consumer
1468 FakeMergeConsumer consumer = new FakeMergeConsumer();
1469
1470 // do the merge
1471 resourceMerger.mergeData(consumer, false /*doCleanUp*/);
1472
1473 // test result of merger.
1474 assertTrue(consumer.touchedItems.isEmpty());
1475 assertEquals(1, consumer.removedItems.size());
1476 }
1477
1478 @Test
1479 public void testTouchedMergedItem() throws Exception {
1480 // locate the merger file that contains exactly the result of the source folders.
1481 File root = TestUtils.getCanonicalRoot("resources", "declareStyleable");
1482 File fakeBlobRoot = getMergedBlobFolder(root, new File(root, "touched_merger.xml"));
1483
1484 // load a resource merger based on it.
1485 ResourceMerger resourceMerger = new ResourceMerger(0);
1486 assertTrue(resourceMerger.loadFromBlob(fakeBlobRoot, true /*incrementalState*/));
1487 checkSourceFolders(resourceMerger);
1488
1489 // we know have to tell the merger that the values files have been touched
1490 // to trigger the removal detection based on the original merger blob.
1491
1492 List<ResourceSet> sets = resourceMerger.getDataSets();
1493 assertEquals(2, sets.size());
1494
1495 RecordingLogger logger = new RecordingLogger();
1496
1497 // ----------------
1498 // Load the main set
1499 ResourceSet mainSet = sets.get(0);
1500 File mainRoot = new File(root, "base");
1501 File mainValues = new File(mainRoot, ResourceFolderType.VALUES.getName());
1502
1503 // trigger changed file event
1504 File touchedValueFile = new File(mainValues, "values.xml");
1505 mainSet.updateWith(mainRoot, touchedValueFile, FileStatus.CHANGED, logger);
1506 checkLogger(logger);
1507
1508 // create a fake consumer
1509 FakeMergeConsumer consumer = new FakeMergeConsumer();
1510
1511 // do the merge
1512 resourceMerger.mergeData(consumer, false /*doCleanUp*/);
1513
1514 // test result of merger.
1515 assertEquals(1, consumer.touchedItems.size());
1516 assertTrue(consumer.removedItems.isEmpty());
1517 }
1518
1519 @Test
1520 public void testTouchedNoDiffMergedItem() throws Exception {
1521 // locate the merger file that contains exactly the result of the source folders.
1522 File root = TestUtils.getCanonicalRoot("resources", "declareStyleable");
1523 File fakeBlobRoot = getMergedBlobFolder(root, new File(root, "touched_nodiff_merger.xml"));
1524
1525 // load a resource merger based on it.
1526 ResourceMerger resourceMerger = new ResourceMerger(0);
1527 assertTrue(resourceMerger.loadFromBlob(fakeBlobRoot, true /*incrementalState*/));
1528 checkSourceFolders(resourceMerger);
1529
1530 // we know have to tell the merger that the values files have been touched
1531 // to trigger the removal detection based on the original merger blob.
1532
1533 List<ResourceSet> sets = resourceMerger.getDataSets();
1534 assertEquals(2, sets.size());
1535
1536 RecordingLogger logger = new RecordingLogger();
1537
1538 // ----------------
1539 // Load the overlay set
1540 ResourceSet overlaySet = sets.get(1);
1541 File overlayRoot = new File(root, "overlay");
1542 File overlayValues = new File(overlayRoot, ResourceFolderType.VALUES.getName());
1543
1544 // trigger changed file event
1545 File touchedValueFile = new File(overlayValues, "values.xml");
1546 overlaySet.updateWith(overlayRoot, touchedValueFile, FileStatus.CHANGED, logger);
1547 checkLogger(logger);
1548
1549 // create a fake consumer
1550 FakeMergeConsumer consumer = new FakeMergeConsumer();
1551
1552 // do the merge
1553 resourceMerger.mergeData(consumer, false /*doCleanUp*/);
1554
1555 // test result of merger.
1556 assertTrue(consumer.touchedItems.isEmpty());
1557 assertTrue(consumer.removedItems.isEmpty());
1558 }
1559
1560 @Test
1561 public void testRemovedOtherWithNoNoDiffTouchMergedItem() throws Exception {
1562 // test that when a non-merged resources is changed/removed, the result of the merge still
1563 // contain the merged items even if they were touched but had no change.
1564
1565 // locate the merger file that contains exactly the result of the source folders.
1566 File root = TestUtils.getCanonicalRoot("resources", "declareStyleable");
1567 File fakeBlobRoot = getMergedBlobFolder(root, new File(root, "removed_other_merger.xml"));
1568
1569 // load a resource merger based on it.
1570 ResourceMerger resourceMerger = new ResourceMerger(0);
1571 assertTrue(resourceMerger.loadFromBlob(fakeBlobRoot, true /*incrementalState*/));
1572 checkSourceFolders(resourceMerger);
1573
1574 // we know have to tell the merger that the values files have been touched
1575 // to trigger the removal detection based on the original merger blob.
1576
1577 List<ResourceSet> sets = resourceMerger.getDataSets();
1578 assertEquals(2, sets.size());
1579
1580 RecordingLogger logger = new RecordingLogger();
1581
1582 // ----------------
1583 // Load the main set
1584 ResourceSet mainSet = sets.get(0);
1585 File mainRoot = new File(root, "base");
1586 File mainValues = new File(mainRoot, ResourceFolderType.VALUES.getName());
1587
1588 // trigger changed file event
1589 File touchedValueFile = new File(mainValues, "values.xml");
1590 mainSet.updateWith(mainRoot, touchedValueFile, FileStatus.CHANGED, logger);
1591 checkLogger(logger);
1592
1593 // same for overlay
1594 ResourceSet overlaySet = sets.get(1);
1595 File overlayRoot = new File(root, "overlay");
1596 File overlayValues = new File(overlayRoot, ResourceFolderType.VALUES.getName());
1597
1598 // trigger changed file event
1599 touchedValueFile = new File(overlayValues, "values.xml");
1600 overlaySet.updateWith(overlayRoot, touchedValueFile, FileStatus.CHANGED, logger);
1601 checkLogger(logger);
1602
1603 // create a fake consumer
1604 FakeMergeConsumer consumer = new FakeMergeConsumer();
1605
1606 // do the merge
1607 resourceMerger.mergeData(consumer, false /*doCleanUp*/);
1608
1609 // test result of merger.
1610 // only 3 items added since attr/bar isn't added (declared inline)
1611 assertEquals(3, consumer.addedItems.size());
1612 // no touched items
1613 assertTrue(consumer.touchedItems.isEmpty());
1614 // one removed string item
1615 assertEquals(1, consumer.removedItems.size());
1616 }
1617
1618 @Test
1619 public void testStringWhiteSpaces() throws Exception {
1620 File root = TestUtils.getRoot("resources", "stringWhiteSpaces");
1621
1622 // load res folder
1623 ResourceSet baseSet = new ResourceSet("main", null);
1624 baseSet.addSource(root);
1625 RecordingLogger logger = new RecordingLogger();
1626 baseSet.loadFromFiles(logger);
1627 checkLogger(logger);
1628
1629 // create a merger
1630 ResourceMerger resourceMerger = new ResourceMerger(0);
1631 resourceMerger.addDataSet(baseSet);
1632
1633 // write the merge result.
1634 File folder = TestUtils.createTempDirDeletedOnExit();
1635 folder.deleteOnExit();
1636
1637 MergedResourceWriter writer = getConsumer(folder);
1638 resourceMerger.mergeData(writer, false /*doCleanUp*/);
1639
1640 // load the result as a set.
1641 ResourceSet mergedSet = new ResourceSet("merged", null);
1642 mergedSet.addSource(folder);
1643 logger = new RecordingLogger();
1644 mergedSet.loadFromFiles(logger);
1645 checkLogger(logger);
1646
1647 ListMultimap<String, ResourceItem> originalItems = baseSet.getDataMap();
1648 ListMultimap<String, ResourceItem> mergedItems = mergedSet.getDataMap();
1649
1650 for (Map.Entry<String, Collection<ResourceItem>> entry : originalItems.asMap().entrySet()) {
1651 Collection<ResourceItem> originalItemList = entry.getValue();
1652 Collection<ResourceItem> mergedItemList = mergedItems.asMap().get(entry.getKey());
1653
1654 // the collection should only have a single items
1655 assertEquals(1, originalItemList.size());
1656 assertEquals(1, mergedItemList.size());
1657
1658 ResourceItem originalItem = originalItemList.iterator().next();
1659 ResourceItem mergedItem = mergedItemList.iterator().next();
1660
1661 assertTrue(originalItem.compareValueWith(mergedItem));
1662 }
1663 }
1664
1665 /**
1666 * Creates a fake merge with given sets.
1667 *
1668 * the data is an array of sets.
1669 *
1670 * Each set is [ setName, folder1, folder2, ...]
1671 *
1672 * @param data the data sets
1673 * @return the merger
1674 */
1675 private static ResourceMerger createMerger(String[][] data) {
1676 ResourceMerger merger = new ResourceMerger(0);
1677 for (String[] setData : data) {
1678 ResourceSet set = new ResourceSet(setData[0], null);
1679 merger.addDataSet(set);
1680 for (int i = 1, n = setData.length; i < n; i++) {
1681 set.addSource(new File(setData[i]));
1682 }
1683 }
1684
1685 return merger;
1686 }
1687
1688 private static ResourceMerger getResourceMerger()
1689 throws MergingException, IOException {
1690 File root = TestUtils.getRoot("resources", "baseMerge");
1691
1692 ResourceSet res = ResourceSetTest.getBaseResourceSet();
1693
1694 RecordingLogger logger = new RecordingLogger();
1695
1696 ResourceSet overlay = new ResourceSet("overlay", null);
1697 overlay.addSource(new File(root, "overlay"));
1698 overlay.loadFromFiles(logger);
1699
1700 checkLogger(logger);
1701
1702 ResourceMerger resourceMerger = new ResourceMerger(0);
1703 resourceMerger.addDataSet(res);
1704 resourceMerger.addDataSet(overlay);
1705
1706 return resourceMerger;
1707 }
1708
1709 private static Pair<ResourceMerger, File> getResourceMergerBackedByTempFiles()
1710 throws MergingException, IOException {
1711 File srcOverlay = TestUtils.getRoot("resources", "baseMerge", "overlay");
1712
1713 RecordingLogger logger = new RecordingLogger();
1714 File testFolder = getFolderCopy(srcOverlay);
1715 testFolder.deleteOnExit();
1716
1717 ResourceSet overlay = new ResourceSet("overlay", null);
1718 overlay.addSource(testFolder);
1719 overlay.loadFromFiles(logger);
1720
1721 checkLogger(logger);
1722
1723 ResourceMerger resourceMerger = new ResourceMerger(0);
1724 resourceMerger.addDataSet(overlay);
1725
1726 return Pair.of(resourceMerger, testFolder);
1727 }
1728
1729 private File getWrittenResources() throws MergingException, IOException {
1730 ResourceMerger resourceMerger = getResourceMerger();
1731
1732 File folder = TestUtils.createTempDirDeletedOnExit();
1733
1734 MergedResourceWriter writer = getConsumer(folder);
1735 resourceMerger.mergeData(writer, false /*doCleanUp*/);
1736
1737 return folder;
1738 }
1739
1740 private static File getIncMergeRoot(String name) throws IOException {
1741 File root = TestUtils.getCanonicalRoot("resources", "incMergeData");
1742 return new File(root, name);
1743 }
1744
1745 private static File getFolderCopy(File folder) throws IOException {
1746 File dest = TestUtils.createTempDirDeletedOnExit();
1747 copyFolder(folder, dest);
1748 return dest;
1749 }
1750
1751 private static void copyFolder(File from, File to) throws IOException {
1752 if (from.isFile()) {
1753 Files.copy(from, to);
1754 } else if (from.isDirectory()) {
1755 if (!to.exists()) {
1756 to.mkdirs();
1757 }
1758
1759 File[] children = from.listFiles();
1760 if (children != null) {
1761 for (File f : children) {
1762 copyFolder(f, new File(to, f.getName()));
1763 }
1764 }
1765 }
1766 }
1767
1768 private static Map<String, String> quickStringOnlyValueFileParser(File file)
1769 throws IOException, MergingException {
1770 Map<String, String> result = Maps.newHashMap();
1771
1772 Document document = ValueResourceParser2.parseDocument(file, true);
1773
1774 // get the root node
1775 Node rootNode = document.getDocumentElement();
1776 if (rootNode == null) {
1777 return Collections.emptyMap();
1778 }
1779
1780 NodeList nodes = rootNode.getChildNodes();
1781
1782 for (int i = 0, n = nodes.getLength(); i < n; i++) {
1783 Node node = nodes.item(i);
1784
1785 if (node.getNodeType() != Node.ELEMENT_NODE) {
1786 continue;
1787 }
1788 if (node.getNodeName().equals(SdkConstants.TAG_EAT_COMMENT)) {
1789 continue;
1790 }
1791
1792 ResourceType type = ValueResourceParser2.getType(node, file);
1793 if (type != ResourceType.STRING) {
1794 throw new IllegalArgumentException("Only String resources supported.");
1795 }
1796 String name = ValueResourceParser2.getName(node);
1797
1798 String value = null;
1799
1800 NodeList nodeList = node.getChildNodes();
1801 nodeLoop: for (int ii = 0, nn = nodes.getLength(); ii < nn; ii++) {
1802 Node subNode = nodeList.item(ii);
1803
1804 switch (subNode.getNodeType()) {
1805 case Node.COMMENT_NODE:
1806 break;
1807 case Node.TEXT_NODE:
1808 value = subNode.getNodeValue().trim(); // TODO: remove trim.
1809 break nodeLoop;
1810 case Node.ELEMENT_NODE:
1811 break;
1812 }
1813 }
1814
1815 result.put(name, value != null ? value : "");
1816 }
1817
1818 return result;
1819 }
1820
1821 @Test
1822 public void testWritePermission() throws Exception {
1823 ResourceMerger merger = getResourceMerger();
1824
1825 File folder = TestUtils.createTempDirDeletedOnExit();
1826 boolean writable = folder.setWritable(false);
1827 if (!writable) {
1828 // Not supported on this platform
1829 return;
1830 }
1831 try {
1832 merger.writeBlobTo(folder, getConsumer(), false);
1833 } catch (MergingException e) {
1834 File file = new File(folder, "merger.xml");
1835 assertEquals(file.getPath() + ": Error: (Permission denied)",
1836 e.getMessage());
1837 return;
1838 }
1839 fail("Exception not thrown as expected");
1840 }
1841
1842 @Test
1843 public void testInvalidFileNames() throws Exception {
1844 File root = TestUtils.getRoot("resources", "brokenSet5");
1845 ResourceSet resourceSet = new ResourceSet("brokenSet5", null);
1846 resourceSet.addSource(root);
1847 RecordingLogger logger = new RecordingLogger();
1848
1849 try {
1850 resourceSet.loadFromFiles(logger);
1851 } catch (MergingException e) {
1852 File file = new File(root, "layout" + File.separator + "ActivityMain.xml");
1853 file = file.getAbsoluteFile();
1854 assertEquals(
1855 file.getPath() +
1856 ": Error: 'A' is not a valid file-based resource name character: "
1857 + "File-based resource names must contain only lowercase a-z, 0-9,"
1858 + " or underscore",
1859 e.getMessage());
1860 return;
1861 }
1862 fail("Expected error");
1863 }
1864
1865 @Test
1866 public void testStricterInvalidFileNames() throws Exception {
1867 File root = TestUtils.getRoot("resources", "brokenSetDrawableFileName");
1868 ResourceSet resourceSet = new ResourceSet("brokenSetDrawableFileName", null);
1869 resourceSet.addSource(root);
1870 RecordingLogger logger = new RecordingLogger();
1871
1872 try {
1873 resourceSet.loadFromFiles(logger);
1874 } catch (MergingException e) {
1875 File file = new File(root, "drawable" + File.separator + "1icon.png");
1876 file = file.getAbsoluteFile();
1877 assertEquals(
1878 file.getPath() +
1879 ": Error: The resource name must start with a letter",
1880 e.getMessage());
1881 return;
1882 }
1883 fail("Expected error");
1884 }
1885
1886 @Test
1887 public void testXmlParseError1() throws Exception {
1888 File root = TestUtils.getRoot("resources", "brokenSet6");
1889 try {
1890 ResourceSet resourceSet = new ResourceSet("brokenSet6", null);
1891 resourceSet.addSource(root);
1892 RecordingLogger logger = new RecordingLogger();
1893 resourceSet.loadFromFiles(logger);
1894
1895 ResourceMerger resourceMerger = new ResourceMerger(0);
1896 resourceMerger.addDataSet(resourceSet);
1897
1898
1899 MergedResourceWriter writer = getConsumer();
1900 resourceMerger.mergeData(writer, false /*doCleanUp*/);
1901 } catch (MergingException e) {
1902 File file = new File(root, "values" + File.separator + "dimens.xml");
1903 file = file.getAbsoluteFile();
1904 assertEquals(file.getPath() + ":4:6: Error: The content of elements must consist "
1905 + "of well-formed character data or markup.",
1906 e.getMessage());
1907 return;
1908 }
1909 fail("Expected error");
1910 }
1911
1912 @Test
1913 public void testXmlParseError7() throws Exception {
1914 File root = TestUtils.getRoot("resources", "brokenSet7");
1915 try {
1916 ResourceSet resourceSet = new ResourceSet("brokenSet7", null);
1917 resourceSet.addSource(root);
1918 RecordingLogger logger = new RecordingLogger();
1919 resourceSet.loadFromFiles(logger);
1920
1921 ResourceMerger resourceMerger = new ResourceMerger(0);
1922 resourceMerger.addDataSet(resourceSet);
1923
1924
1925 MergedResourceWriter writer = getConsumer();
1926 resourceMerger.mergeData(writer, false /*doCleanUp*/);
1927 } catch (MergingException e) {
1928 File file = new File(root, "values" + File.separator + "dimens.xml");
1929 file = file.getAbsoluteFile();
1930 assertTrue(e.getMessage().startsWith(file.getPath() + ":2:17"));
1931 return;
1932 }
1933 fail("Expected error");
1934 }
1935
1936 @Test
1937 public void testSdkFiltering() throws Exception {
1938 ResourceSet resourceSet = new ResourceSet("filterableSet", null);
1939 resourceSet.addSource(TestUtils.getRoot("resources", "filterableSet"));
1940 resourceSet.loadFromFiles(new RecordingLogger());
1941
1942 ResourceMerger resourceMerger = new ResourceMerger(21);
1943 resourceMerger.addDataSet(resourceSet);
1944
1945 MergedResourceWriter consumer = getConsumer();
1946 resourceMerger.mergeData(consumer, false);
1947
1948 File wroteRoot = consumer.getRootFolder();
1949 assertTrue(wroteRoot.isDirectory());
1950 assertEquals(1, wroteRoot.listFiles().length);
1951
1952 File v21 = new File(wroteRoot, "raw-v21");
1953 assertTrue(v21.isDirectory());
1954 assertEquals(1, v21.listFiles().length);
1955
1956 File foo = new File(v21, "foo.txt");
1957 assertTrue(foo.isFile());
1958
1959 String fooContents = Files.toString(foo, Charset.defaultCharset());
1960 assertEquals("21st foo", fooContents);
1961 }
1962
1963
1964 // create a fake consumer
1965 private static class FakeMergeConsumer implements MergeConsumer<ResourceItem> {
1966 final List<ResourceItem> addedItems = Lists.newArrayList();
1967 final List<ResourceItem> touchedItems = Lists.newArrayList();
1968 final List<ResourceItem> removedItems = Lists.newArrayList();
1969
1970 @Override
1971 public void start(@NonNull DocumentBuilderFactory factory)
1972 throws ConsumerException {
1973 // do nothing
1974 }
1975
1976 @Override
1977 public void end() throws ConsumerException {
1978 // do nothing
1979 }
1980
1981 @Override
1982 public void addItem(@NonNull ResourceItem item) throws ConsumerException {
1983 // the default res merge writer calls this, so we should too.
1984 // this is to test that the merged item are properly created
1985 @SuppressWarnings("UnusedDeclaration")
1986 ResourceFile.FileType type = item.getSourceType();
1987
1988 if (item.isTouched()) {
1989 touchedItems.add(item);
1990 }
1991
1992 addedItems.add(item);
1993 }
1994
1995 @Override
1996 public void removeItem(@NonNull ResourceItem removedItem,
1997 @Nullable ResourceItem replacedBy)
1998 throws ConsumerException {
1999 removedItems.add(removedItem);
2000 }
2001
2002 @Override
2003 public boolean ignoreItemInMerge(ResourceItem item) {
2004 return item.getIgnoredFromDiskMerge();
2005 }
2006 }
2007
2008 @NonNull
2009 private MergedResourceWriter getConsumer() {
2010 return getConsumer(TestUtils.createTempDirDeletedOnExit());
2011 }
2012
2013 @NonNull
2014 private MergedResourceWriter getConsumer(File tempDir) {
2015 return MergedResourceWriter.createWriterWithoutPngCruncher(
2016 tempDir,
2017 null /*publicFile*/,
2018 null /*blameLogFolder*/,
2019 mPreprocessor,
2020 mTemporaryFolder.getRoot());
2021 }
2022 }