| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/org/documents/epl-v10.php |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.manifmerger; |
| |
| import com.android.common.annotations.NonNull; |
| import com.android.manifmerger.IMergerLog.FileAndLine; |
| |
| import org.w3c.dom.Document; |
| |
| import java.io.BufferedReader; |
| import java.io.BufferedWriter; |
| import java.io.File; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.UnsupportedEncodingException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import junit.framework.TestCase; |
| |
| /** |
| * Some utilities to reduce repetitions in the {@link ManifestMergerTest}s. |
| * <p/> |
| * See {@link #loadTestData(String)} for an explanation of the data file format. |
| */ |
| abstract class ManifestMergerTestCase extends TestCase { |
| |
| /** |
| * Delimiter that indicates the test must fail. |
| * An XML output and errors are still generated and checked. |
| */ |
| private static final String DELIM_FAILS = "fails"; |
| /** |
| * Delimiter that starts a library XML content. |
| * The delimiter name must be in the form {@code @libSomeName} and it will be |
| * used as the base for the test file name. Using separate lib names is encouraged |
| * since it makes the error output easier to read. |
| */ |
| private static final String DELIM_LIB = "lib"; |
| /** |
| * Delimiter that starts the main manifest XML content. |
| */ |
| private static final String DELIM_MAIN = "main"; |
| /** |
| * Delimiter that starts the resulting XML content, whatever is generated by the merge. |
| */ |
| private static final String DELIM_RESULT = "result"; |
| /** |
| * Delimiter that starts the SdkLog output. |
| * The logger prints each entry on its lines, prefixed with E for errors, |
| * W for warnings and P for regular printfs. |
| */ |
| private static final String DELIM_ERRORS = "errors"; |
| |
| static class TestFiles { |
| private final File mMain; |
| private final File[] mLibs; |
| private final File mActualResult; |
| private final String mExpectedResult; |
| private final String mExpectedErrors; |
| private final boolean mShouldFail; |
| |
| /** |
| * Files used by a given test case. |
| */ |
| public TestFiles( |
| boolean shouldFail, |
| @NonNull File main, |
| @NonNull File[] libs, |
| @NonNull File actualResult, |
| @NonNull String expectedResult, |
| @NonNull String expectedErrors) { |
| mShouldFail = shouldFail; |
| mMain = main; |
| mLibs = libs; |
| mActualResult = actualResult; |
| mExpectedResult = expectedResult; |
| mExpectedErrors = expectedErrors; |
| } |
| |
| public boolean getShouldFail() { |
| return mShouldFail; |
| } |
| |
| @NonNull |
| public File getMain() { |
| return mMain; |
| } |
| |
| @NonNull |
| public File[] getLibs() { |
| return mLibs; |
| } |
| |
| @NonNull |
| public File getActualResult() { |
| return mActualResult; |
| } |
| |
| @NonNull |
| public String getExpectedResult() { |
| return mExpectedResult; |
| } |
| |
| public String getExpectedErrors() { |
| return mExpectedErrors; |
| } |
| |
| // Try to delete any temp file potentially created. |
| public void cleanup() { |
| if (mMain != null && mMain.isFile()) { |
| mMain.delete(); |
| } |
| |
| if (mActualResult != null && mActualResult.isFile()) { |
| mActualResult.delete(); |
| } |
| |
| for (File f : mLibs) { |
| if (f != null && f.isFile()) { |
| f.delete(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Calls {@link #loadTestData(String)} by |
| * inferring the data filename from the caller's method name. |
| * <p/> |
| * The caller method name must be composed of "test" + the leaf filename. |
| * Extensions ".xml" or ".txt" are implied. |
| * <p/> |
| * E.g. to use the data file "12_foo.xml", simply call this from a method |
| * named "test12_foo". |
| * |
| * @return A new {@link TestFiles} instance. Never null. |
| * @throws Exception when things go wrong. |
| * @see #loadTestData(String) |
| */ |
| @NonNull |
| TestFiles loadTestData() throws Exception { |
| StackTraceElement[] stack = Thread.currentThread().getStackTrace(); |
| for (int i = 0, n = stack.length; i < n; i++) { |
| StackTraceElement caller = stack[i]; |
| String name = caller.getMethodName(); |
| if (name.startsWith("test")) { |
| return loadTestData(name.substring(4)); |
| } |
| } |
| |
| throw new IllegalArgumentException("No caller method found which name started with 'test'"); |
| } |
| |
| /** |
| * Loads test data for a given test case. |
| * The input (main + libs) are stored in temp files. |
| * A new destination temp file is created to store the actual result output. |
| * The expected result is actually kept in a string. |
| * <p/> |
| * Data File Syntax: |
| * <ul> |
| * <li> Lines starting with # are ignored (anywhere, as long as # is the first char). |
| * <li> Lines before the first {@code @delimiter} are ignored. |
| * <li> Empty lines just after the {@code @delimiter} |
| * and before the first < XML line are ignored. |
| * <li> Valid delimiters are {@code @main} for the XML of the main app manifest. |
| * <li> Following delimiters are {@code @libXYZ}, read in the order of definition. |
| * The name can be anything as long as it starts with "{@code @lib}". |
| * </ul> |
| * |
| * @param filename The test data filename. If no extension is provided, this will |
| * try with .xml or .txt. Must not be null. |
| * @return A new {@link TestFiles} instance. Must not be null. |
| * @throws Exception when things fail to load properly. |
| */ |
| @NonNull |
| TestFiles loadTestData(@NonNull String filename) throws Exception { |
| |
| String resName = "data" + File.separator + filename; |
| InputStream is = null; |
| BufferedReader reader = null; |
| BufferedWriter writer = null; |
| |
| try { |
| is = this.getClass().getResourceAsStream(resName); |
| if (is == null && !filename.endsWith(".xml")) { |
| String resName2 = resName + ".xml"; |
| is = this.getClass().getResourceAsStream(resName2); |
| if (is != null) { |
| filename = resName2; |
| } |
| } |
| if (is == null && !filename.endsWith(".txt")) { |
| String resName3 = resName + ".txt"; |
| is = this.getClass().getResourceAsStream(resName3); |
| if (is != null) { |
| filename = resName3; |
| } |
| } |
| assertNotNull("Test data file not found for " + filename, is); |
| |
| reader = new BufferedReader(new InputStreamReader(is, "UTF-8")); |
| |
| // Get the temporary directory to use. Just create a temp file, extracts its |
| // directory and remove the file. |
| File tempFile = File.createTempFile(this.getClass().getSimpleName(), ".tmp"); |
| File tempDir = tempFile.getParentFile(); |
| if (!tempFile.delete()) { |
| tempFile.deleteOnExit(); |
| } |
| |
| String line = null; |
| String delimiter = null; |
| boolean skipEmpty = true; |
| |
| boolean shouldFail = false; |
| StringBuilder expectedResult = new StringBuilder(); |
| StringBuilder expectedErrors = new StringBuilder(); |
| File mainFile = null; |
| File actualResultFile = null; |
| List<File> libFiles = new ArrayList<File>(); |
| int tempIndex = 0; |
| |
| while ((line = reader.readLine()) != null) { |
| if (skipEmpty && line.trim().length() == 0) { |
| continue; |
| } |
| if (line.length() > 0 && line.charAt(0) == '#') { |
| continue; |
| } |
| if (line.length() > 0 && line.charAt(0) == '@') { |
| delimiter = line.substring(1); |
| assertTrue( |
| "Unknown delimiter @" + delimiter + " in " + filename, |
| delimiter.startsWith(DELIM_LIB) || |
| delimiter.equals(DELIM_MAIN) || |
| delimiter.equals(DELIM_RESULT) || |
| delimiter.equals(DELIM_ERRORS) || |
| delimiter.equals(DELIM_FAILS)); |
| |
| skipEmpty = true; |
| |
| if (writer != null) { |
| try { |
| writer.close(); |
| } catch (IOException ignore) { |
| } |
| writer = null; |
| } |
| |
| if (delimiter.equals(DELIM_FAILS)) { |
| shouldFail = true; |
| |
| } else if (!delimiter.equals(DELIM_ERRORS)) { |
| tempFile = new File(tempDir, String.format("%1$s%2$d_%3$s.xml", |
| this.getClass().getSimpleName(), |
| tempIndex++, |
| delimiter.replaceAll("[^a-zA-Z0-9_-]", "") |
| )); |
| tempFile.deleteOnExit(); |
| |
| if (delimiter.startsWith(DELIM_LIB)) { |
| libFiles.add(tempFile); |
| |
| } else if (delimiter.equals(DELIM_MAIN)) { |
| mainFile = tempFile; |
| |
| } else if (delimiter.equals(DELIM_RESULT)) { |
| actualResultFile = tempFile; |
| |
| } else { |
| fail("Unexpected data file delimiter @" + delimiter + |
| " in " + filename); |
| } |
| |
| if (!delimiter.equals(DELIM_RESULT)) { |
| writer = new BufferedWriter(new FileWriter(tempFile)); |
| } |
| } |
| |
| continue; |
| } |
| if (delimiter != null && |
| skipEmpty && |
| line.length() > 0 && |
| line.charAt(0) != '#' && |
| line.charAt(0) != '@') { |
| skipEmpty = false; |
| } |
| if (writer != null) { |
| writer.write(line); |
| writer.write('\n'); |
| } else if (DELIM_RESULT.equals(delimiter)) { |
| expectedResult.append(line).append('\n'); |
| } else if (DELIM_ERRORS.equals(delimiter)) { |
| expectedErrors.append(line).append('\n'); |
| } |
| } |
| |
| assertNotNull("Missing @" + DELIM_MAIN + " in " + filename, mainFile); |
| assertNotNull("Missing @" + DELIM_RESULT + " in " + filename, actualResultFile); |
| |
| assert mainFile != null; |
| assert actualResultFile != null; |
| |
| return new TestFiles( |
| shouldFail, |
| mainFile, |
| libFiles.toArray(new File[libFiles.size()]), |
| actualResultFile, |
| expectedResult.toString(), |
| expectedErrors.toString()); |
| |
| } catch (UnsupportedEncodingException e) { |
| // BufferedReader failed to decode UTF-8, O'RLY? |
| throw e; |
| |
| } finally { |
| if (writer != null) { |
| try { |
| writer.close(); |
| } catch (IOException ignore) { |
| } |
| } |
| if (reader != null) { |
| try { |
| reader.close(); |
| } catch (IOException ignore) { |
| } |
| } |
| if (is != null) { |
| try { |
| is.close(); |
| } catch (IOException ignore) { |
| } |
| } |
| } |
| } |
| |
| /** |
| * Loads the data test files using {@link #loadTestData()} and then |
| * invokes {@link #processTestFiles(TestFiles)} to test them. |
| * |
| * @see #loadTestData() |
| * @see #processTestFiles(TestFiles) |
| */ |
| void processTestFiles() throws Exception { |
| processTestFiles(loadTestData()); |
| } |
| |
| /** |
| * Processes the data from the given {@link TestFiles} by |
| * invoking {@link ManifestMerger#process(File, File, File[])}: |
| * the given library files are applied consecutively to the main XML |
| * document and the output is generated. |
| * <p/> |
| * Then the expected and actual outputs are loaded into a DOM, |
| * dumped again to a String using an XML transform and compared. |
| * This makes sure only the structure is checked and that any |
| * formatting is ignored in the comparison. |
| * |
| * @param testFiles The test files to process. Must not be null. |
| * @throws Exception when this go wrong. |
| */ |
| void processTestFiles(TestFiles testFiles) throws Exception { |
| MockLog log = new MockLog(); |
| IMergerLog mergerLog = MergerLog.wrapSdkLog(log); |
| ManifestMerger merger = new ManifestMerger(mergerLog, new ICallback() { |
| @Override |
| public int queryCodenameApiLevel(@NonNull String codename) { |
| if ("ApiCodename1".equals(codename)) { |
| return 1; |
| } else if ("ApiCodename10".equals(codename)) { |
| return 10; |
| } |
| return ICallback.UNKNOWN_CODENAME; |
| } |
| }); |
| boolean processOK = merger.process(testFiles.getActualResult(), |
| testFiles.getMain(), |
| testFiles.getLibs()); |
| |
| String expectedErrors = testFiles.getExpectedErrors().trim(); |
| StringBuilder actualErrors = new StringBuilder(); |
| for (String s : log.getMessages()) { |
| actualErrors.append(s); |
| if (!s.endsWith("\n")) { |
| actualErrors.append('\n'); |
| } |
| } |
| assertEquals("Error generated during merging", |
| expectedErrors, actualErrors.toString().trim()); |
| |
| if (testFiles.getShouldFail()) { |
| assertFalse("Merge process() returned true, expected false", processOK); |
| } else { |
| assertTrue("Merge process() returned false, expected true", processOK); |
| } |
| |
| // Test result XML. There should always be one created |
| // since the process action does not stop on errors. |
| log.clear(); |
| Document document = XmlUtils.parseDocument(testFiles.getActualResult(), mergerLog); |
| assertNotNull(document); |
| assert document != null; // for Eclipse null analysis |
| String actual = XmlUtils.printXmlString(document, mergerLog); |
| assertEquals("Error parsing actual result XML", "[]", log.toString()); |
| log.clear(); |
| document = XmlUtils.parseDocument( |
| testFiles.getExpectedResult(), |
| mergerLog, |
| new FileAndLine("<expected-result>", 0)); |
| assertNotNull(document); |
| assert document != null; |
| String expected = XmlUtils.printXmlString(document, mergerLog); |
| assertEquals("Error parsing expected result XML", "[]", log.toString()); |
| assertEquals("Error comparing expected to actual result", expected, actual); |
| |
| testFiles.cleanup(); |
| } |
| |
| } |