source: other-projects/trunk/gs3-release-maker/apache-ant-1.6.5/src/testcases/org/apache/tools/ant/taskdefs/ManifestTest.java@ 14627

Last change on this file since 14627 was 14627, checked in by oranfry, 17 years ago

initial import of the gs3-release-maker
File size: 11.1 KB
Line 
1/*
2 * Copyright 2001-2002,2004 The Apache Software Foundation
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
18package org.apache.tools.ant.taskdefs;
19
20import java.io.File;
21import java.io.FileReader;
22import java.io.IOException;
23import java.util.Date;
24import java.util.Vector;
25import java.util.Enumeration;
26import org.apache.tools.ant.BuildFileTest;
27import org.apache.tools.ant.Project;
28
29/**
30 * Testcase for the Manifest class used in the jar task.
31 *
32 */
33public class ManifestTest extends BuildFileTest {
34
35 public static final String EXPANDED_MANIFEST
36 = "src/etc/testcases/taskdefs/manifests/META-INF/MANIFEST.MF";
37
38 public static final String LONG_LINE
39 = "AReallyLongLineToTestLineBreakingInManifests-ACapabilityWhich" +
40 "IsSureToLeadToHundredsOfQuestionsAboutWhyAntMungesManifests" +
41 "OfCourseTheAnswerIsThatIsWhatTheSpecRequiresAndIfAnythingHas" +
42 "AProblemWithThatItIsNotABugInAnt";
43
44 public ManifestTest(String name) {
45 super(name);
46 }
47
48 public void setUp() {
49 configureProject("src/etc/testcases/taskdefs/manifest.xml");
50 }
51
52 public void tearDown() {
53 executeTarget("clean");
54 }
55
56 /**
57 * Empty manifest - is OK
58 */
59 public void test1() throws ManifestException, IOException {
60 executeTarget("test1");
61 Manifest manifest = getManifest(EXPANDED_MANIFEST);
62 String version = manifest.getManifestVersion();
63 assertEquals("Manifest was not created with correct version - ", "1.0", version);
64 }
65
66 /**
67 * Simple Manifest with version 2.0
68 */
69 public void test2() throws ManifestException, IOException {
70 executeTarget("test2");
71 Manifest manifest = getManifest(EXPANDED_MANIFEST);
72 String version = manifest.getManifestVersion();
73 assertEquals("Manifest was not created with correct version - ", "2.0", version);
74 }
75
76 /**
77 * Malformed manifest - no : on the line
78 */
79 public void test3() {
80 expectBuildExceptionContaining("test3", "Manifest is invalid - no colon on header line",
81 "Invalid Manifest");
82 }
83
84 /**
85 * Malformed manifest - starts with continuation line
86 */
87 public void test4() {
88 expectBuildExceptionContaining("test4", "Manifest is invalid - section starts with continuation line",
89 "Invalid Manifest");
90 }
91
92 /**
93 * Malformed manifest - Name attribute in main section
94 */
95 public void test5() {
96 executeTarget("test5");
97 String output = getLog();
98 boolean hasWarning = output.indexOf("Manifest warning: \"Name\" attributes should not occur in the main section") != -1;
99 assertEquals("Expected warning about Name in main section", true, hasWarning);
100 }
101
102 /**
103 * New Section not starting with Name attribute.
104 */
105 public void test6() {
106 expectBuildExceptionContaining("test6", "Manifest is invalid - section starts with incorrect attribute",
107 "Invalid Manifest");
108 String output = getLog();
109 boolean hasWarning = output.indexOf("Manifest sections should start with a \"Name\" attribute") != -1;
110 assertEquals("Expected warning about section not starting with Name: attribute", true, hasWarning);
111 }
112
113 /**
114 * From attribute is illegal
115 */
116 public void test7() {
117 executeTarget("test7");
118
119 boolean hasWarning = getLog().indexOf("Manifest attributes should not start with \"From\"") != -1;
120 assertEquals("Expected warning about From: attribute", true, hasWarning);
121 }
122
123 /**
124 * Inline manifest - OK
125 */
126 public void test8() throws IOException, ManifestException {
127 executeTarget("test8");
128 Manifest manifest = getManifest(EXPANDED_MANIFEST);
129 Manifest.Section mainSection = manifest.getMainSection();
130 String classpath = mainSection.getAttributeValue("class-path");
131 assertEquals("Class-Path attribute was not set correctly - ", "fubar", classpath);
132
133 Manifest.Section testSection = manifest.getSection("Test");
134 String testAttr = testSection.getAttributeValue("TestAttr");
135 assertEquals("TestAttr attribute was not set correctly - ", "Test", testAttr);
136 }
137
138 /**
139 * Inline manifest - Invalid since has a Name attribute in the section element
140 */
141 public void test9() {
142 expectBuildExceptionContaining("test9", "Construction is invalid - Name attribute should not be used",
143 "Specify the section name using the \"name\" attribute of the <section> element");
144 }
145
146 /**
147 * Inline manifest - Invalid attribute without name
148 */
149 public void test10() {
150 expectBuildExceptionContaining("test10", "Attribute has no name",
151 "Attributes must have name and value");
152 }
153
154 /**
155 * Inline manifest - Invalid attribute without value
156 */
157 public void test11() {
158 expectBuildExceptionContaining("test11", "Attribute has no value",
159 "Attributes must have name and value");
160 }
161
162 /**
163 * Inline manifest - Invalid attribute without value
164 */
165 public void test12() {
166 expectBuildExceptionContaining("test12", "Section with no name",
167 "Sections must have a name");
168 }
169
170 /**
171 * Inline manifest - Duplicate attribute
172 */
173 public void test13() {
174 expectBuildExceptionContaining("test13", "Duplicate Attribute",
175 "The attribute \"Test\" may not occur more than once in the same section");
176 }
177
178 /**
179 * Inline manifest - OK since classpath entries can be duplicated.
180 */
181 public void test14() throws IOException, ManifestException {
182 executeTarget("test14");
183 Manifest manifest = getManifest(EXPANDED_MANIFEST);
184 Manifest.Section mainSection = manifest.getMainSection();
185 String classpath = mainSection.getAttributeValue("class-path");
186 assertEquals("Class-Path attribute was not set correctly - ",
187 "Test1 Test2 Test3 Test4", classpath);
188 }
189
190 /**
191 * Tets long line wrapping
192 */
193 public void testLongLine() throws IOException, ManifestException {
194 Project project = getProject();
195 project.setUserProperty("test.longline", LONG_LINE);
196 executeTarget("testLongLine");
197
198 Manifest manifest = getManifest(EXPANDED_MANIFEST);
199 Manifest.Section mainSection = manifest.getMainSection();
200 String classpath = mainSection.getAttributeValue("class-path");
201 assertEquals("Class-Path attribute was not set correctly - ",
202 LONG_LINE, classpath);
203 }
204
205 /**
206 * Tests ordering of sections
207 */
208 public void testOrder1() throws IOException, ManifestException {
209 executeTarget("testOrder1");
210
211 Manifest manifest = getManifest(EXPANDED_MANIFEST);
212 Enumeration e = manifest.getSectionNames();
213 String section1 = (String)e.nextElement();
214 String section2 = (String)e.nextElement();
215 assertEquals("First section name unexpected", "Test1", section1);
216 assertEquals("Second section name unexpected", "Test2", section2);
217
218 Manifest.Section section = manifest.getSection("Test1");
219 e = section.getAttributeKeys();
220 String attr1Key = (String)e.nextElement();
221 String attr2Key = (String)e.nextElement();
222 String attr1 = section.getAttribute(attr1Key).getName();
223 String attr2 = section.getAttribute(attr2Key).getName();
224 assertEquals("First attribute name unexpected", "TestAttr1", attr1);
225 assertEquals("Second attribute name unexpected", "TestAttr2", attr2);
226 }
227
228 /**
229 * Tests ordering of sections
230 */
231 public void testOrder2() throws IOException, ManifestException {
232 executeTarget("testOrder2");
233
234 Manifest manifest = getManifest(EXPANDED_MANIFEST);
235 Enumeration e = manifest.getSectionNames();
236 String section1 = (String)e.nextElement();
237 String section2 = (String)e.nextElement();
238 assertEquals("First section name unexpected", "Test2", section1);
239 assertEquals("Second section name unexpected", "Test1", section2);
240
241 Manifest.Section section = manifest.getSection("Test1");
242 e = section.getAttributeKeys();
243 String attr1Key = (String)e.nextElement();
244 String attr2Key = (String)e.nextElement();
245 String attr1 = section.getAttribute(attr1Key).getName();
246 String attr2 = section.getAttribute(attr2Key).getName();
247 assertEquals("First attribute name unexpected", "TestAttr2", attr1);
248 assertEquals("Second attribute name unexpected", "TestAttr1", attr2);
249 }
250
251 /**
252 * file attribute for manifest task is required.
253 */
254 public void testNoFile() {
255 expectBuildException("testNoFile", "file is required");
256 }
257
258 /**
259 * replace changes Manifest-Version from 2.0 to 1.0
260 */
261 public void testReplace() throws IOException, ManifestException {
262 executeTarget("testReplace");
263 Manifest mf = getManifest("src/etc/testcases/taskdefs/mftest.mf");
264 assertNotNull(mf);
265 assertEquals(Manifest.getDefaultManifest(), mf);
266 }
267
268 /**
269 * update keeps the Manifest-Version and adds a new attribute Foo
270 */
271 public void testUpdate() throws IOException, ManifestException {
272 executeTarget("testUpdate");
273 Manifest mf = getManifest("src/etc/testcases/taskdefs/mftest.mf");
274 assertNotNull(mf);
275 assertTrue(!Manifest.getDefaultManifest().equals(mf));
276 String mfAsString = mf.toString();
277 assertNotNull(mfAsString);
278 assertTrue(mfAsString.startsWith("Manifest-Version: 2.0"));
279 assertTrue(mfAsString.indexOf("Foo: Bar") > -1);
280
281 mf = getManifest("src/etc/testcases/taskdefs/mftest2.mf");
282 assertNotNull(mf);
283 mfAsString = mf.toString();
284 assertNotNull(mfAsString);
285 assertEquals(-1, mfAsString.indexOf("Foo: Bar"));
286 assertTrue(mfAsString.indexOf("Foo: Baz") > -1);
287 }
288
289 /**
290 * Reads mftest.mf.
291 */
292 private Manifest getManifest(String filename) throws IOException, ManifestException {
293 FileReader r = new FileReader(filename);
294 try {
295 return new Manifest(r);
296 } finally {
297 r.close();
298 }
299 }
300}
Note: See TracBrowser for help on using the repository browser.