Attachment #158095 for bug #301562

View | Details | Raw Unified | Return to bug 301562
Collapse All | Expand All




			if (File.separatorChar == '/') {
				if (!path.endsWith(normalizedPackageName)) return;
			} else if (!path.endsWith(normalizedPackageName.replace('/', File.separatorChar))) return;
			File[] files = currentFile.listFiles();
			if (files != null) {
				// this was a directory
				for (File f : files) {
					if (f.isDirectory() && recurse) {
						collectAllMatchingFiles(file, normalizedPackageName + '/' + f.getName(), kinds, recurse, collector);
					} else {
						final Kind kind = getKind(f);
						if (kinds.contains(kind)) {
							collector.add(new EclipseFileObject(normalizedPackageName + f.getName(), f.toURI(), kind, this.charset));
						}
					}
				}
   			}
			// currentFile is not a directory
			// check if it matches the criteria
			final Kind kind = getKind(file);
			if (kinds.contains(kind)) {
				collector.add(new EclipseFileObject(normalizedPackageName + currentFile.getName(), currentFile.toURI(), kind, this.charset));
			}
		} else {
			Archive archive = this.getArchive(file);

						ArrayList<String> types = archive.getTypes(packageName);
						if (types != null) {
							for (String typeName : types) {
								final Kind kind = getKind(getExtension(typeName));
								if (kinds.contains(kind)) {
									collector.add(archive.getArchiveFileObject(packageName + typeName, this.charset));
								}
							}
						}
					}

				ArrayList<String> types = archive.getTypes(key);
				if (types != null) {
					for (String typeName : types) {
						final Kind kind = getKind(typeName);
						if (kinds.contains(kind)) {
							collector.add(archive.getArchiveFileObject(normalizedPackageName + typeName, this.charset));
						}
					}
				}
			}

Lines 22-27 Link Here

(-)src/org/eclipse/jdt/compiler/apt/tests/AllTests.java (+1 lines)
22	// run all tests	22	// run all tests
23	public static Test suite() {	23	public static Test suite() {
24	TestSuite suite = new TestSuite();	24	TestSuite suite = new TestSuite();
		25	suite.addTestSuite(FileManagerTests.class);
25	suite.addTestSuite(BatchDispatchTests.class);	26	suite.addTestSuite(BatchDispatchTests.class);
26	suite.addTestSuite(ModelTests.class);	27	suite.addTestSuite(ModelTests.class);
27	suite.addTestSuite(MessagerTests.class);	28	suite.addTestSuite(MessagerTests.class);




/*******************************************************************************
 * Copyright (c) 2007 BEA Systems, Inc. 
 * 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:
 *    wharley@bea.com - initial API and implementation
 *    
 *******************************************************************************/

package org.eclipse.jdt.compiler.apt.tests;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Set;

import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;

import org.eclipse.jdt.internal.compiler.apt.util.EclipseFileManager;

import junit.framework.TestCase;

/**
 * Test the implementation of the Filer interface,
 * in more detail than BatchDispatchTests does.
 * @since 3.4
 */
public class FileManagerTests extends TestCase {

	/* (non-Javadoc)
	 * @see junit.framework.TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		super.setUp();
		BatchTestUtils.init();
	}

	public void testFileManager() {
		String tmpFolder = System.getProperty("java.io.tmpdir");
		File dir = new File(tmpFolder, "src" + System.currentTimeMillis());
		dir.mkdirs();
		File inputFile = new File(dir, "X.java");
		BufferedWriter writer = null;
		try {
			writer = new BufferedWriter(new FileWriter(inputFile));
			writer.write("public class X {}");
			writer.flush();
			writer.close();
		} catch (IOException e) {
			// ignore
		} finally {
			if (writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					// ignore
				}
			}
		}
		try {
			StandardJavaFileManager fileManager = new EclipseFileManager(Locale.getDefault(), Charset.defaultCharset());
	
			List<File> fins = new ArrayList<File>();
			fins.add(dir);
	
			JavaFileManager.Location sourceLoc = javax.tools.StandardLocation.SOURCE_PATH;
			fileManager.setLocation(sourceLoc, fins);
	
			Set<JavaFileObject.Kind> fileTypes = new HashSet<JavaFileObject.Kind>();
			fileTypes.add(JavaFileObject.Kind.SOURCE);
	
			Iterable<? extends JavaFileObject> compilationUnits = fileManager.list(sourceLoc, "", fileTypes, true);
	
			Iterator<? extends JavaFileObject> it = compilationUnits.iterator();
			StringBuilder builder = new StringBuilder();
			while (it.hasNext()) {
				JavaFileObject next = it.next();
				String name = next.getName();
				name = name.replace('\\', '/');
				int lastIndexOf = name.lastIndexOf('/');
				builder.append(name.substring(lastIndexOf + 1));
			}
			assertEquals("Wrong contents", "X.java", String.valueOf(builder));
		} catch (IOException e) {
			e.printStackTrace();
		}
		// check that the .class file exist for X
		assertTrue("delete failed", inputFile.delete());
		assertTrue("delete failed", dir.delete());
	}
}




			if (File.separatorChar == '/') {
				if (!path.endsWith(normalizedPackageName)) return;
			} else if (!path.endsWith(normalizedPackageName.replace('/', File.separatorChar))) return;
			File[] files = currentFile.listFiles();
			if (files != null) {
				// this was a directory
				for (File f : files) {
					if (f.isDirectory() && recurse) {
						collectAllMatchingFiles(file, normalizedPackageName + '/' + f.getName(), kinds, recurse, collector);
					} else {
						final Kind kind = getKind(f);
						if (kinds.contains(kind)) {
							collector.add(new EclipseFileObject(normalizedPackageName + f.getName(), f.toURI(), kind, this.charset));
						}
					}
				}
   			}
			// currentFile is not a directory
			// check if it matches the criteria
			final Kind kind = getKind(file);
			if (kinds.contains(kind)) {
				collector.add(new EclipseFileObject(normalizedPackageName + currentFile.getName(), currentFile.toURI(), kind, this.charset));
			}
		} else {
			Archive archive = this.getArchive(file);

						ArrayList<String> types = archive.getTypes(packageName);
						if (types != null) {
							for (String typeName : types) {
								final Kind kind = getKind(getExtension(typeName));
								if (kinds.contains(kind)) {
									collector.add(archive.getArchiveFileObject(packageName + typeName, this.charset));
								}
							}
						}
					}

				ArrayList<String> types = archive.getTypes(key);
				if (types != null) {
					for (String typeName : types) {
						final Kind kind = getKind(typeName);
						if (kinds.contains(kind)) {
							collector.add(archive.getArchiveFileObject(normalizedPackageName + typeName, this.charset));
						}
					}
				}
			}

Lines 19-31 Link Here

(-)src/org/eclipse/jdt/compiler/tool/tests/CompilerToolTests.java (+136 lines)
19	import java.io.StringWriter;	19	import java.io.StringWriter;
20	import java.nio.charset.Charset;	20	import java.nio.charset.Charset;
21	import java.util.ArrayList;	21	import java.util.ArrayList;
		22	import java.util.HashSet;
		23	import java.util.Iterator;
22	import java.util.List;	24	import java.util.List;
23	import java.util.Locale;	25	import java.util.Locale;
24	import java.util.ServiceLoader;	26	import java.util.ServiceLoader;
		27	import java.util.Set;
25		28
26	import javax.tools.FileObject;	29	import javax.tools.FileObject;
27	import javax.tools.ForwardingJavaFileManager;	30	import javax.tools.ForwardingJavaFileManager;
28	import javax.tools.JavaCompiler;	31	import javax.tools.JavaCompiler;
		32	import javax.tools.JavaFileManager;
29	import javax.tools.JavaFileObject;	33	import javax.tools.JavaFileObject;
30	import javax.tools.StandardJavaFileManager;	34	import javax.tools.StandardJavaFileManager;
31	import javax.tools.StandardLocation;	35	import javax.tools.StandardLocation;
Lines 51-56 Link Here
51	public static TestSuite suite() {	55	public static TestSuite suite() {
52	TestSuite suite = new TestSuite();	56	TestSuite suite = new TestSuite();
53	suite.addTest(new CompilerToolTests("testInitializeJavaCompiler"));	57	suite.addTest(new CompilerToolTests("testInitializeJavaCompiler"));
		58	suite.addTest(new CompilerToolTests("testFileManager"));
		59	suite.addTest(new CompilerToolTests("testFileManager2"));
54	suite.addTest(new CompilerToolTests("testCheckOptions"));	60	suite.addTest(new CompilerToolTests("testCheckOptions"));
55	suite.addTest(new CompilerToolTests("testCompilerOneClassWithSystemCompiler"));	61	suite.addTest(new CompilerToolTests("testCompilerOneClassWithSystemCompiler"));
56	// suite.addTest(new CompilerToolTests("testCompilerOneClassWithSystemCompiler2"));	62	// suite.addTest(new CompilerToolTests("testCompilerOneClassWithSystemCompiler2"));
Lines 682-687 Link Here
682	assertTrue("delete failed", inputFile.delete());	688	assertTrue("delete failed", inputFile.delete());
683	}	689	}
684		690
		691	public void testFileManager() {
		692	String tmpFolder = System.getProperty("java.io.tmpdir");
		693	File dir = new File(tmpFolder, "src" + System.currentTimeMillis());
		694	dir.mkdirs();
		695	File inputFile = new File(dir, "X.java");
		696	BufferedWriter writer = null;
		697	try {
		698	writer = new BufferedWriter(new FileWriter(inputFile));
		699	writer.write("public class X {}");
		700	writer.flush();
		701	writer.close();
		702	} catch (IOException e) {
		703	// ignore
		704	} finally {
		705	if (writer != null) {
		706	try {
		707	writer.close();
		708	} catch (IOException e) {
		709	// ignore
		710	}
		711	}
		712	}
		713	try {
		714	//JavaCompiler systemCompiler = ToolProvider.getSystemJavaCompiler();
		715	StandardJavaFileManager fileManager = Compiler.getStandardFileManager(null, Locale.getDefault(), Charset.defaultCharset());
		716
		717	List<File> fins = new ArrayList<File>();
		718	fins.add(dir);
		719
		720	JavaFileManager.Location sourceLoc = javax.tools.StandardLocation.SOURCE_PATH;
		721	fileManager.setLocation(sourceLoc, fins);
		722
		723	Set<JavaFileObject.Kind> fileTypes = new HashSet<JavaFileObject.Kind>();
		724	fileTypes.add(JavaFileObject.Kind.SOURCE);
		725
		726	Iterable<? extends JavaFileObject> compilationUnits = fileManager.list(sourceLoc, "", fileTypes, true);
		727
		728	Iterator<? extends JavaFileObject> it = compilationUnits.iterator();
		729	StringBuilder builder = new StringBuilder();
		730	while (it.hasNext()) {
		731	JavaFileObject next = it.next();
		732	String name = next.getName();
		733	name = name.replace('\\', '/');
		734	int lastIndexOf = name.lastIndexOf('/');
		735	builder.append(name.substring(lastIndexOf + 1));
		736	}
		737	assertEquals("Wrong contents", "X.java", String.valueOf(builder));
		738	} catch (IOException e) {
		739	e.printStackTrace();
		740	}
		741	// check that the .class file exist for X
		742	assertTrue("delete failed", inputFile.delete());
		743	assertTrue("delete failed", dir.delete());
		744	}
		745	public void testFileManager2() {
		746	String tmpFolder = System.getProperty("java.io.tmpdir");
		747	File dir = new File(tmpFolder, "src" + System.currentTimeMillis());
		748	dir.mkdirs();
		749	File dir2 = new File(dir, "src2");
		750	dir2.mkdirs();
		751	File inputFile = new File(dir, "X.java");
		752	BufferedWriter writer = null;
		753	try {
		754	writer = new BufferedWriter(new FileWriter(inputFile));
755	writer.write("public class X {}");
756	writer.flush();
757	writer.close();
758	} catch (IOException e) {
759	// ignore
760	} finally {
761	if (writer != null) {
762	try {
763	writer.close();
764	} catch (IOException e) {
765	// ignore
766	}
767	}
768	}
769	File inputFile2 = new File(dir2, "X2.java");
770	writer = null;
771	try {
772	writer = new BufferedWriter(new FileWriter(inputFile2));
773	writer.write("public class X2 {}");
774	writer.flush();
775	writer.close();
776	} catch (IOException e) {
777	// ignore
778	} finally {
779	if (writer != null) {
780	try {
781	writer.close();
782	} catch (IOException e) {
783	// ignore
784	}
785	}
786	}
787	try {
788	//JavaCompiler systemCompiler = ToolProvider.getSystemJavaCompiler();
789	StandardJavaFileManager fileManager = Compiler.getStandardFileManager(null, Locale.getDefault(), Charset.defaultCharset());
790
791	List<File> fins = new ArrayList<File>();
792	fins.add(dir);
793
794	JavaFileManager.Location sourceLoc = javax.tools.StandardLocation.SOURCE_PATH;
795	fileManager.setLocation(sourceLoc, fins);
796
797	Set<JavaFileObject.Kind> fileTypes = new HashSet<JavaFileObject.Kind>();
798	fileTypes.add(JavaFileObject.Kind.SOURCE);
799
800	Iterable<? extends JavaFileObject> compilationUnits = fileManager.list(sourceLoc, "", fileTypes, true);
801
802	Iterator<? extends JavaFileObject> it = compilationUnits.iterator();
803	StringBuilder builder = new StringBuilder();
804	while (it.hasNext()) {
805	JavaFileObject next = it.next();
806	String name = next.getName();
807	name = name.replace('\\', '/');
808	int lastIndexOf = name.lastIndexOf('/');
809	builder.append(name.substring(lastIndexOf + 1));
810	}
811	assertEquals("Wrong contents", "X2.javaX.java", String.valueOf(builder));
812	} catch (IOException e) {
813	e.printStackTrace();
814	}
815	// check that the .class file exist for X
816	assertTrue("delete failed", inputFile2.delete());
817	assertTrue("delete failed", dir2.delete());
818	assertTrue("delete failed", inputFile.delete());
819	assertTrue("delete failed", dir.delete());
820	}
685	/*	821	/*
686	* Clean up the compiler	822	* Clean up the compiler
687	*/	823	*/

Return to bug 301562

Lines 147-171 Link Here

(-)src/org/eclipse/jdt/internal/compiler/apt/util/EclipseFileManager.java (-27 / +21 lines)
147	if (File.separatorChar == '/') {	147	if (File.separatorChar == '/') {
148	if (!path.endsWith(normalizedPackageName)) return;	148	if (!path.endsWith(normalizedPackageName)) return;
149	} else if (!path.endsWith(normalizedPackageName.replace('/', File.separatorChar))) return;	149	} else if (!path.endsWith(normalizedPackageName.replace('/', File.separatorChar))) return;
150	File[] files = currentFile.listFiles();	150	File[] files = currentFile.listFiles();
151	if (files != null) {	151	if (files != null) {
152	// this was a directory	152	// this was a directory
153	for (File f : files) {	153	for (File f : files) {
154	if (f.isDirectory() && recurse) {	154	if (f.isDirectory() && recurse) {
155	collectAllMatchingFiles(file, normalizedPackageName + '/' + f.getName(), kinds, recurse, collector);	155	collectAllMatchingFiles(file, normalizedPackageName + '/' + f.getName(), kinds, recurse, collector);
156	} else {	156	} else {
157	final Kind kind = getKind(f);	157	final Kind kind = getKind(f);
158	if (kinds.contains(kind)) {	158	if (kinds.contains(kind)) {
159	collector.add(new EclipseFileObject(normalizedPackageName + currentFile.getName(), currentFile.toURI(), kind, this.charset));	159	collector.add(new EclipseFileObject(normalizedPackageName + f.getName(), f.toURI(), kind, this.charset));
160	}	160	}
161	}	161	}
162	}	162	}
163	}
164	// currentFile is not a directory
165	// check if it matches the criteria
166	final Kind kind = getKind(file);
167	if (kinds.contains(kind)) {
168	collector.add(new EclipseFileObject(normalizedPackageName + currentFile.getName(), currentFile.toURI(), kind, this.charset));
169	}	163	}
170	} else {	164	} else {
171	Archive archive = this.getArchive(file);	165	Archive archive = this.getArchive(file);
Lines 180-189 Link Here
180	ArrayList<String> types = archive.getTypes(packageName);	174	ArrayList<String> types = archive.getTypes(packageName);
181	if (types != null) {	175	if (types != null) {
182	for (String typeName : types) {	176	for (String typeName : types) {
183	final Kind kind = getKind(getExtension(typeName));	177	final Kind kind = getKind(getExtension(typeName));
184	if (kinds.contains(kind)) {	178	if (kinds.contains(kind)) {
185	collector.add(archive.getArchiveFileObject(packageName + typeName, this.charset));	179	collector.add(archive.getArchiveFileObject(packageName + typeName, this.charset));
186	}	180	}
187	}	181	}
188	}	182	}
189	}	183	}
Lines 192-201 Link Here
192	ArrayList<String> types = archive.getTypes(key);	186	ArrayList<String> types = archive.getTypes(key);
193	if (types != null) {	187	if (types != null) {
194	for (String typeName : types) {	188	for (String typeName : types) {
195	final Kind kind = getKind(typeName);	189	final Kind kind = getKind(typeName);
196	if (kinds.contains(kind)) {	190	if (kinds.contains(kind)) {
197	collector.add(archive.getArchiveFileObject(normalizedPackageName + typeName, this.charset));	191	collector.add(archive.getArchiveFileObject(normalizedPackageName + typeName, this.charset));
198	}	192	}
199	}	193	}
200	}	194	}
201	}	195	}

Lines 148-172 Link Here

(-)src/org/eclipse/jdt/internal/compiler/tool/EclipseFileManager.java (-27 / +21 lines)
148	if (File.separatorChar == '/') {	148	if (File.separatorChar == '/') {
149	if (!path.endsWith(normalizedPackageName)) return;	149	if (!path.endsWith(normalizedPackageName)) return;
150	} else if (!path.endsWith(normalizedPackageName.replace('/', File.separatorChar))) return;	150	} else if (!path.endsWith(normalizedPackageName.replace('/', File.separatorChar))) return;
151	File[] files = currentFile.listFiles();	151	File[] files = currentFile.listFiles();
152	if (files != null) {	152	if (files != null) {
153	// this was a directory	153	// this was a directory
154	for (File f : files) {	154	for (File f : files) {
155	if (f.isDirectory() && recurse) {	155	if (f.isDirectory() && recurse) {
156	collectAllMatchingFiles(file, normalizedPackageName + '/' + f.getName(), kinds, recurse, collector);	156	collectAllMatchingFiles(file, normalizedPackageName + '/' + f.getName(), kinds, recurse, collector);
157	} else {	157	} else {
158	final Kind kind = getKind(f);	158	final Kind kind = getKind(f);
159	if (kinds.contains(kind)) {	159	if (kinds.contains(kind)) {
160	collector.add(new EclipseFileObject(normalizedPackageName + currentFile.getName(), currentFile.toURI(), kind, this.charset));	160	collector.add(new EclipseFileObject(normalizedPackageName + f.getName(), f.toURI(), kind, this.charset));
161	}	161	}
162	}	162	}
163	}	163	}
164	}
165	// currentFile is not a directory
166	// check if it matches the criteria
167	final Kind kind = getKind(file);
168	if (kinds.contains(kind)) {
169	collector.add(new EclipseFileObject(normalizedPackageName + currentFile.getName(), currentFile.toURI(), kind, this.charset));
170	}	164	}
171	} else {	165	} else {
172	Archive archive = this.getArchive(file);	166	Archive archive = this.getArchive(file);
Lines 181-190 Link Here
181	ArrayList<String> types = archive.getTypes(packageName);	175	ArrayList<String> types = archive.getTypes(packageName);
182	if (types != null) {	176	if (types != null) {
183	for (String typeName : types) {	177	for (String typeName : types) {
184	final Kind kind = getKind(getExtension(typeName));	178	final Kind kind = getKind(getExtension(typeName));
185	if (kinds.contains(kind)) {	179	if (kinds.contains(kind)) {
186	collector.add(archive.getArchiveFileObject(packageName + typeName, this.charset));	180	collector.add(archive.getArchiveFileObject(packageName + typeName, this.charset));
187	}	181	}
188	}	182	}
189	}	183	}
190	}	184	}
Lines 193-202 Link Here
193	ArrayList<String> types = archive.getTypes(key);	187	ArrayList<String> types = archive.getTypes(key);
194	if (types != null) {	188	if (types != null) {
195	for (String typeName : types) {	189	for (String typeName : types) {
196	final Kind kind = getKind(typeName);	190	final Kind kind = getKind(typeName);
197	if (kinds.contains(kind)) {	191	if (kinds.contains(kind)) {
198	collector.add(archive.getArchiveFileObject(normalizedPackageName + typeName, this.charset));	192	collector.add(archive.getArchiveFileObject(normalizedPackageName + typeName, this.charset));
199	}	193	}
200	}	194	}
201	}	195	}
202	}	196	}

Added Link Here

(-)src/org/eclipse/jdt/compiler/apt/tests/FileManagerTests.java (+103 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 BEA Systems, Inc.
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	* wharley@bea.com - initial API and implementation
10	*
11	*******************************************************************************/
12
13	package org.eclipse.jdt.compiler.apt.tests;
14
15	import java.io.BufferedWriter;
16	import java.io.File;
17	import java.io.FileWriter;
18	import java.io.IOException;
19	import java.nio.charset.Charset;
20	import java.util.ArrayList;
21	import java.util.HashSet;
22	import java.util.Iterator;
23	import java.util.List;
24	import java.util.Locale;
25	import java.util.Set;
26
27	import javax.tools.JavaFileManager;
28	import javax.tools.JavaFileObject;
29	import javax.tools.StandardJavaFileManager;
30
31	import org.eclipse.jdt.internal.compiler.apt.util.EclipseFileManager;
32
33	import junit.framework.TestCase;
34
35	/**
36	* Test the implementation of the Filer interface,
37	* in more detail than BatchDispatchTests does.
38	* @since 3.4
39	*/
40	public class FileManagerTests extends TestCase {
41
42	/* (non-Javadoc)
43	* @see junit.framework.TestCase#setUp()
44	*/
45	protected void setUp() throws Exception {
46	super.setUp();
47	BatchTestUtils.init();
48	}
49
50	public void testFileManager() {
51	String tmpFolder = System.getProperty("java.io.tmpdir");
52	File dir = new File(tmpFolder, "src" + System.currentTimeMillis());
53	dir.mkdirs();
54	File inputFile = new File(dir, "X.java");
55	BufferedWriter writer = null;
56	try {
57	writer = new BufferedWriter(new FileWriter(inputFile));
58	writer.write("public class X {}");
59	writer.flush();
60	writer.close();
61	} catch (IOException e) {
62	// ignore
63	} finally {
64	if (writer != null) {
65	try {
66	writer.close();
67	} catch (IOException e) {
68	// ignore
69	}
70	}
71	}
72	try {
73	StandardJavaFileManager fileManager = new EclipseFileManager(Locale.getDefault(), Charset.defaultCharset());
74
75	List<File> fins = new ArrayList<File>();
76	fins.add(dir);
77
78	JavaFileManager.Location sourceLoc = javax.tools.StandardLocation.SOURCE_PATH;
79	fileManager.setLocation(sourceLoc, fins);
80
81	Set<JavaFileObject.Kind> fileTypes = new HashSet<JavaFileObject.Kind>();
82	fileTypes.add(JavaFileObject.Kind.SOURCE);
83
84	Iterable<? extends JavaFileObject> compilationUnits = fileManager.list(sourceLoc, "", fileTypes, true);
85
86	Iterator<? extends JavaFileObject> it = compilationUnits.iterator();
87	StringBuilder builder = new StringBuilder();
88	while (it.hasNext()) {
89	JavaFileObject next = it.next();
90	String name = next.getName();
91	name = name.replace('\\', '/');
92	int lastIndexOf = name.lastIndexOf('/');
93	builder.append(name.substring(lastIndexOf + 1));
94	}
95	assertEquals("Wrong contents", "X.java", String.valueOf(builder));
96	} catch (IOException e) {
97	e.printStackTrace();
98	}
99	// check that the .class file exist for X
100	assertTrue("delete failed", inputFile.delete());
101	assertTrue("delete failed", dir.delete());
102	}
103	}