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  */
  23 package org.graalvm.compiler.core.test;
  24 
  25 import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_IGNORED;
  26 import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_IGNORED;
  27 
  28 import java.util.Iterator;
  29 
  30 import org.junit.Assert;
  31 import org.junit.Test;
  32 
  33 import org.graalvm.compiler.graph.Node;
  34 import org.graalvm.compiler.graph.NodeClass;
  35 import org.graalvm.compiler.graph.NodeInputList;
  36 import org.graalvm.compiler.graph.NodeSuccessorList;
  37 import org.graalvm.compiler.graph.Position;
  38 import org.graalvm.compiler.graph.iterators.NodeIterable;
  39 import org.graalvm.compiler.nodeinfo.NodeInfo;
  40 import org.graalvm.compiler.nodes.ConstantNode;
  41 import org.graalvm.compiler.nodes.EndNode;
  42 import org.graalvm.compiler.nodes.ValueNode;
  43 import org.graalvm.compiler.nodes.calc.FloatingNode;
  44 
  45 public 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 }