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