19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package org.graalvm.compiler.graph.test;
24
25 import static org.graalvm.compiler.graph.test.matchers.NodeIterableContains.contains;
26 import static org.graalvm.compiler.graph.test.matchers.NodeIterableIsEmpty.isEmpty;
27 import static org.graalvm.compiler.graph.test.matchers.NodeIterableIsEmpty.isNotEmpty;
28 import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_IGNORED;
29 import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_IGNORED;
30 import static org.junit.Assert.assertEquals;
31 import static org.junit.Assert.assertThat;
32
33 import org.junit.Test;
34
35 import org.graalvm.compiler.graph.Graph;
36 import org.graalvm.compiler.graph.Node;
37 import org.graalvm.compiler.graph.NodeClass;
38 import org.graalvm.compiler.nodeinfo.NodeInfo;
39
40 public class NodeUsagesTests extends GraphTest {
41
42 @NodeInfo(cycles = CYCLES_IGNORED, size = SIZE_IGNORED)
43 static final class Def extends Node {
44 public static final NodeClass<Def> TYPE = NodeClass.create(Def.class);
45
46 protected Def() {
47 super(TYPE);
48 }
49 }
50
51 @NodeInfo(cycles = CYCLES_IGNORED, size = SIZE_IGNORED)
52 static final class Use extends Node {
53 public static final NodeClass<Use> TYPE = NodeClass.create(Use.class);
54 @Input Def in0;
55 @Input Def in1;
56 @Input Def in2;
57
58 protected Use(Def in0, Def in1, Def in2) {
59 super(TYPE);
60 this.in0 = in0;
61 this.in1 = in1;
62 this.in2 = in2;
63 }
64
65 }
66
67 @Test
68 public void testReplaceAtUsages() {
69 Graph graph = new Graph(getOptions());
70 Def def0 = graph.add(new Def());
71 Def def1 = graph.add(new Def());
72 Use use0 = graph.add(new Use(def0, null, null));
73 Use use1 = graph.add(new Use(null, def0, null));
74 Use use2 = graph.add(new Use(null, null, def0));
75
76 assertEquals(3, def0.getUsageCount());
77 assertThat(def0.usages(), contains(use0));
78 assertThat(def0.usages(), contains(use1));
79 assertThat(def0.usages(), contains(use2));
80
81 assertThat(def0.usages(), isNotEmpty());
82 assertThat(def1.usages(), isEmpty());
83
84 def0.replaceAtUsages(def1);
85
86 assertThat(def0.usages(), isEmpty());
87
88 assertEquals(3, def1.getUsageCount());
89 assertThat(def1.usages(), contains(use0));
90 assertThat(def1.usages(), contains(use1));
91 assertThat(def1.usages(), contains(use2));
92
93 assertThat(def1.usages(), isNotEmpty());
94 }
95
96 @Test
97 public void testReplaceAtUsagesWithPredicateAll() {
98 Graph graph = new Graph(getOptions());
99 Def def0 = graph.add(new Def());
100 Def def1 = graph.add(new Def());
101 Use use0 = graph.add(new Use(def0, null, null));
102 Use use1 = graph.add(new Use(null, def0, null));
103 Use use2 = graph.add(new Use(null, null, def0));
104
105 assertEquals(3, def0.getUsageCount());
106 assertThat(def0.usages(), contains(use0));
107 assertThat(def0.usages(), contains(use1));
108 assertThat(def0.usages(), contains(use2));
109
110 assertThat(def0.usages(), isNotEmpty());
111 assertThat(def1.usages(), isEmpty());
112
113 def0.replaceAtMatchingUsages(def1, u -> true);
114
115 assertThat(def0.usages(), isEmpty());
116
117 assertEquals(3, def1.getUsageCount());
118 assertThat(def1.usages(), contains(use0));
119 assertThat(def1.usages(), contains(use1));
120 assertThat(def1.usages(), contains(use2));
121
122 assertThat(def1.usages(), isNotEmpty());
123 }
124
125 @Test
126 public void testReplaceAtUsagesWithPredicateNone() {
127 Graph graph = new Graph(getOptions());
128 Def def0 = graph.add(new Def());
129 Def def1 = graph.add(new Def());
130 Use use0 = graph.add(new Use(def0, null, null));
131 Use use1 = graph.add(new Use(null, def0, null));
132 Use use2 = graph.add(new Use(null, null, def0));
133
134 assertEquals(3, def0.getUsageCount());
135 assertThat(def0.usages(), contains(use0));
136 assertThat(def0.usages(), contains(use1));
137 assertThat(def0.usages(), contains(use2));
138
139 assertThat(def0.usages(), isNotEmpty());
140 assertThat(def1.usages(), isEmpty());
141
142 def0.replaceAtMatchingUsages(def1, u -> false);
143
144 assertThat(def1.usages(), isEmpty());
145
146 assertEquals(3, def0.getUsageCount());
147 assertThat(def0.usages(), contains(use0));
148 assertThat(def0.usages(), contains(use1));
149 assertThat(def0.usages(), contains(use2));
150
151 assertThat(def0.usages(), isNotEmpty());
152 }
153
154 @Test
155 public void testReplaceAtUsagesWithPredicate1() {
156 Graph graph = new Graph(getOptions());
157 Def def0 = graph.add(new Def());
158 Def def1 = graph.add(new Def());
159 Use use0 = graph.add(new Use(def0, null, null));
160 Use use1 = graph.add(new Use(null, def0, null));
161 Use use2 = graph.add(new Use(null, null, def0));
162
163 assertEquals(3, def0.getUsageCount());
164 assertThat(def0.usages(), contains(use0));
165 assertThat(def0.usages(), contains(use1));
166 assertThat(def0.usages(), contains(use2));
167
168 assertThat(def0.usages(), isNotEmpty());
169 assertThat(def1.usages(), isEmpty());
170
171 def0.replaceAtMatchingUsages(def1, u -> u == use1);
172
173 assertEquals(1, def1.getUsageCount());
174 assertThat(def1.usages(), contains(use1));
175
176 assertThat(def1.usages(), isNotEmpty());
177
178 assertEquals(2, def0.getUsageCount());
179 assertThat(def0.usages(), contains(use0));
180 assertThat(def0.usages(), contains(use2));
181
182 assertThat(def0.usages(), isNotEmpty());
183 }
184
185 @Test
186 public void testReplaceAtUsagesWithPredicate2() {
187 Graph graph = new Graph(getOptions());
188 Def def0 = graph.add(new Def());
189 Def def1 = graph.add(new Def());
190 Use use0 = graph.add(new Use(def0, null, null));
191 Use use1 = graph.add(new Use(null, def0, null));
192 Use use2 = graph.add(new Use(null, null, def0));
193
194 assertEquals(3, def0.getUsageCount());
195 assertThat(def0.usages(), contains(use0));
196 assertThat(def0.usages(), contains(use1));
197 assertThat(def0.usages(), contains(use2));
198
199 assertThat(def0.usages(), isNotEmpty());
200 assertThat(def1.usages(), isEmpty());
201
202 def0.replaceAtMatchingUsages(def1, u -> u == use2);
203
204 assertEquals(1, def1.getUsageCount());
205 assertThat(def1.usages(), contains(use2));
206
207 assertThat(def1.usages(), isNotEmpty());
208
209 assertEquals(2, def0.getUsageCount());
210 assertThat(def0.usages(), contains(use0));
211 assertThat(def0.usages(), contains(use1));
212
213 assertThat(def0.usages(), isNotEmpty());
214 }
215
216 @Test
217 public void testReplaceAtUsagesWithPredicate0() {
218 Graph graph = new Graph(getOptions());
219 Def def0 = graph.add(new Def());
220 Def def1 = graph.add(new Def());
221 Use use0 = graph.add(new Use(def0, null, null));
222 Use use1 = graph.add(new Use(null, def0, null));
223 Use use2 = graph.add(new Use(null, null, def0));
224
225 assertEquals(3, def0.getUsageCount());
226 assertThat(def0.usages(), contains(use0));
227 assertThat(def0.usages(), contains(use1));
228 assertThat(def0.usages(), contains(use2));
229
230 assertThat(def0.usages(), isNotEmpty());
231 assertThat(def1.usages(), isEmpty());
232
233 def0.replaceAtMatchingUsages(def1, u -> u == use0);
234
235 assertEquals(1, def1.getUsageCount());
236 assertThat(def1.usages(), contains(use0));
237
238 assertThat(def1.usages(), isNotEmpty());
239
240 assertEquals(2, def0.getUsageCount());
241 assertThat(def0.usages(), contains(use1));
242 assertThat(def0.usages(), contains(use2));
243
244 assertThat(def0.usages(), isNotEmpty());
245 }
246
247 @Test
248 public void testReplaceAtUsagesWithPredicate02() {
249 Graph graph = new Graph(getOptions());
250 Def def0 = graph.add(new Def());
251 Def def1 = graph.add(new Def());
252 Use use0 = graph.add(new Use(def0, null, null));
253 Use use1 = graph.add(new Use(null, def0, null));
254 Use use2 = graph.add(new Use(null, null, def0));
255
256 assertEquals(3, def0.getUsageCount());
257 assertThat(def0.usages(), contains(use0));
258 assertThat(def0.usages(), contains(use1));
259 assertThat(def0.usages(), contains(use2));
260
261 assertThat(def0.usages(), isNotEmpty());
262 assertThat(def1.usages(), isEmpty());
263
264 def0.replaceAtMatchingUsages(def1, u -> u != use1);
265
266 assertEquals(1, def0.getUsageCount());
267 assertThat(def0.usages(), contains(use1));
268
269 assertThat(def0.usages(), isNotEmpty());
270
271 assertEquals(2, def1.getUsageCount());
272 assertThat(def1.usages(), contains(use0));
273 assertThat(def1.usages(), contains(use2));
274
275 assertThat(def1.usages(), isNotEmpty());
276 }
277
278 @Test
279 public void testReplaceAtUsagesWithPredicate023() {
280 Graph graph = new Graph(getOptions());
281 Def def0 = graph.add(new Def());
282 Def def1 = graph.add(new Def());
283 Use use0 = graph.add(new Use(def0, null, null));
284 Use use1 = graph.add(new Use(null, def0, null));
285 Use use2 = graph.add(new Use(null, null, def0));
286 Use use3 = graph.add(new Use(null, null, def0));
287
288 assertEquals(4, def0.getUsageCount());
289 assertThat(def0.usages(), contains(use0));
290 assertThat(def0.usages(), contains(use1));
291 assertThat(def0.usages(), contains(use2));
292 assertThat(def0.usages(), contains(use3));
293
294 assertThat(def0.usages(), isNotEmpty());
295 assertThat(def1.usages(), isEmpty());
296
297 def0.replaceAtMatchingUsages(def1, u -> u != use1);
298
299 assertEquals(1, def0.getUsageCount());
300 assertThat(def0.usages(), contains(use1));
301
302 assertThat(def0.usages(), isNotEmpty());
303
304 assertEquals(3, def1.getUsageCount());
305 assertThat(def1.usages(), contains(use0));
306 assertThat(def1.usages(), contains(use2));
307 assertThat(def1.usages(), contains(use3));
308
309 assertThat(def1.usages(), isNotEmpty());
310 }
311
312 @Test
313 public void testReplaceAtUsagesWithPredicate013() {
314 Graph graph = new Graph(getOptions());
315 Def def0 = graph.add(new Def());
316 Def def1 = graph.add(new Def());
317 Use use0 = graph.add(new Use(def0, null, null));
318 Use use1 = graph.add(new Use(null, def0, null));
319 Use use2 = graph.add(new Use(null, null, def0));
320 Use use3 = graph.add(new Use(null, null, def0));
321
322 assertEquals(4, def0.getUsageCount());
323 assertThat(def0.usages(), contains(use0));
324 assertThat(def0.usages(), contains(use1));
325 assertThat(def0.usages(), contains(use2));
326 assertThat(def0.usages(), contains(use3));
327
328 assertThat(def0.usages(), isNotEmpty());
329 assertThat(def1.usages(), isEmpty());
330
331 def0.replaceAtMatchingUsages(def1, u -> u != use2);
332
333 assertEquals(1, def0.getUsageCount());
334 assertThat(def0.usages(), contains(use2));
335
336 assertThat(def0.usages(), isNotEmpty());
337
338 assertEquals(3, def1.getUsageCount());
339 assertThat(def1.usages(), contains(use0));
340 assertThat(def1.usages(), contains(use1));
341 assertThat(def1.usages(), contains(use3));
342
343 assertThat(def1.usages(), isNotEmpty());
344 }
345
346 @Test
347 public void testReplaceAtUsagesWithPredicate203() {
348 Graph graph = new Graph(getOptions());
349 Def def0 = graph.add(new Def());
350 Def def1 = graph.add(new Def());
351 Use use0 = graph.add(new Use(def0, null, null));
352 Use use1 = graph.add(new Use(null, def0, null));
353 Use use2 = graph.add(new Use(null, null, def0));
354 Use use3 = graph.add(new Use(null, null, def0));
355
356 assertEquals(4, def0.getUsageCount());
357 assertThat(def0.usages(), contains(use0));
358 assertThat(def0.usages(), contains(use1));
359 assertThat(def0.usages(), contains(use2));
360 assertThat(def0.usages(), contains(use3));
361
362 assertThat(def0.usages(), isNotEmpty());
363 assertThat(def1.usages(), isEmpty());
364
365 def0.replaceAtMatchingUsages(def1, u -> u == use2);
366
367 assertEquals(1, def1.getUsageCount());
368 assertThat(def1.usages(), contains(use2));
369
370 assertThat(def1.usages(), isNotEmpty());
371
372 assertEquals(3, def0.getUsageCount());
373 assertThat(def0.usages(), contains(use0));
374 assertThat(def0.usages(), contains(use1));
375 assertThat(def0.usages(), contains(use3));
376
377 assertThat(def0.usages(), isNotEmpty());
378 }
379
380 @Test
381 public void testReplaceAtUsagesWithPredicate01() {
382 Graph graph = new Graph(getOptions());
383 Def def0 = graph.add(new Def());
384 Def def1 = graph.add(new Def());
385 Use use0 = graph.add(new Use(def0, null, null));
386 Use use1 = graph.add(new Use(null, def0, null));
387 Use use2 = graph.add(new Use(null, null, def0));
388
389 assertEquals(3, def0.getUsageCount());
390 assertThat(def0.usages(), contains(use0));
391 assertThat(def0.usages(), contains(use1));
392 assertThat(def0.usages(), contains(use2));
393
394 assertThat(def0.usages(), isNotEmpty());
395 assertThat(def1.usages(), isEmpty());
396
397 def0.replaceAtMatchingUsages(def1, u -> u != use2);
398
399 assertEquals(1, def0.getUsageCount());
400 assertThat(def0.usages(), contains(use2));
401
402 assertThat(def0.usages(), isNotEmpty());
403
404 assertEquals(2, def1.getUsageCount());
405 assertThat(def1.usages(), contains(use0));
406 assertThat(def1.usages(), contains(use1));
407
408 assertThat(def1.usages(), isNotEmpty());
409 }
410
411 @Test
412 public void testReplaceAtUsagesWithPredicate12() {
413 Graph graph = new Graph(getOptions());
414 Def def0 = graph.add(new Def());
415 Def def1 = graph.add(new Def());
416 Use use0 = graph.add(new Use(def0, null, null));
417 Use use1 = graph.add(new Use(null, def0, null));
418 Use use2 = graph.add(new Use(null, null, def0));
419
420 assertEquals(3, def0.getUsageCount());
421 assertThat(def0.usages(), contains(use0));
422 assertThat(def0.usages(), contains(use1));
423 assertThat(def0.usages(), contains(use2));
424
425 assertThat(def0.usages(), isNotEmpty());
426 assertThat(def1.usages(), isEmpty());
427
428 def0.replaceAtMatchingUsages(def1, u -> u != use0);
429
430 assertEquals(1, def0.getUsageCount());
431 assertThat(def0.usages(), contains(use0));
432
433 assertThat(def0.usages(), isNotEmpty());
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package org.graalvm.compiler.graph.test;
24
25 import static org.graalvm.compiler.graph.test.matchers.NodeIterableContains.contains;
26 import static org.graalvm.compiler.graph.test.matchers.NodeIterableIsEmpty.isEmpty;
27 import static org.graalvm.compiler.graph.test.matchers.NodeIterableIsEmpty.isNotEmpty;
28 import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_IGNORED;
29 import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_IGNORED;
30 import static org.junit.Assert.assertEquals;
31 import static org.junit.Assert.assertThat;
32
33 import org.junit.Test;
34
35 import org.graalvm.compiler.graph.Graph;
36 import org.graalvm.compiler.graph.Node;
37 import org.graalvm.compiler.graph.NodeClass;
38 import org.graalvm.compiler.nodeinfo.NodeInfo;
39 import org.graalvm.compiler.options.OptionValues;
40
41 public class NodeUsagesTests extends GraphTest {
42
43 @NodeInfo(cycles = CYCLES_IGNORED, size = SIZE_IGNORED)
44 static final class Def extends Node {
45 public static final NodeClass<Def> TYPE = NodeClass.create(Def.class);
46
47 protected Def() {
48 super(TYPE);
49 }
50 }
51
52 @NodeInfo(cycles = CYCLES_IGNORED, size = SIZE_IGNORED)
53 static final class Use extends Node {
54 public static final NodeClass<Use> TYPE = NodeClass.create(Use.class);
55 @Input Def in0;
56 @Input Def in1;
57 @Input Def in2;
58
59 protected Use(Def in0, Def in1, Def in2) {
60 super(TYPE);
61 this.in0 = in0;
62 this.in1 = in1;
63 this.in2 = in2;
64 }
65
66 }
67
68 @Test
69 public void testReplaceAtUsages() {
70 OptionValues options = getOptions();
71 Graph graph = new Graph(options, getDebug(options));
72 Def def0 = graph.add(new Def());
73 Def def1 = graph.add(new Def());
74 Use use0 = graph.add(new Use(def0, null, null));
75 Use use1 = graph.add(new Use(null, def0, null));
76 Use use2 = graph.add(new Use(null, null, def0));
77
78 assertEquals(3, def0.getUsageCount());
79 assertThat(def0.usages(), contains(use0));
80 assertThat(def0.usages(), contains(use1));
81 assertThat(def0.usages(), contains(use2));
82
83 assertThat(def0.usages(), isNotEmpty());
84 assertThat(def1.usages(), isEmpty());
85
86 def0.replaceAtUsages(def1);
87
88 assertThat(def0.usages(), isEmpty());
89
90 assertEquals(3, def1.getUsageCount());
91 assertThat(def1.usages(), contains(use0));
92 assertThat(def1.usages(), contains(use1));
93 assertThat(def1.usages(), contains(use2));
94
95 assertThat(def1.usages(), isNotEmpty());
96 }
97
98 @Test
99 public void testReplaceAtUsagesWithPredicateAll() {
100 OptionValues options = getOptions();
101 Graph graph = new Graph(options, getDebug(options));
102 Def def0 = graph.add(new Def());
103 Def def1 = graph.add(new Def());
104 Use use0 = graph.add(new Use(def0, null, null));
105 Use use1 = graph.add(new Use(null, def0, null));
106 Use use2 = graph.add(new Use(null, null, def0));
107
108 assertEquals(3, def0.getUsageCount());
109 assertThat(def0.usages(), contains(use0));
110 assertThat(def0.usages(), contains(use1));
111 assertThat(def0.usages(), contains(use2));
112
113 assertThat(def0.usages(), isNotEmpty());
114 assertThat(def1.usages(), isEmpty());
115
116 def0.replaceAtMatchingUsages(def1, u -> true);
117
118 assertThat(def0.usages(), isEmpty());
119
120 assertEquals(3, def1.getUsageCount());
121 assertThat(def1.usages(), contains(use0));
122 assertThat(def1.usages(), contains(use1));
123 assertThat(def1.usages(), contains(use2));
124
125 assertThat(def1.usages(), isNotEmpty());
126 }
127
128 @Test
129 public void testReplaceAtUsagesWithPredicateNone() {
130 OptionValues options = getOptions();
131 Graph graph = new Graph(options, getDebug(options));
132 Def def0 = graph.add(new Def());
133 Def def1 = graph.add(new Def());
134 Use use0 = graph.add(new Use(def0, null, null));
135 Use use1 = graph.add(new Use(null, def0, null));
136 Use use2 = graph.add(new Use(null, null, def0));
137
138 assertEquals(3, def0.getUsageCount());
139 assertThat(def0.usages(), contains(use0));
140 assertThat(def0.usages(), contains(use1));
141 assertThat(def0.usages(), contains(use2));
142
143 assertThat(def0.usages(), isNotEmpty());
144 assertThat(def1.usages(), isEmpty());
145
146 def0.replaceAtMatchingUsages(def1, u -> false);
147
148 assertThat(def1.usages(), isEmpty());
149
150 assertEquals(3, def0.getUsageCount());
151 assertThat(def0.usages(), contains(use0));
152 assertThat(def0.usages(), contains(use1));
153 assertThat(def0.usages(), contains(use2));
154
155 assertThat(def0.usages(), isNotEmpty());
156 }
157
158 @Test
159 public void testReplaceAtUsagesWithPredicate1() {
160 OptionValues options = getOptions();
161 Graph graph = new Graph(options, getDebug(options));
162 Def def0 = graph.add(new Def());
163 Def def1 = graph.add(new Def());
164 Use use0 = graph.add(new Use(def0, null, null));
165 Use use1 = graph.add(new Use(null, def0, null));
166 Use use2 = graph.add(new Use(null, null, def0));
167
168 assertEquals(3, def0.getUsageCount());
169 assertThat(def0.usages(), contains(use0));
170 assertThat(def0.usages(), contains(use1));
171 assertThat(def0.usages(), contains(use2));
172
173 assertThat(def0.usages(), isNotEmpty());
174 assertThat(def1.usages(), isEmpty());
175
176 def0.replaceAtMatchingUsages(def1, u -> u == use1);
177
178 assertEquals(1, def1.getUsageCount());
179 assertThat(def1.usages(), contains(use1));
180
181 assertThat(def1.usages(), isNotEmpty());
182
183 assertEquals(2, def0.getUsageCount());
184 assertThat(def0.usages(), contains(use0));
185 assertThat(def0.usages(), contains(use2));
186
187 assertThat(def0.usages(), isNotEmpty());
188 }
189
190 @Test
191 public void testReplaceAtUsagesWithPredicate2() {
192 OptionValues options = getOptions();
193 Graph graph = new Graph(options, getDebug(options));
194 Def def0 = graph.add(new Def());
195 Def def1 = graph.add(new Def());
196 Use use0 = graph.add(new Use(def0, null, null));
197 Use use1 = graph.add(new Use(null, def0, null));
198 Use use2 = graph.add(new Use(null, null, def0));
199
200 assertEquals(3, def0.getUsageCount());
201 assertThat(def0.usages(), contains(use0));
202 assertThat(def0.usages(), contains(use1));
203 assertThat(def0.usages(), contains(use2));
204
205 assertThat(def0.usages(), isNotEmpty());
206 assertThat(def1.usages(), isEmpty());
207
208 def0.replaceAtMatchingUsages(def1, u -> u == use2);
209
210 assertEquals(1, def1.getUsageCount());
211 assertThat(def1.usages(), contains(use2));
212
213 assertThat(def1.usages(), isNotEmpty());
214
215 assertEquals(2, def0.getUsageCount());
216 assertThat(def0.usages(), contains(use0));
217 assertThat(def0.usages(), contains(use1));
218
219 assertThat(def0.usages(), isNotEmpty());
220 }
221
222 @Test
223 public void testReplaceAtUsagesWithPredicate0() {
224 OptionValues options = getOptions();
225 Graph graph = new Graph(options, getDebug(options));
226 Def def0 = graph.add(new Def());
227 Def def1 = graph.add(new Def());
228 Use use0 = graph.add(new Use(def0, null, null));
229 Use use1 = graph.add(new Use(null, def0, null));
230 Use use2 = graph.add(new Use(null, null, def0));
231
232 assertEquals(3, def0.getUsageCount());
233 assertThat(def0.usages(), contains(use0));
234 assertThat(def0.usages(), contains(use1));
235 assertThat(def0.usages(), contains(use2));
236
237 assertThat(def0.usages(), isNotEmpty());
238 assertThat(def1.usages(), isEmpty());
239
240 def0.replaceAtMatchingUsages(def1, u -> u == use0);
241
242 assertEquals(1, def1.getUsageCount());
243 assertThat(def1.usages(), contains(use0));
244
245 assertThat(def1.usages(), isNotEmpty());
246
247 assertEquals(2, def0.getUsageCount());
248 assertThat(def0.usages(), contains(use1));
249 assertThat(def0.usages(), contains(use2));
250
251 assertThat(def0.usages(), isNotEmpty());
252 }
253
254 @Test
255 public void testReplaceAtUsagesWithPredicate02() {
256 OptionValues options = getOptions();
257 Graph graph = new Graph(options, getDebug(options));
258 Def def0 = graph.add(new Def());
259 Def def1 = graph.add(new Def());
260 Use use0 = graph.add(new Use(def0, null, null));
261 Use use1 = graph.add(new Use(null, def0, null));
262 Use use2 = graph.add(new Use(null, null, def0));
263
264 assertEquals(3, def0.getUsageCount());
265 assertThat(def0.usages(), contains(use0));
266 assertThat(def0.usages(), contains(use1));
267 assertThat(def0.usages(), contains(use2));
268
269 assertThat(def0.usages(), isNotEmpty());
270 assertThat(def1.usages(), isEmpty());
271
272 def0.replaceAtMatchingUsages(def1, u -> u != use1);
273
274 assertEquals(1, def0.getUsageCount());
275 assertThat(def0.usages(), contains(use1));
276
277 assertThat(def0.usages(), isNotEmpty());
278
279 assertEquals(2, def1.getUsageCount());
280 assertThat(def1.usages(), contains(use0));
281 assertThat(def1.usages(), contains(use2));
282
283 assertThat(def1.usages(), isNotEmpty());
284 }
285
286 @Test
287 public void testReplaceAtUsagesWithPredicate023() {
288 OptionValues options = getOptions();
289 Graph graph = new Graph(options, getDebug(options));
290 Def def0 = graph.add(new Def());
291 Def def1 = graph.add(new Def());
292 Use use0 = graph.add(new Use(def0, null, null));
293 Use use1 = graph.add(new Use(null, def0, null));
294 Use use2 = graph.add(new Use(null, null, def0));
295 Use use3 = graph.add(new Use(null, null, def0));
296
297 assertEquals(4, def0.getUsageCount());
298 assertThat(def0.usages(), contains(use0));
299 assertThat(def0.usages(), contains(use1));
300 assertThat(def0.usages(), contains(use2));
301 assertThat(def0.usages(), contains(use3));
302
303 assertThat(def0.usages(), isNotEmpty());
304 assertThat(def1.usages(), isEmpty());
305
306 def0.replaceAtMatchingUsages(def1, u -> u != use1);
307
308 assertEquals(1, def0.getUsageCount());
309 assertThat(def0.usages(), contains(use1));
310
311 assertThat(def0.usages(), isNotEmpty());
312
313 assertEquals(3, def1.getUsageCount());
314 assertThat(def1.usages(), contains(use0));
315 assertThat(def1.usages(), contains(use2));
316 assertThat(def1.usages(), contains(use3));
317
318 assertThat(def1.usages(), isNotEmpty());
319 }
320
321 @Test
322 public void testReplaceAtUsagesWithPredicate013() {
323 OptionValues options = getOptions();
324 Graph graph = new Graph(options, getDebug(options));
325 Def def0 = graph.add(new Def());
326 Def def1 = graph.add(new Def());
327 Use use0 = graph.add(new Use(def0, null, null));
328 Use use1 = graph.add(new Use(null, def0, null));
329 Use use2 = graph.add(new Use(null, null, def0));
330 Use use3 = graph.add(new Use(null, null, def0));
331
332 assertEquals(4, def0.getUsageCount());
333 assertThat(def0.usages(), contains(use0));
334 assertThat(def0.usages(), contains(use1));
335 assertThat(def0.usages(), contains(use2));
336 assertThat(def0.usages(), contains(use3));
337
338 assertThat(def0.usages(), isNotEmpty());
339 assertThat(def1.usages(), isEmpty());
340
341 def0.replaceAtMatchingUsages(def1, u -> u != use2);
342
343 assertEquals(1, def0.getUsageCount());
344 assertThat(def0.usages(), contains(use2));
345
346 assertThat(def0.usages(), isNotEmpty());
347
348 assertEquals(3, def1.getUsageCount());
349 assertThat(def1.usages(), contains(use0));
350 assertThat(def1.usages(), contains(use1));
351 assertThat(def1.usages(), contains(use3));
352
353 assertThat(def1.usages(), isNotEmpty());
354 }
355
356 @Test
357 public void testReplaceAtUsagesWithPredicate203() {
358 OptionValues options = getOptions();
359 Graph graph = new Graph(options, getDebug(options));
360 Def def0 = graph.add(new Def());
361 Def def1 = graph.add(new Def());
362 Use use0 = graph.add(new Use(def0, null, null));
363 Use use1 = graph.add(new Use(null, def0, null));
364 Use use2 = graph.add(new Use(null, null, def0));
365 Use use3 = graph.add(new Use(null, null, def0));
366
367 assertEquals(4, def0.getUsageCount());
368 assertThat(def0.usages(), contains(use0));
369 assertThat(def0.usages(), contains(use1));
370 assertThat(def0.usages(), contains(use2));
371 assertThat(def0.usages(), contains(use3));
372
373 assertThat(def0.usages(), isNotEmpty());
374 assertThat(def1.usages(), isEmpty());
375
376 def0.replaceAtMatchingUsages(def1, u -> u == use2);
377
378 assertEquals(1, def1.getUsageCount());
379 assertThat(def1.usages(), contains(use2));
380
381 assertThat(def1.usages(), isNotEmpty());
382
383 assertEquals(3, def0.getUsageCount());
384 assertThat(def0.usages(), contains(use0));
385 assertThat(def0.usages(), contains(use1));
386 assertThat(def0.usages(), contains(use3));
387
388 assertThat(def0.usages(), isNotEmpty());
389 }
390
391 @Test
392 public void testReplaceAtUsagesWithPredicate01() {
393 OptionValues options = getOptions();
394 Graph graph = new Graph(options, getDebug(options));
395 Def def0 = graph.add(new Def());
396 Def def1 = graph.add(new Def());
397 Use use0 = graph.add(new Use(def0, null, null));
398 Use use1 = graph.add(new Use(null, def0, null));
399 Use use2 = graph.add(new Use(null, null, def0));
400
401 assertEquals(3, def0.getUsageCount());
402 assertThat(def0.usages(), contains(use0));
403 assertThat(def0.usages(), contains(use1));
404 assertThat(def0.usages(), contains(use2));
405
406 assertThat(def0.usages(), isNotEmpty());
407 assertThat(def1.usages(), isEmpty());
408
409 def0.replaceAtMatchingUsages(def1, u -> u != use2);
410
411 assertEquals(1, def0.getUsageCount());
412 assertThat(def0.usages(), contains(use2));
413
414 assertThat(def0.usages(), isNotEmpty());
415
416 assertEquals(2, def1.getUsageCount());
417 assertThat(def1.usages(), contains(use0));
418 assertThat(def1.usages(), contains(use1));
419
420 assertThat(def1.usages(), isNotEmpty());
421 }
422
423 @Test
424 public void testReplaceAtUsagesWithPredicate12() {
425 OptionValues options = getOptions();
426 Graph graph = new Graph(options, getDebug(options));
427 Def def0 = graph.add(new Def());
428 Def def1 = graph.add(new Def());
429 Use use0 = graph.add(new Use(def0, null, null));
430 Use use1 = graph.add(new Use(null, def0, null));
431 Use use2 = graph.add(new Use(null, null, def0));
432
433 assertEquals(3, def0.getUsageCount());
434 assertThat(def0.usages(), contains(use0));
435 assertThat(def0.usages(), contains(use1));
436 assertThat(def0.usages(), contains(use2));
437
438 assertThat(def0.usages(), isNotEmpty());
439 assertThat(def1.usages(), isEmpty());
440
441 def0.replaceAtMatchingUsages(def1, u -> u != use0);
442
443 assertEquals(1, def0.getUsageCount());
444 assertThat(def0.usages(), contains(use0));
445
446 assertThat(def0.usages(), isNotEmpty());
|