/*******************************************************************************
* Copyright (c) 2000, 2017 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:
* IBM Corporation - initial API and implementation
* Alexander Kurtakov <akurtako@redhat.com> - Bug 459343
*******************************************************************************/
package org.eclipse.core.tests.internal.builders;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.HashMap;
import java.util.Map;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.tests.harness.TestBarrier;
import org.eclipse.core.tests.harness.TestJob;
/**
* This class tests public API related to building and to build specifications.
* Specifically, the following methods are tested:
*
* IWorkspace#build IProject#build IProjectDescription#getBuildSpec
* IProjectDescription#setBuildSpec
*/
public class BuilderTest extends AbstractBuilderTest {
public static Test suite() {
return new TestSuite(BuilderTest.class);
// TestSuite suite = new TestSuite();
// suite.addTest(new BuilderTest("testInterruptAutobuild"));
// return suite;
}
public BuilderTest() {
super(null);
}
/**
* BuilderTest constructor comment.
*
* @param name
* java.lang.String
*/
public BuilderTest(String name) {
super(name);
}
/**
* Tears down the fixture, for example, close a network connection. This
* method is called after a test is executed.
*/
@Override
protected void tearDown() throws Exception {
super.tearDown();
getWorkspace().getRoot().delete(true, null);
TestBuilder builder = SortBuilder.getInstance();
if (builder != null) {
builder.reset();
}
builder = DeltaVerifierBuilder.getInstance();
if (builder != null) {
builder.reset();
}
}
/**
* Make sure this test runs first, before any other test
* has a chance to mess with the build order.
*/
public void testAardvarkBuildOrder() {
IWorkspace workspace = getWorkspace();
//builder order should initially be null
assertEquals("1.0", null, workspace.getDescription().getBuildOrder());
}
/**
* Tests the lifecycle of a builder.
*
* @see SortBuilder
*/
public void testAutoBuildPR() {
//REF: 1FUQUJ4
// Create some resource handles
IWorkspace workspace = getWorkspace();
IProject project1 = workspace.getRoot().getProject("PROJECT" + 1);
IFolder folder = project1.getFolder("FOLDER");
IFolder sub = folder.getFolder("sub");
IFile fileA = folder.getFile("A");
IFile fileB = sub.getFile("B");
// Create some resources
try {
// Turn auto-building on
setAutoBuilding(true);
project1.create(getMonitor());
project1.open(getMonitor());
// Set build spec
IProjectDescription desc = project1.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(SortBuilder.BUILDER_NAME);
command.getArguments().put(TestBuilder.BUILD_ID, "Project1Build1");
desc.setBuildSpec(new ICommand[] {command});
project1.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("1.99", e);
}
// Create folders and files
try {
folder.create(true, true, getMonitor());
fileA.create(getRandomContents(), true, getMonitor());
sub.create(true, true, getMonitor());
fileB.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("1.99", e);
}
}
/**
* Tests installing and running a builder that always fails during
* instantation.
*/
public void testBrokenBuilder() {
// Create some resource handles
IProject project = getWorkspace().getRoot().getProject("PROJECT");
try {
setAutoBuilding(false);
// Create and open a project
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// Create and set a build spec for the project
try {
IProjectDescription desc = project.getDescription();
ICommand command1 = desc.newCommand();
command1.setBuilderName(BrokenBuilder.BUILDER_NAME);
ICommand command2 = desc.newCommand();
command2.setBuilderName(SortBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command1, command2});
project.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
//do an incremental build -- build should fail, but second builder
// should run
try {
getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
fail("3.0");
} catch (CoreException e) {
//expected
}
TestBuilder verifier = SortBuilder.getInstance();
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent(TestBuilder.DEFAULT_BUILD_ID);
verifier.assertLifecycleEvents("3.1");
//build again -- it should succeed this time
try {
getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
} catch (CoreException e) {
fail("4.0", e);
}
}
public void testBuildClean() {
// Create some resource handles
IProject project = getWorkspace().getRoot().getProject("PROJECT");
try {
// Turn auto-building off
setAutoBuilding(false);
// Create and open a project
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// Create and set a build spec for the project
try {
IProjectDescription desc = project.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, DeltaVerifierBuilder.BUILDER_NAME, "Project2Build2")});
project.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
//start with a clean build
try {
getWorkspace().build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());
} catch (CoreException e) {
fail("3.1", e);
}
DeltaVerifierBuilder verifier = DeltaVerifierBuilder.getInstance();
assertTrue("3.2", verifier.wasCleanBuild());
// Now do an incremental build - since delta was null it should appear as a clean build
try {
getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
} catch (CoreException e) {
fail("3.3", e);
}
assertTrue("3.4", verifier.wasFullBuild());
// next time it will appear as an incremental build
try {
project.touch(getMonitor());
getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
} catch (CoreException e) {
fail("3.5", e);
}
assertTrue("3.6", verifier.wasIncrementalBuild());
//do another clean
try {
getWorkspace().build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());
} catch (CoreException e) {
fail("3.7", e);
}
assertTrue("3.8", verifier.wasCleanBuild());
//doing a full build should still look like a full build
try {
getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
} catch (CoreException e) {
fail("3.9", e);
}
assertTrue("3.10", verifier.wasFullBuild());
}
/**
* Tests the lifecycle of a builder.
*
* @see SortBuilder
*/
public void testBuildCommands() {
// Create some resource handles
IWorkspace workspace = getWorkspace();
IProject project1 = workspace.getRoot().getProject("PROJECT" + 1);
IProject project2 = workspace.getRoot().getProject("PROJECT" + 2);
IFile file1 = project1.getFile("FILE1");
IFile file2 = project2.getFile("FILE2");
//set the build order
try {
IWorkspaceDescription workspaceDesc = workspace.getDescription();
workspaceDesc.setBuildOrder(new String[] {project1.getName(), project2.getName()});
workspace.setDescription(workspaceDesc);
} catch (CoreException e) {
fail("0.0", e);
}
TestBuilder verifier = null;
try {
// Turn auto-building off
setAutoBuilding(false);
// Create some resources
project1.create(getMonitor());
project1.open(getMonitor());
project2.create(getMonitor());
project2.open(getMonitor());
file1.create(getRandomContents(), true, getMonitor());
file2.create(getRandomContents(), true, getMonitor());
// Do an initial build to get the builder instance
IProjectDescription desc = project1.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Project1Build1")});
project1.setDescription(desc, getMonitor());
project1.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier = SortBuilder.getInstance();
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Project1Build1");
verifier.assertLifecycleEvents("1.0");
} catch (CoreException e) {
fail("1.99", e);
}
// Build spec with no commands
try {
IProjectDescription desc = project1.getDescription();
desc.setBuildSpec(new ICommand[] {});
project1.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.99", e);
}
// Build the project -- should do nothing
try {
verifier.reset();
dirty(file1);
project1.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.assertLifecycleEvents("3.1");
} catch (CoreException e) {
fail("3.99", e);
}
// Build command with no arguments -- will use default build ID
try {
IProjectDescription desc = project1.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(SortBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command});
project1.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("4.99", e);
}
// Build the project
// Note that since the arguments have changed, the identity of the build
// command is different so a new builder will be instantiated
try {
dirty(file1);
project1.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent(TestBuilder.DEFAULT_BUILD_ID);
verifier.assertLifecycleEvents("5.2");
} catch (CoreException e) {
fail("5.99", e);
}
// Create and set a build specs for project one
try {
IProjectDescription desc = project1.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Project1Build1")});
project1.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("6.99", e);
}
// Create and set a build spec for project two
try {
IProjectDescription desc = project2.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, SortBuilder.BUILDER_NAME, "Project2Build1"), createCommand(desc, DeltaVerifierBuilder.BUILDER_NAME, "Project2Build2")});
project2.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("7.99", e);
}
// Build
try {
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Project1Build1");
//second builder is touched for the first time
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Project2Build1");
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Project2Build2");
dirty(file1);
dirty(file2);
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.assertLifecycleEvents("8.0");
verifier.addExpectedLifecycleEvent("Project1Build1");
dirty(file1);
project1.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
verifier.assertLifecycleEvents("8.2");
dirty(file2);
project2.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Project2Build1");
verifier.addExpectedLifecycleEvent("Project2Build2");
verifier.assertLifecycleEvents("8.3");
} catch (CoreException e) {
fail("8.99", e);
}
// Change order of build commands
try {
IProjectDescription desc = project2.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, DeltaVerifierBuilder.BUILDER_NAME, "Project2Build2"), createCommand(desc, SortBuilder.BUILDER_NAME, "Project2Build1")});
project2.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("10.99", e);
}
// Build
try {
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Project1Build1");
verifier.addExpectedLifecycleEvent("Project2Build2");
verifier.addExpectedLifecycleEvent("Project2Build1");
verifier.assertLifecycleEvents("11.0");
dirty(file1);
dirty(file2);
project1.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Project1Build1");
verifier.assertLifecycleEvents("11.2");
dirty(file1);
dirty(file2);
project2.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Project2Build2");
verifier.addExpectedLifecycleEvent("Project2Build1");
verifier.assertLifecycleEvents("11.3 ");
} catch (CoreException e) {
fail("11.99", e);
}
}
/**
* Tests that a pre_build listener is not called if there have been no changes
* since the last build of any kind occurred. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=154880.
*/
public void testPreBuildEvent() {
IWorkspace workspace = getWorkspace();
// Create some resource handles
final boolean[] notified = new boolean[] {false};
IProject proj1 = workspace.getRoot().getProject("PROJECT" + 1);
final IResourceChangeListener listener = event -> notified[0] = true;
workspace.addResourceChangeListener(listener, IResourceChangeEvent.PRE_BUILD);
try {
// Turn auto-building off
setAutoBuilding(false);
// Create some resources
proj1.create(getMonitor());
proj1.open(getMonitor());
// Create and set a build spec for project one
IProjectDescription desc = proj1.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build0")});
proj1.setDescription(desc, getMonitor());
proj1.build(IncrementalProjectBuilder.FULL_BUILD, SortBuilder.BUILDER_NAME, new HashMap<String, String>(), null);
notified[0] = false;
//now turn on autobuild and see if the listener is notified again
setAutoBuilding(true);
waitForBuild();
assertTrue("1.0", !notified[0]);
} catch (CoreException e) {
fail("2.99", e);
} finally {
workspace.removeResourceChangeListener(listener);
}
}
/**
* Tests the lifecycle of a builder.
*
* @see SortBuilder
*/
public void testBuildOrder() {
IWorkspace workspace = getWorkspace();
// Create some resource handles
IProject proj1 = workspace.getRoot().getProject("PROJECT" + 1);
IProject proj2 = workspace.getRoot().getProject("PROJECT" + 2);
try {
// Turn auto-building off
setAutoBuilding(false);
// Create some resources
proj1.create(getMonitor());
proj1.open(getMonitor());
proj2.create(getMonitor());
proj2.open(getMonitor());
//set the build order
setBuildOrder(proj1, proj2);
} catch (CoreException e) {
fail("1.99", e);
}
// Create and set a build specs for project one
try {
IProjectDescription desc = proj1.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build0")});
proj1.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.99", e);
}
// Create and set a build spec for project two
try {
IProjectDescription desc = proj2.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build1"), createCommand(desc, "Build2")});
proj2.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("3.99", e);
}
// Set up a plug-in lifecycle verifier for testing purposes
TestBuilder verifier = null;
// Build the workspace
try {
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier = SortBuilder.getInstance();
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Build0");
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Build1");
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Build2");
verifier.assertLifecycleEvents("4.0 ");
} catch (CoreException e) {
fail("4.99", e);
}
//build in reverse order
try {
setBuildOrder(proj2, proj1);
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Build1");
verifier.addExpectedLifecycleEvent("Build2");
verifier.addExpectedLifecycleEvent("Build0");
verifier.assertLifecycleEvents("5.0");
} catch (CoreException e) {
fail("5.99");
}
//only specify build order for project1
try {
setBuildOrder(proj1);
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Build0");
verifier.addExpectedLifecycleEvent("Build1");
verifier.addExpectedLifecycleEvent("Build2");
verifier.assertLifecycleEvents("6.0");
} catch (CoreException e) {
fail("6.99");
}
//only specify build order for project2
try {
setBuildOrder(proj2, proj1);
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Build1");
verifier.addExpectedLifecycleEvent("Build2");
verifier.addExpectedLifecycleEvent("Build0");
verifier.assertLifecycleEvents("7.0");
} catch (CoreException e) {
fail("7.99");
}
}
/**
* Tests that changing the dynamic build order will induce an autobuild on a project.
* This is a regression test for bug 60653.
*/
public void testChangeDynamicBuildOrder() {
IWorkspace workspace = getWorkspace();
// Create some resource handles
final IProject proj1 = workspace.getRoot().getProject("PROJECT" + 1);
final IProject proj2 = workspace.getRoot().getProject("PROJECT" + 2);
try {
// Turn auto-building on and make sure there is no explicit build order
setAutoBuilding(true);
IWorkspaceDescription wsDescription = getWorkspace().getDescription();
wsDescription.setBuildOrder(null);
getWorkspace().setDescription(wsDescription);
// Create and set a build spec for project two
getWorkspace().run((IWorkspaceRunnable) monitor -> {
proj2.create(getMonitor());
proj2.open(getMonitor());
IProjectDescription desc = proj2.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build1")});
proj2.setDescription(desc, getMonitor());
}, getMonitor());
waitForBuild();
} catch (CoreException e) {
fail("1.99", e);
}
// Set up a plug-in lifecycle verifier for testing purposes
TestBuilder verifier = SortBuilder.getInstance();
verifier.reset();
//create project two and establish a build order by adding a dynamic
//reference from proj2->proj1 in the same operation
try {
getWorkspace().run((IWorkspaceRunnable) monitor -> {
// Create and set a build specs for project one
proj1.create(getMonitor());
proj1.open(getMonitor());
IProjectDescription desc = proj1.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build0")});
proj1.setDescription(desc, getMonitor());
//add the dynamic reference to project two
IProjectDescription description = proj2.getDescription();
description.setDynamicReferences(new IProject[] {proj1});
proj2.setDescription(description, IResource.NONE, null);
}, getMonitor());
} catch (CoreException e1) {
fail("2.99", e1);
}
waitForBuild();
//ensure the build happened in the correct order, and that both projects were built
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Build0");
verifier.addExpectedLifecycleEvent("Build1");
verifier.assertLifecycleEvents("3.0");
}
/**
* Tests that changing the dynamic build order during a pre-build notification causes projects
* to be built in the correct order.
* This is a regression test for bug 330194.
*/
public void testChangeDynamicBuildOrderDuringPreBuild() throws Exception {
IWorkspace workspace = getWorkspace();
// Create some resource handles
final IProject proj1 = workspace.getRoot().getProject("bug_330194_referencer");
final IProject proj2 = workspace.getRoot().getProject("bug_330194_referencee");
// Disable workspace auto-build
setAutoBuilding(false);
ensureExistsInWorkspace(proj1, false);
ensureExistsInWorkspace(proj2, false);
IProjectDescription desc = proj1.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build0")});
proj1.setDescription(desc, getMonitor());
desc = proj2.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build1")});
proj2.setDescription(desc, getMonitor());
// Ensure the builder is instantiated
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
// Add pre-build listener that swap around the dependencies
IResourceChangeListener buildListener = event -> {
try {
IProjectDescription desc1 = proj1.getDescription();
IProjectDescription desc2 = proj2.getDescription();
// Swap around the references
if (desc1.getDynamicReferences().length == 0) {
desc1.setDynamicReferences(new IProject[] {proj2});
desc2.setDynamicReferences(new IProject[0]);
} else {
desc1.setDynamicReferences(new IProject[0]);
desc2.setDynamicReferences(new IProject[] {proj1});
}
proj1.setDescription(desc1, getMonitor());
proj2.setDescription(desc2, getMonitor());
} catch (CoreException e) {
fail();
}
};
try {
getWorkspace().addResourceChangeListener(buildListener, IResourceChangeEvent.PRE_BUILD);
// Set up a plug-in lifecycle verifier for testing purposes
TestBuilder verifier = SortBuilder.getInstance();
verifier.reset();
// FULL_BUILD 1
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Build1");
verifier.addExpectedLifecycleEvent("Build0");
verifier.assertLifecycleEvents("1.0");
verifier.reset();
// FULL_BUILD 2
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Build0");
verifier.addExpectedLifecycleEvent("Build1");
verifier.assertLifecycleEvents("2.0");
verifier.reset();
// AUTO_BUILD
setAutoBuilding(true);
proj1.touch(getMonitor());
waitForBuild();
verifier.addExpectedLifecycleEvent("Build1");
verifier.addExpectedLifecycleEvent("Build0");
verifier.assertLifecycleEvents("3.0");
verifier.reset();
// AUTO_BUILD 2
proj1.touch(getMonitor());
waitForBuild();
verifier.addExpectedLifecycleEvent("Build0");
verifier.addExpectedLifecycleEvent("Build1");
verifier.assertLifecycleEvents("4.0");
verifier.reset();
} finally {
getWorkspace().removeResourceChangeListener(buildListener);
}
}
/**
* Ensure that build order is preserved when project is closed/opened.
*/
public void testCloseOpenProject() {
IWorkspace workspace = getWorkspace();
IProject project = workspace.getRoot().getProject("PROJECT" + 1);
try {
// Create some resources
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("1.99", e);
}
// Create and set a build spec
try {
IProjectDescription desc = project.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build1"), createCommand(desc, "Build2")});
project.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.99", e);
}
try {
project.close(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("3.99", e);
}
//ensure the build spec hasn't changed
try {
IProjectDescription desc = project.getDescription();
ICommand[] commands = desc.getBuildSpec();
assertEquals("4.0", 2, commands.length);
assertEquals("4.1", commands[0].getBuilderName(), SortBuilder.BUILDER_NAME);
assertEquals("4.2", commands[1].getBuilderName(), SortBuilder.BUILDER_NAME);
Map<String, String> args = commands[0].getArguments();
assertEquals("4.3", "Build1", args.get(TestBuilder.BUILD_ID));
args = commands[1].getArguments();
assertEquals("4.4", "Build2", args.get(TestBuilder.BUILD_ID));
} catch (CoreException e) {
fail("4.99", e);
}
}
/**
* Tests that when a project is copied, the copied project has a full build
* but the source project does not.
*/
public void testCopyProject() {
IWorkspace workspace = getWorkspace();
// Create some resource handles
IProject proj1 = workspace.getRoot().getProject("testCopyProject" + 1);
IProject proj2 = workspace.getRoot().getProject("testCopyProject" + 2);
try {
// Turn auto-building on
setAutoBuilding(true);
// Create some resources
proj1.create(getMonitor());
proj1.open(getMonitor());
ensureDoesNotExistInWorkspace(proj2);
} catch (CoreException e) {
fail("1.99", e);
}
// Create and set a build spec for project one
try {
IProjectDescription desc = proj1.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build0")});
proj1.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.99", e);
}
waitForBuild();
SortBuilder.getInstance().reset();
try {
IProjectDescription desc = proj1.getDescription();
desc.setName(proj2.getName());
proj1.copy(desc, IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("3.99", e);
}
waitForBuild();
SortBuilder builder = SortBuilder.getInstance();
assertEquals("4.0", proj2, builder.getProject());
//builder 2 should have done a full build
builder.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
builder.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
builder.addExpectedLifecycleEvent("Build0");
builder.assertLifecycleEvents("4.4");
assertTrue("4.5", builder.wasFullBuild());
}
/**
* Tests an implicit workspace build order created by setting dynamic
* project references.
*/
public void testDynamicBuildOrder() {
IWorkspace workspace = getWorkspace();
// Create some resource handles
IProject proj1 = workspace.getRoot().getProject("PROJECT" + 1);
IProject proj2 = workspace.getRoot().getProject("PROJECT" + 2);
try {
// Turn auto-building off
setAutoBuilding(false);
// Create some resources
proj1.create(getMonitor());
proj1.open(getMonitor());
proj2.create(getMonitor());
proj2.open(getMonitor());
//establish a build order by adding a dynamic reference from
// proj2->proj1
IProjectDescription description = proj2.getDescription();
description.setDynamicReferences(new IProject[] {proj1});
proj2.setDescription(description, IResource.NONE, null);
IWorkspaceDescription wsDescription = getWorkspace().getDescription();
wsDescription.setBuildOrder(null);
getWorkspace().setDescription(wsDescription);
} catch (CoreException e) {
fail("1.99", e);
}
// Create and set a build specs for project one
try {
IProjectDescription desc = proj1.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build0")});
proj1.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.99", e);
}
// Create and set a build spec for project two
try {
IProjectDescription desc = proj2.getDescription();
desc.setBuildSpec(new ICommand[] {createCommand(desc, "Build1"), createCommand(desc, "Build2")});
proj2.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("3.99", e);
}
// Set up a plug-in lifecycle verifier for testing purposes
TestBuilder verifier = null;
// Build the workspace
try {
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier = SortBuilder.getInstance();
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Build0");
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Build1");
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent("Build2");
verifier.assertLifecycleEvents("4.0 ");
} catch (CoreException e) {
fail("4.99", e);
}
//build in reverse order
try {
//reverse the order by adding a dynamic reference from proj1->proj2
IProjectDescription description = proj2.getDescription();
description.setDynamicReferences(new IProject[0]);
proj2.setDescription(description, IResource.NONE, null);
description = proj1.getDescription();
description.setDynamicReferences(new IProject[] {proj2});
proj1.setDescription(description, IResource.NONE, null);
workspace.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent("Build1");
verifier.addExpectedLifecycleEvent("Build2");
verifier.addExpectedLifecycleEvent("Build0");
verifier.assertLifecycleEvents("5.0");
} catch (CoreException e) {
fail("5.99");
}
}
/**
* Tests that enabling autobuild causes a build to occur.
*/
public void testEnableAutobuild() {
// Create some resource handles
IProject project = getWorkspace().getRoot().getProject("PROJECT");
try {
// Turn auto-building off
setAutoBuilding(false);
// Create and open a project
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// Create and set a build spec for the project
try {
IProjectDescription desc = project.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(SortBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command});
project.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
// Set up a plug-in lifecycle verifier for testing purposes
TestBuilder verifier = null;
//Cause a build by enabling autobuild
try {
setAutoBuilding(true);
waitForBuild();
verifier = SortBuilder.getInstance();
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent(TestBuilder.DEFAULT_BUILD_ID);
verifier.assertLifecycleEvents("3.1");
} catch (CoreException e) {
fail("3.2", e);
}
}
/**
* Tests installing and running a builder that always fails in its build method
*/
public void testExceptionBuilder() {
// Create some resource handles
IProject project = getWorkspace().getRoot().getProject("PROJECT");
try {
setAutoBuilding(false);
// Create and open a project
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// Create and set a build spec for the project
try {
IProjectDescription desc = project.getDescription();
ICommand command1 = desc.newCommand();
command1.setBuilderName(ExceptionBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command1});
project.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
final boolean[] listenerCalled = new boolean[] {false};
IResourceChangeListener listener = event -> listenerCalled[0] = true;
getWorkspace().addResourceChangeListener(listener, IResourceChangeEvent.POST_BUILD);
//do an incremental build -- build should fail, but POST_BUILD should still occur
try {
getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
fail("3.0");
} catch (CoreException e) {
//see discussion in bug 273147 about build exception severity
assertEquals("3.1", IStatus.ERROR, e.getStatus().getSeverity());
//expected
} finally {
getWorkspace().removeResourceChangeListener(listener);
}
assertTrue("1.0", listenerCalled[0]);
}
/**
* Tests the method IncrementProjectBuilder.forgetLastBuiltState
*/
public void testForgetLastBuiltState() {
// Create some resource handles
IProject project = getWorkspace().getRoot().getProject("PROJECT");
try {
// Turn auto-building off
setAutoBuilding(false);
// Create and open a project
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// Create and set a build spec for the project
try {
IProjectDescription desc = project.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(SortBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command});
project.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
// Set up a plug-in lifecycle verifier for testing purposes
SortBuilder verifier = null;
//do an initial build
try {
project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, SortBuilder.BUILDER_NAME, null, getMonitor());
verifier = SortBuilder.getInstance();
} catch (CoreException e) {
fail("3.2", e);
}
//forget last built state
verifier.forgetLastBuiltState();
// Now do another incremental build. Delta should be null
try {
project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, SortBuilder.BUILDER_NAME, null, getMonitor());
assertTrue("4.0", verifier.wasDeltaNull());
} catch (CoreException e) {
fail("4.99", e);
}
// Do another incremental build, requesting a null build state. Delta
// should not be null
verifier.requestForgetLastBuildState();
try {
project.touch(getMonitor());
project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, SortBuilder.BUILDER_NAME, null, getMonitor());
assertTrue("5.0", !verifier.wasDeltaNull());
} catch (CoreException e) {
fail("5.99", e);
}
//try a snapshot when a builder has a null tree
try {
getWorkspace().save(false, getMonitor());
} catch (CoreException e) {
fail("6.99");
}
// Do another incremental build. Delta should be null
try {
project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, SortBuilder.BUILDER_NAME, null, getMonitor());
assertTrue("7.0", verifier.wasDeltaNull());
} catch (CoreException e) {
fail("7.99", e);
}
// Delete the project
try {
project.delete(false, getMonitor());
} catch (CoreException e) {
fail("99.99", e);
}
}
/**
* Tests that a client invoking a manual incremental build before autobuild has had
* a chance to run will block until the build completes. See bug 275879.
*/
public void testIncrementalBuildBeforeAutobuild() {
// Create some resource handles
final IProject project = getWorkspace().getRoot().getProject("PROJECT");
final IFile input = project.getFolder(SortBuilder.DEFAULT_UNSORTED_FOLDER).getFile("File.txt");
final IFile output = project.getFolder(SortBuilder.DEFAULT_SORTED_FOLDER).getFile("File.txt");
try {
setAutoBuilding(true);
// Create and open a project
project.create(getMonitor());
project.open(getMonitor());
IProjectDescription desc = project.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(SortBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command});
project.setDescription(desc, getMonitor());
ensureExistsInWorkspace(input, getRandomContents());
} catch (CoreException e) {
fail("0.99", e);
}
waitForBuild();
assertTrue("1.0", output.exists());
//change the file and then immediately perform build
final ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
getWorkspace().run((IWorkspaceRunnable) monitor -> {
input.setContents(new ByteArrayInputStream(new byte[] {5, 4, 3, 2, 1}), IResource.NONE, getMonitor());
project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
transferStreams(output.getContents(), out, null, null);
}, getMonitor());
} catch (CoreException e) {
fail("1.99", e);
}
byte[] result = out.toByteArray();
byte[] expected = new byte[] {1, 2, 3, 4, 5};
assertEquals("2.0", expected.length, result.length);
for (int i = 0; i < expected.length; i++) {
assertEquals("2.1." + i, expected[i], result[i]);
}
}
/**
* Tests that autobuild is interrupted by a background scheduled job, but eventually completes.
*/
public void testInterruptAutobuild() {
// Create some resource handles
IProject project = getWorkspace().getRoot().getProject("PROJECT");
final IFile file = project.getFile("File.txt");
try {
setAutoBuilding(true);
// Create and open a project
project.create(getMonitor());
project.open(getMonitor());
IProjectDescription desc = project.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(SortBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command});
project.setDescription(desc, getMonitor());
file.create(getRandomContents(), IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
waitForBuild();
// Set up a plug-in lifecycle verifier for testing purposes
TestBuilder verifier = SortBuilder.getInstance();
verifier.reset();
final TestJob blockedJob = new TestJob("Interrupt build", 3, 1000);
blockedJob.setRule(getWorkspace().getRoot());
//use a barrier to ensure the blocking job starts
final TestBarrier barrier = new TestBarrier();
barrier.setStatus(TestBarrier.STATUS_WAIT_FOR_START);
//install a listener that will cause autobuild to be interrupted
IResourceChangeListener listener = event -> {
blockedJob.schedule();
//wait for autobuild to become blocking
while (!Job.getJobManager().currentJob().isBlocking()) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
//ignore
}
}
//allow the test main method to continue
barrier.setStatus(TestBarrier.STATUS_RUNNING);
};
try {
getWorkspace().addResourceChangeListener(listener, IResourceChangeEvent.PRE_BUILD);
// Now change a file. The build should not complete until the job triggered by the listener completes
file.setContents(getRandomContents(), IResource.NONE, getMonitor());
//wait for job to be scheduled
barrier.waitForStatus(TestBarrier.STATUS_RUNNING);
//wait for test job to complete
try {
blockedJob.join();
} catch (InterruptedException e) {
fail("1.99", e);
}
//autobuild should now run after the blocking job is finished
waitForBuild();
verifier.addExpectedLifecycleEvent(TestBuilder.DEFAULT_BUILD_ID);
verifier.assertLifecycleEvents("2.0");
} catch (CoreException e) {
fail("2.99", e);
} finally {
getWorkspace().removeResourceChangeListener(listener);
}
}
/**
* Tests the lifecycle of a builder.
*/
public void testLifecycleEvents() {
// Create some resource handles
IProject project = getWorkspace().getRoot().getProject("PROJECT");
try {
// Turn auto-building off
setAutoBuilding(false);
// Create and open a project
project.create(getMonitor());
project.open(getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// Create and set a build spec for the project
try {
IProjectDescription desc = project.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(SortBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command});
project.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
// Set up a plug-in lifecycle verifier for testing purposes
TestBuilder verifier = null;
//try to do an incremental build when there has never
//been a batch build
try {
getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
verifier = SortBuilder.getInstance();
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent(TestBuilder.DEFAULT_BUILD_ID);
verifier.assertLifecycleEvents("3.1");
} catch (CoreException e) {
fail("3.2", e);
}
// Now do another incremental build. Since we just did one, nothing
// should happen in this one.
try {
getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
verifier.assertLifecycleEvents("3.4");
} catch (CoreException e) {
fail("3.5", e);
}
// Now do a batch build
try {
getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
verifier.addExpectedLifecycleEvent(TestBuilder.DEFAULT_BUILD_ID);
verifier.assertLifecycleEvents("3.6");
} catch (CoreException e) {
fail("3.8", e);
}
// Close the project
try {
project.close(getMonitor());
} catch (CoreException e) {
fail("4.1", e);
}
// Open the project, build it, and delete it
try {
project.open(getMonitor());
getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
project.delete(false, getMonitor());
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent(TestBuilder.DEFAULT_BUILD_ID);
verifier.assertLifecycleEvents("5.0");
} catch (CoreException e) {
fail("5.1", e);
}
}
/**
* Tests the lifecycle of a builder.
*
* @see SortBuilder
*/
public void testMoveProject() {
// Create some resource handles
IWorkspace workspace = getWorkspace();
IProject proj1 = workspace.getRoot().getProject("PROJECT" + 1);
IProject proj2 = workspace.getRoot().getProject("Destination");
try {
// Turn auto-building off
setAutoBuilding(false);
// Create some resources
proj1.create(getMonitor());
proj1.open(getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// Create and set a build specs for project one
try {
IProjectDescription desc = proj1.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(SortBuilder.BUILDER_NAME);
command.getArguments().put(TestBuilder.BUILD_ID, "Build0");
desc.setBuildSpec(new ICommand[] {command});
proj1.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
// build project1
try {
proj1.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
} catch (CoreException e) {
fail("3.0", e);
}
// move proj1 to proj2
try {
proj1.move(proj2.getFullPath(), false, getMonitor());
} catch (CoreException e) {
fail("4.0", e);
}
// build proj2
try {
proj2.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
} catch (CoreException e) {
fail("5.0", e);
}
}
/**
* Tests that turning autobuild on will invoke a build in the next
* operation.
*/
public void testTurnOnAutobuild() throws CoreException {
// Create some resource handles
IProject project = getWorkspace().getRoot().getProject("PROJECT");
final IFile file = project.getFile("File.txt");
try {
// Turn auto-building off
setAutoBuilding(false);
// Create and open a project
project.create(getMonitor());
project.open(getMonitor());
file.create(getRandomContents(), IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// Create and set a build spec for the project
try {
IProjectDescription desc = project.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(SortBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command});
project.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
// Set up a plug-in lifecycle verifier for testing purposes
TestBuilder verifier = null;
//try to do an incremental build when there has never
//been a batch build
try {
getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
verifier = SortBuilder.getInstance();
verifier.addExpectedLifecycleEvent(TestBuilder.SET_INITIALIZATION_DATA);
verifier.addExpectedLifecycleEvent(TestBuilder.STARTUP_ON_INITIALIZE);
verifier.addExpectedLifecycleEvent(TestBuilder.DEFAULT_BUILD_ID);
verifier.assertLifecycleEvents("3.1");
} catch (CoreException e) {
fail("3.2", e);
}
// Now make a change and then turn autobuild on. Turning it on should
// cause a build.
IWorkspaceRunnable r = monitor -> {
file.setContents(getRandomContents(), IResource.NONE, getMonitor());
IWorkspaceDescription desc = getWorkspace().getDescription();
desc.setAutoBuilding(true);
getWorkspace().setDescription(desc);
};
waitForBuild();
getWorkspace().run(r, getMonitor());
waitForBuild();
verifier.addExpectedLifecycleEvent(TestBuilder.DEFAULT_BUILD_ID);
verifier.assertLifecycleEvents("4.0");
}
}