Debian Codegraph @

sdk-common/src/test/java/com/android/ide/common/res2/AssetMergerTest.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 com.google.common.truth.Truth.assertThat;
20 import static org.junit.Assert.assertEquals;
21 import static org.junit.Assert.assertFalse;
22 import static org.junit.Assert.assertTrue;
23
24 import com.android.SdkConstants;
25 import com.android.testutils.NoErrorsOrWarningsLogger;
26 import com.android.testutils.TestUtils;
27 import com.google.common.base.Charsets;
28 import com.google.common.collect.ListMultimap;
29 import com.google.common.io.Files;
30
31 import org.junit.Rule;
32 import org.junit.Test;
33 import org.junit.rules.TemporaryFolder;
34
35 import java.io.BufferedOutputStream;
36 import java.io.File;
37 import java.io.IOException;
38 import java.nio.file.Path;
39 import java.util.Arrays;
40 import java.util.List;
41 import java.util.zip.GZIPOutputStream;
42
43 public class AssetMergerTest extends BaseTestCase {
44
45 @Rule
46 public final TemporaryFolder mTemporaryFolder = new TemporaryFolder();
47
48 private static AssetMerger sAssetMerger = null;
49
50 @Test
51 public void testMergeByCount() throws Exception {
52 AssetMerger merger = getAssetMerger();
53
54 assertEquals(5, merger.size());
55 }
56
57 @Test
58 public void testMergedAssetsByName() throws Exception {
59 AssetMerger merger = getAssetMerger();
60
61 verifyResourceExists(merger,
62 "foo/icon.png",
63 "icon2.png",
64 "main.xml",
65 "values.xml",
66 "foo/foo.dat"
67 );
68 }
69
70 @Test
71 public void testMergeWrite() throws Exception {
72 AssetMerger merger = getAssetMerger();
73
74 File folder = getWrittenResources();
75
76 RecordingLogger logger = new RecordingLogger();
77
78 AssetSet writtenSet = new AssetSet("unused");
79 writtenSet.addSource(folder);
80 writtenSet.loadFromFiles(logger);
81
82 checkLogger(logger);
83
84 // compare the two maps, but not using the full map as the set loaded from the output
85 // won't contains all versions of each AssetItem item.
86 compareResourceMaps(merger, writtenSet, false /*full compare*/);
87 }
88
89 @Test
90 public void testExtractGzippedAssets() throws Exception {
91 Path assetsSourceDirectory = mTemporaryFolder.newFolder().toPath();
92
93 // Create gzipped asset
94 Path gzippedAsset = assetsSourceDirectory.resolve("asset.txt.gz");
95 try (GZIPOutputStream out = new GZIPOutputStream(new BufferedOutputStream(
96 java.nio.file.Files.newOutputStream(gzippedAsset)))) {
97 out.write("test.txt file content".getBytes(Charsets.UTF_8));
98 }
99
100 // Load asset set containing gzipped asset
101 AssetSet assetSet = new AssetSet("config");
102 assetSet.addSource(assetsSourceDirectory.toFile());
103 assetSet.loadFromFiles(new NoErrorsOrWarningsLogger());
104
105 AssetMerger merger = new AssetMerger();
106 merger.addDataSet(assetSet);
107
108 assertThat(merger.getDataMap()).containsKey("asset.txt");
109 assertThat(merger.getDataMap()).doesNotContainKey("asset.txt.gz");
110
111 Path outputFolder = mTemporaryFolder.newFolder().toPath();
112
113 MergedAssetWriter writer = new MergedAssetWriter(outputFolder.toFile());
114 merger.mergeData(writer, false /*doCleanUp*/);
115
116 assertTrue(Arrays.equals(
117 Files.toByteArray(outputFolder.resolve("asset.txt").toFile()),
118 "test.txt file content".getBytes(Charsets.UTF_8)));
119 }
120
121 @Test
122 public void testMergeBlob() throws Exception {
123 AssetMerger merger = getAssetMerger();
124
125 File folder = TestUtils.createTempDirDeletedOnExit();
126 merger.writeBlobTo(
127 folder, new MergedAssetWriter(TestUtils.createTempDirDeletedOnExit()), false);
128
129 AssetMerger loadedMerger = new AssetMerger();
130 loadedMerger.loadFromBlob(folder, true /*incrementalState*/);
131
132 compareResourceMaps(merger, loadedMerger, true /*full compare*/);
133 }
134
135 /**
136 * Tests the path replacement in the merger.xml file loaded from testData/
137 * @throws Exception
138 */
139 @Test
140 public void testLoadingTestPathReplacement() throws Exception {
141 File root = TestUtils.getRoot("assets", "baseMerge");
142 File fakeRoot = getMergedBlobFolder(root);
143
144 AssetMerger assetMerger = new AssetMerger();
145 assetMerger.loadFromBlob(fakeRoot, true /*incrementalState*/);
146 checkSourceFolders(assetMerger);
147
148 List<AssetSet> sets = assetMerger.getDataSets();
149 for (AssetSet set : sets) {
150 List<File> sourceFiles = set.getSourceFiles();
151
152 // there should only be one
153 assertEquals(1, sourceFiles.size());
154
155 File sourceFile = sourceFiles.get(0);
156 assertTrue(String.format("File %s is located in %s", sourceFile, root),
157 sourceFile.getAbsolutePath().startsWith(root.getAbsolutePath()));
158 }
159 }
160
161 @Test
162 public void testUpdate() throws Exception {
163 File root = getIncMergeRoot("basicFiles");
164 File fakeRoot = getMergedBlobFolder(root);
165 AssetMerger assetMerger = new AssetMerger();
166 assetMerger.loadFromBlob(fakeRoot, true /*incrementalState*/);
167 checkSourceFolders(assetMerger);
168
169 List<AssetSet> sets = assetMerger.getDataSets();
170 assertEquals(2, sets.size());
171
172 RecordingLogger logger = new RecordingLogger();
173
174 // ----------------
175 // first set is the main one, no change here
176 AssetSet mainSet = sets.get(0);
177 File mainFolder = new File(root, "main");
178
179 // touched/removed files:
180 File mainTouched = new File(mainFolder, "touched.png");
181 mainSet.updateWith(mainFolder, mainTouched, FileStatus.CHANGED, logger);
182 checkLogger(logger);
183
184 File mainRemoved = new File(mainFolder, "removed.png");
185 mainSet.updateWith(mainFolder, mainRemoved, FileStatus.REMOVED, logger);
186 checkLogger(logger);
187
188 File mainAdded = new File(mainFolder, "added.png");
189 mainSet.updateWith(mainFolder, mainAdded, FileStatus.NEW, logger);
190 checkLogger(logger);
191
192 // ----------------
193 // second set is the overlay one
194 AssetSet overlaySet = sets.get(1);
195 File overlayFolder = new File(root, "overlay");
196
197 // new/removed files:
198 File overlayAdded = new File(new File(overlayFolder, "foo"), "overlay_added.png");
199 overlaySet.updateWith(overlayFolder, overlayAdded, FileStatus.NEW, logger);
200 checkLogger(logger);
201
202 File overlayRemoved = new File(overlayFolder, "overlay_removed.png");
203 overlaySet.updateWith(overlayFolder, overlayRemoved, FileStatus.REMOVED, logger);
204 checkLogger(logger);
205
206 // validate for duplicates
207 assetMerger.validateDataSets();
208
209 // check the content.
210 ListMultimap<String, AssetItem> mergedMap = assetMerger.getDataMap();
211
212 // check untouched.png file is WRITTEN
213 List<AssetItem> untouchedItem = mergedMap.get("untouched.png");
214 assertEquals(1, untouchedItem.size());
215 assertTrue(untouchedItem.get(0).isWritten());
216 assertFalse(untouchedItem.get(0).isTouched());
217 assertFalse(untouchedItem.get(0).isRemoved());
218
219 // check touched.png file is TOUCHED
220 List<AssetItem> touchedItem = mergedMap.get("touched.png");
221 assertEquals(1, touchedItem.size());
222 assertTrue(touchedItem.get(0).isWritten());
223 assertTrue(touchedItem.get(0).isTouched());
224 assertFalse(touchedItem.get(0).isRemoved());
225
226 // check removed file is REMOVED
227 List<AssetItem> removedItem = mergedMap.get("removed.png");
228 assertEquals(1, removedItem.size());
229 assertTrue(removedItem.get(0).isWritten());
230 assertTrue(removedItem.get(0).isRemoved());
231
232 // check new overlay: two objects, last one is TOUCHED
233 List<AssetItem> overlayAddedItem = mergedMap.get("foo/overlay_added.png");
234 assertEquals(2, overlayAddedItem.size());
235 AssetItem newOverlay0 = overlayAddedItem.get(0);
236 assertTrue(newOverlay0.isWritten());
237 assertFalse(newOverlay0.isTouched());
238 AssetItem newOverlay1 = overlayAddedItem.get(1);
239 assertEquals(overlayAdded, newOverlay1.getSource().getFile());
240 assertFalse(newOverlay1.isWritten());
241 assertTrue(newOverlay1.isTouched());
242
243 // check removed overlay: two objects, last one is removed
244 List<AssetItem> overlayRemovedItem = mergedMap.get("overlay_removed.png");
245 assertEquals(2, overlayRemovedItem.size());
246 AssetItem overlayRemovedItem0 = overlayRemovedItem.get(0);
247 assertFalse(overlayRemovedItem0.isWritten());
248 assertFalse(overlayRemovedItem0.isTouched());
249 AssetItem overlayRemovedItem1 = overlayRemovedItem.get(1);
250 assertEquals(overlayRemoved, overlayRemovedItem1.getSource().getFile());
251 assertTrue(overlayRemovedItem1.isWritten());
252 assertTrue(overlayRemovedItem1.isRemoved());
253
254 // write and check the result of writeResourceFolder
255 // copy the current resOut which serves as pre incremental update state.
256 File resFolder = getFolderCopy(new File(root, "assetOut"));
257
258 // write the content of the resource merger.
259 MergedAssetWriter writer = new MergedAssetWriter(resFolder);
260 assetMerger.mergeData(writer, false /*doCleanUp*/);
261
262 // Check the content by checking the colors. All files should be green
263 checkImageColor(new File(resFolder, "untouched.png"), (int) 0xFF00FF00);
264 checkImageColor(new File(resFolder, "touched.png"), (int) 0xFF00FF00);
265 checkImageColor(new File(resFolder, "added.png"), (int) 0xFF00FF00);
266 checkImageColor(new File(resFolder, "overlay_removed.png"), (int) 0xFF00FF00);
267 checkImageColor(new File(new File(resFolder, "foo"), "overlay_added.png"), (int) 0xFF00FF00);
268
269 // also check the removed file is not there.
270 assertFalse(new File(resFolder, "removed.png").isFile());
271 }
272
273 @Test
274 public void testCheckValidUpdate() throws Exception {
275 // first merger
276 AssetMerger merger1 = createMerger(new String[][] {
277 new String[] { "main", ("/main/res1"), ("/main/res2") },
278 new String[] { "overlay", ("/overlay/res1"), ("/overlay/res2") },
279 });
280
281 // 2nd merger with different order source files in sets.
282 AssetMerger merger2 = createMerger(new String[][] {
283 new String[] { "main", ("/main/res2"), ("/main/res1") },
284 new String[] { "overlay", ("/overlay/res1"), ("/overlay/res2") },
285 });
286
287 assertTrue(merger1.checkValidUpdate(merger2.getDataSets()));
288
289 // write merger1 on disk to test writing empty AssetSets.
290 File folder = TestUtils.createTempDirDeletedOnExit();
291 merger1.writeBlobTo(
292 folder, new MergedAssetWriter(TestUtils.createTempDirDeletedOnExit()), false);
293
294 // reload it
295 AssetMerger loadedMerger = new AssetMerger();
296 loadedMerger.loadFromBlob(folder, true /*incrementalState*/);
297
298 String expected = merger1.toString();
299 String actual = loadedMerger.toString();
300 if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_WINDOWS) {
301 expected = expected.replace(File.separatorChar, '/').
302 replaceAll("[A-Z]:/", "/");
303 actual = actual.replace(File.separatorChar, '/').
304 replaceAll("[A-Z]:/", "/");
305 assertEquals("Actual: " + actual + "\nExpected: " + expected, expected, actual);
306 } else {
307 assertTrue("Actual: " + actual + "\nExpected: " + expected,
308 loadedMerger.checkValidUpdate(merger1.getDataSets()));
309 }
310 }
311
312 @Test
313 public void testUpdateWithRemovedOverlay() throws Exception {
314 // Test with removed overlay
315 AssetMerger merger1 = createMerger(new String[][] {
316 new String[] { "main", "/main/res1", "/main/res2" },
317 new String[] { "overlay", "/overlay/res1", "/overlay/res2" },
318 });
319
320 // 2nd merger with different order source files in sets.
321 AssetMerger merger2 = createMerger(new String[][] {
322 new String[] { "main", "/main/res2", "/main/res1" },
323 });
324
325 assertFalse(merger1.checkValidUpdate(merger2.getDataSets()));
326 }
327
328 @Test
329 public void testUpdateWithReplacedOverlays() throws Exception {
330 // Test with different overlays
331 AssetMerger merger1 = createMerger(new String[][] {
332 new String[] { "main", "/main/res1", "/main/res2" },
333 new String[] { "overlay", "/overlay/res1", "/overlay/res2" },
334 });
335
336 // 2nd merger with different order source files in sets.
337 AssetMerger merger2 = createMerger(new String[][] {
338 new String[] { "main", "/main/res2", "/main/res1" },
339 new String[] { "overlay2", "/overlay2/res1", "/overlay2/res2" },
340 });
341
342 assertFalse(merger1.checkValidUpdate(merger2.getDataSets()));
343 }
344
345 @Test
346 public void testUpdateWithReorderedOverlays() throws Exception {
347 // Test with different overlays
348 AssetMerger merger1 = createMerger(new String[][] {
349 new String[] { "main", "/main/res1", "/main/res2" },
350 new String[] { "overlay1", "/overlay1/res1", "/overlay1/res2" },
351 new String[] { "overlay2", "/overlay2/res1", "/overlay2/res2" },
352 });
353
354 // 2nd merger with different order source files in sets.
355 AssetMerger merger2 = createMerger(new String[][] {
356 new String[] { "main", "/main/res2", "/main/res1" },
357 new String[] { "overlay2", "/overlay2/res1", "/overlay2/res2" },
358 new String[] { "overlay1", "/overlay1/res1", "/overlay1/res2" },
359 });
360
361 assertFalse(merger1.checkValidUpdate(merger2.getDataSets()));
362 }
363
364 @Test
365 public void testUpdateWithRemovedSourceFile() throws Exception {
366 // Test with different source files
367 AssetMerger merger1 = createMerger(new String[][] {
368 new String[] { "main", "/main/res1", "/main/res2" },
369 });
370
371 // 2nd merger with different order source files in sets.
372 AssetMerger merger2 = createMerger(new String[][] {
373 new String[] { "main", "/main/res1" },
374 });
375
376 assertFalse(merger1.checkValidUpdate(merger2.getDataSets()));
377 }
378
379 @Test
380 public void testChangedIgnoredFile() throws Exception {
381 AssetSet assetSet = AssetSetTest.getBaseAssetSet();
382
383 AssetMerger assetMerger = new AssetMerger();
384 assetMerger.addDataSet(assetSet);
385
386 File root = TestUtils.getRoot("assets", "baseSet");
387 File changedCVSFoo = new File(root, "CVS/foo.txt");
388 FileValidity<AssetSet> fileValidity = assetMerger.findDataSetContaining(changedCVSFoo);
389
390 assertEquals(FileValidity.FileStatus.IGNORED_FILE, fileValidity.status);
391 }
392
393 /**
394 * Creates a fake merge with given sets.
395 *
396 * the data is an array of sets.
397 *
398 * Each set is [ setName, folder1, folder2, ...]
399 *
400 * @param data
401 * @return
402 */
403 private static AssetMerger createMerger(String[][] data) {
404 AssetMerger merger = new AssetMerger();
405 for (String[] setData : data) {
406 AssetSet set = new AssetSet(setData[0]);
407 merger.addDataSet(set);
408 for (int i = 1, n = setData.length; i < n; i++) {
409 set.addSource(new File(setData[i]));
410 }
411 }
412
413 return merger;
414 }
415
416 private static AssetMerger getAssetMerger()
417 throws IOException, MergingException {
418 if (sAssetMerger == null) {
419 File root = TestUtils.getRoot("assets", "baseMerge");
420
421 AssetSet res = AssetSetTest.getBaseAssetSet();
422
423 RecordingLogger logger = new RecordingLogger();
424
425 AssetSet overlay = new AssetSet("overlay");
426 overlay.addSource(new File(root, "overlay"));
427 overlay.loadFromFiles(logger);
428
429 checkLogger(logger);
430
431 sAssetMerger = new AssetMerger();
432 sAssetMerger.addDataSet(res);
433 sAssetMerger.addDataSet(overlay);
434 }
435
436 return sAssetMerger;
437 }
438
439 private static File getWrittenResources() throws MergingException, IOException {
440 AssetMerger assetMerger = getAssetMerger();
441
442 File folder = TestUtils.createTempDirDeletedOnExit();
443
444 MergedAssetWriter writer = new MergedAssetWriter(folder);
445 assetMerger.mergeData(writer, false /*doCleanUp*/);
446
447 return folder;
448 }
449
450 private File getIncMergeRoot(String name) throws IOException {
451 File root = TestUtils.getCanonicalRoot("assets", "incMergeData");
452 return new File(root, name);
453 }
454
455 private static File getFolderCopy(File folder) throws IOException {
456 File dest = TestUtils.createTempDirDeletedOnExit();
457 copyFolder(folder, dest);
458 return dest;
459 }
460
461 private static void copyFolder(File from, File to) throws IOException {
462 if (from.isFile()) {
463 Files.copy(from, to);
464 } else if (from.isDirectory()) {
465 if (!to.exists()) {
466 to.mkdirs();
467 }
468
469 File[] children = from.listFiles();
470 if (children != null) {
471 for (File f : children) {
472 copyFolder(f, new File(to, f.getName()));
473 }
474 }
475 }
476 }
477 }