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 }
|
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 test.javafx.scene;
27
28 import javafx.scene.DepthTest;
29 import javafx.scene.Group;
30 import javafx.scene.Node;
31 import javafx.scene.NodeShim;
32 import static org.junit.Assert.assertEquals;
33 import static org.junit.Assert.assertFalse;
34 import static org.junit.Assert.assertTrue;
35 import javafx.scene.shape.Rectangle;
36
37 import org.junit.Test;
38
39 /**
40 * Tests for depth test features.
41 *
42 */
43 public class DepthTestTest {
44
45 /**
46 * Tests the default value for a single node with no parent
47 */
48 @Test public void testDepthTestSingleDefault() {
49 Node node = new Rectangle();
50 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
51 assertTrue(NodeShim.isDerivedDepthTest(node));
52 }
53
54 /**
55 * Tests the default values for a group node with a child node
56 */
57 @Test public void testDepthTestParentChildDefaults() {
58 Group group = new Group();
59 Node node = new Rectangle();
60 group.getChildren().add(node);
61 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
62 assertTrue(NodeShim.isDerivedDepthTest(group));
63 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
64 assertTrue(NodeShim.isDerivedDepthTest(node));
65 validate(group, true);
66 }
67
68 /**
69 * Tests setting the value for a single node with no parent
70 */
71 @Test public void testDepthTestSingleSet() {
72 Node node = new Rectangle();
73 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
74 assertTrue(NodeShim.isDerivedDepthTest(node));
75
76 node.setDepthTest(DepthTest.DISABLE);
77 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
78 assertFalse(NodeShim.isDerivedDepthTest(node));
79
80 node.setDepthTest(DepthTest.ENABLE);
81 assertEquals(node.getDepthTest(), DepthTest.ENABLE);
82 assertTrue(NodeShim.isDerivedDepthTest(node));
83
84 node.setDepthTest(DepthTest.INHERIT);
85 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
86 assertTrue(NodeShim.isDerivedDepthTest(node));
87 }
88
89 /**
90 * Tests setting values for a group node with a child node
91 */
92 @Test public void testDepthTestParentChildSet() {
93 Group group = new Group();
94 Node node = new Rectangle();
95 group.getChildren().add(node);
96 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
97 assertTrue(NodeShim.isDerivedDepthTest(group));
98 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
99 assertTrue(NodeShim.isDerivedDepthTest(node));
100 validate(group, true);
101
102 node.setDepthTest(DepthTest.DISABLE);
103 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
104 assertTrue(NodeShim.isDerivedDepthTest(group));
105 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
106 assertFalse(NodeShim.isDerivedDepthTest(node));
107 validate(group, true);
108
109 node.setDepthTest(DepthTest.ENABLE);
110 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
111 assertTrue(NodeShim.isDerivedDepthTest(group));
112 assertEquals(node.getDepthTest(), DepthTest.ENABLE);
113 assertTrue(NodeShim.isDerivedDepthTest(node));
114 validate(group, true);
115
116 node.setDepthTest(DepthTest.INHERIT);
117 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
118 assertTrue(NodeShim.isDerivedDepthTest(group));
119 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
120 assertTrue(NodeShim.isDerivedDepthTest(node));
121 validate(group, true);
122
123 group.setDepthTest(DepthTest.DISABLE);
124 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
125 assertFalse(NodeShim.isDerivedDepthTest(group));
126 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
127 assertFalse(NodeShim.isDerivedDepthTest(node));
128 validate(group, true);
129
130 node.setDepthTest(DepthTest.DISABLE);
131 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
132 assertFalse(NodeShim.isDerivedDepthTest(group));
133 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
134 assertFalse(NodeShim.isDerivedDepthTest(node));
135 validate(group, true);
136
137 node.setDepthTest(DepthTest.ENABLE);
138 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
139 assertFalse(NodeShim.isDerivedDepthTest(group));
140 assertEquals(node.getDepthTest(), DepthTest.ENABLE);
141 assertTrue(NodeShim.isDerivedDepthTest(node));
142 validate(group, true);
143
144 node.setDepthTest(DepthTest.INHERIT);
145 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
146 assertFalse(NodeShim.isDerivedDepthTest(group));
147 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
148 assertFalse(NodeShim.isDerivedDepthTest(node));
149 validate(group, true);
150
151 group.setDepthTest(DepthTest.INHERIT);
152 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
153 assertTrue(NodeShim.isDerivedDepthTest(group));
154 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
155 assertTrue(NodeShim.isDerivedDepthTest(node));
156 validate(group, true);
157
158 group.setDepthTest(DepthTest.DISABLE);
159 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
160 assertFalse(NodeShim.isDerivedDepthTest(group));
161 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
162 assertFalse(NodeShim.isDerivedDepthTest(node));
163 validate(group, true);
164
165 node.setDepthTest(DepthTest.ENABLE);
166 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
167 assertFalse(NodeShim.isDerivedDepthTest(group));
168 assertEquals(node.getDepthTest(), DepthTest.ENABLE);
169 assertTrue(NodeShim.isDerivedDepthTest(node));
170 validate(group, true);
171
172 node.setDepthTest(DepthTest.DISABLE);
173 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
174 assertFalse(NodeShim.isDerivedDepthTest(group));
175 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
176 assertFalse(NodeShim.isDerivedDepthTest(node));
177 validate(group, true);
178
179 group.setDepthTest(DepthTest.INHERIT);
180 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
181 assertTrue(NodeShim.isDerivedDepthTest(group));
182 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
183 assertFalse(NodeShim.isDerivedDepthTest(node));
184 validate(group, true);
185
186 group.setDepthTest(DepthTest.ENABLE);
187 assertEquals(group.getDepthTest(), DepthTest.ENABLE);
188 assertTrue(NodeShim.isDerivedDepthTest(group));
189 assertEquals(node.getDepthTest(), DepthTest.DISABLE);
190 assertFalse(NodeShim.isDerivedDepthTest(node));
191 validate(group, true);
192 }
193
194 /**
195 * Tests setting values for a group node with a child node, and ensures
196 * that the state is correct when adding and removing the child node.
197 */
198 @Test public void testDepthTestParentChildRemove() {
199 Group group = new Group();
200 Node node = new Rectangle();
201 group.getChildren().add(node);
202 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
203 assertTrue(NodeShim.isDerivedDepthTest(group));
204 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
205 assertTrue(NodeShim.isDerivedDepthTest(node));
206 validate(group, true);
207
208 group.setDepthTest(DepthTest.DISABLE);
209 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
210 assertFalse(NodeShim.isDerivedDepthTest(group));
211 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
212 assertFalse(NodeShim.isDerivedDepthTest(node));
213 validate(group, true);
214
215 group.getChildren().remove(node);
216 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
217 assertFalse(NodeShim.isDerivedDepthTest(group));
218 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
219 assertTrue(NodeShim.isDerivedDepthTest(node));
220 validate(group, true);
221 validate(node, true);
222
223 group.getChildren().add(node);
224 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
225 assertFalse(NodeShim.isDerivedDepthTest(group));
226 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
227 assertFalse(NodeShim.isDerivedDepthTest(node));
228 validate(group, true);
229
230 group.setDepthTest(DepthTest.INHERIT);
231 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
232 assertTrue(NodeShim.isDerivedDepthTest(group));
233 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
234 assertTrue(NodeShim.isDerivedDepthTest(node));
235 validate(group, true);
236
237 group.getChildren().remove(node);
238 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
239 assertTrue(NodeShim.isDerivedDepthTest(group));
240 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
241 assertTrue(NodeShim.isDerivedDepthTest(node));
242 validate(group, true);
243 validate(node, true);
244
245 group.setDepthTest(DepthTest.DISABLE);
246 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
247 assertFalse(NodeShim.isDerivedDepthTest(group));
248 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
249 assertTrue(NodeShim.isDerivedDepthTest(node));
250 validate(group, true);
251 validate(node, true);
252
253 group.getChildren().add(node);
254 assertEquals(group.getDepthTest(), DepthTest.DISABLE);
255 assertFalse(NodeShim.isDerivedDepthTest(group));
256 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
257 assertFalse(NodeShim.isDerivedDepthTest(node));
258 validate(group, true);
259
260 group.setDepthTest(DepthTest.INHERIT);
261 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
262 assertTrue(NodeShim.isDerivedDepthTest(group));
263 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
264 assertTrue(NodeShim.isDerivedDepthTest(node));
265 validate(group, true);
266 }
267
268 /**
269 * Tests two levels of children and ensures that the state is correct when
270 * adding and removing the second group.
271 */
272 @Test public void testDepthTestMutliParentChildRemove() {
273 Group root = new Group();
274 Group group = new Group();
275 root.getChildren().add(group);
276 Node node = new Rectangle();
277 group.getChildren().add(node);
278 validate(root, true);
279
280 root.setDepthTest(DepthTest.DISABLE);
281 assertEquals(root.getDepthTest(), DepthTest.DISABLE);
282 assertFalse(NodeShim.isDerivedDepthTest(root));
283 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
284 assertFalse(NodeShim.isDerivedDepthTest(group));
285 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
286 assertFalse(NodeShim.isDerivedDepthTest(node));
287 validate(root, true);
288
289 root.getChildren().remove(group);
290 assertEquals(root.getDepthTest(), DepthTest.DISABLE);
291 assertFalse(NodeShim.isDerivedDepthTest(root));
292 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
293 assertTrue(NodeShim.isDerivedDepthTest(group));
294 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
295 assertTrue(NodeShim.isDerivedDepthTest(node));
296 validate(root, true);
297 validate(group, true);
298
299 root.getChildren().add(group);
300 assertEquals(root.getDepthTest(), DepthTest.DISABLE);
301 assertFalse(NodeShim.isDerivedDepthTest(root));
302 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
303 assertFalse(NodeShim.isDerivedDepthTest(group));
304 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
305 assertFalse(NodeShim.isDerivedDepthTest(node));
306 validate(root, true);
307
308 root.setDepthTest(DepthTest.INHERIT);
309 assertEquals(root.getDepthTest(), DepthTest.INHERIT);
310 assertTrue(NodeShim.isDerivedDepthTest(root));
311 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
312 assertTrue(NodeShim.isDerivedDepthTest(group));
313 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
314 assertTrue(NodeShim.isDerivedDepthTest(node));
315 validate(root, true);
316 }
317
318 /**
319 * Tests two levels of children and ensures that the state is correct when
320 * reparenting a group of nodes.
321 */
322 @Test public void testDepthTestReparent() {
323 Group root1 = new Group();
324 Group root2 = new Group();
325
326 Group group = new Group();
327 root1.getChildren().add(group);
328 Node node = new Rectangle();
329 group.getChildren().add(node);
330 validate(root1, true);
331 validate(root2, true);
332
333 root1.setDepthTest(DepthTest.DISABLE);
334 assertEquals(root1.getDepthTest(), DepthTest.DISABLE);
335 assertFalse(NodeShim.isDerivedDepthTest(root1));
336 assertEquals(root2.getDepthTest(), DepthTest.INHERIT);
337 assertTrue(NodeShim.isDerivedDepthTest(root2));
338 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
339 assertFalse(NodeShim.isDerivedDepthTest(group));
340 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
341 assertFalse(NodeShim.isDerivedDepthTest(node));
342 validate(root1, true);
343 validate(root2, true);
344
345 root2.getChildren().add(group);
346 assertEquals(root1.getDepthTest(), DepthTest.DISABLE);
347 assertFalse(NodeShim.isDerivedDepthTest(root1));
348 assertEquals(root2.getDepthTest(), DepthTest.INHERIT);
349 assertTrue(NodeShim.isDerivedDepthTest(root2));
350 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
351 assertTrue(NodeShim.isDerivedDepthTest(group));
352 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
353 assertTrue(NodeShim.isDerivedDepthTest(node));
354 validate(root1, true);
355 validate(root2, true);
356
357 root2.setDepthTest(DepthTest.DISABLE);
358 assertEquals(root1.getDepthTest(), DepthTest.DISABLE);
359 assertFalse(NodeShim.isDerivedDepthTest(root1));
360 assertEquals(root2.getDepthTest(), DepthTest.DISABLE);
361 assertFalse(NodeShim.isDerivedDepthTest(root2));
362 assertEquals(group.getDepthTest(), DepthTest.INHERIT);
363 assertFalse(NodeShim.isDerivedDepthTest(group));
364 assertEquals(node.getDepthTest(), DepthTest.INHERIT);
365 assertFalse(NodeShim.isDerivedDepthTest(node));
366 validate(root1, true);
367 validate(root2, true);
368 }
369
370 private void validate(Node n, boolean parentDerivedDepthTest) {
371 boolean nodeDerivedDepthTest = n.getDepthTest() == DepthTest.INHERIT
372 ? parentDerivedDepthTest
373 : n.getDepthTest() == DepthTest.ENABLE;
374 assertEquals(nodeDerivedDepthTest, NodeShim.isDerivedDepthTest(n));
375 if (n instanceof Group) {
376 Group g = (Group) n;
377 for (Node child : g.getChildren()) {
378 validate(child, nodeDerivedDepthTest);
379 }
380 }
381 }
382
383 }
|