diff options
Diffstat (limited to 'framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/ManifestTest.java')
| -rw-r--r-- | framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/ManifestTest.java | 477 |
1 files changed, 477 insertions, 0 deletions
diff --git a/framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/ManifestTest.java b/framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/ManifestTest.java new file mode 100644 index 00000000..6e794327 --- /dev/null +++ b/framework/src/ant/apache-ant-1.9.6/src/tests/junit/org/apache/tools/ant/taskdefs/ManifestTest.java @@ -0,0 +1,477 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0 + * + * 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 org.apache.tools.ant.taskdefs; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.util.Enumeration; +import java.util.HashSet; +import java.util.Set; + +import org.apache.tools.ant.BuildException; +import org.apache.tools.ant.BuildFileRule; +import org.apache.tools.ant.Project; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import static org.apache.tools.ant.AntAssert.assertContains; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +/** + * Testcase for the Manifest class used in the jar task. + * + */ +public class ManifestTest { + + @Rule + public final BuildFileRule buildRule = new BuildFileRule(); + + private File expandedManifest; + private File outDir; + + public static final String LONG_LINE + = "AReallyLongLineToTestLineBreakingInManifests-ACapabilityWhich" + + "IsSureToLeadToHundredsOfQuestionsAboutWhyAntMungesManifests" + + "OfCourseTheAnswerIsThatIsWhatTheSpecRequiresAndIfAnythingHas" + + "AProblemWithThatItIsNotABugInAnt"; + + public static final String LONG_70_NAME + = "ThisNameIsJustSeventyCharactersWhichIsAllowedAccordingToTheSpecsFiller"; + public static final String LONG_68_NAME + = "ThisNameIsJustSixtyEightCharactersWhichIsAllowedAccordingToTheSpecsX"; + public static final String NOT_LONG_NAME + = "NameIsJustUnderSeventyCharactersWhichIsAllowedAccordingTheSpec"; + + public static final String VALUE = "NOT_LONG"; + + + @Before + public void setUp() { + buildRule.configureProject("src/etc/testcases/taskdefs/manifest.xml"); + outDir = new File(buildRule.getProject().getProperty("output")); + expandedManifest = new File(outDir, "manifests/META-INF/MANIFEST.MF"); + } + + @After + public void tearDown() { + buildRule.executeTarget("tearDown"); + } + + /** + * Empty manifest - is OK + */ + @Test + public void test1() throws ManifestException, IOException { + buildRule.executeTarget("test1"); + Manifest manifest = getManifest(expandedManifest); + String version = manifest.getManifestVersion(); + assertEquals("Manifest was not created with correct version - ", "1.0", version); + } + + /** + * Simple Manifest with version 2.0 + */ + @Test + public void test2() throws ManifestException, IOException { + buildRule.executeTarget("test2"); + Manifest manifest = getManifest(expandedManifest); + String version = manifest.getManifestVersion(); + assertEquals("Manifest was not created with correct version - ", "2.0", version); + } + + /** + * Malformed manifest - no : on the line + */ + @Test + public void test3() { + try { + buildRule.executeTarget("test3"); + fail("BuildException expected: Manifest is invalid - no colon on header line"); + } catch (BuildException ex) { + assertContains("Invalid Manifest", ex.getMessage()); + } + } + + /** + * Malformed manifest - starts with continuation line + */ + @Test + public void test4() { + try { + buildRule.executeTarget("test4"); + fail("BuildException expected: Manifest is invalid - section starts with continuation line"); + } catch (BuildException ex) { + assertContains("Invalid Manifest", ex.getMessage()); + } + } + + /** + * Malformed manifest - Name attribute in main section + */ + @Test + public void test5() { + buildRule.executeTarget("test5"); + String output = buildRule.getLog(); + boolean hasWarning = output.indexOf("Manifest warning: \"Name\" attributes should not occur in the main section") != -1; + assertTrue("Expected warning about Name in main section", hasWarning); + } + + /** + * New Section not starting with Name attribute. + */ + @Test + public void test6() { + try { + buildRule.executeTarget("test6"); + fail("BuildException expected: Manifest is invalid - section starts with incorrect attribute"); + } catch (BuildException ex) { + assertContains("Invalid Manifest", ex.getMessage()); + } + String output = buildRule.getLog(); + boolean hasWarning = output.indexOf("Manifest sections should start with a \"Name\" attribute") != -1; + assertTrue("Expected warning about section not starting with Name: attribute", hasWarning); + } + + + /** + * From attribute is illegal + */ + @Test + public void test7() { + buildRule.executeTarget("test7"); + + boolean hasWarning = buildRule.getLog().indexOf(Manifest.ERROR_FROM_FORBIDDEN) != -1; + assertTrue("Expected warning about From: attribute", hasWarning); + } + + /** + * Inline manifest - OK + */ + @Test + public void test8() throws IOException, ManifestException { + buildRule.executeTarget("test8"); + Manifest manifest = getManifest(expandedManifest); + Manifest.Section mainSection = manifest.getMainSection(); + String classpath = mainSection.getAttributeValue("class-path"); + assertEquals("Class-Path attribute was not set correctly - ", "fubar", classpath); + + Manifest.Section testSection = manifest.getSection("Test"); + String testAttr = testSection.getAttributeValue("TestAttr"); + assertEquals("TestAttr attribute was not set correctly - ", "Test", testAttr); + } + + /** + * Inline manifest - Invalid since has a Name attribute in the section element + */ + @Test + public void test9() { + try { + buildRule.executeTarget("test9"); + fail("BuildException expected: Construction is invalid - Name attribute should not be used"); + } catch (BuildException ex) { + assertContains("Specify the section name using the \"name\" attribute of the <section> element", + ex.getMessage()); + } + } + + /** + * Inline manifest - Invalid attribute without name + */ + @Test + public void test10() { + try { + buildRule.executeTarget("test10"); + fail("BuildException expected: Attribute has no name"); + } catch (BuildException ex) { + assertContains("Attributes must have name and value", ex.getMessage()); + } + } + + /** + * Inline manifest - Invalid attribute without value + */ + @Test + public void test11() { + try { + buildRule.executeTarget("test11"); + fail("BuildException expected: Attribute has no value"); + } catch (BuildException ex) { + assertContains("Attributes must have name and value", ex.getMessage()); + } + } + + /** + * Inline manifest - Invalid attribute without value + */ + @Test + public void test12() { + try { + buildRule.executeTarget("test12"); + fail("BuildException expected: Section with no name"); + } catch (BuildException ex) { + assertContains("Sections must have a name", ex.getMessage()); + } + } + + /** + * Inline manifest - Duplicate attribute + */ + @Test + public void test13() { + try { + buildRule.executeTarget("test13"); + fail("BuildException expected: Duplicate Attribute"); + } catch (BuildException ex) { + assertContains("The attribute \"Test\" may not occur more than once in the same section", ex.getMessage()); + } + } + + /** + * Inline manifest - OK since classpath entries can be duplicated. + */ + @Test + public void test14() throws IOException, ManifestException { + buildRule.executeTarget("test14"); + Manifest manifest = getManifest(expandedManifest); + Manifest.Section mainSection = manifest.getMainSection(); + String classpath = mainSection.getAttributeValue("class-path"); + assertEquals("Class-Path attribute was not set correctly - ", + "Test1 Test2 Test3 Test4", classpath); + } + + /** + * Tets long line wrapping + */ + @Test + public void testLongLine() throws IOException, ManifestException { + Project p = buildRule.getProject(); + p.setUserProperty("test.longline", LONG_LINE); + p.setUserProperty("test.long68name" , LONG_68_NAME); + p.setUserProperty("test.long70name" , LONG_70_NAME); + p.setUserProperty("test.notlongname" , NOT_LONG_NAME); + p.setUserProperty("test.value", VALUE); + buildRule.executeTarget("testLongLine"); + + Manifest manifest = getManifest(expandedManifest); + Manifest.Section mainSection = manifest.getMainSection(); + String classpath = mainSection.getAttributeValue("class-path"); + assertEquals("Class-Path attribute was not set correctly - ", + LONG_LINE, classpath); + + String value = mainSection.getAttributeValue(LONG_68_NAME); + assertEquals("LONG_68_NAME_VALUE_MISMATCH", VALUE, value); + value = mainSection.getAttributeValue(LONG_70_NAME); + assertEquals("LONG_70_NAME_VALUE_MISMATCH", VALUE, value); + value = mainSection.getAttributeValue(NOT_LONG_NAME); + assertEquals("NOT_LONG_NAME_VALUE_MISMATCH", VALUE, value); + + Set set = new HashSet(); + FileReader fin = new FileReader(expandedManifest); + try { + BufferedReader in = new BufferedReader(fin); + + String read = in.readLine(); + while (read != null) { + set.add(read); + read = in.readLine(); + } + in.close(); + } finally { + fin.close(); + } + + assertTrue("Manifest file should have contained string ", set + .remove(" NOT_LONG")); + assertTrue("Manifest file should have contained string ", set + .remove(" NG")); + assertTrue("Manifest file should have contained string ", set + .remove(LONG_70_NAME + ": ")); + assertTrue("Manifest file should have contained string ", set + .remove(NOT_LONG_NAME + ": NOT_LO")); + } + + /** + * Tests ordering of sections + */ + @Test + public void testOrder1() throws IOException, ManifestException { + buildRule.executeTarget("testOrder1"); + + Manifest manifest = getManifest(expandedManifest); + Enumeration e = manifest.getSectionNames(); + String section1 = (String)e.nextElement(); + String section2 = (String)e.nextElement(); + assertEquals("First section name unexpected", "Test1", section1); + assertEquals("Second section name unexpected", "Test2", section2); + + Manifest.Section section = manifest.getSection("Test1"); + e = section.getAttributeKeys(); + String attr1Key = (String)e.nextElement(); + String attr2Key = (String)e.nextElement(); + String attr1 = section.getAttribute(attr1Key).getName(); + String attr2 = section.getAttribute(attr2Key).getName(); + assertEquals("First attribute name unexpected", "TestAttr1", attr1); + assertEquals("Second attribute name unexpected", "TestAttr2", attr2); + } + + /** + * Tests ordering of sections + */ + @Test + public void testOrder2() throws IOException, ManifestException { + buildRule.executeTarget("testOrder2"); + + Manifest manifest = getManifest(expandedManifest); + Enumeration e = manifest.getSectionNames(); + String section1 = (String)e.nextElement(); + String section2 = (String)e.nextElement(); + assertEquals("First section name unexpected", "Test2", section1); + assertEquals("Second section name unexpected", "Test1", section2); + + Manifest.Section section = manifest.getSection("Test1"); + e = section.getAttributeKeys(); + String attr1Key = (String)e.nextElement(); + String attr2Key = (String)e.nextElement(); + String attr1 = section.getAttribute(attr1Key).getName(); + String attr2 = section.getAttribute(attr2Key).getName(); + assertEquals("First attribute name unexpected", "TestAttr2", attr1); + assertEquals("Second attribute name unexpected", "TestAttr1", attr2); + } + + /** + * file attribute for manifest task is required. + */ + @Test + public void testNoFile() { + try { + buildRule.executeTarget("testNoFile"); + fail("BuildException expected: file is required"); + } catch (BuildException ex) { + //TODO assert value + } + } + + /** + * replace changes Manifest-Version from 2.0 to 1.0 + */ + @Test + public void testReplace() throws IOException, ManifestException { + buildRule.executeTarget("testReplace"); + Manifest mf = getManifest(new File(outDir, "mftest.mf")); + assertNotNull(mf); + assertEquals(Manifest.getDefaultManifest(), mf); + } + + /** + * update keeps the Manifest-Version and adds a new attribute Foo + */ + @Test + public void testUpdate() throws IOException, ManifestException { + buildRule.executeTarget("testUpdate"); + Manifest mf = getManifest(new File(outDir, "mftest.mf")); + assertNotNull(mf); + assertTrue(!Manifest.getDefaultManifest().equals(mf)); + String mfAsString = mf.toString(); + assertNotNull(mfAsString); + assertTrue(mfAsString.startsWith("Manifest-Version: 2.0")); + assertTrue(mfAsString.indexOf("Foo: Bar") > -1); + + mf = getManifest(new File(outDir, "mftest2.mf")); + assertNotNull(mf); + mfAsString = mf.toString(); + assertNotNull(mfAsString); + assertEquals(-1, mfAsString.indexOf("Foo: Bar")); + assertTrue(mfAsString.indexOf("Foo: Baz") > -1); + } + + @Test + public void testFrom() { + buildRule.executeTarget("testFrom"); + assertContains(Manifest.ERROR_FROM_FORBIDDEN, buildRule.getLog()); + } + + @Test + public void testIllegalName() { + try { + buildRule.executeTarget("testIllegalName"); + fail("BuildException expected: Manifest attribute names must not contain ' '"); + } catch (BuildException ex) { + //TODO assert value + } + } + + @Test + public void testIllegalNameInSection() { + try { + buildRule.executeTarget("testIllegalNameInSection"); + fail("BuildException expected: Manifest attribute names must not contain ' '"); + } catch (BuildException ex) { + //TODO assert value + } + } + + @Test + public void testIllegalNameBegin() { + try { + buildRule.executeTarget("testIllegalNameInSection"); + fail("BuildException expected: Manifest attribute names must not start with '-' at the begin."); + } catch (BuildException ex) { + //TODO assert value + } + } + + @Test + public void testIllegalName2() { + try { + buildRule.executeTarget("testIllegalName"); + fail("BuildException expected: Manifest attribute names must not contain '.'"); + } catch (BuildException ex) { + //TODO assert value + } + } + + @Test + public void testIllegalName3() { + try { + buildRule.executeTarget("testIllegalName"); + fail("BuildException expected: Manifest attribute names must not contain '*'"); + } catch (BuildException ex) { + //TODO assert value + } + } + + /** + * Reads mftest.mf. + */ + private Manifest getManifest(File file) throws IOException, ManifestException { + FileReader r = new FileReader(file); + try { + return new Manifest(r); + } finally { + r.close(); + } + } +} |