1/*
2 * Copyright (c) 2012, 2012, 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.core.test;
24
25import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_IGNORED;
26import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_IGNORED;
27
28import java.util.Iterator;
29
30import org.junit.Assert;
31import org.junit.Test;
32
33import org.graalvm.compiler.graph.Node;
34import org.graalvm.compiler.graph.NodeClass;
35import org.graalvm.compiler.graph.NodeInputList;
36import org.graalvm.compiler.graph.NodeSuccessorList;
37import org.graalvm.compiler.graph.Position;
38import org.graalvm.compiler.graph.iterators.NodeIterable;
39import org.graalvm.compiler.nodeinfo.NodeInfo;
40import org.graalvm.compiler.nodes.ConstantNode;
41import org.graalvm.compiler.nodes.EndNode;
42import org.graalvm.compiler.nodes.ValueNode;
43import org.graalvm.compiler.nodes.calc.FloatingNode;
44
45public class NodePosIteratorTest extends GraalCompilerTest {
46
47    @NodeInfo(cycles = CYCLES_IGNORED, size = SIZE_IGNORED)
48    static final class TestNode extends Node {
49        public static final NodeClass<TestNode> TYPE = NodeClass.create(TestNode.class);
50        @Successor Node s1;
51        @Successor Node s2;
52        @Successor NodeSuccessorList<Node> stail;
53
54        @Input NodeInputList<ValueNode> itail;
55        @Input ConstantNode i1;
56        @Input FloatingNode i2;
57
58        protected TestNode() {
59            super(TYPE);
60        }
61
62    }
63
64    @Test
65    public void testInputs() {
66        TestNode n = new TestNode();
67
68        ConstantNode i1 = ConstantNode.forInt(1);
69        ConstantNode i2 = ConstantNode.forDouble(1.0d);
70        ConstantNode i3 = ConstantNode.forInt(4);
71        ConstantNode i4 = ConstantNode.forInt(14);
72        n.itail = new NodeInputList<>(n, new ValueNode[]{i3, i4});
73        n.i1 = i1;
74        n.i2 = i2;
75
76        NodeIterable<Node> inputs = n.inputs();
77
78        Iterator<Node> iterator = inputs.iterator();
79        Assert.assertTrue(iterator.hasNext());
80        Assert.assertTrue(iterator.hasNext());
81        Assert.assertEquals(iterator.next(), i1);
82        Assert.assertTrue(iterator.hasNext());
83        Assert.assertTrue(iterator.hasNext());
84        Assert.assertEquals(iterator.next(), i2);
85        Assert.assertTrue(iterator.hasNext());
86        Assert.assertTrue(iterator.hasNext());
87        Assert.assertEquals(iterator.next(), i3);
88        Assert.assertTrue(iterator.hasNext());
89        Assert.assertTrue(iterator.hasNext());
90        Assert.assertEquals(iterator.next(), i4);
91        Assert.assertFalse(iterator.hasNext());
92        Assert.assertFalse(iterator.hasNext());
93
94        Iterator<Position> positionIterator = n.inputPositions().iterator();
95        Assert.assertTrue(positionIterator.hasNext());
96        Assert.assertTrue(positionIterator.hasNext());
97        Assert.assertEquals("ConstantNode:i1", positionIterator.next().toString());
98        Assert.assertTrue(positionIterator.hasNext());
99        Assert.assertTrue(positionIterator.hasNext());
100        Assert.assertEquals("FloatingNode:i2", positionIterator.next().toString());
101        Assert.assertTrue(positionIterator.hasNext());
102        Assert.assertTrue(positionIterator.hasNext());
103        Assert.assertEquals("NodeInputList:itail[0]", positionIterator.next().toString());
104        Assert.assertTrue(positionIterator.hasNext());
105        Assert.assertTrue(positionIterator.hasNext());
106        Assert.assertEquals("NodeInputList:itail[1]", positionIterator.next().toString());
107        Assert.assertFalse(positionIterator.hasNext());
108        Assert.assertFalse(positionIterator.hasNext());
109
110        iterator = inputs.iterator();
111        n.i1 = i4;
112        Assert.assertTrue(iterator.hasNext());
113        Assert.assertEquals(iterator.next(), i4);
114        n.i2 = i1;
115        Assert.assertTrue(iterator.hasNext());
116        Assert.assertEquals(iterator.next(), i1);
117        Assert.assertTrue(iterator.hasNext());
118        Assert.assertEquals(iterator.next(), i3);
119        n.itail.initialize(1, i4);
120        Assert.assertTrue(iterator.hasNext());
121        Assert.assertEquals(iterator.next(), i4);
122        Assert.assertFalse(iterator.hasNext());
123
124        iterator = inputs.iterator();
125        n.i1 = null;
126        n.i2 = i2;
127        n.itail.initialize(0, null);
128        n.itail.initialize(1, i4);
129        Assert.assertTrue(iterator.hasNext());
130        Assert.assertEquals(iterator.next(), i2);
131        Assert.assertTrue(iterator.hasNext());
132        Assert.assertEquals(iterator.next(), i4);
133        Assert.assertFalse(iterator.hasNext());
134    }
135
136    @Test
137    public void testSuccessors() {
138        TestNode n = new TestNode();
139        EndNode s1 = new EndNode();
140        EndNode s2 = new EndNode();
141        EndNode s3 = new EndNode();
142        EndNode s4 = new EndNode();
143        n.s1 = s1;
144        n.s2 = s2;
145        n.stail = new NodeSuccessorList<>(n, new Node[]{s3, s4});
146
147        NodeIterable<Node> successors = n.successors();
148        Iterator<Node> iterator = successors.iterator();
149        Assert.assertTrue(iterator.hasNext());
150        Assert.assertTrue(iterator.hasNext());
151        Assert.assertEquals(iterator.next(), s1);
152        Assert.assertTrue(iterator.hasNext());
153        Assert.assertTrue(iterator.hasNext());
154        Assert.assertEquals(iterator.next(), s2);
155        Assert.assertTrue(iterator.hasNext());
156        Assert.assertTrue(iterator.hasNext());
157        Assert.assertEquals(iterator.next(), s3);
158        Assert.assertTrue(iterator.hasNext());
159        Assert.assertTrue(iterator.hasNext());
160        Assert.assertEquals(iterator.next(), s4);
161        Assert.assertFalse(iterator.hasNext());
162        Assert.assertFalse(iterator.hasNext());
163
164        Iterator<Position> positionIterator = n.successorPositions().iterator();
165        Assert.assertTrue(positionIterator.hasNext());
166        Assert.assertTrue(positionIterator.hasNext());
167        Assert.assertEquals(Node.class.getSimpleName() + ":s1", positionIterator.next().toString());
168        Assert.assertTrue(positionIterator.hasNext());
169        Assert.assertTrue(positionIterator.hasNext());
170        Assert.assertEquals(Node.class.getSimpleName() + ":s2", positionIterator.next().toString());
171        Assert.assertTrue(positionIterator.hasNext());
172        Assert.assertTrue(positionIterator.hasNext());
173        Assert.assertEquals(NodeSuccessorList.class.getSimpleName() + ":stail[0]", positionIterator.next().toString());
174        Assert.assertTrue(positionIterator.hasNext());
175        Assert.assertTrue(positionIterator.hasNext());
176        Assert.assertEquals(NodeSuccessorList.class.getSimpleName() + ":stail[1]", positionIterator.next().toString());
177        Assert.assertFalse(positionIterator.hasNext());
178        Assert.assertFalse(positionIterator.hasNext());
179
180        iterator = successors.iterator();
181        n.s1 = s4;
182        Assert.assertTrue(iterator.hasNext());
183        Assert.assertEquals(iterator.next(), s4);
184        n.s2 = s1;
185        Assert.assertTrue(iterator.hasNext());
186        Assert.assertEquals(iterator.next(), s1);
187        Assert.assertTrue(iterator.hasNext());
188        Assert.assertEquals(iterator.next(), s3);
189        n.stail.initialize(1, s4);
190        Assert.assertTrue(iterator.hasNext());
191        Assert.assertEquals(iterator.next(), s4);
192        Assert.assertFalse(iterator.hasNext());
193
194        iterator = successors.iterator();
195        n.s1 = null;
196        n.s2 = s2;
197        n.stail.initialize(0, null);
198        n.stail.initialize(1, s4);
199        Assert.assertTrue(iterator.hasNext());
200        Assert.assertEquals(iterator.next(), s2);
201        Assert.assertTrue(iterator.hasNext());
202        Assert.assertEquals(iterator.next(), s4);
203        Assert.assertFalse(iterator.hasNext());
204    }
205}
206