/*******************************************************************************
* Copyright (c) 2000, 2015 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
*******************************************************************************/
package org.eclipse.core.tests.internal.builders;
import java.io.ByteArrayInputStream;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.CoreException;
/**
* Tests that deltas supplied to the builder are accurate
*/
public class BuildDeltaVerificationTest extends AbstractBuilderTest {
DeltaVerifierBuilder verifier;
/* some random resource handles */
protected static final String PROJECT1 = "Project1";
protected static final String PROJECT2 = "Project2";
protected static final String FOLDER1 = "Folder1";
protected static final String FOLDER2 = "Folder2";
protected static final String FILE1 = "File1";
protected static final String FILE2 = "File2";
protected static final String FILE3 = "File3";
IProject project1;
IProject project2;
IFolder folder1;//below project2
IFolder folder2;//below folder1
IFolder folder3;//same as file1
IFile file1;//below folder1
IFile file2;//below folder1
IFile file3;//below folder2
public BuildDeltaVerificationTest() {
super(null);
}
/**
* Creates a new instance of BuildDeltaVerificationTest.
* @param name java.lang.String
*/
public BuildDeltaVerificationTest(String name) {
super(name);
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void assertDelta() {
if (!verifier.isDeltaValid()) {
// System.out.println(verifier.getMessage());
}
assertTrue("Should be an incremental build", verifier.wasIncrementalBuild());
assertTrue(verifier.getMessage(), verifier.isDeltaValid());
}
/**
* Runs code to handle a core exception
*/
protected void handleCoreException(CoreException e) {
assertTrue("CoreException: " + e.getMessage(), false);
}
/**
* Rebuilds the solution.
*/
protected void rebuild() throws CoreException {
project1.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
project2.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, getMonitor());
}
/**
* Sets up the fixture, for example, open a network connection.
* This method is called before a test is executed.
*/
@Override
protected void setUp() throws Exception {
super.setUp();
// Turn auto-building off
IWorkspace workspace = getWorkspace();
setAutoBuilding(false);
// Create some resource handles
project1 = workspace.getRoot().getProject(PROJECT1);
project2 = workspace.getRoot().getProject(PROJECT2);
folder1 = project1.getFolder(FOLDER1);
folder2 = folder1.getFolder(FOLDER2);
folder3 = folder1.getFolder(FILE1);
file1 = folder1.getFile(FILE1);
file2 = folder1.getFile(FILE2);
file3 = folder2.getFile(FILE1);
// Create and open a project, folder and file
try {
project1.create(getMonitor());
project1.open(getMonitor());
folder1.create(true, true, getMonitor());
file1.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// Create and set a build spec for the project
try {
IProjectDescription desc = project1.getDescription();
ICommand command = desc.newCommand();
command.setBuilderName(DeltaVerifierBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {command});
project1.setDescription(desc, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
// Build the project
try {
project1.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());
} catch (CoreException e) {
fail("3.3", e);
}
verifier = DeltaVerifierBuilder.getInstance();
assertNotNull("Builder was not instantiated", verifier);
assertTrue("First build should be a batch build", verifier.wasFullBuild());
}
public static Test suite() {
TestSuite suite = new TestSuite(BuildDeltaVerificationTest.class);
// suite.addTest(new BuildDeltaVerificationTest("testCloseOpenReplaceFile"));
return suite;
}
/**
* 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, getMonitor());
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testAddAndRemoveFile() {
try {
ByteArrayInputStream in = new ByteArrayInputStream(new byte[] {4, 5, 6});
file2.create(in, true, getMonitor());
file2.delete(true, getMonitor());
rebuild();
//builder for project1 may not even be called (empty delta)
if (verifier.wasFullBuild()) {
verifier.emptyBuild();
}
assertTrue(verifier.getMessage(), verifier.isDeltaValid());
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testAddAndRemoveFolder() {
try {
folder2.create(true, true, getMonitor());
folder2.delete(true, getMonitor());
rebuild();
//builder for project1 may not even be called (empty delta)
if (verifier.wasFullBuild()) {
verifier.emptyBuild();
}
assertTrue(verifier.getMessage(), verifier.isDeltaValid());
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testAddFile() {
try {
verifier.addExpectedChange(file2, project1, IResourceDelta.ADDED, 0);
ByteArrayInputStream in = new ByteArrayInputStream(new byte[] {4, 5, 6});
file2.create(in, true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testAddFileAndFolder() {
try {
verifier.addExpectedChange(folder2, project1, IResourceDelta.ADDED, 0);
verifier.addExpectedChange(file3, project1, IResourceDelta.ADDED, 0);
folder2.create(true, true, getMonitor());
ByteArrayInputStream in = new ByteArrayInputStream(new byte[] {4, 5, 6});
file3.create(in, true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testAddFolder() {
try {
verifier.addExpectedChange(folder2, project1, IResourceDelta.ADDED, 0);
folder2.create(true, true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testAddProject() {
try {
//should not affect project1's delta
project2.create(getMonitor());
rebuild();
//builder for project1 should not even be called
assertTrue(verifier.getMessage(), verifier.isDeltaValid());
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testChangeFile() {
try {
/* change file1's contents */
verifier.addExpectedChange(file1, project1, IResourceDelta.CHANGED, IResourceDelta.CONTENT);
ByteArrayInputStream in = new ByteArrayInputStream(new byte[] {4, 5, 6});
file1.setContents(in, true, false, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testChangeFileToFolder() {
try {
/* change file1 into a folder */
verifier.addExpectedChange(file1, project1, IResourceDelta.CHANGED, IResourceDelta.CONTENT | IResourceDelta.TYPE | IResourceDelta.REPLACED);
file1.delete(true, getMonitor());
folder3.create(true, true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testChangeFolderToFile() {
try {
/* change to a folder */
file1.delete(true, getMonitor());
folder3.create(true, true, getMonitor());
rebuild();
/* now change back to a file and verify */
verifier.addExpectedChange(file1, project1, IResourceDelta.CHANGED, IResourceDelta.CONTENT | IResourceDelta.TYPE | IResourceDelta.REPLACED);
folder3.delete(true, getMonitor());
ByteArrayInputStream in = new ByteArrayInputStream(new byte[] {1, 2});
file1.create(in, true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testCloseOpenReplaceFile() {
try {
rebuild();
project1.close(null);
project1.open(null);
/* change file1's contents */
verifier = DeltaVerifierBuilder.getInstance();
verifier.addExpectedChange(file1, project1, IResourceDelta.CHANGED, IResourceDelta.REPLACED | IResourceDelta.CONTENT);
file1.delete(true, null);
file1.create(getRandomContents(), true, null);
rebuild();
//new builder gets instantiated so grab a reference to the latest builder
verifier = DeltaVerifierBuilder.getInstance();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testMoveFile() {
try {
verifier.addExpectedChange(folder2, project1, IResourceDelta.ADDED, 0);
verifier.addExpectedChange(file1, project1, IResourceDelta.REMOVED, IResourceDelta.MOVED_TO, null, file3.getFullPath());
verifier.addExpectedChange(file3, project1, IResourceDelta.ADDED, IResourceDelta.MOVED_FROM, file1.getFullPath(), null);
folder2.create(true, true, getMonitor());
file1.move(file3.getFullPath(), true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testRemoveFile() {
try {
verifier.addExpectedChange(file1, project1, IResourceDelta.REMOVED, 0);
file1.delete(true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testRemoveFileAndFolder() {
try {
verifier.addExpectedChange(folder1, project1, IResourceDelta.REMOVED, 0);
verifier.addExpectedChange(file1, project1, IResourceDelta.REMOVED, 0);
folder1.delete(true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testReplaceFile() {
try {
/* change file1's contents */
verifier.addExpectedChange(file1, project1, IResourceDelta.CHANGED, IResourceDelta.REPLACED | IResourceDelta.CONTENT);
ByteArrayInputStream in = new ByteArrayInputStream(new byte[] {4, 5, 6});
file1.delete(true, getMonitor());
file1.create(in, true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
/**
* Tests that the builder is receiving an appropriate delta
* @see SortBuilderPlugin
* @see SortBuilder
*/
public void testTwoFileChanges() {
try {
verifier.addExpectedChange(file1, project1, IResourceDelta.CHANGED, IResourceDelta.CONTENT);
verifier.addExpectedChange(file2, project1, IResourceDelta.ADDED, 0);
ByteArrayInputStream in = new ByteArrayInputStream(new byte[] {4, 5, 6});
file1.setContents(in, true, false, getMonitor());
ByteArrayInputStream in2 = new ByteArrayInputStream(new byte[] {4, 5, 6});
file2.create(in2, true, getMonitor());
rebuild();
assertDelta();
} catch (CoreException e) {
handleCoreException(e);
}
}
}