1/*
2 * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
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 */
23package org.graalvm.compiler.graph.test;
24
25import static org.graalvm.compiler.graph.test.matchers.NodeIterableContains.contains;
26import static org.graalvm.compiler.graph.test.matchers.NodeIterableIsEmpty.isEmpty;
27import static org.graalvm.compiler.graph.test.matchers.NodeIterableIsEmpty.isNotEmpty;
28import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_IGNORED;
29import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_IGNORED;
30import static org.junit.Assert.assertEquals;
31import static org.junit.Assert.assertThat;
32
33import org.junit.Test;
34
35import org.graalvm.compiler.graph.Graph;
36import org.graalvm.compiler.graph.Node;
37import org.graalvm.compiler.graph.NodeClass;
38import org.graalvm.compiler.nodeinfo.NodeInfo;
39
40public class NodeUsagesTests {
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();
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();
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();
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();
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();
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();
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();
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();
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();
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();
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();
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();
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());
434
435        assertEquals(2, def1.getUsageCount());
436        assertThat(def1.usages(), contains(use1));
437        assertThat(def1.usages(), contains(use2));
438
439        assertThat(def1.usages(), isNotEmpty());
440    }
441}
442