Attachment #127487 for bug #265103




		SKIP_LINE = 6;
	private static final char[] CLASSPATH_HEADER_TOKEN =
		"Class-Path:".toCharArray(); //$NON-NLS-1$
	private int classpathSectionsCount;
	private ArrayList calledFilesNames;
	public boolean analyzeManifestContents(Reader reader) throws IOException {
		int state = START, substate = 0;
		StringBuffer currentJarToken = new StringBuffer();
		int currentChar;
		this.classpathSectionsCount = 0;
		this.calledFilesNames = null;
		for (;;) {
			currentChar = reader.read();

				case PAST_CLASSPATH_HEADER:
					if (currentChar == ' ') {
						state = SKIPPING_WHITESPACE;
						this.classpathSectionsCount++;
					} else {
						return false;
					}
					break;
				case SKIPPING_WHITESPACE:
					if (currentChar == -1) {
						// >>>>>>>>>>>>>>>>>> Add the latest jar read
						addCurrentTokenJarWhenNecessary(currentJarToken);
						return true;
					} else if (currentChar == '\n') {
						state = CONTINUING;
					} else if (currentChar != ' ') {
						currentJarToken.append((char) currentChar);
						state = READING_JAR;
					} else {
						// >>>>>>>>>>>>>>>>>> Add the latest jar read
						addCurrentTokenJarWhenNecessary(currentJarToken);
					}
					break;
				case CONTINUING:
					if (currentChar == -1) {
						// >>>>>>>>>>>>>>>>>> Add the latest jar read
						addCurrentTokenJarWhenNecessary(currentJarToken);
						return true;
					} else if (currentChar == '\n') {
						addCurrentTokenJarWhenNecessary(currentJarToken);
						state = START;
					} else if (currentChar == ' ') {
						state = SKIPPING_WHITESPACE;
					} else if (currentChar == CLASSPATH_HEADER_TOKEN[0]) {
						addCurrentTokenJarWhenNecessary(currentJarToken);
						state = IN_CLASSPATH_HEADER;
						substate = 1;
					} else if (this.calledFilesNames == null) {
						// >>>>>>>>>>>>>>>>>> Add the latest jar read
						addCurrentTokenJarWhenNecessary(currentJarToken);
						state = START;
					} else {
						// >>>>>>>>>>>>>>>>>> Add the latest jar read
						addCurrentTokenJarWhenNecessary(currentJarToken);
						state = SKIP_LINE;
					}
					break;
				case SKIP_LINE:
					if (currentChar == -1) {
						if (this.classpathSectionsCount != 0) {
							if (this.calledFilesNames == null) {
								return false;
							}
						}
						return true;
					} else if (currentChar == '\n') {
						state = START;

					break;
				case READING_JAR:
					if (currentChar == -1) {
						// >>>>>>>>>>>>>>>>>> Add the latest jar read
						return false;
					} else if (currentChar == '\n') {
						// appends token below
						state = CONTINUING;
						// >>>>>>>>>>> Add a break to not add the jar yet as it can continue on the next line
						break;
					} else if (currentChar == ' ') {
						// appends token below
						state = SKIPPING_WHITESPACE;

						currentJarToken.append((char) currentChar);
						break;
					}
					addCurrentTokenJarWhenNecessary(currentJarToken);
						this.calledFilesNames = new ArrayList();
					}
					this.calledFilesNames.add(currentJarToken.toString());
					currentJarToken.setLength(0);
					break;
			}
		}
	}	

	// >>>>>>>>>>>>>>>> Method Extracted from analyzeManifestContents in the READING_JAR Block
	private boolean addCurrentTokenJarWhenNecessary(StringBuffer currentJarToken) {
		if (currentJarToken != null && currentJarToken.length() > 0) {
			if (this.calledFilesNames == null) {
				this.calledFilesNames = new ArrayList();
			}
			this.calledFilesNames.add(currentJarToken.toString());
			currentJarToken.setLength(0);
			return true;
		}
		return false;
	}
	// <<<<<<<<<<<<<<<<<<<<<<


	public int getClasspathSectionsCount() {
		return this.classpathSectionsCount;
	}
	public List getCalledFileNames() {
		return this.calledFilesNames;

Lines 70-75 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/TestAll.java (+1 lines)
70	standardTests.add(SerialVersionUIDTests.class);	70	standardTests.add(SerialVersionUIDTests.class);
71	standardTests.add(LineNumberAttributeTest.class);	71	standardTests.add(LineNumberAttributeTest.class);
72	standardTests.add(ProgrammingProblemsTest.class);	72	standardTests.add(ProgrammingProblemsTest.class);
		73	standardTests.add(ManifestAnalyzerTest.class);
73		74
74	// add all javadoc tests	75	// add all javadoc tests
75	for (int i=0, l=JavadocTest.ALL_CLASSES.size(); i<l; i++) {	76	for (int i=0, l=JavadocTest.ALL_CLASSES.size(); i<l; i++) {




/*******************************************************************************
 * Copyright (c) 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Fabrice Matrat - initial contribution
 *     IBM Corporation - code review and integration
 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;
import java.io.IOException;
import java.io.StringReader;
import java.util.List;

import org.eclipse.jdt.internal.compiler.util.ManifestAnalyzer;

public class ManifestAnalyzerTest extends AbstractRegressionTest {

	private static final String FIRST_JAR = "firstJar.jar";
	private static final String SECOND_JAR = "secondJar.jar";
	private static final String WHITESPACE = " ";

	ManifestAnalyzer manifestAnalyzer = new ManifestAnalyzer();

	public ManifestAnalyzerTest(String name) {
		super(name);
	}
	public void testWithOneJar() throws IOException {
		String testWithOneJar = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + "\nBuild-Reference: Version toto";
		StringReader reader = new StringReader(testWithOneJar);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 1, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
	}

	public void testWithOneJarWithWiteSpace() throws IOException {
		String testWithOneJarWithWiteSpace = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + WHITESPACE + "\nBuild-Reference: Version toto";
		StringReader reader = new StringReader(testWithOneJarWithWiteSpace);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 1, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
	}

	public void testWithSecondJarOnNextLine() throws IOException {
		String testWithSecondJarOnNextLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + "\n"+ WHITESPACE + WHITESPACE +"secondJar.jar\nBuild-Reference: Version toto";
		StringReader reader = new StringReader(testWithSecondJarOnNextLine);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 2, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
		assertEquals(SECOND_JAR, jars.get(1));
	}

	public void testWithSecondJarOnTwoLine() throws IOException {
		String testWithSecondJarOnTwoLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + WHITESPACE + "second\n" + WHITESPACE + "Jar.jar\nBuild-Reference: Version toto";
		StringReader reader = new StringReader(testWithSecondJarOnTwoLine);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 2, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
		assertEquals(SECOND_JAR, jars.get(1));
	}

	public void testWithSecondJarOnTwoLine2() throws IOException {
		String testWithSecondJarOnTwoLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + WHITESPACE + "second\n" + WHITESPACE + WHITESPACE + "Jar.jar\nBuild-Reference: Version toto";
		StringReader reader = new StringReader(testWithSecondJarOnTwoLine);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 3, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
		assertEquals("second", jars.get(1));
		assertEquals("Jar.jar", jars.get(2));
	}

	public void testWithSecondJarOnTwoLine3() throws IOException {
		String testWithSecondJarOnTwoLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + WHITESPACE + "second\n" + "Jar.jar\nBuild-Reference: Version toto";
		StringReader reader = new StringReader(testWithSecondJarOnTwoLine);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 2, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
		assertEquals("second", jars.get(1));
	}

	public void testWithSecondJarOnTwoLine4() throws IOException {
		String testWithSecondJarOnTwoLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + "\n" + "second\n" + WHITESPACE + "Jar.jar\nBuild-Reference: Version toto";
		StringReader reader = new StringReader(testWithSecondJarOnTwoLine);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 1, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
	}

	public void testWithSecondJarOnNextLine5() throws IOException {
		String testWithSecondJarOnNextLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + "\n"+ WHITESPACE + "secondJar.jar\nBuild-Reference: Version toto";
		StringReader reader = new StringReader(testWithSecondJarOnNextLine);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 1, jars.size());
		assertEquals(FIRST_JAR + SECOND_JAR, jars.get(0));
	}

	public void testWithSecondJarOnTwoLineEndedWithEOF() throws IOException {
		String testWithSecondJarOnTwoLineEndedWithEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar";
		StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithEOF);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 1, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
	}

	public void testWithSecondJarOnTwoLineEndedWithEOF2() throws IOException {
		String testWithSecondJarOnTwoLineEndedWithEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar\n";
		StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithEOF);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 2, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
		assertEquals(SECOND_JAR, jars.get(1));
	}

	public void testWithSecondJarOnTwoLineEndedWithWhiteSpaceEOF() throws IOException {
		String testWithSecondJarOnTwoLineEndedWithWhiteSpaceEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar ";
		StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithWhiteSpaceEOF);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 2, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
		assertEquals(SECOND_JAR, jars.get(1));
	}

	public void testWithSecondJarOnTwoLineEndedWithWhiteSpaceNewLineEOF() throws IOException {
		String testWithSecondJarOnTwoLineEndedWithWhiteSpaceNewLineEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar \n";
		StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithWhiteSpaceNewLineEOF);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 2, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
		assertEquals(SECOND_JAR, jars.get(1));
	}

	public void testWithSecondJarOnTwoLineEndedWithNewLineEOF() throws IOException {
		String testWithSecondJarOnTwoLineEndedWithNewLineEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar\n";
		StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithNewLineEOF);
		this.manifestAnalyzer.analyzeManifestContents(reader);
		List jars = this.manifestAnalyzer.getCalledFileNames();
		assertEquals("Wrong size", 2, jars.size());
		assertEquals(FIRST_JAR, jars.get(0));
		assertEquals(SECOND_JAR, jars.get(1));
	}
}

Return to bug 265103

Lines 26-38 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/util/ManifestAnalyzer.java (-10 / +43 lines)
26	SKIP_LINE = 6;	26	SKIP_LINE = 6;
27	private static final char[] CLASSPATH_HEADER_TOKEN =	27	private static final char[] CLASSPATH_HEADER_TOKEN =
28	"Class-Path:".toCharArray(); //$NON-NLS-1$	28	"Class-Path:".toCharArray(); //$NON-NLS-1$
29	private int ClasspathSectionsCount;	29	private int classpathSectionsCount;
30	private ArrayList calledFilesNames;	30	private ArrayList calledFilesNames;
31	public boolean analyzeManifestContents(Reader reader) throws IOException {	31	public boolean analyzeManifestContents(Reader reader) throws IOException {
32	int state = START, substate = 0;	32	int state = START, substate = 0;
33	StringBuffer currentJarToken = new StringBuffer();	33	StringBuffer currentJarToken = new StringBuffer();
34	int currentChar;	34	int currentChar;
35	this.ClasspathSectionsCount = 0;	35	this.classpathSectionsCount = 0;
36	this.calledFilesNames = null;	36	this.calledFilesNames = null;
37	for (;;) {	37	for (;;) {
38	currentChar = reader.read();	38	currentChar = reader.read();
Lines 63-101 Link Here
63	case PAST_CLASSPATH_HEADER:	63	case PAST_CLASSPATH_HEADER:
64	if (currentChar == ' ') {	64	if (currentChar == ' ') {
65	state = SKIPPING_WHITESPACE;	65	state = SKIPPING_WHITESPACE;
66	this.ClasspathSectionsCount++;	66	this.classpathSectionsCount++;
67	} else {	67	} else {
68	return false;	68	return false;
69	}	69	}
70	break;	70	break;
71	case SKIPPING_WHITESPACE:	71	case SKIPPING_WHITESPACE:
72	if (currentChar == -1) {	72	if (currentChar == -1) {
		73	// >>>>>>>>>>>>>>>>>> Add the latest jar read
		74	addCurrentTokenJarWhenNecessary(currentJarToken);
73	return true;	75	return true;
74	} else if (currentChar == '\n') {	76	} else if (currentChar == '\n') {
75	state = CONTINUING;	77	state = CONTINUING;
76	} else if (currentChar != ' ') {	78	} else if (currentChar != ' ') {
77	currentJarToken.append((char) currentChar);	79	currentJarToken.append((char) currentChar);
78	state = READING_JAR;	80	state = READING_JAR;
		81	} else {
		82	// >>>>>>>>>>>>>>>>>> Add the latest jar read
		83	addCurrentTokenJarWhenNecessary(currentJarToken);
79	}	84	}
80	break;	85	break;
81	case CONTINUING:	86	case CONTINUING:
82	if (currentChar == -1) {	87	if (currentChar == -1) {
		88	// >>>>>>>>>>>>>>>>>> Add the latest jar read
		89	addCurrentTokenJarWhenNecessary(currentJarToken);
83	return true;	90	return true;
84	} else if (currentChar == '\n') {	91	} else if (currentChar == '\n') {
		92	addCurrentTokenJarWhenNecessary(currentJarToken);
85	state = START;	93	state = START;
86	} else if (currentChar == ' ') {	94	} else if (currentChar == ' ') {
87	state = SKIPPING_WHITESPACE;	95	state = SKIPPING_WHITESPACE;
88	} else if (currentChar == CLASSPATH_HEADER_TOKEN[0]) {	96	} else if (currentChar == CLASSPATH_HEADER_TOKEN[0]) {
		97	addCurrentTokenJarWhenNecessary(currentJarToken);
89	state = IN_CLASSPATH_HEADER;	98	state = IN_CLASSPATH_HEADER;
90	substate = 1;	99	substate = 1;
91	} else if (this.calledFilesNames == null) {	100	} else if (this.calledFilesNames == null) {
92	return false;	101	// >>>>>>>>>>>>>>>>>> Add the latest jar read
		102	addCurrentTokenJarWhenNecessary(currentJarToken);
		103	state = START;
93	} else {	104	} else {
		105	// >>>>>>>>>>>>>>>>>> Add the latest jar read
		106	addCurrentTokenJarWhenNecessary(currentJarToken);
94	state = SKIP_LINE;	107	state = SKIP_LINE;
95	}	108	}
96	break;	109	break;
97	case SKIP_LINE:	110	case SKIP_LINE:
98	if (currentChar == -1) {	111	if (currentChar == -1) {
		112	if (this.classpathSectionsCount != 0) {
		113	if (this.calledFilesNames == null) {
		114	return false;
		115	}
		116	}
99	return true;	117	return true;
100	} else if (currentChar == '\n') {	118	} else if (currentChar == '\n') {
101	state = START;	119	state = START;
Lines 103-112 Link Here
103	break;	121	break;
104	case READING_JAR:	122	case READING_JAR:
105	if (currentChar == -1) {	123	if (currentChar == -1) {
		124	// >>>>>>>>>>>>>>>>>> Add the latest jar read
106	return false;	125	return false;
107	} else if (currentChar == '\n') {	126	} else if (currentChar == '\n') {
108	// appends token below	127	// appends token below
109	state = CONTINUING;	128	state = CONTINUING;
		129	// >>>>>>>>>>> Add a break to not add the jar yet as it can continue on the next line
		130	break;
110	} else if (currentChar == ' ') {	131	} else if (currentChar == ' ') {
111	// appends token below	132	// appends token below
112	state = SKIPPING_WHITESPACE;	133	state = SKIPPING_WHITESPACE;
Lines 114-130 Link Here
114	currentJarToken.append((char) currentChar);	135	currentJarToken.append((char) currentChar);
115	break;	136	break;
116	}	137	}
117	if (this.calledFilesNames == null) {	138	addCurrentTokenJarWhenNecessary(currentJarToken);
118	this.calledFilesNames = new ArrayList();
119	}
120	this.calledFilesNames.add(currentJarToken.toString());
121	currentJarToken.setLength(0);
122	break;	139	break;
123	}	140	}
124	}	141	}
		142	}
		143
		144	// >>>>>>>>>>>>>>>> Method Extracted from analyzeManifestContents in the READING_JAR Block
		145	private boolean addCurrentTokenJarWhenNecessary(StringBuffer currentJarToken) {
		146	if (currentJarToken != null && currentJarToken.length() > 0) {
		147	if (this.calledFilesNames == null) {
		148	this.calledFilesNames = new ArrayList();
		149	}
		150	this.calledFilesNames.add(currentJarToken.toString());
		151	currentJarToken.setLength(0);
		152	return true;
		153	}
		154	return false;
125	}	155	}
		156	// <<<<<<<<<<<<<<<<<<<<<<
		157
		158
126	public int getClasspathSectionsCount() {	159	public int getClasspathSectionsCount() {
127	return this.ClasspathSectionsCount;	160	return this.classpathSectionsCount;
128	}	161	}
129	public List getCalledFileNames() {	162	public List getCalledFileNames() {
130	return this.calledFilesNames;	163	return this.calledFilesNames;

Added Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/ManifestAnalyzerTest.java (+155 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Fabrice Matrat - initial contribution
10	* IBM Corporation - code review and integration
11	*******************************************************************************/
12	package org.eclipse.jdt.core.tests.compiler.regression;
13	import java.io.IOException;
14	import java.io.StringReader;
15	import java.util.List;
16
17	import org.eclipse.jdt.internal.compiler.util.ManifestAnalyzer;
18
19	public class ManifestAnalyzerTest extends AbstractRegressionTest {
20
21	private static final String FIRST_JAR = "firstJar.jar";
22	private static final String SECOND_JAR = "secondJar.jar";
23	private static final String WHITESPACE = " ";
24
25	ManifestAnalyzer manifestAnalyzer = new ManifestAnalyzer();
26
27	public ManifestAnalyzerTest(String name) {
28	super(name);
29	}
30	public void testWithOneJar() throws IOException {
31	String testWithOneJar = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + "\nBuild-Reference: Version toto";
32	StringReader reader = new StringReader(testWithOneJar);
33	this.manifestAnalyzer.analyzeManifestContents(reader);
34	List jars = this.manifestAnalyzer.getCalledFileNames();
35	assertEquals("Wrong size", 1, jars.size());
36	assertEquals(FIRST_JAR, jars.get(0));
37	}
38
39	public void testWithOneJarWithWiteSpace() throws IOException {
40	String testWithOneJarWithWiteSpace = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + WHITESPACE + "\nBuild-Reference: Version toto";
41	StringReader reader = new StringReader(testWithOneJarWithWiteSpace);
42	this.manifestAnalyzer.analyzeManifestContents(reader);
43	List jars = this.manifestAnalyzer.getCalledFileNames();
44	assertEquals("Wrong size", 1, jars.size());
45	assertEquals(FIRST_JAR, jars.get(0));
46	}
47
48	public void testWithSecondJarOnNextLine() throws IOException {
49	String testWithSecondJarOnNextLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + "\n"+ WHITESPACE + WHITESPACE +"secondJar.jar\nBuild-Reference: Version toto";
50	StringReader reader = new StringReader(testWithSecondJarOnNextLine);
51	this.manifestAnalyzer.analyzeManifestContents(reader);
52	List jars = this.manifestAnalyzer.getCalledFileNames();
53	assertEquals("Wrong size", 2, jars.size());
54	assertEquals(FIRST_JAR, jars.get(0));
55	assertEquals(SECOND_JAR, jars.get(1));
56	}
57
58	public void testWithSecondJarOnTwoLine() throws IOException {
59	String testWithSecondJarOnTwoLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + WHITESPACE + "second\n" + WHITESPACE + "Jar.jar\nBuild-Reference: Version toto";
60	StringReader reader = new StringReader(testWithSecondJarOnTwoLine);
61	this.manifestAnalyzer.analyzeManifestContents(reader);
62	List jars = this.manifestAnalyzer.getCalledFileNames();
63	assertEquals("Wrong size", 2, jars.size());
64	assertEquals(FIRST_JAR, jars.get(0));
65	assertEquals(SECOND_JAR, jars.get(1));
66	}
67
68	public void testWithSecondJarOnTwoLine2() throws IOException {
69	String testWithSecondJarOnTwoLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + WHITESPACE + "second\n" + WHITESPACE + WHITESPACE + "Jar.jar\nBuild-Reference: Version toto";
70	StringReader reader = new StringReader(testWithSecondJarOnTwoLine);
71	this.manifestAnalyzer.analyzeManifestContents(reader);
72	List jars = this.manifestAnalyzer.getCalledFileNames();
73	assertEquals("Wrong size", 3, jars.size());
74	assertEquals(FIRST_JAR, jars.get(0));
75	assertEquals("second", jars.get(1));
76	assertEquals("Jar.jar", jars.get(2));
77	}
78
79	public void testWithSecondJarOnTwoLine3() throws IOException {
80	String testWithSecondJarOnTwoLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + WHITESPACE + "second\n" + "Jar.jar\nBuild-Reference: Version toto";
81	StringReader reader = new StringReader(testWithSecondJarOnTwoLine);
82	this.manifestAnalyzer.analyzeManifestContents(reader);
83	List jars = this.manifestAnalyzer.getCalledFileNames();
84	assertEquals("Wrong size", 2, jars.size());
85	assertEquals(FIRST_JAR, jars.get(0));
86	assertEquals("second", jars.get(1));
87	}
88
89	public void testWithSecondJarOnTwoLine4() throws IOException {
90	String testWithSecondJarOnTwoLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + "\n" + "second\n" + WHITESPACE + "Jar.jar\nBuild-Reference: Version toto";
91	StringReader reader = new StringReader(testWithSecondJarOnTwoLine);
92	this.manifestAnalyzer.analyzeManifestContents(reader);
93	List jars = this.manifestAnalyzer.getCalledFileNames();
94	assertEquals("Wrong size", 1, jars.size());
95	assertEquals(FIRST_JAR, jars.get(0));
96	}
97
98	public void testWithSecondJarOnNextLine5() throws IOException {
99	String testWithSecondJarOnNextLine = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + "\n"+ WHITESPACE + "secondJar.jar\nBuild-Reference: Version toto";
100	StringReader reader = new StringReader(testWithSecondJarOnNextLine);
101	this.manifestAnalyzer.analyzeManifestContents(reader);
102	List jars = this.manifestAnalyzer.getCalledFileNames();
103	assertEquals("Wrong size", 1, jars.size());
104	assertEquals(FIRST_JAR + SECOND_JAR, jars.get(0));
105	}
106
107	public void testWithSecondJarOnTwoLineEndedWithEOF() throws IOException {
108	String testWithSecondJarOnTwoLineEndedWithEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar";
109	StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithEOF);
110	this.manifestAnalyzer.analyzeManifestContents(reader);
111	List jars = this.manifestAnalyzer.getCalledFileNames();
112	assertEquals("Wrong size", 1, jars.size());
113	assertEquals(FIRST_JAR, jars.get(0));
114	}
115
116	public void testWithSecondJarOnTwoLineEndedWithEOF2() throws IOException {
117	String testWithSecondJarOnTwoLineEndedWithEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar\n";
118	StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithEOF);
119	this.manifestAnalyzer.analyzeManifestContents(reader);
120	List jars = this.manifestAnalyzer.getCalledFileNames();
121	assertEquals("Wrong size", 2, jars.size());
122	assertEquals(FIRST_JAR, jars.get(0));
123	assertEquals(SECOND_JAR, jars.get(1));
124	}
125
126	public void testWithSecondJarOnTwoLineEndedWithWhiteSpaceEOF() throws IOException {
127	String testWithSecondJarOnTwoLineEndedWithWhiteSpaceEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar ";
128	StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithWhiteSpaceEOF);
129	this.manifestAnalyzer.analyzeManifestContents(reader);
130	List jars = this.manifestAnalyzer.getCalledFileNames();
131	assertEquals("Wrong size", 2, jars.size());
132	assertEquals(FIRST_JAR, jars.get(0));
133	assertEquals(SECOND_JAR, jars.get(1));
134	}
135
136	public void testWithSecondJarOnTwoLineEndedWithWhiteSpaceNewLineEOF() throws IOException {
137	String testWithSecondJarOnTwoLineEndedWithWhiteSpaceNewLineEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar \n";
138	StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithWhiteSpaceNewLineEOF);
139	this.manifestAnalyzer.analyzeManifestContents(reader);
140	List jars = this.manifestAnalyzer.getCalledFileNames();
141	assertEquals("Wrong size", 2, jars.size());
142	assertEquals(FIRST_JAR, jars.get(0));
143	assertEquals(SECOND_JAR, jars.get(1));
144	}
145
146	public void testWithSecondJarOnTwoLineEndedWithNewLineEOF() throws IOException {
147	String testWithSecondJarOnTwoLineEndedWithNewLineEOF = "Manifest-Version: 1.0\nAnt-Version: Apache Ant 1.6.5\nCreated-By: 1.5.0_14-b03 (Sun Microsystems Inc.)\nClass-Path: " + FIRST_JAR + " second\n Jar.jar\n";
148	StringReader reader = new StringReader(testWithSecondJarOnTwoLineEndedWithNewLineEOF);
149	this.manifestAnalyzer.analyzeManifestContents(reader);
150	List jars = this.manifestAnalyzer.getCalledFileNames();
151	assertEquals("Wrong size", 2, jars.size());
152	assertEquals(FIRST_JAR, jars.get(0));
153	assertEquals(SECOND_JAR, jars.get(1));
154	}
155	}