0001: /*
0002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
0003: *
0004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
0005: *
0006: * The contents of this file are subject to the terms of either the GNU
0007: * General Public License Version 2 only ("GPL") or the Common
0008: * Development and Distribution License("CDDL") (collectively, the
0009: * "License"). You may not use this file except in compliance with the
0010: * License. You can obtain a copy of the License at
0011: * http://www.netbeans.org/cddl-gplv2.html
0012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
0013: * specific language governing permissions and limitations under the
0014: * License. When distributing the software, include this License Header
0015: * Notice in each file and include the License file at
0016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
0017: * particular file as subject to the "Classpath" exception as provided
0018: * by Sun in the GPL Version 2 section of the License file that
0019: * accompanied this code. If applicable, add the following below the
0020: * License Header, with the fields enclosed by brackets [] replaced by
0021: * your own identifying information:
0022: * "Portions Copyrighted [year] [name of copyright owner]"
0023: *
0024: * Contributor(s):
0025: *
0026: * The Original Software is NetBeans. The Initial Developer of the Original
0027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
0028: * Microsystems, Inc. All Rights Reserved.
0029: *
0030: * If you wish your version of this file to be governed by only the CDDL
0031: * or only the GPL Version 2, indicate your decision by adding
0032: * "[Contributor] elects to include this software in this distribution
0033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
0034: * single choice of license, a recipient has the option to distribute
0035: * your version of this file under either the CDDL, the GPL Version 2 or
0036: * to extend the choice of license to its licensees as provided above.
0037: * However, if you add GPL Version 2 code and therefore, elected the GPL
0038: * Version 2 license, then the option applies only if the new code is
0039: * made subject to such option by the copyright holder.
0040: */
0041:
0042: package org.netbeans.modules.java.j2seproject;
0043:
0044: import java.io.File;
0045: import java.io.IOException;
0046: import java.io.Reader;
0047: import java.io.StringReader;
0048: import java.io.StringWriter;
0049: import java.util.ArrayList;
0050: import java.util.List;
0051: import java.util.Properties;
0052: import java.util.jar.Attributes;
0053: import java.util.jar.JarFile;
0054: import org.apache.tools.ant.module.api.support.ActionUtils;
0055: import org.netbeans.api.project.Project;
0056: import org.netbeans.api.project.ProjectManager;
0057: import org.netbeans.api.project.ant.AntArtifact;
0058: import org.netbeans.junit.MockServices;
0059: import org.netbeans.junit.NbTestCase;
0060: import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;
0061: import org.netbeans.spi.project.ant.AntArtifactProvider;
0062: import org.netbeans.spi.project.support.ant.AntProjectHelper;
0063: import org.netbeans.spi.project.support.ant.EditableProperties;
0064: import org.netbeans.spi.project.support.ant.ReferenceHelper;
0065: import org.openide.execution.ExecutorTask;
0066: import org.openide.filesystems.FileObject;
0067: import org.openide.filesystems.FileUtil;
0068: import org.openide.filesystems.test.TestFileUtils;
0069: import org.openide.modules.InstalledFileLocator;
0070: import org.openide.modules.SpecificationVersion;
0071: import org.openide.windows.IOProvider;
0072: import org.openide.windows.InputOutput;
0073: import org.openide.windows.OutputListener;
0074: import org.openide.windows.OutputWriter;
0075:
0076: /**
0077: * Test build-impl.xml functionality.
0078: * Large portion of this class was copied from JavaAntLoggerTest.
0079: * @author Jesse Glick, David Konecny
0080: */
0081: public final class BuildImplTest extends NbTestCase {
0082:
0083: public BuildImplTest(String name) {
0084: super (name);
0085: }
0086:
0087: private File junitJar;
0088:
0089: protected @Override
0090: void setUp() throws Exception {
0091: super .setUp();
0092: clearWorkDir();
0093: output.clear();
0094: outputPosition = 0;
0095: outputType.clear();
0096: String junitJarProp = System.getProperty("test.junit.jar");
0097: assertNotNull("must set test.junit.jar", junitJarProp);
0098: junitJar = new File(junitJarProp);
0099: assertTrue("file " + junitJar + " exists", junitJar.isFile());
0100: MockServices.setServices(IOP.class, IFL.class);
0101: }
0102:
0103: private AntProjectHelper setupProject(String subFolder,
0104: int numberOfSourceFiles, boolean generateTests)
0105: throws Exception {
0106: File proj = getWorkDir();
0107: if (subFolder != null) {
0108: proj = new File(getWorkDir(), subFolder);
0109: }
0110: J2SEProjectGenerator
0111: .setDefaultSourceLevel(new SpecificationVersion("1.4")); //NOI18N
0112: AntProjectHelper aph = J2SEProjectGenerator.createProject(proj,
0113: subFolder != null ? subFolder + getName() : getName(),
0114: (String) null, (String) null, null);
0115: EditableProperties ep = aph
0116: .getProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH);
0117: ep.put(J2SEProjectProperties.DO_DEPEND, "true"); // to avoid too many changes in tests from issue #118079
0118: aph.putProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH, ep);
0119: ProjectManager.getDefault().saveProject(
0120: ProjectManager.getDefault().findProject(
0121: aph.getProjectDirectory()));
0122: J2SEProjectGenerator.setDefaultSourceLevel(null);
0123: FileObject root = aph.getProjectDirectory();
0124: for (int i = 0; i < numberOfSourceFiles; i++) {
0125: generateJava(root, "src/pkg/Source" + i + ".java", false);
0126: if (generateTests) {
0127: generateJava(root, "test/pkg/Source" + i + "Test.java",
0128: true);
0129: }
0130: }
0131: return aph;
0132: }
0133:
0134: private AntProjectHelper setupProject(int numberOfSourceFiles,
0135: boolean generateTests) throws Exception {
0136: clearWorkDir();
0137: return setupProject(null, numberOfSourceFiles, generateTests);
0138: }
0139:
0140: private void generateJava(FileObject root, String path, boolean test)
0141: throws Exception {
0142: String name = path.replaceFirst("^.+/", "").replaceFirst(
0143: "\\..+$", "");
0144: if (test) {
0145: TestFileUtils
0146: .writeFile(
0147: root,
0148: path,
0149: "package pkg;\n"
0150: + "import junit.framework.TestCase;\n"
0151: + "public class "
0152: + name
0153: + " extends TestCase {\n"
0154: + "public "
0155: + name
0156: + "() { }\n"
0157: + "public void testDoSomething() { System.out.println(\""
0158: + name + " test executed\"); }\n"
0159: + "}\n");
0160: } else {
0161: TestFileUtils
0162: .writeFile(
0163: root,
0164: path,
0165: "package pkg;\n"
0166: + "public class "
0167: + name
0168: + " {\n"
0169: + "public boolean doSomething() { return true; }\n"
0170: + "public static void main(String[] args) { System.err.println(\""
0171: + name
0172: + " main class executed\"); }\n"
0173: + "}\n");
0174: }
0175: }
0176:
0177: private Properties getProperties() {
0178: Properties p = new Properties();
0179: p.setProperty("libs.junit.classpath", junitJar
0180: .getAbsolutePath());
0181: return p;
0182: }
0183:
0184: public void testDefaultTargets() throws Exception {
0185: AntProjectHelper aph = setupProject(1, true);
0186: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0187: "build.xml");
0188: assertNotNull("Must have build.xml", buildXml);
0189: Properties p = getProperties();
0190: assertBuildSuccess(ActionUtils.runTarget(buildXml, null, p));
0191: assertTrue("Default target must test project", output
0192: .contains("test:"));
0193: assertTrue("Default target must jar project", output
0194: .contains("jar:"));
0195: assertTrue("Default target must build javadoc", output
0196: .contains("javadoc:"));
0197:
0198: FileObject fo = aph.getProjectDirectory();
0199: assertNotNull("build/classes/pkg/Source0.class must exist", fo
0200: .getFileObject("build/classes/pkg/Source0.class"));
0201: assertNotNull(
0202: "build/test/classes/pkg/Source0Test.class must exist",
0203: fo
0204: .getFileObject("build/test/classes/pkg/Source0Test.class"));
0205: assertNotNull("dist/testDefaultTargets.jar must exist", fo
0206: .getFileObject("dist/testDefaultTargets.jar"));
0207: assertNotNull("dist/javadoc/index.html must exist", fo
0208: .getFileObject("dist/javadoc/index.html"));
0209: }
0210:
0211: public void testCompile() throws Exception {
0212: AntProjectHelper aph = setupProject(2, true);
0213: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0214: "build.xml");
0215: assertNotNull("Must have build.xml", buildXml);
0216: Properties p = getProperties();
0217: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0218: new String[] { "compile" }, p));
0219: assertTrue("compile target was not executed", output
0220: .contains("compile:"));
0221:
0222: FileObject fo = aph.getProjectDirectory();
0223: assertNotNull("build/classes/pkg/Source0.class must exist", fo
0224: .getFileObject("build/classes/pkg/Source0.class"));
0225: assertNotNull("build/classes/pkg/Source1.class must exist", fo
0226: .getFileObject("build/classes/pkg/Source1.class"));
0227: assertNull("build/test folder should not be created", fo
0228: .getFileObject("build/test"));
0229: assertNull("dist folder should not be created", fo
0230: .getFileObject("dist"));
0231: }
0232:
0233: public void testCompileSingle() throws Exception {
0234: AntProjectHelper aph = setupProject(3, true);
0235: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0236: "build.xml");
0237: assertNotNull("Must have build.xml", buildXml);
0238: Properties p = getProperties();
0239: p.setProperty("javac.includes", "pkg/Source2.java");
0240: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0241: new String[] { "compile-single" }, p));
0242: assertTrue("compile-single target was not executed", output
0243: .contains("compile-single:"));
0244:
0245: FileObject fo = aph.getProjectDirectory();
0246: assertNotNull("build/classes/pkg/Source2.class must exist", fo
0247: .getFileObject("build/classes/pkg/Source2.class"));
0248: assertEquals(
0249: "Only one class should be compiled",
0250: 1,
0251: fo.getFileObject("build/classes/pkg").getChildren().length);
0252: assertNull("build/test folder should not be created", fo
0253: .getFileObject("build/test"));
0254: assertNull("dist folder should not be created", fo
0255: .getFileObject("dist"));
0256: }
0257:
0258: public void testCompileSingleWithoutDependencyAnalysis()
0259: throws Exception { // #85707
0260: AntProjectHelper aph = setupProject(0, false);
0261: FileObject root = aph.getProjectDirectory();
0262: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0263: "build.xml");
0264: Properties p = getProperties();
0265: FileObject s1 = TestFileUtils.writeFile(root,
0266: "src/pack/age/Source1.java",
0267: "package pack.age; class Source1 {}");
0268: // Oddly, "class Source2 {Source1 s;}" does not trigger a dep Source2 -> Source1
0269: // ...which is technically correct (contents of Source1 cannot affect Source2's compilability)
0270: // but is <depend> really this clever?
0271: TestFileUtils.writeFile(root, "src/pack/age/Source2.java",
0272: "package pack.age; class Source2 {{new Source1();}}");
0273: p.setProperty("javac.includes", "pack/age/Source1.java");
0274: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0275: new String[] { "compile-single" }, p));
0276: File classes = new File(new File(getWorkDir(), "build"),
0277: "classes");
0278: assertOutput("Compiling 1 source file to " + classes);
0279: File classesPackage = new File(new File(classes, "pack"), "age");
0280: assertEquals(1, classesPackage.list().length);
0281: p.setProperty("javac.includes", "pack/age/Source2.java");
0282: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0283: new String[] { "compile-single" }, p));
0284: assertOutput("Compiling 1 source file to " + classes);
0285: assertEquals(2, classesPackage.list().length);
0286: // Compiling an already-compiled file forces it to be recompiled:
0287: p.setProperty("javac.includes", "pack/age/Source1.java");
0288: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0289: new String[] { "compile-single" }, p));
0290: assertOutput("Compiling 1 source file to " + classes);
0291: assertEquals(2, classesPackage.list().length);
0292: // Can compile several at once:
0293: p.setProperty("javac.includes",
0294: "pack/age/Source1.java,pack/age/Source2.java");
0295: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0296: new String[] { "compile-single" }, p));
0297: assertOutput("Compiling 2 source files to " + classes);
0298: assertEquals(2, classesPackage.list().length);
0299: // But <depend> is not run:
0300: TestFileUtils.touch(s1, null);
0301: p.setProperty("javac.includes", "pack/age/Source1.java");
0302: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0303: new String[] { "compile-single" }, p));
0304: assertOutput("Compiling 1 source file to " + classes);
0305: assertEquals(2, classesPackage.list().length);
0306: // Same for tests:
0307: FileObject t1 = TestFileUtils.writeFile(root,
0308: "test/pack/age/Test1.java",
0309: "package pack.age; class Test1 {}");
0310: TestFileUtils.writeFile(root, "test/pack/age/Test2.java",
0311: "package pack.age; class Test2 {{new Test1();}}");
0312: p.setProperty("javac.includes", "pack/age/Test1.java");
0313: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0314: new String[] { "compile-test-single" }, p));
0315: classes = new File(new File(new File(getWorkDir(), "build"),
0316: "test"), "classes");
0317: assertOutput("Compiling 1 source file to " + classes);
0318: classesPackage = new File(new File(classes, "pack"), "age");
0319: assertEquals(1, classesPackage.list().length);
0320: p.setProperty("javac.includes", "pack/age/Test2.java");
0321: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0322: new String[] { "compile-test-single" }, p));
0323: assertOutput("Compiling 1 source file to " + classes);
0324: assertEquals(2, classesPackage.list().length);
0325: p.setProperty("javac.includes", "pack/age/Test1.java");
0326: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0327: new String[] { "compile-test-single" }, p));
0328: assertOutput("Compiling 1 source file to " + classes);
0329: assertEquals(2, classesPackage.list().length);
0330: p.setProperty("javac.includes",
0331: "pack/age/Test1.java,pack/age/Test2.java");
0332: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0333: new String[] { "compile-test-single" }, p));
0334: assertOutput("Compiling 2 source files to " + classes);
0335: assertEquals(2, classesPackage.list().length);
0336: TestFileUtils.touch(t1, null);
0337: p.setProperty("javac.includes", "pack/age/Test1.java");
0338: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0339: new String[] { "compile-test-single" }, p));
0340: assertOutput("Compiling 1 source file to " + classes);
0341: assertEquals(2, classesPackage.list().length);
0342: }
0343:
0344: public void testCompileSingleTransitive() throws Exception { // #115918
0345: AntProjectHelper aph = setupProject(0, false);
0346: FileObject root = aph.getProjectDirectory();
0347: FileObject a = TestFileUtils.writeFile(root, "src/p/A.java",
0348: "package p; class A {}");
0349: TestFileUtils.writeFile(root, "src/p/B.java",
0350: "package p; class B {A a;}");
0351: TestFileUtils.writeFile(root, "src/p/C.java",
0352: "package p; class C {}");
0353: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0354: "build.xml");
0355: Properties p = getProperties();
0356: p.setProperty("javac.includes", "p/B.java");
0357: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0358: new String[] { "compile-single" }, p));
0359: File classes = new File(new File(getWorkDir(), "build"),
0360: "classes");
0361: assertOutput("Compiling 1 source file to " + classes);
0362: assertNotNull(root.getFileObject("build/classes/p/A.class"));
0363: assertNotNull(root.getFileObject("build/classes/p/B.class"));
0364: assertNull(root.getFileObject("build/classes/p/C.class"));
0365: TestFileUtils.writeFile(root, "src/p/A.java", "BROKEN");
0366: TestFileUtils.touch(a, root
0367: .getFileObject("build/classes/p/A.class"));
0368: assertBuildFailure(ActionUtils.runTarget(buildXml,
0369: new String[] { "compile-single" }, p));
0370: TestFileUtils.touch(a, root
0371: .getFileObject("build/classes/p/A.class"));
0372: TestFileUtils.writeFile(root, "src/p/A.java",
0373: "package p; class A {}");
0374: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0375: new String[] { "compile-single" }, p));
0376: // XXX test same in test dir
0377: // XXX test alternate src/test dirs
0378: }
0379:
0380: public void testIncludesExcludes() throws Exception {
0381: AntProjectHelper aph = setupProject(12, true);
0382: EditableProperties ep = aph
0383: .getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
0384: ep.setProperty(J2SEProjectProperties.INCLUDES, "**/*1*");
0385: ep.setProperty(J2SEProjectProperties.EXCLUDES, "**/*0*");
0386: aph.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, ep);
0387: ProjectManager.getDefault().saveAllProjects();
0388: FileObject dir = aph.getProjectDirectory();
0389: FileUtil.createData(dir, "src/data0.xml");
0390: FileUtil.createData(dir, "src/data1.xml");
0391: FileUtil.createData(dir, "src/data2.xml");
0392: FileUtil.createData(dir, "src/data10.xml");
0393: FileUtil.createData(dir, "src/data11.xml");
0394: generateJava(dir, "test/pkg/Utils1.java", true);
0395: FileObject buildXml = dir.getFileObject("build.xml");
0396: assertNotNull(buildXml);
0397: Properties p = getProperties();
0398: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0399: new String[] { "test" }, p));
0400: assertNull(dir.getFileObject("build/classes/pkg/Source0.class"));
0401: assertNotNull(dir
0402: .getFileObject("build/classes/pkg/Source1.class"));
0403: assertNull(dir.getFileObject("build/classes/pkg/Source2.class"));
0404: assertNull(dir
0405: .getFileObject("build/classes/pkg/Source10.class"));
0406: assertNotNull(dir
0407: .getFileObject("build/classes/pkg/Source11.class"));
0408: assertNull(dir.getFileObject("build/classes/data0.xml"));
0409: assertNotNull(dir.getFileObject("build/classes/data1.xml"));
0410: assertNull(dir.getFileObject("build/classes/data2.xml"));
0411: assertNull(dir.getFileObject("build/classes/data10.xml"));
0412: assertNotNull(dir.getFileObject("build/classes/data11.xml"));
0413: assertNull(dir
0414: .getFileObject("build/test/classes/pkg/Source0Test.class"));
0415: assertNotNull(dir
0416: .getFileObject("build/test/classes/pkg/Source1Test.class"));
0417: assertNull(dir
0418: .getFileObject("build/test/classes/pkg/Source2Test.class"));
0419: assertNull(dir
0420: .getFileObject("build/test/classes/pkg/Source10Test.class"));
0421: assertNotNull(dir
0422: .getFileObject("build/test/classes/pkg/Source11Test.class"));
0423: assertNotNull(dir
0424: .getFileObject("build/test/classes/pkg/Utils1.class"));
0425: assertFalse(output.contains("Source0Test test executed"));
0426: assertTrue(output.contains("Source1Test test executed"));
0427: assertFalse(output.contains("Source2Test test executed"));
0428: assertFalse(output.contains("Source10Test test executed"));
0429: assertTrue(output.contains("Source11Test test executed"));
0430: assertFalse(output.contains("Utils1 test executed"));
0431: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0432: new String[] { "javadoc" }, p));
0433: assertNull(dir.getFileObject("dist/javadoc/pkg/Source0.html"));
0434: assertNotNull(dir
0435: .getFileObject("dist/javadoc/pkg/Source1.html"));
0436: assertNull(dir.getFileObject("dist/javadoc/pkg/Source2.html"));
0437: assertNull(dir.getFileObject("dist/javadoc/pkg/Source10.html"));
0438: assertNotNull(dir
0439: .getFileObject("dist/javadoc/pkg/Source11.html"));
0440: p.setProperty("javac.includes", "pkg/Source4.java");
0441: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0442: new String[] { "compile-single" }, p));
0443: assertNotNull(dir
0444: .getFileObject("build/classes/pkg/Source4.class"));
0445: p.setProperty("javac.includes", "pkg/Source4Test.java");
0446: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0447: new String[] { "compile-test-single" }, p));
0448: assertNotNull(dir
0449: .getFileObject("build/test/classes/pkg/Source4Test.class"));
0450: p.setProperty("javac.includes", "pkg/Source7Test.java");
0451: p.setProperty("test.includes", "pkg/Source7Test.java");
0452: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0453: new String[] { "test-single" }, p));
0454: assertNotNull(dir
0455: .getFileObject("build/test/classes/pkg/Source7Test.class"));
0456: assertTrue(output.contains("Source7Test test executed"));
0457: TestFileUtils.writeFile(dir, "src/RefersToExcluded1a.java",
0458: "class RefersToExcluded1a {{new pkg.Source11();}}");
0459: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0460: new String[] { "compile" }, p));
0461: TestFileUtils.writeFile(dir, "src/RefersToExcluded1b.java",
0462: "class RefersToExcluded1b {{new pkg.Source10();}}");
0463: assertBuildFailure(ActionUtils.runTarget(buildXml,
0464: new String[] { "compile" }, p));
0465: }
0466:
0467: /** @see "issue #36033" */
0468: public void testCompileWithDependencyAnalysis() throws Exception {
0469: AntProjectHelper aph = setupProject(0, false);
0470: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0471: "build.xml");
0472: FileObject d = aph.getProjectDirectory();
0473: FileObject x = TestFileUtils.writeFile(d, "src/p/X.java",
0474: "package p; public class X {static {Y.y1();}}");
0475: FileObject y = TestFileUtils.writeFile(d, "src/p/Y.java",
0476: "package p; public class Y {static void y1() {}}");
0477: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0478: new String[] { "compile" }, getProperties()));
0479: TestFileUtils.writeFile(d, "src/p/Y.java",
0480: "package p; public class Y {static void y2() {}}");
0481: TestFileUtils.touch(y, d
0482: .getFileObject("build/classes/p/Y.class"));
0483: assertBuildFailure(ActionUtils.runTarget(buildXml,
0484: new String[] { "compile" }, getProperties()));
0485: TestFileUtils.writeFile(d, "src/p/X.java",
0486: "package p; public class X {static {Y.y2();}}");
0487: TestFileUtils.touch(x, null);
0488: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0489: new String[] { "compile" }, getProperties()));
0490: FileObject yt = TestFileUtils
0491: .writeFile(
0492: d,
0493: "test/p/YTest.java",
0494: "package p; public class YTest extends junit.framework.TestCase {public void testY() {Y.y2();}}");
0495: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0496: new String[] { "compile-test" }, getProperties()));
0497: TestFileUtils.writeFile(d, "src/p/X.java",
0498: "package p; public class X {static {Y.y1();}}");
0499: TestFileUtils.touch(x, d
0500: .getFileObject("build/classes/p/X.class"));
0501: TestFileUtils.writeFile(d, "src/p/Y.java",
0502: "package p; public class Y {static void y1() {}}");
0503: assertNotNull(d.getFileObject("build/classes/p/Y.class"));
0504: TestFileUtils.touch(y, d
0505: .getFileObject("build/classes/p/Y.class"));
0506: assertBuildFailure(ActionUtils.runTarget(buildXml,
0507: new String[] { "compile-test" }, getProperties()));
0508: TestFileUtils
0509: .writeFile(
0510: d,
0511: "test/p/YTest.java",
0512: "package p; public class YTest extends junit.framework.TestCase {public void testY() {Y.y1();}}");
0513: TestFileUtils.touch(yt, null);
0514: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0515: new String[] { "compile-test" }, getProperties()));
0516: }
0517:
0518: public void testRun() throws Exception {
0519: AntProjectHelper aph = setupProject(3, true);
0520: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0521: "build.xml");
0522: assertNotNull("Must have build.xml", buildXml);
0523: Properties p = getProperties();
0524: p.setProperty("main.class", "pkg.Source1");
0525: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0526: new String[] { "run" }, p));
0527: assertTrue("compile target was not executed", output
0528: .contains("compile:"));
0529: assertTrue("run target was not executed", output
0530: .contains("run:"));
0531: assertTrue("main class was not executed", output
0532: .contains("Source1 main class executed"));
0533:
0534: FileObject fo = aph.getProjectDirectory();
0535: assertNotNull("build/classes/pkg/Source0.class must exist", fo
0536: .getFileObject("build/classes/pkg/Source0.class"));
0537: assertNotNull("build/classes/pkg/Source1.class must exist", fo
0538: .getFileObject("build/classes/pkg/Source1.class"));
0539: assertNotNull("build/classes/pkg/Source2.class must exist", fo
0540: .getFileObject("build/classes/pkg/Source2.class"));
0541: assertNull("build/test folder should not be created", fo
0542: .getFileObject("build/test"));
0543: assertNull("dist folder should not be created", fo
0544: .getFileObject("dist"));
0545: }
0546:
0547: public void testRunSingle() throws Exception {
0548: AntProjectHelper aph = setupProject(3, true);
0549: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0550: "build.xml");
0551: assertNotNull("Must have build.xml", buildXml);
0552: Properties p = getProperties();
0553: p.setProperty("main.class", "pkg.Source0");
0554: p.setProperty("javac.includes", "pkg/Source2.java");
0555: p.setProperty("run.class", "pkg.Source2");
0556: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0557: new String[] { "run-single" }, p));
0558: assertTrue("compile-single target was not executed", output
0559: .contains("compile-single:"));
0560: assertTrue("run target was not executed", output
0561: .contains("run-single:"));
0562: assertTrue("main class was not executed", output
0563: .contains("Source2 main class executed"));
0564:
0565: FileObject fo = aph.getProjectDirectory();
0566: assertNotNull("build/classes/pkg/Source2.class must exist", fo
0567: .getFileObject("build/classes/pkg/Source2.class"));
0568: assertEquals(
0569: "Only one class should be compiled",
0570: 1,
0571: fo.getFileObject("build/classes/pkg").getChildren().length);
0572: assertNull("build/test folder should not be created", fo
0573: .getFileObject("build/test"));
0574: assertNull("dist folder should not be created", fo
0575: .getFileObject("dist"));
0576: }
0577:
0578: public void testJar() throws Exception {
0579: AntProjectHelper aph = setupProject(2, true);
0580: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0581: "build.xml");
0582: assertNotNull("Must have build.xml", buildXml);
0583: Properties p = getProperties();
0584: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0585: new String[] { "jar" }, p));
0586: assertTrue("compile target was not executed", output
0587: .contains("compile:"));
0588: assertTrue("jar target was not executed", output
0589: .contains("jar:"));
0590:
0591: FileObject fo = aph.getProjectDirectory();
0592: assertNotNull("build/classes/pkg/Source0.class must exist", fo
0593: .getFileObject("build/classes/pkg/Source0.class"));
0594: assertNotNull("build/classes/pkg/Source1.class must exist", fo
0595: .getFileObject("build/classes/pkg/Source1.class"));
0596: assertNull("build/test folder should not be created", fo
0597: .getFileObject("build/test"));
0598: assertNotNull("dist/testJar.jar must exist", fo
0599: .getFileObject("dist/testJar.jar"));
0600: assertNull("dist/javadoc fodler should not be created", fo
0601: .getFileObject("dist/javadoc"));
0602: Attributes mf = getJarManifest(fo
0603: .getFileObject("dist/testJar.jar"));
0604: assertNull("Main-class was not set", mf.getValue("Main-class"));
0605:
0606: // set a manifest
0607:
0608: TestFileUtils.writeFile(aph.getProjectDirectory(),
0609: "manifest/manifest.mf", "Manifest-Version: 1.0\n"
0610: + "Something: s.o.m.e\n\n");
0611: p.setProperty("manifest.file", "manifest/manifest.mf");
0612: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0613: new String[] { "jar" }, p));
0614: assertTrue("compile target was not executed", output
0615: .contains("compile:"));
0616: assertTrue("jar target was not executed", output
0617: .contains("jar:"));
0618: assertNull("build/test folder should not be created", fo
0619: .getFileObject("build/test"));
0620: assertNotNull("dist/testJar.jar must exist", fo
0621: .getFileObject("dist/testJar.jar"));
0622: assertNull("dist/javadoc fodler should not be created", fo
0623: .getFileObject("dist/javadoc"));
0624: mf = getJarManifest(fo.getFileObject("dist/testJar.jar"));
0625: assertEquals("Specified manifest was not used", "s.o.m.e", mf
0626: .getValue("Something"));
0627: assertNull("Main-class was not set", mf.getValue("Main-class"));
0628:
0629: // set a mainclass
0630:
0631: p.setProperty("main.class", "some.clazz.Main");
0632: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0633: new String[] { "jar" }, p));
0634: assertTrue("compile target was not executed", output
0635: .contains("compile:"));
0636: assertTrue("jar target was not executed", output
0637: .contains("jar:"));
0638: assertNull("build/test folder should not be created", fo
0639: .getFileObject("build/test"));
0640: assertNotNull("dist/testJar.jar must exist", fo
0641: .getFileObject("dist/testJar.jar"));
0642: assertNull("dist/javadoc fodler should not be created", fo
0643: .getFileObject("dist/javadoc"));
0644: mf = getJarManifest(fo.getFileObject("dist/testJar.jar"));
0645: assertEquals("Specified manifest was not used", "s.o.m.e", mf
0646: .getValue("Something"));
0647: assertEquals("Main-class was not set", "some.clazz.Main", mf
0648: .getValue("Main-class"));
0649: }
0650:
0651: public void testJavadoc() throws Exception {
0652: AntProjectHelper aph = setupProject(3, true);
0653: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0654: "build.xml");
0655: assertNotNull("Must have build.xml", buildXml);
0656: Properties p = getProperties();
0657: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0658: new String[] { "javadoc" }, p));
0659: assertTrue("javadoc target was not executed", output
0660: .contains("javadoc:"));
0661:
0662: FileObject fo = aph.getProjectDirectory();
0663: assertNull("build folder should not be created", fo
0664: .getFileObject("build"));
0665: assertNull("dist/testJavadoc.jar should not exist", fo
0666: .getFileObject("dist/testJavadoc.jar"));
0667: assertNotNull("dist/javadoc/index.html must exist", fo
0668: .getFileObject("dist/javadoc/index.html"));
0669: }
0670:
0671: public void testJavadocPackagesDocumented() throws Exception {
0672: AntProjectHelper aph = setupProject(0, false);
0673: TestFileUtils.writeFile(aph.getProjectDirectory(),
0674: "src/pkg1/A.java", "package pkg1; public class A {}");
0675: TestFileUtils.writeFile(aph.getProjectDirectory(),
0676: "src/pkg1/package.html",
0677: "<html><body>Floopy blint.</body></html>");
0678: TestFileUtils.writeFile(aph.getProjectDirectory(),
0679: "src/pkg2/B.java", "package pkg2; public class B {}");
0680: TestFileUtils.writeFile(aph.getProjectDirectory(),
0681: "src/pkg2/package-info.java",
0682: "/** Floppy blunt. */ package pkg2;");
0683: assertBuildSuccess(ActionUtils.runTarget(aph
0684: .getProjectDirectory().getFileObject("build.xml"),
0685: new String[] { "javadoc" }, getProperties()));
0686: TestFileUtils
0687: .assertContains(
0688: aph
0689: .resolveFileObject("dist/javadoc/pkg1/package-summary.html"),
0690: "Floopy blint.");
0691: TestFileUtils
0692: .assertContains(
0693: aph
0694: .resolveFileObject("dist/javadoc/pkg2/package-summary.html"),
0695: "Floppy blunt.");
0696: }
0697:
0698: public void testJavadocExcludedClassesAndPackagesNotDocumented()
0699: throws Exception { // part of #49026
0700: AntProjectHelper aph = setupProject(0, false);
0701: TestFileUtils.writeFile(aph.getProjectDirectory(),
0702: "src/incl/A.java", "package incl; public class A {}");
0703: TestFileUtils.writeFile(aph.getProjectDirectory(),
0704: "src/incl/A_.java", "package incl; public class A_ {}");
0705: TestFileUtils.writeFile(aph.getProjectDirectory(),
0706: "src/excl/B.java", "package excl; public class B {}");
0707: TestFileUtils.writeFile(aph.getProjectDirectory(),
0708: "src/other/C.java", "package other; public class C {}");
0709: EditableProperties ep = aph
0710: .getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
0711: ep.setProperty("includes", "*cl/");
0712: ep.setProperty("excludes", "excl/,**/*_*");
0713: aph.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, ep);
0714: ProjectManager.getDefault().saveProject(
0715: ProjectManager.getDefault().findProject(
0716: aph.getProjectDirectory()));
0717: assertBuildSuccess(ActionUtils.runTarget(aph
0718: .getProjectDirectory().getFileObject("build.xml"),
0719: new String[] { "javadoc" }, getProperties()));
0720: assertNotNull(aph.resolveFileObject("dist/javadoc/incl/A.html"));
0721: assertNull(aph.resolveFileObject("dist/javadoc/incl/A_.html"));
0722: assertNull(aph.resolveFileObject("dist/javadoc/excl"));
0723: assertNull(aph.resolveFileObject("dist/javadoc/other"));
0724: }
0725:
0726: // XXX cannot be made to work without breaking something else:
0727: // public void testJavadocSeeWorksOnPackages() throws Exception { // #57940
0728: // AntProjectHelper aph = setupProject(0, false);
0729: // TestFileUtils.writeFile(aph.getProjectDirectory(), "src/pkg1/A.java", "package pkg1; public class A {}");
0730: // TestFileUtils.writeFile(aph.getProjectDirectory(), "src/pkg2/B.java", "package pkg2; /** @see pkg1 */ public class B {}");
0731: // assertBuildSuccess(ActionUtils.runTarget(aph.getProjectDirectory().getFileObject("build.xml"), new String[] {"javadoc"}, getProperties()));
0732: // TestFileUtils.assertContains(aph.resolveFileObject("dist/javadoc/pkg2/B.html"), "../pkg1/package-summary.html");
0733: // }
0734: public void testJavadocNoDuplicatedClassNamesInIndex()
0735: throws Exception { // #102036
0736: AntProjectHelper aph = setupProject(0, false);
0737: TestFileUtils.writeFile(aph.getProjectDirectory(),
0738: "src/pkg1/A.java", "package pkg1; public class A {}");
0739: assertBuildSuccess(ActionUtils.runTarget(aph
0740: .getProjectDirectory().getFileObject("build.xml"),
0741: new String[] { "javadoc" }, getProperties()));
0742: String text = TestFileUtils
0743: .readFile(aph
0744: .resolveFileObject("dist/javadoc/allclasses-frame.html"));
0745: assertTrue(text.matches("(?s).*pkg1/A\\.html.*"));
0746: assertFalse(text
0747: .matches("(?s).*pkg1/A\\.html.*pkg1/A\\.html.*"));
0748: }
0749:
0750: public void testTest() throws Exception {
0751: AntProjectHelper aph = setupProject(2, true);
0752: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0753: "build.xml");
0754: assertNotNull("Must have build.xml", buildXml);
0755: Properties p = getProperties();
0756: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0757: new String[] { "test" }, p));
0758: assertTrue("compile target was not executed", output
0759: .contains("compile:"));
0760: assertTrue("compile-test target was not executed", output
0761: .contains("compile-test:"));
0762: assertTrue("test target was not executed", output
0763: .contains("test:"));
0764: assertTrue("test 0 was not executed", output
0765: .contains("Source0Test test executed"));
0766: assertTrue("test 1 was not executed", output
0767: .contains("Source1Test test executed"));
0768:
0769: FileObject fo = aph.getProjectDirectory();
0770: assertNotNull("build/classes/pkg/Source0.class must exist", fo
0771: .getFileObject("build/classes/pkg/Source0.class"));
0772: assertNotNull("build/classes/pkg/Source1.class must exist", fo
0773: .getFileObject("build/classes/pkg/Source1.class"));
0774: assertNotNull(
0775: "build/test/classes/pkg/Source0Test.class must exist",
0776: fo
0777: .getFileObject("build/test/classes/pkg/Source0Test.class"));
0778: assertNotNull(
0779: "build/test/classes/pkg/Source1Test.class must exist",
0780: fo
0781: .getFileObject("build/test/classes/pkg/Source1Test.class"));
0782: assertNull("dist folder should not be created", fo
0783: .getFileObject("dist"));
0784: }
0785:
0786: public void testCompileSingleTest() throws Exception {
0787: AntProjectHelper aph = setupProject(3, true);
0788: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0789: "build.xml");
0790: assertNotNull("Must have build.xml", buildXml);
0791: Properties p = getProperties();
0792: p.setProperty("javac.includes", "pkg/Source2Test.java");
0793: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0794: new String[] { "compile-test-single" }, p));
0795: assertTrue("compile-single target was not executed", output
0796: .contains("compile:"));
0797: assertTrue("compile-single target was not executed", output
0798: .contains("compile-test-single:"));
0799:
0800: FileObject fo = aph.getProjectDirectory();
0801: assertNotNull("build/classes/pkg/Source0.class must exist", fo
0802: .getFileObject("build/classes/pkg/Source0.class"));
0803: assertNotNull("build/classes/pkg/Source1.class must exist", fo
0804: .getFileObject("build/classes/pkg/Source1.class"));
0805: assertNotNull("build/classes/pkg/Source2.class must exist", fo
0806: .getFileObject("build/classes/pkg/Source2.class"));
0807: assertNotNull(
0808: "build/test/classes/pkg/Source2Test.class must exist",
0809: fo
0810: .getFileObject("build/test/classes/pkg/Source2Test.class"));
0811: assertEquals("Only one test class should be compiled", 1,
0812: fo.getFileObject("build/test/classes/pkg")
0813: .getChildren().length);
0814: assertNull("dist folder should not be created", fo
0815: .getFileObject("dist"));
0816: }
0817:
0818: public void testRunSingleTest() throws Exception {
0819: AntProjectHelper aph = setupProject(3, true);
0820: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0821: "build.xml");
0822: assertNotNull("Must have build.xml", buildXml);
0823: Properties p = getProperties();
0824: p.setProperty("javac.includes", "pkg/Source2Test.java");
0825: p.setProperty("test.includes", "pkg/Source2Test.java");
0826: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0827: new String[] { "test-single" }, p));
0828: assertTrue("compile target was not executed", output
0829: .contains("compile:"));
0830: assertTrue("run target was not executed", output
0831: .contains("compile-test-single:"));
0832: assertTrue("run target was not executed", output
0833: .contains("test-single:"));
0834: assertTrue("test was not executed", output
0835: .contains("Source2Test test executed"));
0836:
0837: FileObject fo = aph.getProjectDirectory();
0838: assertNotNull("build/classes/pkg/Source0.class must exist", fo
0839: .getFileObject("build/classes/pkg/Source0.class"));
0840: assertNotNull("build/classes/pkg/Source1.class must exist", fo
0841: .getFileObject("build/classes/pkg/Source1.class"));
0842: assertNotNull("build/classes/pkg/Source2.class must exist", fo
0843: .getFileObject("build/classes/pkg/Source2.class"));
0844: assertNotNull(
0845: "build/test/classes/pkg/Source2Test.class must exist",
0846: fo
0847: .getFileObject("build/test/classes/pkg/Source2Test.class"));
0848: /* No longer true as of #97053:
0849: assertEquals("Only one test class should be compiled", 1, fo.getFileObject("build/test/classes/pkg").getChildren().length);
0850: */
0851: assertNull("dist folder should not be created", fo
0852: .getFileObject("dist"));
0853: }
0854:
0855: public void testRunSingleTestWithDep() throws Exception { // #97053
0856: AntProjectHelper aph = setupProject(1, false);
0857: FileObject root = aph.getProjectDirectory();
0858: TestFileUtils.writeFile(root, "test/pkg/TestUtil.java",
0859: "package pkg; class TestUtil {}");
0860: TestFileUtils
0861: .writeFile(
0862: root,
0863: "test/pkg/SomeTest.java",
0864: "package pkg; public class SomeTest extends junit.framework.TestCase {public void testX() {new Source0(); new TestUtil();}}");
0865: FileObject buildXml = aph.getProjectDirectory().getFileObject(
0866: "build.xml");
0867: Properties p = getProperties();
0868: p.setProperty("javac.includes", "pkg/SomeTest.java");
0869: p.setProperty("test.includes", "pkg/SomeTest.java");
0870: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0871: new String[] { "test-single" }, p));
0872: assertOutput("Testsuite: pkg.SomeTest");
0873: }
0874:
0875: public void testSubprojects() throws Exception {
0876: clearWorkDir();
0877: AntProjectHelper aph1 = setupProject("p1", 1, false);
0878: AntProjectHelper aph2 = setupProject("p2", 1, false);
0879: Project proj1 = ProjectManager.getDefault().findProject(
0880: aph1.getProjectDirectory());
0881: Project proj2 = ProjectManager.getDefault().findProject(
0882: aph2.getProjectDirectory());
0883: ReferenceHelper refHelper = ((J2SEProject) proj1)
0884: .getReferenceHelper();
0885: AntArtifactProvider aap = proj2.getLookup().lookup(
0886: AntArtifactProvider.class);
0887: AntArtifact[] aa = aap.getBuildArtifacts();
0888: assertTrue("Project should have an artifact", aa.length > 0);
0889: refHelper.addReference(aa[0], aa[0].getArtifactLocations()[0]);
0890: ProjectManager.getDefault().saveAllProjects();
0891: FileObject fo = aph1.getProjectDirectory();
0892: assertNull("build folder cannot exist", fo
0893: .getFileObject("build"));
0894: assertNull("dist folder cannot exist", fo.getFileObject("dist"));
0895: fo = aph2.getProjectDirectory();
0896: assertNull("build folder cannot exist", fo
0897: .getFileObject("build"));
0898: assertNull("dist folder cannot exist", fo.getFileObject("dist"));
0899:
0900: FileObject buildXml = aph1.getProjectDirectory().getFileObject(
0901: "build.xml");
0902: assertNotNull("Must have build.xml", buildXml);
0903: Properties p = getProperties();
0904: p.setProperty("no.dependencies", "true");
0905: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0906: new String[] { "jar" }, p));
0907: assertTrue("jar target was not executed", output
0908: .contains("jar:"));
0909: output.remove("jar:");
0910: assertFalse("subproject's jar should not be executed", output
0911: .contains("jar:"));
0912: fo = aph1.getProjectDirectory();
0913: assertNotNull("build folder must exist", fo
0914: .getFileObject("build"));
0915: assertNotNull("dist folder must exist", fo
0916: .getFileObject("dist"));
0917: fo = aph2.getProjectDirectory();
0918: assertNull("build folder cannot exist", fo
0919: .getFileObject("build"));
0920: assertNull("dist folder cannot exist", fo.getFileObject("dist"));
0921:
0922: p.setProperty("no.dependencies", "false");
0923: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0924: new String[] { "jar" }, p));
0925: assertTrue("jar target was not executed", output
0926: .contains("jar:"));
0927: output.remove("jar:");
0928: assertTrue("subproject's jar target was not executed", output
0929: .contains("jar:"));
0930: fo = aph1.getProjectDirectory();
0931: assertNotNull("build folder must exist", fo
0932: .getFileObject("build"));
0933: assertNotNull("dist folder must exist", fo
0934: .getFileObject("dist"));
0935: fo = aph2.getProjectDirectory();
0936: assertNotNull("build folder must exist", fo
0937: .getFileObject("build"));
0938: assertNotNull("dist folder must exist", fo
0939: .getFileObject("dist"));
0940:
0941: p.setProperty("no.dependencies", "true");
0942: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0943: new String[] { "clean" }, p));
0944: assertTrue("clean target was not executed", output
0945: .contains("clean:"));
0946: output.remove("clean:");
0947: assertFalse("subproject's clean should not be executed", output
0948: .contains("clean:"));
0949: fo = aph1.getProjectDirectory();
0950: fo.refresh();
0951: assertNull("build folder cannot exist", fo
0952: .getFileObject("build"));
0953: assertNull("dist folder cannot exist", fo.getFileObject("dist"));
0954: fo = aph2.getProjectDirectory();
0955: fo.refresh();
0956: assertNotNull("build folder must exist", fo
0957: .getFileObject("build"));
0958: assertNotNull("dist folder must exist", fo
0959: .getFileObject("dist"));
0960:
0961: p.setProperty("no.dependencies", "false");
0962: assertBuildSuccess(ActionUtils.runTarget(buildXml,
0963: new String[] { "clean" }, p));
0964: assertTrue("clean target was not executed", output
0965: .contains("clean:"));
0966: output.remove("clean:");
0967: assertTrue("subproject's clean target was not executed", output
0968: .contains("clean:"));
0969: fo = aph1.getProjectDirectory();
0970: fo.refresh();
0971: assertNull("build folder must be removed", fo
0972: .getFileObject("build"));
0973: assertNull("dist folder must be removed", fo
0974: .getFileObject("dist"));
0975: fo = aph2.getProjectDirectory();
0976: fo.refresh();
0977: assertNull("build folder must be removed", fo
0978: .getFileObject("build"));
0979: assertNull("dist folder must be removed", fo
0980: .getFileObject("dist"));
0981: }
0982:
0983: /* XXX: impossible to test currently, because J2SEActionProvider.invokeAction must be called, but that is nonblocking.
0984: public void testFirstBuildAfterBrokenCleanBuild() throws Exception {
0985: // #120843. Should really in J2SEActionProviderTest but needs infrastructure of running builds.
0986: MockLookup.setInstances(new IOP(), new IFL(), new J2SEActionProviderTest.SimplePlatformProvider()); // may need to be in setUp
0987: AntProjectHelper aph = setupProject(0, false);
0988: EditableProperties ep = aph.getProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH);
0989: ep.put(J2SEProjectProperties.DO_DEPEND, "false");
0990: ep.put(J2SEProjectProperties.DO_JAR, "false");
0991: aph.putProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH, ep);
0992: ProjectManager.getDefault().saveProject(ProjectManager.getDefault().findProject(aph.getProjectDirectory()));
0993: FileObject root = aph.getProjectDirectory();
0994: FileObject buildXml = root.getFileObject("build.xml");
0995: Properties p = getProperties();
0996: FileObject a = TestFileUtils.writeFile(root, "src/A.java", "class A {}");
0997: FileObject b = TestFileUtils.writeFile(root, "src/B.java", "class B {A v;}broken");
0998: J2SEActionProvider actionProvider = ProjectManager.getDefault().findProject(root).getLookup().lookup(J2SEActionProvider.class);
0999: assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ActionProvider.COMMAND_BUILD, Lookup.EMPTY, p)));
1000: assertEquals(null, p.get("includes"));
1001: assertBuildFailure(ActionUtils.runTarget(buildXml, new String[] {"compile"}, p));
1002: assertNull(root.getFileObject("build/classes/A.class"));
1003: assertNull(root.getFileObject("build/classes/B.class"));
1004: TestFileUtils.writeFile(root, "src/B.java", "class B {A v;}");
1005: TestFileUtils.touch(b, null);
1006: p = getProperties();
1007: assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ActionProvider.COMMAND_BUILD, Lookup.EMPTY, p)));
1008: assertEquals(null, p.get("includes"));
1009: assertBuildSuccess(ActionUtils.runTarget(buildXml, new String[] {"compile"}, p));
1010: }
1011: */
1012:
1013: private Attributes getJarManifest(FileObject fo) throws Exception {
1014: File f = FileUtil.toFile(fo);
1015: JarFile jf = new JarFile(f);
1016: Attributes attrs = (Attributes) jf.getManifest()
1017: .getMainAttributes().clone();
1018: jf.close();
1019: return attrs;
1020: }
1021:
1022: private void assertBuildSuccess(ExecutorTask task) {
1023: if (task.result() != 0) {
1024: dumpOutput();
1025: fail("target failed");
1026: }
1027: }
1028:
1029: private void assertBuildFailure(ExecutorTask task) {
1030: if (task.result() == 0) {
1031: dumpOutput();
1032: fail("target failed");
1033: }
1034: }
1035:
1036: private void dumpOutput() {
1037: System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1038: for (String line : output) {
1039: System.out.println(line);
1040: }
1041: System.out.println("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
1042: }
1043:
1044: private void assertOutput(String line) {
1045: int newpos = output.size();
1046: if (!output.subList(outputPosition, newpos).contains(line)) {
1047: dumpOutput();
1048: fail("looking for '" + line + "' starting at line #"
1049: + (outputPosition + 1));
1050: }
1051: outputPosition = newpos;
1052: }
1053:
1054: @SuppressWarnings("deprecation")
1055: public static final class IOP extends IOProvider implements
1056: InputOutput {
1057:
1058: public IOP() {
1059: }
1060:
1061: public InputOutput getIO(String name, boolean newIO) {
1062: return this ;
1063: }
1064:
1065: public OutputWriter getStdOut() {
1066: throw new UnsupportedOperationException();
1067: }
1068:
1069: public OutputWriter getOut() {
1070: return new OW(false);
1071: }
1072:
1073: public OutputWriter getErr() {
1074: return new OW(true);
1075: }
1076:
1077: public Reader getIn() {
1078: return new StringReader("");
1079: }
1080:
1081: public Reader flushReader() {
1082: return getIn();
1083: }
1084:
1085: public void closeInputOutput() {
1086: }
1087:
1088: public boolean isClosed() {
1089: return false;
1090: }
1091:
1092: public boolean isErrSeparated() {
1093: return false;
1094: }
1095:
1096: public boolean isFocusTaken() {
1097: return false;
1098: }
1099:
1100: public void select() {
1101: }
1102:
1103: public void setErrSeparated(boolean value) {
1104: }
1105:
1106: public void setErrVisible(boolean value) {
1107: }
1108:
1109: public void setFocusTaken(boolean value) {
1110: }
1111:
1112: public void setInputVisible(boolean value) {
1113: }
1114:
1115: public void setOutputVisible(boolean value) {
1116: }
1117:
1118: }
1119:
1120: private static final List<String> output = new ArrayList<String>();
1121: private static int outputPosition;
1122: private static final List<String> outputType = new ArrayList<String>();
1123:
1124: private static final String TYPE_ERR = "err";
1125: private static final String TYPE_OK = "ok";
1126:
1127: private static final class OW extends OutputWriter {
1128:
1129: private final boolean err;
1130:
1131: public OW(boolean err) {
1132: super (new StringWriter());
1133: this .err = err;
1134: }
1135:
1136: public void println(String s, OutputListener l)
1137: throws IOException {
1138: message(s, l != null);
1139: }
1140:
1141: public @Override
1142: void println(String x) {
1143: message(x, false);
1144: }
1145:
1146: private void message(String msg, boolean hyperlinked) {
1147: output.add(msg);
1148: String type = err ? TYPE_ERR : TYPE_OK;
1149: outputType.add(type);
1150: }
1151:
1152: public void reset() throws IOException {
1153: }
1154:
1155: }
1156:
1157: /** Copied from AntLoggerTest. */
1158: public static final class IFL extends InstalledFileLocator {
1159: public IFL() {
1160: }
1161:
1162: public File locate(String relativePath, String codeNameBase,
1163: boolean localized) {
1164: if (relativePath.equals("ant/nblib/bridge.jar")) {
1165: String path = System.getProperty("test.bridge.jar");
1166: assertNotNull("must set test.bridge.jar", path);
1167: return new File(path);
1168: } else if (relativePath.equals("ant")) {
1169: String path = System.getProperty("test.ant.home");
1170: assertNotNull("must set test.ant.home", path);
1171: return new File(path);
1172: } else if (relativePath.startsWith("ant/")) {
1173: String path = System.getProperty("test.ant.home");
1174: assertNotNull("must set test.ant.home", path);
1175: return new File(path, relativePath.substring(4)
1176: .replace('/', File.separatorChar));
1177: } else {
1178: return null;
1179: }
1180: }
1181: }
1182:
1183: }
|