1 /*
2 * Copyright (c) 2010, 2015, 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 test.javafx.scene.canvas;
27
28 import javafx.geometry.VPos;
29 import test.javafx.scene.NodeTest;
30 import javafx.scene.canvas.Canvas;
31 import javafx.scene.canvas.GraphicsContext;
32 import javafx.scene.effect.BlendMode;
33 import test.javafx.scene.image.ImageForTesting;
34 import javafx.scene.paint.Color;
35 import javafx.scene.shape.ArcType;
36 import javafx.scene.shape.FillRule;
37 import javafx.scene.shape.StrokeLineCap;
38 import javafx.scene.shape.StrokeLineJoin;
39 import javafx.scene.text.Font;
40 import javafx.scene.text.FontSmoothingType;
41 import javafx.scene.text.TextAlignment;
42 import javafx.scene.transform.Affine;
43 import javafx.scene.transform.Rotate;
44 import javafx.scene.transform.Transform;
45 import org.junit.Before;
46 import org.junit.Test;
47
48 import static org.junit.Assert.assertEquals;
49 import static org.junit.Assert.assertArrayEquals;
50 import static org.junit.Assert.assertNull;
51 import static org.junit.Assert.assertNotNull;
52
53 public class CanvasTest {
54
55 private Canvas canvas;
56 private GraphicsContext gc;
57
58 @Before
59 public void setUp() {
60 canvas = new Canvas();
61 gc = canvas.getGraphicsContext2D();
62 }
63
64 @Test public void testPropertyPropagation_visible() throws Exception {
65 NodeTest.testBooleanPropertyPropagation(canvas, "visible", false, true);
66 }
67
68 //maybe test doing stuff from different threads
69 @Test public void testGetGC2() throws Exception {
70 GraphicsContext gc2 = canvas.getGraphicsContext2D();
71 GraphicsContext gc3 = canvas.getGraphicsContext2D();
72 GraphicsContext gc4 = canvas.getGraphicsContext2D();
73 GraphicsContext gc5 = canvas.getGraphicsContext2D();
74 assertEquals(gc,gc2);
75 assertEquals(gc,gc3);
76 assertEquals(gc,gc4);
77 assertEquals(gc,gc5);
78 }
79
80 //basic tests make sure that the methods do not blow up.
81 @Test public void testGCfillRect_basic() throws Exception {
82 gc.fillRect(0, 0, 1, 1);
83 }
84
85 @Test public void testGCfillOval_basic() throws Exception {
86 gc.fillOval(0, 0, 1, 1);
87 }
88
89 @Test public void testGCfillRoundRect_basic() throws Exception {
90 gc.fillRoundRect(0, 0, 1, 1, 2, 2);
91 }
92
93 @Test public void testGCfillText_basic() throws Exception {
94 gc.fillText("Test", 0, 0);
95 gc.fillText("Test", 0, 0, 0);
96 gc.fillText("", 0, 0, 0);
97 gc.fillText("", 0, 0);
98 gc.fillText(null, 0, 0);
99 gc.fillText(null, 0, 0, 0);
100 }
101
102 @Test public void testGCfillPolygon_basic() throws Exception {
103 double[] xPoints = {0.0,10.0};
104 double[] yPoints = {0.0,10.0};
105 gc.fillPolygon( xPoints, yPoints, 2);
106 gc.fillPolygon( xPoints, null, 2);
107 gc.fillPolygon( null, yPoints, 2);
108 }
109
110 @Test public void testGCfillArc_basic() throws Exception {
111 gc.fillArc(10, 10, 100, 100, 0, 40, ArcType.OPEN);
112 gc.fillArc(10, 10, 100, 100, 0, 360, ArcType.CHORD);
113 gc.fillArc(10, 10, 100, 100, 0, 361, ArcType.ROUND);
114 gc.fillArc(10, 10, 100, 100, 0, 361, null);
115 }
116
117 @Test public void testGCdrawRect_basic() throws Exception {
118 gc.rect(0, 0, 1, 1);
119 }
120
121 @Test public void testGCdrawOval_basic() throws Exception {
122 gc.strokeOval(0, 0, 1, 1);
123 }
124
125 @Test public void testGCdrawRoundRect_basic() throws Exception {
126 gc.strokeRoundRect(0, 0, 1, 1, 2, 2);
127 }
128
129 @Test public void testGCstrokeText_basic() throws Exception {
130 gc.strokeText("Test", 0, 0);
131 gc.strokeText("", 0, 0);
132 gc.strokeText(null, 0, 0);
133 }
134
135 @Test public void testGCdrawPolygon_basic() throws Exception {
136 double[] xPoints = {0.0,10.0};
137 double[] yPoints = {0.0,10.0};
138 gc.strokePolygon( xPoints, yPoints, 2);
139 gc.strokePolygon( null, yPoints, 2);
140 gc.strokePolygon( xPoints, null, 2);
141 }
142
143 @Test public void testGCdrawArc_basic() throws Exception {
144 gc.strokeArc(10, 10, 100, 100, 0, 40, ArcType.OPEN);
145 gc.strokeArc(10, 10, 100, 100, 0, 360, ArcType.CHORD);
146 gc.strokeArc(10, 10, 100, 100, 0, 361, ArcType.ROUND);
147 gc.strokeArc(10, 10, 100, 100, 0, 361, null);
148 }
149
150 @Test public void testGCfillPath_basic() throws Exception {
151 gc.arcTo(0, 0, 5, 5, 5);
152 gc.moveTo(50, 50);
153 gc.lineTo(100, 100);
154 gc.bezierCurveTo(75, 150, 75, 150, 80, 80);
155 gc.beginPath();
156 gc.moveTo(50, 50);
157 gc.lineTo(100, 100);
158 gc.bezierCurveTo(75, 150, 75, 150, 80, 80);
159 gc.arcTo(0, 0, 5, 5, 5);
160 gc.closePath();
161 }
162
163 @Test public void testGCclip_basic() throws Exception {
164 gc.beginPath();
165 gc.moveTo(50, 50);
166 gc.lineTo(100, 100);
167 gc.bezierCurveTo(75, 150, 75, 150, 80, 80);
168 gc.arcTo(0, 0, 5, 5, 5);
169 gc.closePath();
170 gc.clip();
171 }
172
173 @Test public void testGCfillDrawPath_basic() throws Exception {
174 gc.beginPath();
175 gc.moveTo(50, 50);
176 gc.lineTo(100, 100);
177 gc.bezierCurveTo(75, 150, 75, 150, 80, 80);
178 gc.arcTo(0, 0, 5, 5, 5);
179 gc.closePath();
180 gc.stroke();
181 gc.fill();
182 }
183
184 @Test public void testGCPath_LineTo_NoMoveto() throws Exception {
185 gc.lineTo(10, 10);
186 }
187
188 @Test public void testGCPath_QuadraticCurveTo_NoMoveto() throws Exception {
189 gc.quadraticCurveTo(10, 10, 20, 20);
190 }
191
192 @Test public void testGCPath_BezierCurveTo_NoMoveto() throws Exception {
193 gc.bezierCurveTo(10, 10, 20, 20, 30, 30);
194 }
195
196 @Test public void testGCPath_ArcTo_NoMoveto() throws Exception {
197 gc.arcTo(10, 10, 20, 20, 30);
198 }
199
200 @Test public void testGCPath_Arc_NoMoveto() throws Exception {
201 gc.arc(10, 10, 20, 20, 30, 30);
202 }
203
204 @Test public void testGCPath_ClosePath_NoMoveto() throws Exception {
205 gc.closePath();
206 }
207
208 @Test public void testGCPath_Rect_NoMoveto() throws Exception {
209 gc.rect(10, 10, 20, 20);
210 }
211
212 @Test public void testGCState_Translate() throws Exception {
213 gc.translate(50, 50);
214 Affine result = gc.getTransform();
215 Affine expected = new Affine();
216
217 expected.setTx(50);
218 expected.setTy(50);
219
220 assertMatrix(result, expected);
221 }
222
223 @Test public void testGCState_Scale() throws Exception {
224 gc.scale(3, 3);
225 Affine result = gc.getTransform();
226 Affine expected = new Affine();
227
228 expected.setMxx(3);
229 expected.setMyy(3);
230
231 assertMatrix(result, expected);
232 }
233
234 @Test public void testGCState_Rotate() throws Exception {
235 gc.rotate(45.0);
236 Affine result = gc.getTransform();
237
238 Rotate expected = new Rotate(45, 0, 0);
239
240 assertMatrix(result, expected);
241 }
242
243 @Test public void testGCState_getTransform() throws Exception {
244 Affine expected = new Affine();
245 gc.setTransform(expected);
246 Affine result = gc.getTransform();
247
248 assertMatrix(result, expected);
249
250 gc.setTransform(expected.getMxx(), expected.getMyx(), expected.getMxy(),
251 expected.getMyy(), expected.getTx(), expected.getTy());
252
253 Affine result2 = gc.getTransform();
254
255 assertMatrix(result2, expected);
256 }
257
258 @Test public void testGCState_FillStrokeSaveRestore() throws Exception {
259 Affine expected = new Affine();
260 gc.setTransform(expected);
261 Affine result = gc.getTransform();
262
263 assertMatrix(result, expected);
264
265 gc.setFill(Color.BLACK);
266 assertEquals(Color.BLACK, gc.getFill());
267 gc.save();
268 gc.setFill(Color.RED);
269 assertEquals(gc.getFill(), Color.RED);
270 gc.restore();
271 assertEquals(Color.BLACK, gc.getFill());
272 gc.setStroke(Color.BLACK);
273 assertEquals(Color.BLACK, gc.getStroke());
274 gc.save();
275 gc.setStroke(Color.RED);
276 assertEquals(gc.getStroke(), Color.RED);
277 gc.restore();
278 assertEquals(Color.BLACK, gc.getStroke());
279 assertMatrix(result, expected);
280 }
281
282 @Test public void testGCState_SetStroke() {
283 gc.setStroke(Color.RED);
284 assertEquals(Color.RED, gc.getStroke());
285 gc.setStroke(null);
286 assertEquals(Color.RED, gc.getStroke());
287 }
288
289 @Test public void testGCState_Fill_Null() {
290 gc.setFill(Color.BLACK);
291 assertEquals(Color.BLACK, gc.getFill());
292 gc.setFill(Color.RED);
293 assertEquals(gc.getFill(), Color.RED);
294 gc.setFill(null);
295 assertEquals(gc.getFill(), Color.RED);
296 }
297
298 @Test public void testGCState_FillRule_Null() {
299 gc.setFillRule(FillRule.EVEN_ODD);
300 assertEquals(FillRule.EVEN_ODD, gc.getFillRule());
301 gc.setFillRule(null);
302 assertEquals(FillRule.EVEN_ODD, gc.getFillRule());
303 }
304
305 @Test public void testGCState_Font_Null() {
306 Font f = new Font(10);
307 gc.setFont(f);
308 assertEquals(f, gc.getFont());
309 gc.setFont(null);
310 assertEquals(f, gc.getFont());
311 }
312
313 @Test public void testGCState_FontSmoothing_Null() {
314 gc.setFontSmoothingType(FontSmoothingType.GRAY);
315 assertEquals(FontSmoothingType.GRAY, gc.getFontSmoothingType());
316 gc.setFontSmoothingType(null);
317 assertEquals(FontSmoothingType.GRAY, gc.getFontSmoothingType());
318 }
319
320 @Test public void testGCState_TextBaseline_Null() {
321 gc.setTextBaseline(VPos.BASELINE);
322 assertEquals(VPos.BASELINE, gc.getTextBaseline());
323 gc.setTextBaseline(null);
324 assertEquals(VPos.BASELINE, gc.getTextBaseline());
325 }
326
327 @Test public void testGCState_TextAlign_Null() {
328 gc.setTextAlign(TextAlignment.JUSTIFY);
329 assertEquals(TextAlignment.JUSTIFY, gc.getTextAlign());
330 gc.setTextAlign(null);
331 assertEquals(TextAlignment.JUSTIFY, gc.getTextAlign());
332 }
333
334 @Test public void testGCState_Line() throws Exception {
335 gc.setLineCap(StrokeLineCap.BUTT);
336 gc.setLineJoin(StrokeLineJoin.MITER);
337 gc.setLineWidth(5);
338 gc.setMiterLimit(3);
339
340 gc.save();
341 gc.setLineCap(StrokeLineCap.ROUND);
342 gc.setLineJoin(StrokeLineJoin.BEVEL);
343 gc.setLineWidth(1);
344 gc.setMiterLimit(1);
345 gc.setLineDashes(10, 10);
346 gc.setLineDashOffset(100);
347 assertEquals(gc.getLineCap(), StrokeLineCap.ROUND);
348 assertEquals(gc.getLineJoin(), StrokeLineJoin.BEVEL);
349 assertEquals(gc.getLineWidth(), 1, 0.00001);
350 assertEquals(gc.getMiterLimit(), 1, 0.00001);
351 assertArrayEquals(gc.getLineDashes(), new double[] {10, 10}, 0.00001);
352 assertEquals(gc.getLineDashOffset(), 100, 0.00001);
353 gc.restore();
354
355 assertEquals(gc.getLineCap(), StrokeLineCap.BUTT);
356 assertEquals(gc.getLineJoin(), StrokeLineJoin.MITER);
357 assertEquals(gc.getLineWidth(), 5, 0.00001);
358 assertEquals(gc.getMiterLimit(), 3, 0.00001);
359 assertNull(gc.getLineDashes());
360 assertEquals(gc.getLineDashOffset(), 0, 0.00001);
361 }
362
363 @Test
364 public void testGCState_LineCapNull() throws Exception {
365 gc.setLineCap(StrokeLineCap.BUTT);
366 gc.setLineCap(null);
367 assertEquals(gc.getLineCap(), StrokeLineCap.BUTT);
368 gc.setLineCap(StrokeLineCap.ROUND);
369 gc.setLineCap(null);
370 assertEquals(gc.getLineCap(), StrokeLineCap.ROUND);
371 gc.setLineCap(StrokeLineCap.SQUARE);
372 gc.setLineCap(null);
373 assertEquals(gc.getLineCap(), StrokeLineCap.SQUARE);
374 }
375
376 @Test
377 public void testGCState_LineJoinNull() throws Exception {
378 gc.setLineJoin(StrokeLineJoin.BEVEL);
379 gc.setLineJoin(null);
380 assertEquals(gc.getLineJoin(), StrokeLineJoin.BEVEL);
381 gc.setLineJoin(StrokeLineJoin.MITER);
382 gc.setLineJoin(null);
383 assertEquals(gc.getLineJoin(), StrokeLineJoin.MITER);
384 gc.setLineJoin(StrokeLineJoin.ROUND);
385 gc.setLineJoin(null);
386 assertEquals(gc.getLineJoin(), StrokeLineJoin.ROUND);
387 }
388
389 @Test
390 public void testGCState_LineDashNonPositive() throws Exception {
391 gc.setLineDashes(20, 10);
392 assertArrayEquals(gc.getLineDashes(), new double[] {20, 10}, 0.00001);
393 gc.setLineDashes(1, Double.NaN);
394 assertArrayEquals(gc.getLineDashes(), new double[] {20, 10}, 0.00001);
395 gc.setLineDashes(1, Double.POSITIVE_INFINITY);
396 assertArrayEquals(gc.getLineDashes(), new double[] {20, 10}, 0.00001);
397 gc.setLineDashes(1, -1);
398 assertArrayEquals(gc.getLineDashes(), new double[] {20, 10}, 0.00001);
399 }
400
401 @Test
402 public void testGCState_LineDashNull() throws Exception {
403 gc.setLineDashes(10, 10);
404 assertNotNull(gc.getLineDashes());
405 gc.setLineDashes(null);
406 assertNull(gc.getLineDashes());
407
408 gc.setLineDashes(10, 10);
409 assertNotNull(gc.getLineDashes());
410 gc.setLineDashes();
411 assertNull(gc.getLineDashes());
412
413 gc.setLineDashes(10, 10);
414 assertNotNull(gc.getLineDashes());
415 gc.setLineDashes(new double[0]);
416 assertNull(gc.getLineDashes());
417
418 gc.setLineDashes(10, 10);
419 assertNotNull(gc.getLineDashes());
420 gc.setLineDashes(0, 0);
421 assertNull(gc.getLineDashes());
422 }
423
424 @Test
425 public void testGCState_LineDashOddLength() throws Exception {
426 gc.setLineDashes(10);
427 assertArrayEquals(gc.getLineDashes(), new double[] {10, 10}, 0.00001);
428 gc.setLineDashes(10, 20, 30);
429 assertArrayEquals(gc.getLineDashes(), new double[] {10, 20, 30, 10, 20, 30}, 0.00001);
430 }
431
432 @Test
433 public void testGCState_LineDashOffsetNonFinite() throws Exception {
434 gc.setLineDashOffset(5.0);
435 assertEquals(gc.getLineDashOffset(), 5.0, 0.00001);
436 gc.setLineDashOffset(Double.NaN);
437 assertEquals(gc.getLineDashOffset(), 5.0, 0.00001);
438 gc.setLineDashOffset(Double.NEGATIVE_INFINITY);
439 assertEquals(gc.getLineDashOffset(), 5.0, 0.00001);
440 gc.setLineDashOffset(Double.POSITIVE_INFINITY);
441 assertEquals(gc.getLineDashOffset(), 5.0, 0.00001);
442 }
443
444 @Test public void testGCState_BlendMode() throws Exception {
445 gc.setGlobalBlendMode(BlendMode.ADD);
446 gc.setGlobalAlpha(0);
447
448 gc.save();
449 gc.setGlobalAlpha(0.5);
450 gc.setGlobalBlendMode(BlendMode.COLOR_BURN);
451 assertEquals(gc.getGlobalBlendMode(), BlendMode.COLOR_BURN);
452 assertEquals(gc.getGlobalAlpha(), 0.5, 0.000001);
453 gc.restore();
454
455 assertEquals(BlendMode.ADD, gc.getGlobalBlendMode());
456 assertEquals(0, gc.getGlobalAlpha(), 0.000001);
457 }
458
459 @Test public void testGCState_BlendMode_Null() {
460 gc.setGlobalBlendMode(BlendMode.ADD);
461 assertEquals(BlendMode.ADD, gc.getGlobalBlendMode());
462 gc.setGlobalBlendMode(null);
463 assertEquals(BlendMode.ADD, gc.getGlobalBlendMode());
464 }
465
466 @Test public void testGCappendSVGPath_Null() {
467 gc.appendSVGPath("m 0 0");
468 gc.appendSVGPath("Q 150 -300 300 0");
469 gc.appendSVGPath(null);
470 }
471
472 @Test public void testGCappendSVGPath_IncorrectPath() {
473 gc.appendSVGPath("Q 150 -300 300 0"); // No move at the beginning
474 }
475
476 @Test public void testGCappendSVGPath_IncorrectPath2() {
477 gc.appendSVGPath("F 150"); // No move at the beginning
478 }
479
480 @Test public void testGCapplyEffect_Null() {
481 gc.applyEffect(null);
482 }
483
484 @Test public void testGCdrawImage_Null() {
485 gc.drawImage(null, 0 ,0);
486 gc.drawImage(null, 0 ,0, 100, 100);
487 gc.drawImage(null, 0, 0, 100, 100, 0, 0, 100, 100);
488 }
489
490 @Test public void testGCdrawImage_InProgress() {
491 ImageForTesting image = new ImageForTesting("http://something.png", false);
492 image.updateProgress(0.5);
493
494 gc.drawImage(image, 0 ,0);
495 gc.drawImage(image, 0 ,0, 100, 100);
496 gc.drawImage(image, 0, 0, 100, 100, 0, 0, 100, 100);
497 }
498
499 public static void assertMatrix(Transform expected,
500 Transform result) {
501 assertEquals(expected.getMxx(), result.getMxx(), 0.00001);
502 assertEquals(expected.getMxy(), result.getMxy(), 0.00001);
503 assertEquals(expected.getMxz(), result.getMxz(), 0.00001);
504 assertEquals(expected.getTx(), result.getTx(), 0.00001);
505 assertEquals(expected.getMyx(), result.getMyx(), 0.00001);
506 assertEquals(expected.getMyy(), result.getMyy(), 0.00001);
507 assertEquals(expected.getMyz(), result.getMyz(), 0.00001);
508 assertEquals(expected.getTy(), result.getTy(), 0.00001);
509 assertEquals(expected.getMzx(), result.getMzx(), 0.00001);
510 assertEquals(expected.getMzy(), result.getMzy(), 0.00001);
511 assertEquals(expected.getMzz(), result.getMzz(), 0.00001);
512 assertEquals(expected.getTz(), result.getTz(), 0.00001);
513 }
514 }