View Javadoc

1   /*
2    * VectorGraphics2D: Vector export for Java(R) Graphics2D
3    *
4    * (C) Copyright 2010 Erich Seifert <dev[at]erichseifert.de>
5    *
6    * This file is part of VectorGraphics2D.
7    *
8    * VectorGraphics2D is free software: you can redistribute it and/or modify
9    * it under the terms of the GNU Lesser General Public License as published by
10   * the Free Software Foundation, either version 3 of the License, or
11   * (at your option) any later version.
12   *
13   * VectorGraphics2D is distributed in the hope that it will be useful,
14   * but WITHOUT ANY WARRANTY; without even the implied warranty of
15   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   * GNU Lesser General Public License for more details.
17   *
18   * You should have received a copy of the GNU Lesser General Public License
19   * along with VectorGraphics2D.  If not, see <http://www.gnu.org/licenses/>.
20   */
21  
22  package de.erichseifert.vectorgraphics2d;
23  
24  import static org.junit.Assert.assertEquals;
25  import static org.junit.Assert.assertNull;
26  import static org.junit.Assert.assertTrue;
27  
28  import java.awt.BasicStroke;
29  import java.awt.Color;
30  import java.awt.Font;
31  import java.awt.Paint;
32  import java.awt.RenderingHints;
33  import java.awt.Shape;
34  import java.awt.Stroke;
35  import java.awt.geom.AffineTransform;
36  import java.awt.geom.Arc2D;
37  import java.awt.geom.Ellipse2D;
38  import java.awt.geom.GeneralPath;
39  import java.awt.geom.Line2D;
40  import java.awt.geom.Path2D;
41  import java.awt.geom.Rectangle2D;
42  import java.awt.geom.RoundRectangle2D;
43  import java.awt.image.AffineTransformOp;
44  import java.awt.image.BufferedImage;
45  
46  import org.junit.Before;
47  import org.junit.Test;
48  
49  
50  public abstract class VectorGraphics2DTest {
51  	protected static final double DOC_X =   0.0;
52  	protected static final double DOC_Y =   0.0;
53  	protected static final double DOC_W = 210.0;
54  	protected static final double DOC_H = 297.0;
55  
56  	protected VectorGraphics2D g;
57  
58  	@Before
59  	public abstract void setUp();
60  
61  	@Test
62  	public void testCreation() {
63  		assertEquals(Color.WHITE, g.getBackground());
64  		assertEquals(Color.BLACK, g.getColor());
65  		assertNull(g.getClip());
66  		assertNull(g.getClipBounds());
67  	}
68  
69  	@Test
70  	public void testBounds() {
71  		Rectangle2D bounds = new Rectangle2D.Double(DOC_X, DOC_Y, DOC_W, DOC_H);
72  		assertEquals(bounds, g.getBounds());
73  	}
74  
75  	@Test
76  	public void testDraw() {
77  		g.drawArc(0, 0, 210, 297, 30, 330);
78  		g.drawLine(0, 0, 210, 297);
79  		g.drawOval(0, 0, 210, 297);
80  		g.drawPolygon(new int[] {0, 210, 0}, new int[] {0, 297, 297}, 3);
81  		g.drawPolyline(new int[] {0, 210}, new int[] {0, 297}, 2);
82  		g.drawRect(0, 0, 210, 297);
83  		g.drawRoundRect(0, 0, 210, 297, 5, 5);
84  		// TODO Assert something
85  	}
86  
87  	@Test
88  	public void testFill() {
89  		g.fillArc(0, 0, 210, 297, 30, 330);
90  		g.fillOval(0, 0, 210, 297);
91  		g.fillPolygon(new int[] {0, 210, 0}, new int[] {0, 297, 297}, 3);
92  		g.fillRect(0, 0, 210, 297);
93  		g.fillRoundRect(0, 0, 210, 297, 5, 5);
94  		// TODO Assert something
95  	}
96  
97  	@Test
98  	public void testShapes() {
99  		Path2D path = new GeneralPath();
100 		path.moveTo(0.0, 0.0);
101 		path.lineTo(1.0, 1.0);
102 		path.curveTo(0.7, 1.0, 0.0, 0.7, 0.0, 0.5);
103 		path.quadTo(0.0, 0.0, 0.5, 0.5);
104 		path.closePath();
105 
106 		Shape[] shapes = {
107 			new Line2D.Double(0.00, 0.25, 1.00, 0.75),
108 			new Rectangle2D.Double(0.0, 0.0, 1.0, 1.0),
109 			new RoundRectangle2D.Double(0.0, 0.0, 1.0, 1.0, 0.25, 0.25),
110 			new Ellipse2D.Double(0.0, 0.0, 1.0, 1.0),
111 			new Arc2D.Double(0.0, 0.0, 1.0, 1.0, 30.0, 330.0, Arc2D.PIE),
112 			path
113 		};
114 
115 		for (Shape shape : shapes) {
116 			g.fill(shape);
117 			g.draw(shape);
118 		}
119 		// TODO Assert something
120 	}
121 
122 	@Test
123 	public void testToString() {
124 		g.draw(new Line2D.Double(0.00, 0.25, 1.00, 0.75));
125 		String emptyDoc = g.toString();
126 		assertTrue(emptyDoc.length() > 0);
127 	}
128 
129 	@Test
130 	public void testDrawString() {
131 		g.drawString("foo", 0, 0);
132 		g.drawString("bar", 0f, 0.5f);
133 		// TODO Assert something
134 	}
135 
136 	@Test
137 	public void testRenderingHints() {
138 		// Initialization
139 		assertEquals(0, g.getRenderingHints().size());
140 		// Modification
141 		g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
142 		assertEquals(RenderingHints.VALUE_INTERPOLATION_BICUBIC, g.getRenderingHint(RenderingHints.KEY_INTERPOLATION));
143 	}
144 
145 	@Test
146 	public void testBackground() {
147 		Color c = Color.BLUE;
148 		g.setBackground(c);
149 		assertEquals(c, g.getBackground());
150 	}
151 
152 	@Test
153 	public void testColor() {
154 		Color c = Color.RED;
155 		g.setColor(c);
156 		assertEquals(c, g.getColor());
157 	}
158 
159 	@Test
160 	public void testFont() {
161 		Font f = Font.decode(null);
162 		f = f.deriveFont(f.getSize2D()*2f);
163 		g.setFont(f);
164 		assertEquals(f, g.getFont());
165 	}
166 
167 	@Test
168 	public void testPaint() {
169 		Paint p = Color.GREEN;
170 		g.setPaint(p);
171 		assertEquals(p, g.getPaint());
172 		assertEquals(p, g.getColor());
173 	}
174 
175 	@Test
176 	public void testStroke() {
177 		Stroke s = new BasicStroke(3f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 20f, new float[] {1f, 1f}, 2f);
178 		g.setStroke(s);
179 		assertEquals(s, g.getStroke());
180 	}
181 
182 	@Test
183 	public void testDrawImage() {
184 		BufferedImage image = new BufferedImage(320, 240, BufferedImage.TYPE_INT_ARGB);
185 		g.drawImage(image, AffineTransform.getScaleInstance(0.5, 0.5), null);
186 		g.drawImage(image, new AffineTransformOp(AffineTransform.getTranslateInstance(0.5, 0.5), AffineTransformOp.TYPE_NEAREST_NEIGHBOR), 0, 0);
187 		g.drawImage(image, 0, 0, image.getWidth(), image.getHeight(), Color.WHITE, null);
188 		// TODO Assert something
189 	}
190 
191 	@Test
192 	public void testTransform() {
193 		// Initial transform must be identity
194 		AffineTransform txOrig = g.getTransform();
195 		assertEquals(new AffineTransform(), txOrig);
196 		// Translate
197 		g.setTransform(txOrig);
198 		g.translate(1, 2);
199 		assertEquals(AffineTransform.getTranslateInstance(1, 2), g.getTransform());
200 		// Scale
201 		g.setTransform(txOrig);
202 		g.scale(3, 4);
203 		assertEquals(AffineTransform.getScaleInstance(3, 4), g.getTransform());
204 		// Rotate 1
205 		g.setTransform(txOrig);
206 		g.rotate(Math.PI/4.0);
207 		assertEquals(AffineTransform.getRotateInstance(Math.PI/4.0), g.getTransform());
208 		// Rotate 2
209 		g.setTransform(txOrig);
210 		g.rotate(Math.PI/2.0, 0.5, 0.5);
211 		assertEquals(AffineTransform.getRotateInstance(Math.PI/2.0, 0.5, 0.5), g.getTransform());
212 		// Shear
213 		g.setTransform(txOrig);
214 		g.shear(5, 6);
215 		assertEquals(AffineTransform.getShearInstance(5, 6), g.getTransform());
216 	}
217 
218 }