1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
|
/*******************************************************************************
* Copyright (c) 2008, 2009 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.equinox.p2.tests.core;
import java.util.*;
import junit.framework.TestCase;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.*;
/**
* Tests for the {@link org.eclipse.equinox.internal.provisional.p2.query.Query} class.
*/
public class QueryTest extends TestCase {
static class AnyStringQuery extends MatchQuery {
@Override
public boolean isMatch(Object candidate) {
return candidate instanceof String;
}
}
static class PerformHookQuery extends AnyStringQuery {
private boolean prepared = false;
private boolean complete = false;
public boolean areHooksExecutedProperly() {
// Either they have both been called, or neither has been called
return (prepared & complete) || (!prepared & !complete);
}
public boolean isComplete() {
return this.complete;
}
public boolean isPrepared() {
return this.prepared;
}
public void prePerform() {
prepared = true;
}
public void postPerform() {
if (!(prepared)) // Note: is match might not be called if it can be determined it's not needed
fail("prePerform not called");
complete = true;
}
public boolean isMatch(Object candidate) {
if (!prepared)
fail("prePerform not called");
if (!(candidate instanceof String))
throw new RuntimeException("Exception intentionally thrown by test");
return candidate instanceof String;
}
}
/**
* 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.
*/
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"));
}
/**
* Tests a perform where only some items match.
*/
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"));
}
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);
assertTrue("1.2", query.isComplete());
assertTrue("1.3", query.isPrepared());
assertTrue("1.4", query.areHooksExecutedProperly());
}
public void testPropertyLookupMatchQuery() {
Query query1 = new PropertyLookupQuery1();
Object property = query1.getProperty("SomeProperty");
assertEquals("1.0", "foo", property);
}
public void testPropertyLookupContextQuery() {
Query query1 = new PropertyLookupQuery2();
Object property = query1.getProperty("SomeOtherProperty");
assertEquals("1.0", "bar", property);
}
public void testPropertyLookupInvalidProperty1() {
Query query1 = new PropertyLookupQuery1();
Object property = query1.getProperty("ThisProperty");
assertEquals("1.0", null, property);
}
public void testPropertyLookupInvalidProperty2() {
Query query1 = new PropertyLookupQuery1();
Object property = query1.getProperty("SomeOtherProperty");
assertEquals("1.0", null, property);
}
public void testIDLookup() {
Query query1 = new PropertyLookupQuery1();
Query 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());
}
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);
} catch (RuntimeException e) {
// expected
}
assertTrue("1.2", query.isComplete());
assertTrue("1.3", query.isPrepared());
assertTrue("1.4", query.areHooksExecutedProperly());
}
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);
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);
assertTrue("1.4", query1.isComplete());
assertTrue("1.5", query1.isPrepared());
assertTrue("1.6", query2.isComplete());
assertTrue("1.7", query2.isPrepared());
assertTrue("1.8", query1.areHooksExecutedProperly());
assertTrue("1.9", query2.areHooksExecutedProperly());
}
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);
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);
assertTrue("1.4", query1.isComplete());
assertTrue("1.5", query1.isPrepared());
assertTrue("1.6", query2.isComplete());
assertTrue("1.7", query2.isPrepared());
assertTrue("1.8", query1.areHooksExecutedProperly());
assertTrue("1.9", query2.areHooksExecutedProperly());
}
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});
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);
assertTrue("1.4", query1.isComplete());
assertTrue("1.5", query1.isPrepared());
assertTrue("1.6", query2.isComplete());
assertTrue("1.7", query2.isPrepared());
assertTrue("1.8", query1.areHooksExecutedProperly());
assertTrue("1.9", query2.areHooksExecutedProperly());
}
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);
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);
fail("This query is expected to fail");
} catch (RuntimeException e) {
// expected
}
assertTrue("1.4", query1.isComplete());
assertTrue("1.5", query1.isPrepared());
assertTrue("1.6", query2.isComplete());
assertTrue("1.7", query2.isPrepared());
assertTrue("1.8", query1.areHooksExecutedProperly());
assertTrue("1.9", query2.areHooksExecutedProperly());
}
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});
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);
fail("This query is expected to fail");
} catch (RuntimeException e) {
// expected
}
assertTrue("1.4", query1.isComplete());
assertTrue("1.5", query1.isPrepared());
assertFalse("1.6", query2.isComplete()); // This should fail, the second query was never executed
assertFalse("1.7", query2.isPrepared()); // This should fail, the second query was never executed
assertTrue("1.8", query1.areHooksExecutedProperly());
assertTrue("1.9", query2.areHooksExecutedProperly());
}
/**
* Tests a perform where the collector decides to short-circuit the query.
*/
public void testShortCircuit() {
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"));
}
}
|
