/*******************************************************************************
* 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
* Alexander Kurtakov <akurtako@redhat.com> - Bug 459343
*******************************************************************************/
package org.eclipse.core.tests.resources;
import java.util.*;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.CoreException;
/**
* Performs black box testing of the following API methods:
* <code>IWorkspace.computeProjectOrder(IProject[])</code>
* <code>IWorkspace.computePrerequisiteOrder(IProject[])</code>
*/
public class ProjectOrderTest extends ResourceTest {
public ProjectOrderTest() {
super();
}
public ProjectOrderTest(String name) {
super(name);
}
public static Test suite() {
TestSuite suite = new TestSuite(ProjectOrderTest.class);
return suite;
}
/**
* Adds a project reference from the given source project, which must
* be accessible, to the given target project, which need not be accessible.
* Does nothing if the source project already has a project reference
* to the target project.
*
* @param source the source project; must be accessible
* @param target the target project; need not be accessible
*/
void addProjectReference(IProject source, IProject target) {
try {
IProjectDescription pd = source.getDescription();
IProject[] a = pd.getReferencedProjects();
Set<IProject> x = new HashSet<>();
x.addAll(Arrays.asList(a));
x.add(target);
IProject[] r = new IProject[x.size()];
x.toArray(r);
pd.setReferencedProjects(r);
source.setDescription(pd, null);
} catch (CoreException e) {
assertTrue("", false);
}
}
/**
* P0, P1<-P2<-P3<-P4, P5
*/
public void test0() {
IWorkspace ws = getWorkspace();
IWorkspaceRoot root = ws.getRoot();
IProject p0 = root.getProject("p0");
IProject p1 = root.getProject("p1");
IProject p2 = root.getProject("p2");
IProject p3 = root.getProject("p3");
IProject p4 = root.getProject("p4");
IProject p5 = root.getProject("p5");
try {
p0.create(null);
p0.open(null);
p1.create(null);
p1.open(null);
p2.create(null);
p2.open(null);
p3.create(null);
p3.open(null);
p4.create(null);
p4.open(null);
p5.create(null);
p5.open(null);
addProjectReference(p2, p1);
addProjectReference(p3, p2);
addProjectReference(p4, p3);
IProject[] projects = new IProject[] {p4, p3, p2, p5, p1, p0};
IProject[][] oldOrder = ws.computePrerequisiteOrder(projects);
assertTrue("0.1", oldOrder[1].length == 0);
List<IProject> x = Arrays.asList(oldOrder[0]);
assertTrue("0.2", x.size() == 6);
assertTrue("0.3", x.indexOf(p0) >= 0);
assertTrue("0.4", x.indexOf(p1) >= 0);
assertTrue("0.5", x.indexOf(p5) >= 0);
assertTrue("0.6", x.indexOf(p2) > x.indexOf(p1));
assertTrue("0.7", x.indexOf(p3) > x.indexOf(p2));
assertTrue("0.8", x.indexOf(p4) > x.indexOf(p3));
IWorkspace.ProjectOrder order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("0.9", !order.hasCycles);
assertTrue("0.10", order.knots.length == 0);
assertTrue("0.11", x.size() == 6);
assertTrue("0.12", x.indexOf(p0) < x.indexOf(p1)); //alpha
assertTrue("0.13", x.indexOf(p2) > x.indexOf(p1)); //ref
assertTrue("0.14", x.indexOf(p3) > x.indexOf(p2)); //ref
assertTrue("0.15", x.indexOf(p4) > x.indexOf(p3)); //ref
assertTrue("0.16", x.indexOf(p5) > x.indexOf(p4)); //alpha
} catch (CoreException e) {
assertTrue("0.0", false);
}
}
public void test1() {
IWorkspace ws = getWorkspace();
IWorkspaceRoot root = ws.getRoot();
IProject p0 = root.getProject("p0");
IProject p1 = root.getProject("p1");
IProject[] projects = new IProject[] {};
IProject[][] oldOrder = ws.computePrerequisiteOrder(projects);
List<IProject> x = Arrays.asList(oldOrder[0]);
assertTrue("1.1", oldOrder[1].length == 0);
assertTrue("1.2", x.size() == 0);
// no projects
IWorkspace.ProjectOrder order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.3", !order.hasCycles);
assertTrue("1.4", order.knots.length == 0);
assertTrue("1.5", x.size() == 0);
// 1 project
try {
// open projects show up
p0.create(null);
p0.open(null);
projects = new IProject[] {p0};
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.6.1", oldOrder[1].length == 0);
assertTrue("1.6.2", x.size() == 1);
assertTrue("1.6.3", x.indexOf(p0) >= 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.6.4", !order.hasCycles);
assertTrue("1.6.5", order.knots.length == 0);
assertTrue("1.6.6", x.size() == 1);
assertTrue("1.6.7", x.indexOf(p0) >= 0);
// closed projects do not show up
p0.close(null);
projects = new IProject[] {p0};
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.6,8", oldOrder[1].length == 0);
assertTrue("1.6.9", x.size() == 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.6.10", !order.hasCycles);
assertTrue("1.6.11", order.knots.length == 0);
assertTrue("1.6.12", x.size() == 0);
// non-existent projects do not show up either
projects = new IProject[] {p0, p1};
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.6.13", oldOrder[1].length == 0);
assertTrue("1.6.14", x.size() == 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.6.15", !order.hasCycles);
assertTrue("1.6.16", order.knots.length == 0);
assertTrue("1.6.17", x.size() == 0);
p0.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, null);
} catch (CoreException e) {
assertTrue("1.6.0", false);
}
// 2 projects no references
try {
// open projects show up
p0.create(null);
p0.open(null);
p1.create(null);
p1.open(null);
projects = new IProject[] {p1, p0};
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.7.1", oldOrder[1].length == 0);
assertTrue("1.7.2", x.size() == 2);
assertTrue("1.7.3", x.indexOf(p0) >= 0);
assertTrue("1.7.4", x.indexOf(p1) >= 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.7.5", x.size() == 2);
assertTrue("1.7.6", x.indexOf(p0) >= 0);
assertTrue("1.7.7", x.indexOf(p1) >= 0);
// alpha order
assertTrue("1.7.8", x.indexOf(p0) < x.indexOf(p1));
assertTrue("1.7.9", !order.hasCycles);
assertTrue("1.7.10", order.knots.length == 0);
// closed projects do not show up
p0.close(null);
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.7.11", oldOrder[1].length == 0);
assertTrue("1.7.12", x.size() == 1);
assertTrue("1.7.13", x.indexOf(p0) < 0);
assertTrue("1.7.14", x.indexOf(p1) >= 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.7.15", !order.hasCycles);
assertTrue("1.7.16", order.knots.length == 0);
assertTrue("1.7.17", x.size() == 1);
assertTrue("1.7.18", x.indexOf(p0) < 0);
assertTrue("1.7.19", x.indexOf(p1) >= 0);
p0.open(null);
p1.close(null);
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.7.20", oldOrder[1].length == 0);
assertTrue("1.7.21", x.size() == 1);
assertTrue("1.7.22", x.indexOf(p0) >= 0);
assertTrue("1.7.23", x.indexOf(p1) < 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.7.24", !order.hasCycles);
assertTrue("1.7.25", order.knots.length == 0);
assertTrue("1.7.26", x.size() == 1);
assertTrue("1.7.27", x.indexOf(p0) >= 0);
assertTrue("1.7.28", x.indexOf(p1) < 0);
p0.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, null);
p1.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, null);
} catch (CoreException e) {
assertTrue("1.7.0", false);
}
// 2 projects: "p0" refs "p1"
try {
p0.create(null);
p0.open(null);
p1.create(null);
p1.open(null);
addProjectReference(p0, p1);
projects = new IProject[] {p1, p0};
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.8.1", oldOrder[1].length == 0);
assertTrue("1.8.2", x.size() == 2);
assertTrue("1.8.3", x.indexOf(p0) >= 0);
assertTrue("1.8.4", x.indexOf(p1) >= 0);
assertTrue("1.8.5", x.indexOf(p0) > x.indexOf(p1));
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.8.6", x.size() == 2);
assertTrue("1.8.7", x.indexOf(p0) >= 0);
assertTrue("1.8.8", x.indexOf(p1) >= 0);
assertTrue("1.8.9", x.indexOf(p0) > x.indexOf(p1));
assertTrue("1.8.10", !order.hasCycles);
assertTrue("1.8.11", order.knots.length == 0);
p0.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, null);
p1.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, null);
} catch (CoreException e) {
assertTrue("1.8.0", false);
}
// 2 projects: "p1" refs "p0"
try {
p0.create(null);
p0.open(null);
p1.create(null);
p1.open(null);
addProjectReference(p1, p0);
projects = new IProject[] {p1, p0};
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.9.1", oldOrder[1].length == 0);
assertTrue("1.9.2", x.size() == 2);
assertTrue("1.9.3", x.indexOf(p0) >= 0);
assertTrue("1.9.4", x.indexOf(p1) >= 0);
assertTrue("1.9.5", x.indexOf(p1) > x.indexOf(p0));
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.9.6", !order.hasCycles);
assertTrue("1.9.7", order.knots.length == 0);
assertTrue("1.9.8", x.size() == 2);
assertTrue("1.9.9", x.indexOf(p0) >= 0);
assertTrue("1.9.10", x.indexOf(p1) >= 0);
assertTrue("1.9.11", x.indexOf(p1) > x.indexOf(p0));
p0.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, null);
p1.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, null);
} catch (CoreException e) {
assertTrue("1.9.0", false);
}
// 2 projects: "p0" refs "p1" and "p1" refs "p0"
try {
// open projects show up
p0.create(null);
p0.open(null);
p1.create(null);
p1.open(null);
addProjectReference(p1, p0);
addProjectReference(p0, p1);
projects = new IProject[] {p1, p0};
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
List<IProject> unordered = Arrays.asList(oldOrder[1]);
assertTrue("1.10.1", oldOrder[1].length == 2);
assertTrue("1.10.2", x.size() == 0);
assertTrue("1.10.3", unordered.size() == 2);
assertTrue("1.10.4", unordered.indexOf(p0) >= 0);
assertTrue("1.10.5", unordered.indexOf(p1) >= 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.10.6", order.hasCycles);
assertTrue("1.10.7", order.knots.length == 1);
assertTrue("1.10.8", x.size() == 2);
assertTrue("1.10.9", x.indexOf(p0) >= 0);
assertTrue("1.10.10", x.indexOf(p1) >= 0);
List<IProject> knot = Arrays.asList(order.knots[0]);
assertTrue("1.10.11", knot.size() == 2);
assertTrue("1.10.12", knot.indexOf(p0) >= 0);
assertTrue("1.10.13", knot.indexOf(p1) >= 0);
// closing one breaks the cycle
p0.close(null);
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.10.14", oldOrder[1].length == 0);
assertTrue("1.10.15", x.size() == 1);
assertTrue("1.10.16", x.indexOf(p1) >= 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.10.17", !order.hasCycles);
assertTrue("1.10.18", order.knots.length == 0);
assertTrue("1.10.19", x.size() == 1);
assertTrue("1.10.20", x.indexOf(p1) >= 0);
// closing other instead breaks the cycle
p0.open(null);
p1.close(null);
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
assertTrue("1.10.21", oldOrder[1].length == 0);
assertTrue("1.10.22", x.size() == 1);
assertTrue("1.10.23", x.indexOf(p0) >= 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.10.24", !order.hasCycles);
assertTrue("1.10.25", order.knots.length == 0);
assertTrue("1.10.26", x.size() == 1);
assertTrue("1.10.27", x.indexOf(p0) >= 0);
// reopening both brings back the cycle
p1.open(null);
oldOrder = ws.computePrerequisiteOrder(projects);
x = Arrays.asList(oldOrder[0]);
unordered = Arrays.asList(oldOrder[1]);
assertTrue("1.10.28", oldOrder[1].length == 2);
assertTrue("1.10.29", x.size() == 0);
assertTrue("1.10.30", unordered.size() == 2);
assertTrue("1.10.31", unordered.indexOf(p0) >= 0);
assertTrue("1.10.32", unordered.indexOf(p1) >= 0);
order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("1.10.33", order.hasCycles);
assertTrue("1.10.34", order.knots.length == 1);
assertTrue("1.10.35", x.size() == 2);
assertTrue("1.10.36", x.indexOf(p0) >= 0);
assertTrue("1.10.37", x.indexOf(p1) >= 0);
knot = Arrays.asList(order.knots[0]);
assertTrue("1.10.38", knot.size() == 2);
assertTrue("1.10.39", knot.indexOf(p0) >= 0);
assertTrue("1.10.40", knot.indexOf(p1) >= 0);
p0.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, null);
p1.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, null);
} catch (CoreException e) {
assertTrue("1.10.41", false);
}
}
/**
* Introduction to Algorithms
* Cormen, Leiserson, Rivest
* Figure 23.9(b)
*/
public void test2() {
IWorkspace ws = getWorkspace();
IWorkspaceRoot root = ws.getRoot();
IProject a = root.getProject("a");
IProject b = root.getProject("b");
IProject c = root.getProject("c");
IProject d = root.getProject("d");
IProject e = root.getProject("e");
IProject f = root.getProject("f");
IProject g = root.getProject("g");
IProject h = root.getProject("h");
try {
a.create(null);
a.open(null);
b.create(null);
b.open(null);
c.create(null);
c.open(null);
d.create(null);
d.open(null);
e.create(null);
e.open(null);
f.create(null);
f.open(null);
g.create(null);
g.open(null);
h.create(null);
h.open(null);
// knot 1
addProjectReference(b, a);
addProjectReference(a, e);
addProjectReference(e, b);
// knot 2
addProjectReference(c, d);
addProjectReference(d, c);
// knot 3
addProjectReference(f, g);
addProjectReference(g, f);
// self-reference
addProjectReference(h, h);
// inter-knot references
addProjectReference(c, b);
addProjectReference(f, b);
addProjectReference(g, c);
addProjectReference(h, d);
addProjectReference(h, g);
IProject[] projects = new IProject[] {a, b, c, d, e, f, g, h};
IProject[][] oldOrder = ws.computePrerequisiteOrder(projects);
List<IProject> x = Arrays.asList(oldOrder[0]);
List<IProject> unordered = Arrays.asList(oldOrder[1]);
assertTrue("2.1", x.size() == 1);
assertTrue("2.2", x.indexOf(h) >= 0);
assertTrue("2.3", unordered.size() == 7);
assertTrue("2.4", unordered.indexOf(a) >= 0);
assertTrue("2.5", unordered.indexOf(b) >= 0);
assertTrue("2.6", unordered.indexOf(c) >= 0);
assertTrue("2.7", unordered.indexOf(d) >= 0);
assertTrue("2.8", unordered.indexOf(e) >= 0);
assertTrue("2.9", unordered.indexOf(f) >= 0);
assertTrue("2.10", unordered.indexOf(g) >= 0);
IWorkspace.ProjectOrder order = ws.computeProjectOrder(projects);
x = Arrays.asList(order.projects);
assertTrue("2.11", x.size() == 8);
assertTrue("2.12", x.indexOf(a) >= 0);
assertTrue("2.13", x.indexOf(b) >= 0);
assertTrue("2.14", x.indexOf(c) >= 0);
assertTrue("2.15", x.indexOf(d) >= 0);
assertTrue("2.16", x.indexOf(e) >= 0);
assertTrue("2.17", x.indexOf(f) >= 0);
assertTrue("2.18", x.indexOf(g) >= 0);
assertTrue("2.19", x.indexOf(h) >= 0);
// {a, b, e} < {c,d} < {f, g} < {h}
assertTrue("2.20", x.indexOf(b) < x.indexOf(c));
assertTrue("2.21", x.indexOf(b) < x.indexOf(d));
assertTrue("2.22", x.indexOf(a) < x.indexOf(c));
assertTrue("2.23", x.indexOf(a) < x.indexOf(d));
assertTrue("2.24", x.indexOf(e) < x.indexOf(c));
assertTrue("2.25", x.indexOf(e) < x.indexOf(d));
assertTrue("2.26", x.indexOf(c) < x.indexOf(f));
assertTrue("2.27", x.indexOf(c) < x.indexOf(g));
assertTrue("2.28", x.indexOf(d) < x.indexOf(f));
assertTrue("2.29", x.indexOf(d) < x.indexOf(g));
assertTrue("2.30", x.indexOf(f) < x.indexOf(h));
assertTrue("2.31", x.indexOf(g) < x.indexOf(h));
assertTrue("2.32", order.hasCycles);
assertTrue("2.33", order.knots.length == 3);
List<IProject> k1 = Arrays.asList(order.knots[0]);
List<IProject> k2 = Arrays.asList(order.knots[1]);
List<IProject> k3 = Arrays.asList(order.knots[2]);
// sort 3 groups
if (k2.indexOf(b) >= 0) {
List<IProject> temp = k1;
k1 = k2;
k2 = temp;
} else if (k3.indexOf(b) >= 0) {
List<IProject> temp = k1;
k1 = k3;
k3 = temp;
}
if (k3.indexOf(c) >= 0) {
List<IProject> temp = k2;
k2 = k3;
k3 = temp;
}
// knot 1
assertTrue("2.34", k1.size() == 3);
assertTrue("2.35", k1.indexOf(a) >= 0);
assertTrue("2.36", k1.indexOf(b) >= 0);
assertTrue("2.37", k1.indexOf(e) >= 0);
// knot 2
assertTrue("2.38", k2.size() == 2);
assertTrue("2.39", k2.indexOf(c) >= 0);
assertTrue("2.40", k2.indexOf(d) >= 0);
// knot 3
assertTrue("2.41", k3.size() == 2);
assertTrue("2.42", k3.indexOf(f) >= 0);
assertTrue("2.43", k3.indexOf(g) >= 0);
} catch (CoreException ex) {
assertTrue("2.4.0", false);
}
}
}