1 /*
2 * Copyright (c) 2011, 2013, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package javafx.scene;
27
28 import static org.junit.Assert.assertEquals;
29 import static org.junit.Assert.assertFalse;
30 import static org.junit.Assert.assertTrue;
31 import javafx.scene.shape.Rectangle;
32
33 import org.junit.Test;
34
35 /**
36 * Tests for depth test features.
37 *
38 */
39 public class DepthTestTest {
40
41 /**
42 * Tests the default value for a single node with no parent
43 */
44 @Test public void testDepthTestSingleDefault() {
45 Node node = new Rectangle();
46 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
47 assertTrue(node.isDerivedDepthTest());
48 }
49
50 /**
51 * Tests the default values for a group node with a child node
52 */
53 @Test public void testDepthTestParentChildDefaults() {
54 Group group = new Group();
55 Node node = new Rectangle();
56 group.getChildren().add(node);
57 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
58 assertTrue(group.isDerivedDepthTest());
59 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
60 assertTrue(node.isDerivedDepthTest());
61 validate(group, true);
62 }
63
64 /**
65 * Tests setting the value for a single node with no parent
66 */
67 @Test public void testDepthTestSingleSet() {
68 Node node = new Rectangle();
69 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
70 assertTrue(node.isDerivedDepthTest());
71
72 node.setDepthTest(DepthTest.DISABLE);
73 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
74 assertFalse(node.isDerivedDepthTest());
75
76 node.setDepthTest(DepthTest.ENABLE);
77 assertEquals(node.getDepthTest(), DepthTest.ENABLE);
78 assertTrue(node.isDerivedDepthTest());
79
80 node.setDepthTest(DepthTest.INHERIT);
81 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
82 assertTrue(node.isDerivedDepthTest());
83 }
84
85 /**
86 * Tests setting values for a group node with a child node
87 */
88 @Test public void testDepthTestParentChildSet() {
89 Group group = new Group();
90 Node node = new Rectangle();
91 group.getChildren().add(node);
92 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
93 assertTrue(group.isDerivedDepthTest());
94 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
95 assertTrue(node.isDerivedDepthTest());
96 validate(group, true);
97
98 node.setDepthTest(DepthTest.DISABLE);
99 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
100 assertTrue(group.isDerivedDepthTest());
101 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
102 assertFalse(node.isDerivedDepthTest());
103 validate(group, true);
104
105 node.setDepthTest(DepthTest.ENABLE);
106 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
107 assertTrue(group.isDerivedDepthTest());
108 assertEquals(node.getDepthTest(), DepthTest.ENABLE);
109 assertTrue(node.isDerivedDepthTest());
110 validate(group, true);
111
112 node.setDepthTest(DepthTest.INHERIT);
113 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
114 assertTrue(group.isDerivedDepthTest());
115 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
116 assertTrue(node.isDerivedDepthTest());
117 validate(group, true);
118
119 group.setDepthTest(DepthTest.DISABLE);
120 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
121 assertFalse(group.isDerivedDepthTest());
122 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
123 assertFalse(node.isDerivedDepthTest());
124 validate(group, true);
125
126 node.setDepthTest(DepthTest.DISABLE);
127 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
128 assertFalse(group.isDerivedDepthTest());
129 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
130 assertFalse(node.isDerivedDepthTest());
131 validate(group, true);
132
133 node.setDepthTest(DepthTest.ENABLE);
134 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
135 assertFalse(group.isDerivedDepthTest());
136 assertEquals(node.getDepthTest(), DepthTest.ENABLE);
137 assertTrue(node.isDerivedDepthTest());
138 validate(group, true);
139
140 node.setDepthTest(DepthTest.INHERIT);
141 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
142 assertFalse(group.isDerivedDepthTest());
143 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
144 assertFalse(node.isDerivedDepthTest());
145 validate(group, true);
146
147 group.setDepthTest(DepthTest.INHERIT);
148 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
149 assertTrue(group.isDerivedDepthTest());
150 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
151 assertTrue(node.isDerivedDepthTest());
152 validate(group, true);
153
154 group.setDepthTest(DepthTest.DISABLE);
155 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
156 assertFalse(group.isDerivedDepthTest());
157 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
158 assertFalse(node.isDerivedDepthTest());
159 validate(group, true);
160
161 node.setDepthTest(DepthTest.ENABLE);
162 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
163 assertFalse(group.isDerivedDepthTest());
164 assertEquals(node.getDepthTest(), DepthTest.ENABLE);
165 assertTrue(node.isDerivedDepthTest());
166 validate(group, true);
167
168 node.setDepthTest(DepthTest.DISABLE);
169 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
170 assertFalse(group.isDerivedDepthTest());
171 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
172 assertFalse(node.isDerivedDepthTest());
173 validate(group, true);
174
175 group.setDepthTest(DepthTest.INHERIT);
176 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
177 assertTrue(group.isDerivedDepthTest());
178 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
179 assertFalse(node.isDerivedDepthTest());
180 validate(group, true);
181
182 group.setDepthTest(DepthTest.ENABLE);
183 assertEquals(group.getDepthTest(), DepthTest.ENABLE);
184 assertTrue(group.isDerivedDepthTest());
185 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
186 assertFalse(node.isDerivedDepthTest());
187 validate(group, true);
188 }
189
190 /**
191 * Tests setting values for a group node with a child node, and ensures
192 * that the state is correct when adding and removing the child node.
193 */
194 @Test public void testDepthTestParentChildRemove() {
195 Group group = new Group();
196 Node node = new Rectangle();
197 group.getChildren().add(node);
198 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
199 assertTrue(group.isDerivedDepthTest());
200 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
201 assertTrue(node.isDerivedDepthTest());
202 validate(group, true);
203
204 group.setDepthTest(DepthTest.DISABLE);
205 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
206 assertFalse(group.isDerivedDepthTest());
207 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
208 assertFalse(node.isDerivedDepthTest());
209 validate(group, true);
210
211 group.getChildren().remove(node);
212 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
213 assertFalse(group.isDerivedDepthTest());
214 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
215 assertTrue(node.isDerivedDepthTest());
216 validate(group, true);
217 validate(node, true);
218
219 group.getChildren().add(node);
220 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
221 assertFalse(group.isDerivedDepthTest());
222 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
223 assertFalse(node.isDerivedDepthTest());
224 validate(group, true);
225
226 group.setDepthTest(DepthTest.INHERIT);
227 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
228 assertTrue(group.isDerivedDepthTest());
229 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
230 assertTrue(node.isDerivedDepthTest());
231 validate(group, true);
232
233 group.getChildren().remove(node);
234 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
235 assertTrue(group.isDerivedDepthTest());
236 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
237 assertTrue(node.isDerivedDepthTest());
238 validate(group, true);
239 validate(node, true);
240
241 group.setDepthTest(DepthTest.DISABLE);
242 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
243 assertFalse(group.isDerivedDepthTest());
244 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
245 assertTrue(node.isDerivedDepthTest());
246 validate(group, true);
247 validate(node, true);
248
249 group.getChildren().add(node);
250 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
251 assertFalse(group.isDerivedDepthTest());
252 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
253 assertFalse(node.isDerivedDepthTest());
254 validate(group, true);
255
256 group.setDepthTest(DepthTest.INHERIT);
257 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
258 assertTrue(group.isDerivedDepthTest());
259 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
260 assertTrue(node.isDerivedDepthTest());
261 validate(group, true);
262 }
263
264 /**
265 * Tests two levels of children and ensures that the state is correct when
266 * adding and removing the second group.
267 */
268 @Test public void testDepthTestMutliParentChildRemove() {
269 Group root = new Group();
270 Group group = new Group();
271 root.getChildren().add(group);
272 Node node = new Rectangle();
273 group.getChildren().add(node);
274 validate(root, true);
275
276 root.setDepthTest(DepthTest.DISABLE);
277 assertEquals(root.getDepthTest(), DepthTest.DISABLE);
278 assertFalse(root.isDerivedDepthTest());
279 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
280 assertFalse(group.isDerivedDepthTest());
281 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
282 assertFalse(node.isDerivedDepthTest());
283 validate(root, true);
284
285 root.getChildren().remove(group);
286 assertEquals(root.getDepthTest(), DepthTest.DISABLE);
287 assertFalse(root.isDerivedDepthTest());
288 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
289 assertTrue(group.isDerivedDepthTest());
290 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
291 assertTrue(node.isDerivedDepthTest());
292 validate(root, true);
293 validate(group, true);
294
295 root.getChildren().add(group);
296 assertEquals(root.getDepthTest(), DepthTest.DISABLE);
297 assertFalse(root.isDerivedDepthTest());
298 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
299 assertFalse(group.isDerivedDepthTest());
300 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
301 assertFalse(node.isDerivedDepthTest());
302 validate(root, true);
303
304 root.setDepthTest(DepthTest.INHERIT);
305 assertEquals(root.getDepthTest(), DepthTest.INHERIT);
306 assertTrue(root.isDerivedDepthTest());
307 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
308 assertTrue(group.isDerivedDepthTest());
309 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
310 assertTrue(node.isDerivedDepthTest());
311 validate(root, true);
312 }
313
314 /**
315 * Tests two levels of children and ensures that the state is correct when
316 * reparenting a group of nodes.
317 */
318 @Test public void testDepthTestReparent() {
319 Group root1 = new Group();
320 Group root2 = new Group();
321
322 Group group = new Group();
323 root1.getChildren().add(group);
324 Node node = new Rectangle();
325 group.getChildren().add(node);
326 validate(root1, true);
327 validate(root2, true);
328
329 root1.setDepthTest(DepthTest.DISABLE);
330 assertEquals(root1.getDepthTest(), DepthTest.DISABLE);
331 assertFalse(root1.isDerivedDepthTest());
332 assertEquals(root2.getDepthTest(), DepthTest.INHERIT);
333 assertTrue(root2.isDerivedDepthTest());
334 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
335 assertFalse(group.isDerivedDepthTest());
336 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
337 assertFalse(node.isDerivedDepthTest());
338 validate(root1, true);
339 validate(root2, true);
340
341 root2.getChildren().add(group);
342 assertEquals(root1.getDepthTest(), DepthTest.DISABLE);
343 assertFalse(root1.isDerivedDepthTest());
344 assertEquals(root2.getDepthTest(), DepthTest.INHERIT);
345 assertTrue(root2.isDerivedDepthTest());
346 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
347 assertTrue(group.isDerivedDepthTest());
348 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
349 assertTrue(node.isDerivedDepthTest());
350 validate(root1, true);
351 validate(root2, true);
352
353 root2.setDepthTest(DepthTest.DISABLE);
354 assertEquals(root1.getDepthTest(), DepthTest.DISABLE);
355 assertFalse(root1.isDerivedDepthTest());
356 assertEquals(root2.getDepthTest(), DepthTest.DISABLE);
357 assertFalse(root2.isDerivedDepthTest());
358 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
359 assertFalse(group.isDerivedDepthTest());
360 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
361 assertFalse(node.isDerivedDepthTest());
362 validate(root1, true);
363 validate(root2, true);
364 }
365
366 private void validate(Node n, boolean parentDerivedDepthTest) {
367 boolean nodeDerivedDepthTest = n.getDepthTest() == DepthTest.INHERIT
368 ? parentDerivedDepthTest
369 : n.getDepthTest() == DepthTest.ENABLE;
370 assertEquals(nodeDerivedDepthTest, n.isDerivedDepthTest());
371 if (n instanceof Group) {
372 Group g = (Group) n;
373 for (Node child : g.getChildren()) {
374 validate(child, nodeDerivedDepthTest);
375 }
376 }
377 }
378
379 }