NodeBitMapTest.java revision 13522:0c2d710aa6df 
1140088Sdas/*
2140088Sdas * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
3140088Sdas * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4140088Sdas *
5140088Sdas * This code is free software; you can redistribute it and/or modify it
6140088Sdas * under the terms of the GNU General Public License version 2 only, as
7140088Sdas * published by the Free Software Foundation.
8140088Sdas *
9140088Sdas * 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.nodeinfo.NodeCycles.CYCLES_IGNORED;
26import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_IGNORED;
27
28import java.util.ConcurrentModificationException;
29import java.util.Iterator;
30import java.util.NoSuchElementException;
31
32import org.graalvm.compiler.api.test.Graal;
33import org.graalvm.compiler.graph.Graph;
34import org.graalvm.compiler.graph.Node;
35import org.graalvm.compiler.graph.NodeBitMap;
36import org.graalvm.compiler.graph.NodeClass;
37import org.graalvm.compiler.nodeinfo.NodeInfo;
38import org.graalvm.compiler.options.OptionValues;
39import org.junit.Assert;
40import org.junit.Before;
41import org.junit.Test;
42
43public class NodeBitMapTest extends GraphTest {
44
45    @NodeInfo(cycles = CYCLES_IGNORED, size = SIZE_IGNORED)
46    static final class TestNode extends Node {
47        public static final NodeClass<TestNode> TYPE = NodeClass.create(TestNode.class);
48
49        protected TestNode() {
50            super(TYPE);
51        }
52    }
53
54    private Graph graph;
55    private TestNode[] nodes = new TestNode[100];
56    private NodeBitMap map;
57
58    @Before
59    public void before() {
60        // Need to initialize HotSpotGraalRuntime before any Node class is initialized.
61        Graal.getRuntime();
62
63        OptionValues options = getOptions();
64        graph = new Graph(options, getDebug(options));
65        for (int i = 0; i < nodes.length; i++) {
66            nodes[i] = graph.add(new TestNode());
67        }
68        map = graph.createNodeBitMap();
69    }
70
71    @Test
72    public void iterateEmpty() {
73        for (Node n : map) {
74            Assert.fail("no elements expected: " + n);
75        }
76    }
77
78    @Test
79    public void iterateMarkedNodes() {
80        map.mark(nodes[99]);
81        map.mark(nodes[0]);
82        map.mark(nodes[7]);
83        map.mark(nodes[1]);
84        map.mark(nodes[53]);
85
86        Iterator<Node> iter = map.iterator();
87        Assert.assertTrue(iter.hasNext());
88        Assert.assertEquals(nodes[0], iter.next());
89        Assert.assertTrue(iter.hasNext());
90        Assert.assertEquals(nodes[1], iter.next());
91        Assert.assertTrue(iter.hasNext());
92        Assert.assertEquals(nodes[7], iter.next());
93        Assert.assertTrue(iter.hasNext());
94        Assert.assertEquals(nodes[53], iter.next());
95        Assert.assertTrue(iter.hasNext());
96        Assert.assertEquals(nodes[99], iter.next());
97        Assert.assertFalse(iter.hasNext());
98    }
99
100    @Test
101    public void deleteNodeWhileIterating() {
102        map.mark(nodes[99]);
103        map.mark(nodes[0]);
104        map.mark(nodes[7]);
105        map.mark(nodes[1]);
106        map.mark(nodes[53]);
107
108        Iterator<Node> iter = map.iterator();
109        Assert.assertTrue(iter.hasNext());
110        Assert.assertEquals(nodes[0], iter.next());
111        Assert.assertTrue(iter.hasNext());
112        Assert.assertEquals(nodes[1], iter.next());
113        nodes[7].markDeleted();
114        nodes[53].markDeleted();
115        Assert.assertTrue(iter.hasNext());
116        Assert.assertEquals(nodes[99], iter.next());
117        Assert.assertFalse(iter.hasNext());
118    }
119
120    @Test
121    public void deleteAllNodesBeforeIterating() {
122        for (int i = 0; i < nodes.length; i++) {
123            map.mark(nodes[i]);
124            nodes[i].markDeleted();
125        }
126
127        Iterator<Node> iter = map.iterator();
128        Assert.assertFalse(iter.hasNext());
129    }
130
131    @Test
132    public void multipleHasNextInvocations() {
133        map.mark(nodes[7]);
134
135        Iterator<Node> iter = map.iterator();
136        Assert.assertTrue(iter.hasNext());
137        Assert.assertTrue(iter.hasNext());
138        Assert.assertEquals(nodes[7], iter.next());
139        Assert.assertFalse(iter.hasNext());
140    }
141
142    @Test(expected = NoSuchElementException.class)
143    public void noSuchElement() {
144        map.iterator().next();
145    }
146
147    @Test(expected = ConcurrentModificationException.class)
148    public void concurrentModification() {
149        map.mark(nodes[7]);
150
151        map.mark(nodes[99]);
152        map.mark(nodes[0]);
153        map.mark(nodes[7]);
154        map.mark(nodes[1]);
155        map.mark(nodes[53]);
156
157        Iterator<Node> iter = map.iterator();
158        Assert.assertTrue(iter.hasNext());
159        Assert.assertEquals(nodes[0], iter.next());
160        Assert.assertTrue(iter.hasNext());
161        Assert.assertEquals(nodes[1], iter.next());
162        Assert.assertTrue(iter.hasNext());
163        nodes[7].markDeleted();
164        iter.next();
165    }
166
167    @Test
168    public void nextWithoutHasNext() {
169        map.mark(nodes[99]);
170        map.mark(nodes[0]);
171        map.mark(nodes[7]);
172        map.mark(nodes[1]);
173        map.mark(nodes[53]);
174
175        Iterator<Node> iter = map.iterator();
176        Assert.assertEquals(nodes[0], iter.next());
177        Assert.assertEquals(nodes[1], iter.next());
178        Assert.assertEquals(nodes[7], iter.next());
179        Assert.assertEquals(nodes[53], iter.next());
180        Assert.assertEquals(nodes[99], iter.next());
181        Assert.assertFalse(iter.hasNext());
182    }
183
184    @Test
185    public void markWhileIterating() {
186        map.mark(nodes[0]);
187
188        Iterator<Node> iter = map.iterator();
189        Assert.assertTrue(iter.hasNext());
190        Assert.assertEquals(nodes[0], iter.next());
191        map.mark(nodes[7]);
192        Assert.assertTrue(iter.hasNext());
193        map.mark(nodes[1]);
194        Assert.assertEquals(nodes[7], iter.next());
195        map.mark(nodes[99]);
196        map.mark(nodes[53]);
197        Assert.assertTrue(iter.hasNext());
198        Assert.assertEquals(nodes[53], iter.next());
199        Assert.assertTrue(iter.hasNext());
200        Assert.assertEquals(nodes[99], iter.next());
201        Assert.assertFalse(iter.hasNext());
202    }
203}
204