Debian Codegraph @

build-system/manifest-merger/src/test/java/com/android/manifmerger/ManifestMerger2Test.java

raw
1 /*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package com.android.manifmerger;
18
19 import static com.android.manifmerger.ManifestMergerTestUtil.loadTestData;
20 import static com.android.manifmerger.ManifestMergerTestUtil.transformParameters;
21 import static com.android.manifmerger.MergingReport.Record;
22 import static org.junit.Assert.assertFalse;
23 import static org.junit.Assert.assertNotNull;
24 import static org.junit.Assert.fail;
25
26 import com.android.annotations.Nullable;
27 import com.android.utils.StdLogger;
28 import com.google.common.base.Optional;
29 import com.google.common.base.Strings;
30
31 import org.junit.Test;
32 import org.junit.runner.RunWith;
33 import org.junit.runners.Parameterized;
34
35 import java.io.BufferedReader;
36 import java.io.FileWriter;
37 import java.io.IOException;
38 import java.io.StringReader;
39 import java.util.ArrayList;
40 import java.util.Collection;
41 import java.util.List;
42 import java.util.Map;
43 import java.util.logging.Logger;
44 import java.util.regex.Matcher;
45 import java.util.regex.Pattern;
46
47 /**
48 * Tests for the {@link com.android.manifmerger.ManifestMerger2} class
49 */
50 @RunWith(Parameterized.class)
51 public class ManifestMerger2Test {
52
53 private static final String TEST_DATA_DIRECTORY = "data2";
54
55 @SuppressWarnings("SpellCheckingInspection")
56 private static final String[] DATA_FILES = new String[]{
57 "00_noop",
58 "03_inject_attributes.xml",
59 "05_inject_package.xml",
60 "05_inject_package_placeholder.xml",
61 "05_inject_package_with_overlays.xml",
62 "06_inject_attributes_with_specific_prefix.xml",
63 "05_inject_applicationid_not_provided.xml",
64 "07_no_package_provided.xml",
65 "08_no_library_package_provided.xml",
66 "09_overlay_package_provided.xml",
67 "08b_library_injection.xml",
68 "09b_overlay_package_different.xml",
69 "09c_overlay_package_not_provided.xml",
70 "10_activity_merge",
71 "11_activity_dup",
72 "12_alias_dup",
73 "13_service_dup",
74 "14_receiver_dup",
75 "15_provider_dup",
76 "16_fqcn_merge",
77 "17_fqcn_conflict",
78 "18_fqcn_success",
79 "20_uses_lib_merge",
80 "21_uses_main_errors",
81 "22_uses_lib_errors",
82 "25_permission_merge",
83 "26_permission_dup",
84 "28_uses_perm_merge",
85 "29_uses_perm_selector",
86 "29b_uses_perm_invalidSelector",
87 "30_uses_sdk_ok",
88 "32_uses_sdk_minsdk_ok",
89 "33_uses_sdk_minsdk_conflict",
90 "33b_uses_sdk_minsdk_override.xml",
91 "33c_uses_sdk_minsdk_override_and_conflict.xml",
92 "34_inject_uses_sdk_no_dup.xml",
93 "36_uses_sdk_targetsdk_warning",
94 "40_uses_feat_merge",
95 "41_uses_feat_errors",
96 "45_uses_feat_gles_once",
97 "47_uses_feat_gles_conflict",
98 "50_uses_conf_warning",
99 "52_support_screens_warning",
100 "54_compat_screens_warning",
101 "56_support_gltext_warning",
102 "60_merge_order",
103 "65_override_app",
104 "66_remove_app",
105 "67_override_activities",
106 "68_override_uses",
107 "69_remove_uses",
108 "70_expand_fqcns",
109 "71_extract_package_prefix",
110 "75_app_metadata_merge",
111 "76_app_metadata_ignore",
112 "77_app_metadata_conflict",
113 "78_removeAll",
114 "78b_removeAllActivities",
115 "79_custom_node.xml",
116 };
117
118
119 @Parameterized.Parameters(name = "{0}")
120 public static Collection<Object[]> getParameters() {
121 return transformParameters(DATA_FILES);
122 }
123
124 private final String fileName;
125
126 public ManifestMerger2Test(String fileName) {
127 this.fileName = fileName;
128 }
129
130 @Test
131 public void processTestFiles() throws Exception {
132 ManifestMergerTestUtil.TestFiles testFiles =
133 loadTestData(TEST_DATA_DIRECTORY, fileName, getClass().getSimpleName());
134
135 StdLogger stdLogger = new StdLogger(StdLogger.Level.VERBOSE);
136 ManifestMerger2.Invoker invoker = ManifestMerger2.newMerger(testFiles.getMain(),
137 stdLogger, ManifestMerger2.MergeType.APPLICATION)
138 .addLibraryManifests(testFiles.getLibs())
139 .addFlavorAndBuildTypeManifests(testFiles.getOverlayFiles())
140 .withFeatures(ManifestMerger2.Invoker.Feature.KEEP_INTERMEDIARY_STAGES,
141 ManifestMerger2.Invoker.Feature.REMOVE_TOOLS_DECLARATIONS);
142
143 if (!Strings.isNullOrEmpty(testFiles.getPackageOverride())) {
144 invoker.setOverride(ManifestSystemProperty.PACKAGE, testFiles.getPackageOverride());
145 }
146
147 for (Map.Entry<String, String> injectable : testFiles.getInjectAttributes().entrySet()) {
148 ManifestSystemProperty manifestSystemProperty = getSystemProperty(injectable.getKey());
149 if (manifestSystemProperty != null) {
150 invoker.setOverride(manifestSystemProperty, injectable.getValue());
151 } else {
152 invoker.setPlaceHolderValue(injectable.getKey(), injectable.getValue());
153 }
154 }
155
156 MergingReport mergeReport = invoker.merge();
157
158 // this is obviously quite hacky, refine once merge output is better defined.
159 boolean notExpectingError = !isExpectingError(testFiles.getExpectedErrors());
160 mergeReport.log(stdLogger);
161 if (mergeReport.getResult().isSuccess()) {
162 String xmlDocument = mergeReport.getMergedDocument(
163 MergingReport.MergedManifestKind.MERGED);
164 assertNotNull(xmlDocument);
165 stdLogger.info(xmlDocument);
166
167 if (testFiles.getActualResult() != null) {
168 FileWriter writer = new FileWriter(testFiles.getActualResult());
169 try {
170 writer.append(xmlDocument);
171 } finally {
172 writer.close();
173 }
174 }
175
176 if (!notExpectingError) {
177 fail("Did not get expected error : " + testFiles.getExpectedErrors());
178 }
179
180 XmlDocument expectedResult = TestUtils.xmlDocumentFromString(
181 TestUtils.sourceFile(getClass(), testFiles.getMain().getName()),
182 testFiles.getExpectedResult());
183
184 XmlDocument actualResult = TestUtils.xmlDocumentFromString(
185 TestUtils.sourceFile(getClass(), testFiles.getMain().getName()),
186 xmlDocument);
187
188 Optional<String> comparingMessage =
189 expectedResult.compareTo(actualResult);
190
191 if (comparingMessage.isPresent()) {
192 Logger.getAnonymousLogger().severe(comparingMessage.get());
193 fail(comparingMessage.get());
194 }
195 // process any warnings.
196 if (mergeReport.getResult() == MergingReport.Result.WARNING) {
197 compareExpectedAndActualErrors(mergeReport, testFiles.getExpectedErrors());
198 }
199 } else {
200 for (Record record : mergeReport.getLoggingRecords()) {
201 Logger.getAnonymousLogger().info("Returned log: " + record);
202 }
203 compareExpectedAndActualErrors(mergeReport, testFiles.getExpectedErrors());
204 assertFalse(notExpectingError);
205 }
206 }
207
208 private static boolean isExpectingError(String expectedOutput) throws IOException {
209 StringReader stringReader = new StringReader(expectedOutput);
210 BufferedReader reader = new BufferedReader(stringReader);
211 try {
212 String line;
213 while ((line = reader.readLine()) != null) {
214 if (line.startsWith("ERROR")) {
215 return true;
216 }
217 }
218 return false;
219 } finally {
220 reader.close();
221 }
222 }
223
224 private static void compareExpectedAndActualErrors(
225 MergingReport mergeReport,
226 String expectedOutput) throws IOException {
227
228 StringReader stringReader = new StringReader(expectedOutput);
229 List<Record> records = new ArrayList<Record>(mergeReport.getLoggingRecords());
230 BufferedReader reader = new BufferedReader(stringReader);
231 try {
232 String line = reader.readLine();
233 while (line != null) {
234 if (line.startsWith("WARNING") || line.startsWith("ERROR")) {
235 String message = line;
236 do {
237 line = reader.readLine();
238 if (line != null && line.startsWith(" ")) {
239 message = message + "\n" + line;
240 }
241 } while (line != null && line.startsWith(" "));
242
243 // next might generate an exception which will make the test fail when we
244 // get unexpected error message.
245 if (!findLineInRecords(message, records)) {
246
247 StringBuilder errorMessage = new StringBuilder();
248 dumpRecords(records, errorMessage);
249 errorMessage.append("Cannot find expected error : \n").append(message);
250 fail(errorMessage.toString());
251 }
252 }
253 }
254 } finally {
255 reader.close();
256 }
257 // check that we do not have any unexpected error messages.
258 if (!records.isEmpty()) {
259 StringBuilder message = new StringBuilder();
260 dumpRecords(records, message);
261 message.append("Unexpected error message(s)");
262 fail(message.toString());
263 }
264 }
265
266 private static boolean findLineInRecords(String errorLine, List<Record> records) {
267 String severity = errorLine.substring(0, errorLine.indexOf(':'));
268 String message = errorLine.substring(errorLine.indexOf(':') + 1);
269 for (Record record : records) {
270 int indexOfSuggestions = record.getMessage().indexOf("\n\tSuggestion:");
271 String messageRecord = indexOfSuggestions != -1
272 ? record.getMessage().substring(0, indexOfSuggestions)
273 : record.getMessage();
274 Pattern pattern = Pattern.compile(message);
275 Matcher matcher = pattern.matcher(messageRecord.replaceAll("\t", " "));
276 if (matcher.matches() && record.getSeverity() == Record.Severity.valueOf(severity)) {
277 records.remove(record);
278 return true;
279 }
280 }
281 return false;
282 }
283
284 @Nullable
285 private static ManifestSystemProperty getSystemProperty(String name) {
286 for (ManifestSystemProperty manifestSystemProperty : ManifestSystemProperty.values()) {
287 if (manifestSystemProperty.toCamelCase().equals(name)) {
288 return manifestSystemProperty;
289 }
290 }
291 return null;
292 }
293
294 private static void dumpRecords(List<Record> records, StringBuilder stringBuilder) {
295 stringBuilder.append("\n------------ Records : \n");
296 for (Record record : records) {
297 stringBuilder.append(record.toString());
298 stringBuilder.append("\n");
299 }
300 stringBuilder.append("------------ End of records.\n");
301 }
302 }