Merging api branch back to HEADv20100113

6 files changed, 305 insertions, 346 deletions

diff --git a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/AggregateQueryTest.java b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/AggregateQueryTest.java
index ddf8fca34..bea6a9cdc 100644
--- a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/AggregateQueryTest.java
+++ b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/AggregateQueryTest.java
@@ -11,7 +11,8 @@ package org.eclipse.equinox.p2.tests.core;
 
 import java.util.*;
 import junit.framework.TestCase;
-import org.eclipse.equinox.internal.provisional.p2.metadata.query.*;
+import org.eclipse.equinox.p2.query.*;
+import org.eclipse.equinox.p2.tests.AbstractProvisioningTest;
 
 /**
  * This tests both Compound and Composite queries
@@ -28,16 +29,17 @@ public class AggregateQueryTest extends TestCase {
 	}
 
 	public void testEmptyCompositeQuery() {
-		CompositeQuery query = new CompositeQuery(new Query[0]);
-		query.perform(getABCDE().iterator(), new Collector());
+		PipedQuery query = new PipedQuery(new IQuery[0]);
+		query.perform(getABCDE().iterator());
 		// We should not throw an exception.  No guarantee on what perform
 		// will return in this case
 	}
 
 	public void testSymmetry() {
-		Query getLatest = new ContextQuery() {
+		IQuery getLatest = new ContextQuery() {
 
-			public Collector perform(Iterator iterator, Collector result) {
+			public Collector perform(Iterator iterator) {
+				Collector result = new Collector();
 				List list = new ArrayList();
 				while (iterator.hasNext()) {
 					list.add(iterator.next());
@@ -48,9 +50,10 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		Query getAllBut3 = new ContextQuery() {
+		IQuery getAllBut3 = new ContextQuery() {
 
-			public Collector perform(Iterator iterator, Collector result) {
+			public Collector perform(Iterator iterator) {
+				Collector result = new Collector();
 				while (iterator.hasNext()) {
 					Object o = iterator.next();
 					if (!o.equals("3"))
@@ -60,21 +63,21 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {getLatest, getAllBut3}, true);
-		Collector result = compoundQuery.perform(get123().iterator(), new Collector());
-		assertEquals(0, result.size());
+		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getLatest, getAllBut3}, true);
+		IQueryResult result = compoundQuery.perform(get123().iterator());
+		assertEquals(0, AbstractProvisioningTest.queryResultSize(result));
 
-		compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {getAllBut3, getLatest}, true);
-		result = compoundQuery.perform(get123().iterator(), new Collector());
-		assertEquals(0, result.size());
+		compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getAllBut3, getLatest}, true);
+		result = compoundQuery.perform(get123().iterator());
+		assertEquals(0, AbstractProvisioningTest.queryResultSize(result));
 
-		compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {getLatest, getAllBut3}, false);
-		result = compoundQuery.perform(get123().iterator(), new Collector());
-		assertEquals(3, result.size());
+		compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getLatest, getAllBut3}, false);
+		result = compoundQuery.perform(get123().iterator());
+		assertEquals(3, AbstractProvisioningTest.queryResultSize(result));
 
-		compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {getAllBut3, getLatest}, false);
-		result = compoundQuery.perform(get123().iterator(), new Collector());
-		assertEquals(3, result.size());
+		compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getAllBut3, getLatest}, false);
+		result = compoundQuery.perform(get123().iterator());
+		assertEquals(3, AbstractProvisioningTest.queryResultSize(result));
 
 	}
 
@@ -83,9 +86,10 @@ public class AggregateQueryTest extends TestCase {
 	 * This method tests that
 	 */
 	public void testNonSymmetry() {
-		Query getLatest = new ContextQuery() {
+		IQuery getLatest = new ContextQuery() {
 
-			public Collector perform(Iterator iterator, Collector result) {
+			public Collector perform(Iterator iterator) {
+				Collector result = new Collector();
 				List list = new ArrayList();
 				while (iterator.hasNext()) {
 					list.add(iterator.next());
@@ -96,9 +100,11 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		Query getAllBut3 = new ContextQuery() {
+		IQuery getAllBut3 = new ContextQuery() {
+
+			public Collector perform(Iterator iterator) {
+				Collector result = new Collector();
 
-			public Collector perform(Iterator iterator, Collector result) {
 				while (iterator.hasNext()) {
 					Object o = iterator.next();
 					if (!o.equals("3"))
@@ -108,95 +114,95 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		CompositeQuery compoundQuery = new CompositeQuery(new Query[] {getLatest, getAllBut3});
-		Collector result = compoundQuery.perform(get123().iterator(), new Collector());
-		assertEquals(0, result.size());
+		PipedQuery compoundQuery = new PipedQuery(getLatest, getAllBut3);
+		IQueryResult result = compoundQuery.perform(get123().iterator());
+		assertEquals(0, AbstractProvisioningTest.queryResultSize(result));
 
-		compoundQuery = new CompositeQuery(new Query[] {getAllBut3, getLatest});
-		result = compoundQuery.perform(get123().iterator(), new Collector());
-		assertEquals(1, result.size());
-		assertEquals("2", result.toCollection().iterator().next());
+		compoundQuery = new PipedQuery(getAllBut3, getLatest);
+		result = compoundQuery.perform(get123().iterator());
+		assertEquals(1, AbstractProvisioningTest.queryResultSize(result));
+		assertEquals("2", result.iterator().next());
 
 	}
 
 	public void testCompoundAllMatchQueries() {
-		Query A = new MatchQuery() {
+		IQuery A = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				return false;
 			}
 		};
-		Query B = new MatchQuery() {
+		IQuery B = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				return false;
 			}
 		};
-		Query C = new MatchQuery() {
+		IQuery C = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				return false;
 			}
 		};
-		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {A, B, C}, true);
+		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {A, B, C}, true);
 		assertTrue("1.0", compoundQuery instanceof IMatchQuery);
-		assertEquals("1.1", 3, compoundQuery.getQueries().length);
-		assertEquals("1.2", A, compoundQuery.getQueries()[0]);
-		assertEquals("1.3", B, compoundQuery.getQueries()[1]);
-		assertEquals("1.4", C, compoundQuery.getQueries()[2]);
+		assertEquals("1.1", 3, compoundQuery.getQueries().size());
+		assertEquals("1.2", A, compoundQuery.getQueries().get(0));
+		assertEquals("1.3", B, compoundQuery.getQueries().get(1));
+		assertEquals("1.4", C, compoundQuery.getQueries().get(2));
 	}
 
 	public void testCompoundSomeMatchQueries() {
-		Query A = new MatchQuery() {
+		IQuery A = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				return false;
 			}
 		};
-		Query B = new ContextQuery() {
-			public Collector perform(Iterator iterator, Collector result) {
+		IQuery B = new ContextQuery() {
+			public Collector perform(Iterator iterator) {
 				// TODO Auto-generated method stub
 				return null;
 			}
 		};
-		Query C = new MatchQuery() {
+		IQuery C = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				return false;
 			}
 		};
-		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {A, B, C}, true);
+		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {A, B, C}, true);
 		assertTrue("1.0", !(compoundQuery instanceof IMatchQuery));
-		assertEquals("1.1", 3, compoundQuery.getQueries().length);
-		assertEquals("1.2", A, compoundQuery.getQueries()[0]);
-		assertEquals("1.3", B, compoundQuery.getQueries()[1]);
-		assertEquals("1.4", C, compoundQuery.getQueries()[2]);
+		assertEquals("1.1", 3, compoundQuery.getQueries().size());
+		assertEquals("1.2", A, compoundQuery.getQueries().get(0));
+		assertEquals("1.3", B, compoundQuery.getQueries().get(1));
+		assertEquals("1.4", C, compoundQuery.getQueries().get(2));
 	}
 
 	public void testCompoundNoMatchQueries() {
-		Query A = new ContextQuery() {
-			public Collector perform(Iterator iterator, Collector result) {
+		IQuery A = new ContextQuery() {
+			public Collector perform(Iterator iterator) {
 				// TODO Auto-generated method stub
 				return null;
 			}
 		};
-		Query B = new ContextQuery() {
-			public Collector perform(Iterator iterator, Collector result) {
+		IQuery B = new ContextQuery() {
+			public Collector perform(Iterator iterator) {
 				// TODO Auto-generated method stub
 				return null;
 			}
 		};
-		Query C = new ContextQuery() {
-			public Collector perform(Iterator iterator, Collector result) {
+		IQuery C = new ContextQuery() {
+			public Collector perform(Iterator iterator) {
 				// TODO Auto-generated method stub
 				return null;
 			}
 		};
-		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {A, B, C}, true);
+		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {A, B, C}, true);
 		assertTrue("1.0", !(compoundQuery instanceof IMatchQuery));
-		assertEquals("1.1", 3, compoundQuery.getQueries().length);
-		assertEquals("1.2", A, compoundQuery.getQueries()[0]);
-		assertEquals("1.3", B, compoundQuery.getQueries()[1]);
-		assertEquals("1.4", C, compoundQuery.getQueries()[2]);
+		assertEquals("1.1", 3, compoundQuery.getQueries().size());
+		assertEquals("1.2", A, compoundQuery.getQueries().get(0));
+		assertEquals("1.3", B, compoundQuery.getQueries().get(1));
+		assertEquals("1.4", C, compoundQuery.getQueries().get(2));
 	}
 
 	public void testIntersection() {
-		Query ABC = new MatchQuery() {
+		IQuery ABC = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				if (candidate.equals("A") || candidate.equals("B") || candidate.equals("C"))
 					return true;
@@ -204,7 +210,7 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		Query BCDE = new MatchQuery() {
+		IQuery BCDE = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				if (candidate.equals("B") || candidate.equals("C") || candidate.equals("D") || candidate.equals("E"))
 					return true;
@@ -212,16 +218,17 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {ABC, BCDE}, true);
-		Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
-		assertEquals("1.0", result.size(), 2);
-		assertTrue("1.1", result.toCollection().contains("B"));
-		assertTrue("1.2", result.toCollection().contains("C"));
+		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, true);
+		IQueryResult result = compoundQuery.perform(getABCDE().iterator());
+		assertEquals("1.0", AbstractProvisioningTest.queryResultSize(result), 2);
+		AbstractProvisioningTest.assertContains("1.1", result, "B");
+		AbstractProvisioningTest.assertContains("1.2", result, "C");
 	}
 
 	public void testIntersection2() {
-		Query ABC = new ContextQuery() {
-			public Collector perform(Iterator iterator, Collector result) {
+		IQuery ABC = new ContextQuery() {
+			public Collector perform(Iterator iterator) {
+				Collector result = new Collector();
 				while (iterator.hasNext()) {
 					Object o = iterator.next();
 					if (o.equals("A") || o.equals("B") || o.equals("C"))
@@ -231,8 +238,9 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		Query BCDE = new ContextQuery() {
-			public Collector perform(Iterator iterator, Collector result) {
+		IQuery BCDE = new ContextQuery() {
+			public Collector perform(Iterator iterator) {
+				Collector result = new Collector();
 				while (iterator.hasNext()) {
 					Object o = iterator.next();
 					if (o.equals("B") || o.equals("C") || o.equals("D") || o.equals("E"))
@@ -242,15 +250,15 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {ABC, BCDE}, true);
-		Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
-		assertEquals("1.0", result.size(), 2);
-		assertTrue("1.1", result.toCollection().contains("B"));
-		assertTrue("1.2", result.toCollection().contains("C"));
+		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, true);
+		IQueryResult result = compoundQuery.perform(getABCDE().iterator());
+		assertEquals("1.0", AbstractProvisioningTest.queryResultSize(result), 2);
+		AbstractProvisioningTest.assertContains("1.1", result, "B");
+		AbstractProvisioningTest.assertContains("1.2", result, "C");
 	}
 
 	public void testUnion() {
-		Query ABC = new MatchQuery() {
+		IQuery ABC = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				if (candidate.equals("A") || candidate.equals("B") || candidate.equals("C"))
 					return true;
@@ -258,7 +266,7 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		Query BCDE = new MatchQuery() {
+		IQuery BCDE = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				if (candidate.equals("B") || candidate.equals("C") || candidate.equals("D") || candidate.equals("E"))
 					return true;
@@ -266,19 +274,20 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {ABC, BCDE}, false);
-		Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
-		assertEquals("1.0", result.size(), 5);
-		assertTrue("1.1", result.toCollection().contains("A"));
-		assertTrue("1.2", result.toCollection().contains("B"));
-		assertTrue("1.3", result.toCollection().contains("C"));
-		assertTrue("1.4", result.toCollection().contains("D"));
-		assertTrue("1.5", result.toCollection().contains("E"));
+		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, false);
+		IQueryResult result = compoundQuery.perform(getABCDE().iterator());
+		assertEquals("1.0", AbstractProvisioningTest.queryResultSize(result), 5);
+		AbstractProvisioningTest.assertContains("1.1", result, "A");
+		AbstractProvisioningTest.assertContains("1.2", result, "B");
+		AbstractProvisioningTest.assertContains("1.3", result, "C");
+		AbstractProvisioningTest.assertContains("1.4", result, "D");
+		AbstractProvisioningTest.assertContains("1.5", result, "E");
 	}
 
 	public void testUnion2() {
-		Query ABC = new ContextQuery() {
-			public Collector perform(Iterator iterator, Collector result) {
+		IQuery ABC = new ContextQuery() {
+			public Collector perform(Iterator iterator) {
+				Collector result = new Collector();
 				while (iterator.hasNext()) {
 					Object o = iterator.next();
 					if (o.equals("A") || o.equals("B") || o.equals("C"))
@@ -288,8 +297,9 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		Query BCDE = new ContextQuery() {
-			public Collector perform(Iterator iterator, Collector result) {
+		IQuery BCDE = new ContextQuery() {
+			public Collector perform(Iterator iterator) {
+				Collector result = new Collector();
 				while (iterator.hasNext()) {
 					Object o = iterator.next();
 					if (o.equals("B") || o.equals("C") || o.equals("D") || o.equals("E"))
@@ -299,13 +309,13 @@ public class AggregateQueryTest extends TestCase {
 			}
 		};
 
-		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {ABC, BCDE}, false);
-		Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
-		assertEquals("1.0", result.size(), 5);
-		assertTrue("1.1", result.toCollection().contains("A"));
-		assertTrue("1.2", result.toCollection().contains("B"));
-		assertTrue("1.3", result.toCollection().contains("C"));
-		assertTrue("1.4", result.toCollection().contains("D"));
-		assertTrue("1.5", result.toCollection().contains("E"));
+		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, false);
+		IQueryResult result = compoundQuery.perform(getABCDE().iterator());
+		assertEquals("1.0", AbstractProvisioningTest.queryResultSize(result), 5);
+		AbstractProvisioningTest.assertContains("1.1", result, "A");
+		AbstractProvisioningTest.assertContains("1.2", result, "B");
+		AbstractProvisioningTest.assertContains("1.3", result, "C");
+		AbstractProvisioningTest.assertContains("1.4", result, "D");
+		AbstractProvisioningTest.assertContains("1.5", result, "E");
 	}
 }
diff --git a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/CollectorTest.java b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/CollectorTest.java
index 7e12817bc..8b2760129 100644
--- a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/CollectorTest.java
+++ b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/CollectorTest.java
@@ -12,7 +12,7 @@
 package org.eclipse.equinox.p2.tests.core;
 
 import java.util.*;
-import org.eclipse.equinox.internal.provisional.p2.metadata.query.*;
+import org.eclipse.equinox.p2.query.*;
 import org.eclipse.equinox.p2.tests.AbstractProvisioningTest;
 
 /**
@@ -47,7 +47,7 @@ public class CollectorTest extends AbstractProvisioningTest {
 	public void testCompositeCollectors() {
 		String[] s = new String[] {"A", "B", "C", "D", "E", "F", "G", "1", "2", "3", "4", "5", "6", "7"};
 		List list = Arrays.asList(s);
-		Query numeric = new MatchQuery() {
+		IQuery numeric = new MatchQuery() {
 
 			public boolean isMatch(Object candidate) {
 				if (((String) candidate).compareTo("0") > 0 && ((String) candidate).compareTo("8") < 0) {
@@ -57,7 +57,7 @@ public class CollectorTest extends AbstractProvisioningTest {
 			}
 		};
 
-		Query fourOrFiveOrABC = new MatchQuery() {
+		IQuery fourOrFiveOrABC = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				if (((String) candidate).equals("4") || ((String) candidate).equals("5") || ((String) candidate).equals("A") || ((String) candidate).equals("B") || ((String) candidate).equals("C")) {
 					return true;
@@ -65,20 +65,19 @@ public class CollectorTest extends AbstractProvisioningTest {
 				return false;
 			}
 		};
-		Collector collector = numeric.perform(list.iterator(), new Collector());
-		assertEquals("1.0", 7, collector.toCollection().size());
-
-		collector = collector.query(fourOrFiveOrABC, new Collector(), null);
-		Collection collection = collector.toCollection();
-		assertEquals("2.0", 2, collection.size());
-		assertTrue("2.1", collection.contains("4"));
-		assertTrue("2.2", collection.contains("5"));
+		IQueryResult queryResult = numeric.perform(list.iterator());
+		assertEquals("1.0", 7, queryResultSize(queryResult));
+
+		queryResult = queryResult.query(fourOrFiveOrABC, null);
+		assertEquals("2.0", 2, queryResultSize(queryResult));
+		assertContains("2.1", queryResult, "4");
+		assertContains("2.2", queryResult, "5");
 	}
 
 	public void testSameCollector() {
 		String[] s = new String[] {"A", "B", "C", "D", "E", "F", "G", "1", "2", "3", "4", "5", "6", "7"};
 		List list = Arrays.asList(s);
-		Query numeric = new MatchQuery() {
+		IQuery numeric = new MatchQuery() {
 
 			public boolean isMatch(Object candidate) {
 				if (((String) candidate).compareTo("0") > 0 && ((String) candidate).compareTo("8") < 0) {
@@ -88,7 +87,7 @@ public class CollectorTest extends AbstractProvisioningTest {
 			}
 		};
 
-		Query fourOrFiveOrABC = new MatchQuery() {
+		IQuery fourOrFiveOrABC = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				if (((String) candidate).equals("4") || ((String) candidate).equals("5") || ((String) candidate).equals("A") || ((String) candidate).equals("B") || ((String) candidate).equals("C")) {
 					return true;
@@ -96,11 +95,12 @@ public class CollectorTest extends AbstractProvisioningTest {
 				return false;
 			}
 		};
-		Collector collector = numeric.perform(list.iterator(), new Collector());
-		assertEquals("1.0", 7, collector.toCollection().size());
+		Collector collector = new Collector();
+		collector.addAll(numeric.perform(list.iterator()));
+		assertEquals("1.0", 7, collector.unmodifiableSet().size());
 
-		collector = collector.query(fourOrFiveOrABC, collector, null);
-		Collection collection = collector.toCollection();
+		collector.addAll(collector.query(fourOrFiveOrABC, null));
+		Collection collection = collector.unmodifiableSet();
 		assertEquals("2.0", 7, collection.size());
 	}
 
@@ -110,7 +110,7 @@ public class CollectorTest extends AbstractProvisioningTest {
 	public void testEmptyCompositeCollectors() {
 		String[] s = new String[] {"A", "B", "C", "D", "E", "F", "G", "1", "2", "3", "4", "5", "6", "7"};
 		List list = Arrays.asList(s);
-		Query eightOrNine = new MatchQuery() {
+		IQuery eightOrNine = new MatchQuery() {
 
 			public boolean isMatch(Object candidate) {
 				if (((String) candidate).compareTo("8") > 0 && ((String) candidate).compareTo("9") < 0) {
@@ -120,7 +120,7 @@ public class CollectorTest extends AbstractProvisioningTest {
 			}
 		};
 
-		Query fourOrFiveOrABC = new MatchQuery() {
+		IQuery fourOrFiveOrABC = new MatchQuery() {
 			public boolean isMatch(Object candidate) {
 				if (((String) candidate).equals("4") || ((String) candidate).equals("5") || ((String) candidate).equals("A") || ((String) candidate).equals("B") || ((String) candidate).equals("C")) {
 					return true;
@@ -128,17 +128,16 @@ public class CollectorTest extends AbstractProvisioningTest {
 				return false;
 			}
 		};
-		Collector collector = eightOrNine.perform(list.iterator(), new Collector());
-		assertEquals("1.0", 0, collector.toCollection().size());
+		IQueryResult queryResult = eightOrNine.perform(list.iterator());
+		assertTrue("1.0", queryResult.isEmpty());
 
-		collector = collector.query(fourOrFiveOrABC, new Collector(), null);
-		Collection collection = collector.toCollection();
-		assertEquals("2.0", 0, collection.size());
+		queryResult = queryResult.query(fourOrFiveOrABC, null);
+		assertTrue("2.0", queryResult.isEmpty());
 	}
 
 	public void testToCollection() {
 		Collector collector = new Collector();
-		Collection result = collector.toCollection();
+		Collection result = collector.unmodifiableSet();
 		assertEquals("1.0", 0, result.size());
 		//collection should be immutable
 		try {
@@ -150,7 +149,7 @@ public class CollectorTest extends AbstractProvisioningTest {
 
 		String value = "value";
 		collector.accept(value);
-		result = collector.toCollection();
+		result = collector.unmodifiableSet();
 		assertEquals("2.0", 1, result.size());
 		assertEquals("2.1", value, result.iterator().next());
 		//collection should be immutable
diff --git a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/CompoundQueryableTest.java b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/CompoundQueryableTest.java
index 16783c3f7..c05dd804a 100644
--- a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/CompoundQueryableTest.java
+++ b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/CompoundQueryableTest.java
@@ -9,11 +9,13 @@
 ******************************************************************************/
 package org.eclipse.equinox.p2.tests.core;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.Iterator;
 import junit.framework.TestCase;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.tests.harness.TestProgressMonitor;
-import org.eclipse.equinox.internal.provisional.p2.metadata.query.*;
+import org.eclipse.equinox.p2.query.*;
+import org.eclipse.equinox.p2.tests.AbstractProvisioningTest;
 
 /**
  * Tests the compound queryable
@@ -56,10 +58,11 @@ public class CompoundQueryableTest extends TestCase {
 	IQueryable queryable1 = new IQueryable() {
 		Integer[] elements = new Integer[] {1, 2, 3, 4, 5};
 
-		public Collector query(Query query, Collector collector, IProgressMonitor monitor) {
+		public IQueryResult query(IQuery query, IProgressMonitor monitor) {
+			IQueryResult collector;
 			try {
 				monitor.beginTask("", 10);
-				collector = query.perform(createIterator(elements), collector);
+				collector = query.perform(createIterator(elements));
 				monitor.worked(10);
 			} finally {
 				monitor.done();
@@ -71,10 +74,11 @@ public class CompoundQueryableTest extends TestCase {
 	IQueryable queryable2 = new IQueryable() {
 		Integer[] elements = new Integer[] {4, 6, 8, 10, 12};
 
-		public Collector query(Query query, Collector collector, IProgressMonitor monitor) {
+		public IQueryResult query(IQuery query, IProgressMonitor monitor) {
+			IQueryResult collector;
 			try {
 				monitor.beginTask("", 10);
-				collector = query.perform(createIterator(elements), collector);
+				collector = query.perform(createIterator(elements));
 				monitor.worked(10);
 			} finally {
 				monitor.done();
@@ -86,10 +90,11 @@ public class CompoundQueryableTest extends TestCase {
 	IQueryable queryable3 = new IQueryable() {
 		Integer[] elements = new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
 
-		public Collector query(Query query, Collector collector, IProgressMonitor monitor) {
+		public IQueryResult query(IQuery query, IProgressMonitor monitor) {
+			IQueryResult collector;
 			try {
 				monitor.beginTask("", 10);
-				collector = query.perform(createIterator(elements), collector);
+				collector = query.perform(createIterator(elements));
 				monitor.worked(10);
 			} finally {
 				monitor.done();
@@ -98,7 +103,7 @@ public class CompoundQueryableTest extends TestCase {
 		}
 	};
 
-	Query matchQuery = new MatchQuery() {
+	IQuery matchQuery = new MatchQuery() {
 
 		public boolean isMatch(Object candidate) {
 			if (candidate instanceof Integer) {
@@ -110,7 +115,7 @@ public class CompoundQueryableTest extends TestCase {
 		}
 	};
 
-	Query matchMod4query = new MatchQuery() {
+	IQuery matchMod4query = new MatchQuery() {
 		public boolean isMatch(Object candidate) {
 			if (candidate instanceof Integer) {
 				int x = ((Integer) candidate).intValue();
@@ -121,9 +126,10 @@ public class CompoundQueryableTest extends TestCase {
 		}
 	};
 
-	Query contextQuery = new ContextQuery() {
+	IQuery contextQuery = new ContextQuery() {
 
-		public Collector perform(Iterator iterator, Collector result) {
+		public Collector perform(Iterator iterator) {
+			Collector result = new Collector();
 			while (iterator.hasNext()) {
 				Object o = iterator.next();
 				if (o instanceof Integer && ((Integer) o).intValue() % 2 == 0) {
@@ -135,8 +141,9 @@ public class CompoundQueryableTest extends TestCase {
 
 	};
 
-	Query greatestNumberQuery = new ContextQuery() {
-		public Collector perform(Iterator iterator, Collector result) {
+	IQuery greatestNumberQuery = new ContextQuery() {
+		public Collector perform(Iterator iterator) {
+			Collector result = new Collector();
 			int greatest = Integer.MIN_VALUE;
 			while (iterator.hasNext()) {
 				int item = ((Integer) iterator.next()).intValue();
@@ -151,208 +158,129 @@ public class CompoundQueryableTest extends TestCase {
 	};
 
 	public void testMatchQuery() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1, queryable2);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.query(matchQuery, new Collector(), monitor);
-		assertEquals("1.0", 6, collector.size());
-		Collection collection = collector.toCollection();
-		assertTrue("1.1", collection.contains(2));
-		assertTrue("1.2", collection.contains(4));
-		assertTrue("1.3", collection.contains(6));
-		assertTrue("1.4", collection.contains(8));
-		assertTrue("1.5", collection.contains(10));
-		assertTrue("1.6", collection.contains(12));
+		IQueryResult queryResult = cQueryable.query(matchQuery, monitor);
+		assertEquals("1.0", 6, AbstractProvisioningTest.queryResultSize(queryResult));
+		AbstractProvisioningTest.assertContains("1.1", queryResult, 2);
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 4);
+		AbstractProvisioningTest.assertContains("1.3", queryResult, 6);
+		AbstractProvisioningTest.assertContains("1.4", queryResult, 8);
+		AbstractProvisioningTest.assertContains("1.5", queryResult, 10);
+		AbstractProvisioningTest.assertContains("1.6", queryResult, 12);
 	}
 
 	public void testSingleQueryable() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.query(matchQuery, new Collector(), monitor);
-		assertEquals("1.0", 2, collector.size());
-		Collection collection = collector.toCollection();
-		assertTrue("1.1", collection.contains(2));
-		assertTrue("1.2", collection.contains(4));
+		IQueryResult queryResult = cQueryable.query(matchQuery, monitor);
+		assertEquals("1.0", 2, AbstractProvisioningTest.queryResultSize(queryResult));
+		AbstractProvisioningTest.assertContains("1.1", queryResult, 2);
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 4);
 	}
 
 	public void testSingleContextQuery() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.query(greatestNumberQuery, new Collector(), monitor);
-		assertEquals("1.0", 1, collector.size());
-		Collection collection = collector.toCollection();
-		assertTrue("1.1", collection.contains(5));
+		IQueryResult queryResult = cQueryable.query(greatestNumberQuery, monitor);
+		assertEquals("1.0", 1, AbstractProvisioningTest.queryResultSize(queryResult));
+		AbstractProvisioningTest.assertContains("1.1", queryResult, 5);
 	}
 
 	public void testMultipleContextQueries() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1, queryable2);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.query(greatestNumberQuery, new Collector(), monitor);
-		assertEquals("1.0", 1, collector.size());
-		Collection collection = collector.toCollection();
-		assertTrue("1.1", collection.contains(12));
-	}
-
-	public void testListCollector1() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
-		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.query(contextQuery, cQueryable.new ListCollector(), monitor);
-
-		// We use a list so there should be 7 elements (4 is there twice)
-		assertEquals("1.0", 7, collector.size());
-		Collection collection = collector.toCollection();
-		assertTrue("1.1", collection.contains(2));
-		assertTrue("1.2", collection.contains(4));
-		assertTrue("1.3", collection.contains(6));
-		assertTrue("1.4", collection.contains(8));
-		assertTrue("1.5", collection.contains(10));
-		assertTrue("1.6", collection.contains(12));
-	}
-
-	public void testListCollector_isEmpty() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
-		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.new ListCollector();
-		assertTrue("1.0", collector.isEmpty());
-		collector = cQueryable.query(contextQuery, cQueryable.new ListCollector(), monitor);
-		assertFalse("1.0", collector.isEmpty());
-	}
-
-	public void testListCollector_getCollection() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
-		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-
-		Collector collector = cQueryable.query(contextQuery, cQueryable.new ListCollector(), monitor);
-
-		// We use a list so there should be 7 elements (4 is there twice)
-		assertEquals("1.0", 7, collector.size());
-		Integer[] array = (Integer[]) collector.toArray(Integer.class);
-		Collection collection = Arrays.asList(array);
-		assertTrue("1.1", collection.contains(2));
-		assertTrue("1.2", collection.contains(4));
-		assertTrue("1.3", collection.contains(6));
-		assertTrue("1.4", collection.contains(8));
-		assertTrue("1.5", collection.contains(10));
-		assertTrue("1.6", collection.contains(12));
-	}
-
-	public void testListCollector_toArray() {
-		final CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
-		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-
-		class CustomListCollector extends CompoundQueryable.ListCollector {
-
-			public CustomListCollector() {
-				cQueryable.super();
-			}
-
-			public Collection getCollection() {
-				return super.getCollection();
-			}
-		}
-
-		CustomListCollector collector = (CustomListCollector) cQueryable.query(contextQuery, new CustomListCollector(), monitor);
-
-		// We use a list so there should be 7 elements (4 is there twice)
-		assertEquals("1.0", 7, collector.size());
-		Collection collection = collector.getCollection();
-		assertTrue("1.1", collection.contains(2));
-		assertTrue("1.2", collection.contains(4));
-		assertTrue("1.3", collection.contains(6));
-		assertTrue("1.4", collection.contains(8));
-		assertTrue("1.5", collection.contains(10));
-		assertTrue("1.6", collection.contains(12));
+		IQueryResult queryResult = cQueryable.query(greatestNumberQuery, monitor);
+		assertEquals("1.0", 1, AbstractProvisioningTest.queryResultSize(queryResult));
+		AbstractProvisioningTest.assertContains("1.1", queryResult, 12);
 	}
 
 	public void testCompoundMatchAndQuery() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1, queryable2);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.query(CompoundQuery.createCompoundQuery(new Query[] {matchQuery, matchMod4query}, true), new Collector(), monitor);
-		assertEquals("1.0", 3, collector.size());
-		Collection collection = collector.toCollection();
-		assertTrue("1.2", collection.contains(4));
-		assertTrue("1.4", collection.contains(8));
-		assertTrue("1.6", collection.contains(12));
+		IQueryResult queryResult = cQueryable.query(CompoundQuery.createCompoundQuery(new IQuery[] {matchQuery, matchMod4query}, true), monitor);
+		assertEquals("1.0", 3, AbstractProvisioningTest.queryResultSize(queryResult));
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 4);
+		AbstractProvisioningTest.assertContains("1.4", queryResult, 8);
+		AbstractProvisioningTest.assertContains("1.6", queryResult, 12);
 	}
 
 	public void testCompoundMatchOrQuery() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1, queryable2);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.query(CompoundQuery.createCompoundQuery(new Query[] {matchQuery, matchMod4query}, false), new Collector(), monitor);
-		assertEquals("1.0", 6, collector.size());
-		Collection collection = collector.toCollection();
-		assertTrue("1.2", collection.contains(2));
-		assertTrue("1.2", collection.contains(4));
-		assertTrue("1.2", collection.contains(6));
-		assertTrue("1.4", collection.contains(8));
-		assertTrue("1.2", collection.contains(10));
-		assertTrue("1.6", collection.contains(12));
+		IQueryResult queryResult = cQueryable.query(CompoundQuery.createCompoundQuery(new IQuery[] {matchQuery, matchMod4query}, false), monitor);
+		assertEquals("1.0", 6, AbstractProvisioningTest.queryResultSize(queryResult));
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 2);
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 4);
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 6);
+		AbstractProvisioningTest.assertContains("1.4", queryResult, 8);
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 10);
+		AbstractProvisioningTest.assertContains("1.6", queryResult, 12);
 	}
 
 	public void testMatchQueryProgressMonitor() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1, queryable2);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		cQueryable.query(matchQuery, new Collector(), monitor);
+		cQueryable.query(matchQuery, monitor);
 		assertTrue("1.0", monitor.isDone());
 		assertTrue("1.1", monitor.isWorkDone());
 	}
 
 	public void testSingleQueryableProgressMonitor() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		cQueryable.query(matchQuery, new Collector(), monitor);
+		cQueryable.query(matchQuery, monitor);
 		assertTrue("1.0", monitor.isDone());
 		assertTrue("1.1", monitor.isWorkDone());
 	}
 
 	public void testSingleContextQueryProgressMonitor() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		cQueryable.query(greatestNumberQuery, new Collector(), monitor);
+		cQueryable.query(greatestNumberQuery, monitor);
 		assertTrue("1.0", monitor.isDone());
 		assertTrue("1.1", monitor.isWorkDone());
 	}
 
 	public void testMultipleContextQueriesProgressMonitor() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1, queryable2);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		cQueryable.query(greatestNumberQuery, new Collector(), monitor);
+		cQueryable.query(greatestNumberQuery, monitor);
 		assertTrue("1.0", monitor.isDone());
 		assertTrue("1.1", monitor.isWorkDone());
 	}
 
 	public void testNullProgressMonitor() {
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {queryable1, queryable2});
-		cQueryable.query(greatestNumberQuery, new Collector(), null);
+		CompoundQueryable cQueryable = new CompoundQueryable(queryable1, queryable2);
+		cQueryable.query(greatestNumberQuery, null);
 		// this is the same as above will null passed in, this should not throw any exceptions
 
 	}
 
 	public void testDoubleCompoundContextOrQuery() {
-		CompoundQueryable cQueryable1 = new CompoundQueryable(new IQueryable[] {queryable3, queryable2});
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {cQueryable1, queryable1});
+		CompoundQueryable cQueryable1 = new CompoundQueryable(queryable3, queryable2);
+		CompoundQueryable cQueryable = new CompoundQueryable(cQueryable1, queryable1);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.query(CompoundQuery.createCompoundQuery(new Query[] {contextQuery, greatestNumberQuery}, false), new Collector(), monitor);
-		assertEquals("1.0", 7, collector.size());
-		Collection collection = collector.toCollection();
-		assertTrue("1.2", collection.contains(2));
-		assertTrue("1.2", collection.contains(4));
-		assertTrue("1.2", collection.contains(6));
-		assertTrue("1.4", collection.contains(8));
-		assertTrue("1.2", collection.contains(10));
-		assertTrue("1.6", collection.contains(12));
-		assertTrue("1.6", collection.contains(13));
+		IQueryResult queryResult = cQueryable.query(CompoundQuery.createCompoundQuery(new IQuery[] {contextQuery, greatestNumberQuery}, false), monitor);
+		assertEquals("1.0", 7, AbstractProvisioningTest.queryResultSize(queryResult));
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 2);
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 4);
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 6);
+		AbstractProvisioningTest.assertContains("1.4", queryResult, 8);
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 10);
+		AbstractProvisioningTest.assertContains("1.6", queryResult, 12);
+		AbstractProvisioningTest.assertContains("1.6", queryResult, 13);
 		assertTrue("1.0", monitor.isDone());
 		assertTrue("1.1", monitor.isWorkDone());
 	}
 
 	public void testDoubleCompositeQuery() {
-		CompoundQueryable cQueryable1 = new CompoundQueryable(new IQueryable[] {queryable3, queryable2});
-		CompoundQueryable cQueryable = new CompoundQueryable(new IQueryable[] {cQueryable1, queryable1});
+		CompoundQueryable cQueryable1 = new CompoundQueryable(queryable3, queryable2);
+		CompoundQueryable cQueryable = new CompoundQueryable(cQueryable1, queryable1);
 		CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
-		Collector collector = cQueryable.query(new CompositeQuery(new Query[] {contextQuery, greatestNumberQuery}), new Collector(), monitor);
-		assertEquals("1.0", 1, collector.size());
-		Collection collection = collector.toCollection();
-		assertTrue("1.2", collection.contains(12));
+		IQueryResult queryResult = cQueryable.query(new PipedQuery(contextQuery, greatestNumberQuery), monitor);
+		assertEquals("1.0", 1, AbstractProvisioningTest.queryResultSize(queryResult));
+		AbstractProvisioningTest.assertContains("1.2", queryResult, 12);
 		assertTrue("1.0", monitor.isDone());
 		assertTrue("1.1", monitor.isWorkDone());
 	}
diff --git a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/PropertyLookupQuery1.java b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/PropertyLookupQuery1.java
index 22d98ddbc..b212c8c28 100644
--- a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/PropertyLookupQuery1.java
+++ b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/PropertyLookupQuery1.java
@@ -9,7 +9,7 @@
 ******************************************************************************/
 package org.eclipse.equinox.p2.tests.core;
 
-import org.eclipse.equinox.internal.provisional.p2.metadata.query.MatchQuery;
+import org.eclipse.equinox.p2.query.MatchQuery;
 
 public class PropertyLookupQuery1 extends MatchQuery {
 
diff --git a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/PropertyLookupQuery2.java b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/PropertyLookupQuery2.java
index 7564cc633..e7e45457a 100644
--- a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/PropertyLookupQuery2.java
+++ b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/PropertyLookupQuery2.java
@@ -10,8 +10,8 @@
 package org.eclipse.equinox.p2.tests.core;
 
 import java.util.Iterator;
-import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
-import org.eclipse.equinox.internal.provisional.p2.metadata.query.ContextQuery;
+import org.eclipse.equinox.p2.query.Collector;
+import org.eclipse.equinox.p2.query.ContextQuery;
 
 public class PropertyLookupQuery2 extends ContextQuery {
 
@@ -19,7 +19,7 @@ public class PropertyLookupQuery2 extends ContextQuery {
 		return "bar";
 	}
 
-	public Collector perform(Iterator iterator, Collector result) {
+	public Collector perform(Iterator iterator) {
 		return null;
 	}
 }
diff --git a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/QueryTest.java b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/QueryTest.java
index 81c2d9ca6..e05b16f25 100644
--- a/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/QueryTest.java
+++ b/bundles/org.eclipse.equinox.p2.tests/src/org/eclipse/equinox/p2/tests/core/QueryTest.java
@@ -10,9 +10,11 @@
  *******************************************************************************/
 package org.eclipse.equinox.p2.tests.core;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.List;
 import junit.framework.TestCase;
-import org.eclipse.equinox.internal.provisional.p2.metadata.query.*;
+import org.eclipse.equinox.p2.query.*;
+import org.eclipse.equinox.p2.tests.AbstractProvisioningTest;
 
 /**
  * Tests for the {@link org.eclipse.equinox.internal.provisional.p2.query.Query} class.
@@ -63,29 +65,16 @@ public class QueryTest extends TestCase {
 	}
 
 	/**
-	 * A collector that only accepts the first element and then short-circuits.
-	 */
-	static class ShortCircuitCollector extends Collector {
-		@Override
-		public boolean accept(Object object) {
-			super.accept(object);
-			return false;
-		}
-	}
-
-	/**
-	 * Tests a simple perform where all items match.
-	 */
+	* Tests a simple perform where all items match.
+	*/
 	public void testPerformSimple() {
 		List items = Arrays.asList("red", "green", "blue");
-		Query query = new AnyStringQuery();
-		Collector collector = new Collector();
-		query.perform(items.iterator(), collector);
-		Collection result = collector.toCollection();
-		assertEquals("1.0", 3, result.size());
-		assertTrue("1.1", result.contains("red"));
-		assertTrue("1.2", result.contains("green"));
-		assertTrue("1.3", result.contains("blue"));
+		IQuery query = new AnyStringQuery();
+		IQueryResult collector = query.perform(items.iterator());
+		assertEquals("1.0", 3, AbstractProvisioningTest.queryResultSize(collector));
+		AbstractProvisioningTest.assertContains("1.1", collector, "red");
+		AbstractProvisioningTest.assertContains("1.2", collector, "green");
+		AbstractProvisioningTest.assertContains("1.3", collector, "blue");
 	}
 
 	/**
@@ -93,53 +82,50 @@ public class QueryTest extends TestCase {
 	 */
 	public void testPerformSomeMatches() {
 		List items = Arrays.asList(new Object(), "green", new Object());
-		Query query = new AnyStringQuery();
-		Collector collector = new Collector();
-		query.perform(items.iterator(), collector);
-		Collection result = collector.toCollection();
-		assertEquals("1.0", 1, result.size());
-		assertTrue("1.1", result.contains("green"));
+		IQuery query = new AnyStringQuery();
+		IQueryResult collector = query.perform(items.iterator());
+		assertEquals("1.0", 1, AbstractProvisioningTest.queryResultSize(collector));
+		AbstractProvisioningTest.assertContains("1.1", collector, "green");
 	}
 
 	public void testPerformHooks() {
 		List items = Arrays.asList("red", "green", "blue");
 		PerformHookQuery query = new PerformHookQuery();
-		Collector collector = new Collector();
 		assertFalse("1.0", query.isComplete());
 		assertFalse("1.1", query.isPrepared());
-		query.perform(items.iterator(), collector);
+		query.perform(items.iterator());
 		assertTrue("1.2", query.isComplete());
 		assertTrue("1.3", query.isPrepared());
 		assertTrue("1.4", query.areHooksExecutedProperly());
 	}
 
 	public void testPropertyLookupMatchQuery() {
-		Query query1 = new PropertyLookupQuery1();
+		IQuery query1 = new PropertyLookupQuery1();
 		Object property = query1.getProperty("SomeProperty");
 		assertEquals("1.0", "foo", property);
 	}
 
 	public void testPropertyLookupContextQuery() {
-		Query query1 = new PropertyLookupQuery2();
+		IQuery query1 = new PropertyLookupQuery2();
 		Object property = query1.getProperty("SomeOtherProperty");
 		assertEquals("1.0", "bar", property);
 	}
 
 	public void testPropertyLookupInvalidProperty1() {
-		Query query1 = new PropertyLookupQuery1();
+		IQuery query1 = new PropertyLookupQuery1();
 		Object property = query1.getProperty("ThisProperty");
 		assertEquals("1.0", null, property);
 	}
 
 	public void testPropertyLookupInvalidProperty2() {
-		Query query1 = new PropertyLookupQuery1();
+		IQuery query1 = new PropertyLookupQuery1();
 		Object property = query1.getProperty("SomeOtherProperty");
 		assertEquals("1.0", null, property);
 	}
 
 	public void testIDLookup() {
-		Query query1 = new PropertyLookupQuery1();
-		Query query2 = new PropertyLookupQuery2();
+		IQuery query1 = new PropertyLookupQuery1();
+		IQuery query2 = new PropertyLookupQuery2();
 		assertEquals("1.0", "org.eclipse.equinox.p2.tests.core.PropertyLookupQuery1", query1.getId());
 		assertEquals("1.0", "org.eclipse.equinox.p2.tests.core.PropertyLookupQuery2", query2.getId());
 	}
@@ -147,11 +133,10 @@ public class QueryTest extends TestCase {
 	public void testPerformHooksOnQueryFail() {
 		List items = Arrays.asList("red", new Object());
 		PerformHookQuery query = new PerformHookQuery();
-		Collector collector = new Collector();
 		assertFalse("1.0", query.isComplete());
 		assertFalse("1.1", query.isPrepared());
 		try {
-			query.perform(items.iterator(), collector);
+			query.perform(items.iterator());
 		} catch (RuntimeException e) {
 			// expected
 		}
@@ -162,15 +147,14 @@ public class QueryTest extends TestCase {
 
 	public void testPreAndPostCompoundANDQuery() {
 		List items = Arrays.asList("red", "green", "blue");
-		Collector collector = new Collector();
 		PerformHookQuery query1 = new PerformHookQuery();
 		PerformHookQuery query2 = new PerformHookQuery();
-		CompoundQuery cQuery = CompoundQuery.createCompoundQuery(new Query[] {query1, query2}, true);
+		CompoundQuery cQuery = CompoundQuery.createCompoundQuery(new IQuery[] {query1, query2}, true);
 		assertFalse("1.0", query1.isComplete());
 		assertFalse("1.1", query1.isPrepared());
 		assertFalse("1.2", query2.isComplete());
 		assertFalse("1.3", query2.isPrepared());
-		cQuery.perform(items.iterator(), collector);
+		cQuery.perform(items.iterator());
 		assertTrue("1.4", query1.isComplete());
 		assertTrue("1.5", query1.isPrepared());
 		assertTrue("1.6", query2.isComplete());
@@ -181,15 +165,14 @@ public class QueryTest extends TestCase {
 
 	public void testPreAndPostCompoundOrQuery() {
 		List items = Arrays.asList("red", "green", "blue");
-		Collector collector = new Collector();
 		PerformHookQuery query1 = new PerformHookQuery();
 		PerformHookQuery query2 = new PerformHookQuery();
-		CompoundQuery cQuery = CompoundQuery.createCompoundQuery(new Query[] {query1, query2}, false);
+		CompoundQuery cQuery = CompoundQuery.createCompoundQuery(new IQuery[] {query1, query2}, false);
 		assertFalse("1.0", query1.isComplete());
 		assertFalse("1.1", query1.isPrepared());
 		assertFalse("1.2", query2.isComplete());
 		assertFalse("1.3", query2.isPrepared());
-		cQuery.perform(items.iterator(), collector);
+		cQuery.perform(items.iterator());
 		assertTrue("1.4", query1.isComplete());
 		assertTrue("1.5", query1.isPrepared());
 		assertTrue("1.6", query2.isComplete());
@@ -200,15 +183,14 @@ public class QueryTest extends TestCase {
 
 	public void testPreAndPostCompositeQuery() {
 		List items = Arrays.asList("red", "green", "blue");
-		Collector collector = new Collector();
 		PerformHookQuery query1 = new PerformHookQuery();
 		PerformHookQuery query2 = new PerformHookQuery();
-		CompositeQuery cQuery = new CompositeQuery(new Query[] {query1, query2});
+		PipedQuery cQuery = new PipedQuery(query1, query2);
 		assertFalse("1.0", query1.isComplete());
 		assertFalse("1.1", query1.isPrepared());
 		assertFalse("1.2", query2.isComplete());
 		assertFalse("1.3", query2.isPrepared());
-		cQuery.perform(items.iterator(), collector);
+		cQuery.perform(items.iterator());
 		assertTrue("1.4", query1.isComplete());
 		assertTrue("1.5", query1.isPrepared());
 		assertTrue("1.6", query2.isComplete());
@@ -219,16 +201,15 @@ public class QueryTest extends TestCase {
 
 	public void testPreAndPostCompoundQueryFail() {
 		List items = Arrays.asList("red", new Object());
-		Collector collector = new Collector();
 		PerformHookQuery query1 = new PerformHookQuery();
 		PerformHookQuery query2 = new PerformHookQuery();
-		CompoundQuery cQuery = CompoundQuery.createCompoundQuery(new Query[] {query1, query2}, true);
+		CompoundQuery cQuery = CompoundQuery.createCompoundQuery(new IQuery[] {query1, query2}, true);
 		assertFalse("1.0", query1.isComplete());
 		assertFalse("1.1", query1.isPrepared());
 		assertFalse("1.2", query2.isComplete());
 		assertFalse("1.3", query2.isPrepared());
 		try {
-			cQuery.perform(items.iterator(), collector);
+			cQuery.perform(items.iterator());
 			fail("This query is expected to fail");
 		} catch (RuntimeException e) {
 			// expected
@@ -243,16 +224,15 @@ public class QueryTest extends TestCase {
 
 	public void testPreAndPostCompositeQueryFail() {
 		List items = Arrays.asList("red", new Object());
-		Collector collector = new Collector();
 		PerformHookQuery query1 = new PerformHookQuery();
 		PerformHookQuery query2 = new PerformHookQuery();
-		CompositeQuery cQuery = new CompositeQuery(new Query[] {query1, query2});
+		PipedQuery cQuery = new PipedQuery(query1, query2);
 		assertFalse("1.0", query1.isComplete());
 		assertFalse("1.1", query1.isPrepared());
 		assertFalse("1.2", query2.isComplete());
 		assertFalse("1.3", query2.isPrepared());
 		try {
-			cQuery.perform(items.iterator(), collector);
+			cQuery.perform(items.iterator());
 			fail("This query is expected to fail");
 		} catch (RuntimeException e) {
 			// expected
@@ -265,17 +245,59 @@ public class QueryTest extends TestCase {
 		assertTrue("1.9", query2.areHooksExecutedProperly());
 	}
 
-	/**
-	 * Tests a perform where the collector decides to short-circuit the query.
-	 */
-	public void testShortCircuit() {
+	public void testLimitQuery() {
 		List items = Arrays.asList("red", "green", "blue");
-		Query query = new AnyStringQuery();
-		Collector collector = new ShortCircuitCollector();
-		query.perform(items.iterator(), collector);
-		Collection result = collector.toCollection();
-		assertEquals("1.0", 1, result.size());
-		assertTrue("1.1", result.contains("red"));
+		IQuery query = new AnyStringQuery();
+		IQuery limitQuery = new LimitQuery(query, 1);
+		IQueryResult collector = limitQuery.perform(items.iterator());
+		assertEquals("1.0", 1, AbstractProvisioningTest.queryResultSize(collector));
+		AbstractProvisioningTest.assertContains("1.1", collector, "red");
 	}
 
+	public void testLimitQuery2() {
+		List items = Arrays.asList("red", "green", "blue");
+		IQuery query = new AnyStringQuery();
+		IQuery limitQuery = new LimitQuery(query, 2);
+		IQueryResult collector = limitQuery.perform(items.iterator());
+		assertEquals("1.0", 2, AbstractProvisioningTest.queryResultSize(collector));
+		AbstractProvisioningTest.assertContains("1.1", collector, "red");
+		AbstractProvisioningTest.assertContains("1.2", collector, "green");
+	}
+
+	public void testLimitQuery3() {
+		List items = Arrays.asList("red", "green", "blue");
+		IQuery query = new AnyStringQuery();
+		IQuery limitQuery = new LimitQuery(query, 3);
+		IQueryResult collector = limitQuery.perform(items.iterator());
+		assertEquals("1.0", 3, AbstractProvisioningTest.queryResultSize(collector));
+		AbstractProvisioningTest.assertContains("1.1", collector, "red");
+		AbstractProvisioningTest.assertContains("1.2", collector, "green");
+		AbstractProvisioningTest.assertContains("1.3", collector, "blue");
+	}
+
+	public void testLimitQuery0() {
+		List items = Arrays.asList("red", "green", "blue");
+		IQuery query = new AnyStringQuery();
+		IQuery limitQuery = new LimitQuery(query, 0);
+		IQueryResult collector = limitQuery.perform(items.iterator());
+		assertEquals("1.0", 0, AbstractProvisioningTest.queryResultSize(collector));
+	}
+
+	//	public void testPipedLimitQuery() {
+	//		List items = Arrays.asList("pink", "red", "green", "pink");
+	//		IQuery anyString = new AnyStringQuery();
+	//		IQuery containsI = new MatchQuery() {
+	//
+	//			public boolean isMatch(Object candidate) {
+	//				return ((String) candidate).contains("e");
+	//			}
+	//		};
+	//		IQuery pipedQuery = new PipedQuery(new IQuery[] {anyString, containsI});
+	//		IQuery limitQuery = new LimitQuery(pipedQuery, 1);
+	//		Collector collector = limitQuery.perform(items.iterator(), new Collector());
+	//		Collection result = collector.toCollection();
+	//		assertEquals("1.0", 1, result.size());
+	//		assertTrue("1.1", result.contains("red"));
+	//	}
+
 }