| /* AnimationApplet.java -- An example of an old-style AWT applet |
| Copyright (C) 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath examples. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. */ |
| |
| package gnu.classpath.examples.awt; |
| |
| import java.awt.BorderLayout; |
| import java.awt.Canvas; |
| import java.awt.Color; |
| import java.awt.Dimension; |
| import java.awt.Frame; |
| import java.awt.Graphics; |
| import java.awt.Image; |
| import java.awt.Insets; |
| import java.awt.Label; |
| import java.awt.Panel; |
| import java.awt.Toolkit; |
| import java.awt.event.WindowAdapter; |
| import java.awt.event.WindowEvent; |
| import java.net.URL; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.StringTokenizer; |
| import java.util.TreeMap; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| public class AicasGraphicsBenchmark extends Panel |
| { |
| /** |
| * Default number of test-iterations. |
| */ |
| private static final int DEFAULT_TEST_SIZE = 1000; |
| |
| /** |
| * Default screen size. |
| */ |
| private static final int DEFAULT_SCREEN_WIDTH = 320; |
| private static final int DEFAULT_SCREEN_HEIGHT = 240; |
| |
| /** |
| * AWT tests. |
| */ |
| private static final int AWTTEST_LINES = 1 << 0; |
| private static final int AWTTEST_RECT = 1 << 1; |
| private static final int AWTTEST_POLYLINE = 1 << 2; |
| private static final int AWTTEST_POLYGON = 1 << 3; |
| private static final int AWTTEST_ARC = 1 << 4; |
| private static final int AWTTEST_OVAL = 1 << 5; |
| private static final int AWTTEST_ROUNDRECT = 1 << 6; |
| private static final int AWTTEST_STRING = 1 << 7; |
| private static final int AWTTEST_TRANSPARENTIMAGE = 1 << 8; |
| private static final int AWTTEST_IMAGE = 1 << 9; |
| |
| private static final int AWTTEST_NONE = 0; |
| private static final int AWTTEST_ALL = AWTTEST_LINES |
| | AWTTEST_RECT |
| | AWTTEST_POLYLINE |
| | AWTTEST_POLYGON |
| | AWTTEST_ARC |
| | AWTTEST_OVAL |
| | AWTTEST_ROUNDRECT |
| | AWTTEST_STRING |
| | AWTTEST_TRANSPARENTIMAGE |
| | AWTTEST_IMAGE |
| ; |
| |
| int iterations = 1; |
| private int screenWidth = DEFAULT_SCREEN_WIDTH; |
| private int screenHeight = DEFAULT_SCREEN_HEIGHT; |
| boolean doubleBufferFlag = true; |
| private int awtTests = AWTTEST_ALL; |
| |
| private Label testLabel; |
| |
| private String testContext = ""; |
| |
| Logger logger = Logger.getLogger("AicasGraphicsBenchmark"); |
| |
| private Image pngTestImage; |
| private Image gifTestImage; |
| |
| private TestSet testSetMap = new TestSet(); |
| |
| public AicasGraphicsBenchmark() |
| { |
| pngTestImage = loadImage("aicas.png"); |
| gifTestImage = loadImage("palme.gif"); |
| |
| setLayout(new BorderLayout()); |
| testLabel = new Label(); |
| add(testLabel,BorderLayout.NORTH); |
| add(new GraphicsTest(),BorderLayout.CENTER); |
| } |
| |
| void setTestContext(String testName) |
| { |
| logger.logp(Level.INFO, "AicasGraphicsBenchmark", "recordTest", |
| "--- Starting new test context: " + testName); |
| testContext = testName; |
| testLabel.setText(testName); |
| } |
| |
| private void recordTest(String testName, long time) |
| { |
| logger.logp(Level.INFO, "AicasGraphicsBenchmark", "recordTest", |
| testContext + ": " + testName + " duration (ms): " + time); |
| TestRecorder recorder = testSetMap.getTest(testName); |
| if (recorder == null) |
| { |
| recorder = new TestRecorder(testName); |
| testSetMap.putTest(testName,recorder); |
| } |
| recorder.addRun(time); |
| } |
| |
| void printReport() |
| { |
| for (Iterator i = testSetMap.testIterator(); i.hasNext(); ) |
| { |
| TestRecorder recorder = testSetMap.getTest((String)i.next()); |
| System.out.println("TEST " + recorder.getTestName() + ": average " |
| + recorder.getAverage() + "ms [" |
| + recorder.getMinTime() + "-" + recorder.getMaxTime() |
| + "]"); |
| } |
| } |
| |
| public static void main(String[] args) |
| { |
| int awtTests; |
| int i; |
| boolean endOfOptionsFlag; |
| AicasGraphicsBenchmark speed= new AicasGraphicsBenchmark(); |
| |
| // Parse arguments. |
| i = 0; |
| endOfOptionsFlag = false; |
| awtTests = AWTTEST_NONE; |
| while (i < args.length) |
| { |
| if (!endOfOptionsFlag) |
| { |
| if (args[i].equals("--help") || args[i].equals("-help") |
| || args[i].equals("-h")) |
| { |
| System.out.println("Usage: AicasGraphicsBenchmark [<options>] [<test> ...]"); |
| System.out.println(""); |
| System.out.println("Options: -i|--iterations=<n|-1> - number of iterations (-1 is infinite)"); |
| System.out.println(" -w|--width=<n> - screen width; default "+DEFAULT_SCREEN_WIDTH); |
| System.out.println(" -h|--height=<n> - screen height; default "+DEFAULT_SCREEN_HEIGHT); |
| System.out.println(" -n|--noDoubleBuffer - disable double-buffering test"); |
| System.out.println(""); |
| System.out.println("Tests: line"); |
| System.out.println(" rect"); |
| System.out.println(" polyline"); |
| System.out.println(" polygon"); |
| System.out.println(" arc"); |
| System.out.println(" oval"); |
| System.out.println(" roundrect"); |
| System.out.println(" string"); |
| System.out.println(" transparentimage"); |
| System.out.println(" image"); |
| System.exit(1); |
| } |
| else if ((args[i].startsWith("-i=") |
| || args[i].startsWith("--iterations="))) |
| { |
| speed.iterations = |
| Integer.parseInt(args[i].substring(args[i].indexOf('=') + 1)); |
| i += 1; |
| continue; |
| } |
| else if ((args[i].equals("-i") || args[i].equals("--iterations"))) |
| { |
| if ((i + 1) >= args.length) |
| { |
| System.err.println("ERROR: No argument given for option '" |
| + args[i] + "'!"); |
| System.exit(2); |
| } |
| speed.iterations = Integer.parseInt(args[i + 1]); |
| i += 2; |
| continue; |
| } |
| else if ((args[i].startsWith("-w=") |
| || args[i].startsWith("--width="))) |
| { |
| speed.screenWidth = |
| Integer.parseInt(args[i].substring(args[i].indexOf('=') + 1)); |
| i += 1; |
| continue; |
| } |
| else if ((args[i].equals("-w") || args[i].equals("--width"))) |
| { |
| if ((i + 1) >= args.length) |
| { |
| System.err.println("ERROR: No argument given for option '" |
| + args[i] + "'!"); |
| System.exit(2); |
| } |
| speed.screenWidth = Integer.parseInt(args[i + 1]); |
| i += 2; |
| continue; |
| } |
| else if ((args[i].startsWith("-h=") |
| || args[i].startsWith("--height="))) |
| { |
| speed.screenHeight = |
| Integer.parseInt(args[i].substring(args[i].indexOf('=') + 1)); |
| i+=1; |
| continue; |
| } |
| else if ((args[i].equals("-h") || args[i].equals("--height"))) |
| { |
| if ((i+1) >= args.length) |
| { |
| System.err.println("ERROR: No argument given for option '" |
| + args[i] + "'!"); |
| System.exit(2); |
| } |
| speed.screenHeight = Integer.parseInt(args[i + 1]); |
| i += 2; |
| continue; |
| } |
| else if ((args[i].equals("-n") |
| || args[i].equals("--noDoubleBuffer"))) |
| { |
| speed.doubleBufferFlag = false; |
| i += 1; |
| continue; |
| } |
| else if (args[i].equals("--")) |
| { |
| endOfOptionsFlag = true; |
| i += 1; |
| continue; |
| } |
| else if (args[i].startsWith("-")) |
| { |
| System.err.println("ERROR: Unknown option '" + args[i] + "'!"); |
| System.exit(2); |
| } |
| } |
| StringTokenizer tokenizer = new StringTokenizer(args[i], " +,"); |
| while (tokenizer.hasMoreTokens()) |
| { |
| String s = tokenizer.nextToken().toLowerCase(); |
| if (s.equals("line")) |
| awtTests |= AWTTEST_LINES; |
| else if (s.equals("rect")) |
| awtTests |= AWTTEST_RECT; |
| else if (s.equals("polyline")) |
| awtTests |= AWTTEST_POLYLINE; |
| else if (s.equals("polygon")) |
| awtTests |= AWTTEST_POLYGON; |
| else if (s.equals("arc")) |
| awtTests |= AWTTEST_ARC; |
| else if (s.equals("oval")) |
| awtTests |= AWTTEST_OVAL; |
| else if (s.equals("roundrect")) |
| awtTests |= AWTTEST_ROUNDRECT; |
| else if (s.equals("string")) |
| awtTests |= AWTTEST_STRING; |
| else if (s.equals("transparentimage")) |
| awtTests |= AWTTEST_TRANSPARENTIMAGE; |
| else if (s.equals("image")) |
| awtTests |= AWTTEST_IMAGE; |
| else |
| { |
| System.err.println("Unknown AWT test '" + s + "'!"); |
| System.exit(2); |
| } |
| } |
| i += 1; |
| } |
| if (awtTests != AWTTEST_NONE) |
| speed.awtTests = awtTests; |
| |
| // Create graphics. |
| final Frame frame = new Frame("AicasGraphicsBenchmark"); |
| |
| frame.addWindowListener(new WindowAdapter() |
| { |
| public void windowClosing(WindowEvent e) |
| { |
| frame.setVisible(false); |
| System.exit(0); |
| } |
| }); |
| |
| frame.add(speed,BorderLayout.CENTER); |
| frame.setSize(speed.screenWidth,speed.screenHeight); |
| frame.setVisible(true); |
| |
| // Insets are correctly set only after the native peer was created. |
| Insets insets = frame.getInsets(); |
| // The internal size of the frame should be 320x240. |
| frame.setSize(320 + insets.right + insets.left, |
| 240 + insets.top + insets.bottom); |
| } |
| |
| private Image loadImage(String imageName) |
| { |
| Image result = null; |
| logger.logp(Level.INFO, "AicasGraphicsBenchmark", "loadImage", |
| "Loading image: " + imageName); |
| URL url = getClass().getResource(imageName); |
| if (url != null) |
| { |
| result = Toolkit.getDefaultToolkit().getImage(url); |
| prepareImage(result, this); |
| } |
| else |
| { |
| logger.logp(Level.WARNING, "AicasGraphicsBenchmark", "loadImage", |
| "Could not locate image resource in class path: " |
| + imageName); |
| } |
| return result; |
| } |
| |
| /** |
| * Executes the test methods. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| void runTestSet(Graphics g, Dimension size) |
| { |
| if ((awtTests & AWTTEST_LINES) != 0) |
| test_drawLine(g, size); |
| if ((awtTests & AWTTEST_RECT) != 0) |
| test_drawRect(g, size); |
| if ((awtTests & AWTTEST_RECT) != 0) |
| test_fillRect(g, size); |
| if ((awtTests & AWTTEST_POLYLINE) != 0) |
| test_drawPolyline(g, size); |
| if ((awtTests & AWTTEST_POLYGON) != 0) |
| test_drawPolygon(g, size); |
| if ((awtTests & AWTTEST_POLYGON) != 0) |
| test_fillPolygon(g,size); |
| if ((awtTests & AWTTEST_ARC) != 0) |
| test_drawArc(g,size); |
| if ((awtTests & AWTTEST_ARC) != 0) |
| test_fillArc(g,size); |
| if ((awtTests & AWTTEST_OVAL) != 0) |
| test_drawOval(g, size); |
| if ((awtTests & AWTTEST_OVAL) != 0) |
| test_fillOval(g, size); |
| if ((awtTests & AWTTEST_ROUNDRECT) != 0) |
| test_fillRoundRect(g, size); |
| if ((awtTests & AWTTEST_STRING) != 0) |
| test_drawString(g, size); |
| if ((awtTests & AWTTEST_TRANSPARENTIMAGE) != 0) |
| test_drawTransparentImage(g,size); |
| if ((awtTests & AWTTEST_IMAGE) != 0) |
| test_drawImage(g,size); |
| } |
| |
| /** |
| * Gets a new random Color. |
| * |
| * @returna new random Color |
| */ |
| private Color getNextColor() |
| { |
| return new Color((int) (Math.random() * 254) + 1, |
| (int) (Math.random() * 254) + 1, |
| (int) (Math.random() * 254) + 1); |
| } |
| |
| /** |
| * Draws random lines within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_drawLine(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| int minSize = 10; |
| long startTime = System.currentTimeMillis(); |
| for (int i=0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int x1 = (int) (Math.random() * (size.width-minSize)); |
| int y1 = (int) (Math.random() * (size.height-minSize)); |
| int x2 = (int) (Math.random() * (size.width-minSize)); |
| int y2 = (int) (Math.random() * (size.height-minSize)); |
| g.drawLine(x1, y1, x2, y2); |
| } |
| long endTime = System.currentTimeMillis(); |
| recordTest("drawLine " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random rectangles within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_drawRect(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| int minSize = 10; |
| long startTime = System.currentTimeMillis(); |
| for (int i=0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int x1 = (int) (Math.random() * (size.width-minSize)); |
| int y1 = (int) (Math.random() * (size.height-minSize)); |
| int x2 = (int) (Math.random() * (size.width-minSize)); |
| int y2 = (int) (Math.random() * (size.height-minSize)); |
| g.drawRect(x1, y1, x2, y2); |
| } |
| long endTime = System.currentTimeMillis(); |
| recordTest("drawRect " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random rectangles within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_fillRect(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| int minSize = 10; |
| long startTime = System.currentTimeMillis(); |
| for (int i = 0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int x1 = (int) (Math.random() * (size.width-minSize)); |
| int y1 = (int) (Math.random() * (size.height-minSize)); |
| int x2 = (int) (Math.random() * (size.width-minSize)); |
| int y2 = (int) (Math.random() * (size.height-minSize)); |
| g.fillRect(x1, y1, x2, y2); |
| } |
| long endTime = System.currentTimeMillis(); |
| recordTest("fillRect " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random polylines within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_drawPolyline(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| long startTime = System.currentTimeMillis(); |
| for (int i=0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int points = (int)(Math.random() * 6) + 3; |
| int[] x_coords = new int[points]; |
| int[] y_coords = new int[points]; |
| for (int j = 0; j < points; j+=1) |
| { |
| x_coords[j] = (int)(Math.random() * (size.width)); |
| y_coords[j] = (int)(Math.random() * (size.height)); |
| } |
| g.drawPolyline(x_coords,y_coords, points); |
| } |
| long endTime = System.currentTimeMillis(); |
| recordTest("drawPolyline " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random polygons within the given dimensions. |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_drawPolygon(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| long startTime = System.currentTimeMillis(); |
| for (int i=0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int points = (int) (Math.random() * 6) + 3; |
| int[] xcoords = new int[points]; |
| int[] ycoords = new int[points]; |
| for(int j = 0; j < points; j+=1) |
| { |
| xcoords[j] = (int) (Math.random() * (size.width)); |
| ycoords[j] = (int) (Math.random() * (size.height)); |
| } |
| g.drawPolygon(xcoords, ycoords, points); |
| } |
| long endTime = System.currentTimeMillis(); |
| recordTest("drawPolygon " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random filled polygons within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_fillPolygon(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| long startTime = System.currentTimeMillis(); |
| for (int i=0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int points = (int) (Math.random() * 6) + 3; |
| int[] xcoords = new int[points]; |
| int[] ycoords = new int[points]; |
| for (int j = 0; j < points; j+=1) |
| { |
| xcoords[j] = (int) (Math.random() * (size.width)); |
| ycoords[j] = (int) (Math.random() * (size.height)); |
| } |
| g.fillPolygon(xcoords, ycoords, points); |
| } |
| long endTime = System.currentTimeMillis(); |
| recordTest("fillPolygon " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random arcs within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_drawArc(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| int minSize; |
| long startTime; |
| long endTime; |
| minSize = 10; |
| startTime = System.currentTimeMillis(); |
| for (int i=0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int x = (int) (Math.random() * (size.width - minSize + 1)); |
| int y = (int) (Math.random() * (size.height - minSize + 1)); |
| int width = (int) (Math.random() * (size.width - x - minSize) + minSize); |
| int height = (int) (Math.random() * (size.height - y - minSize) + minSize); |
| int startAngle = (int) (Math.random() * 360); |
| int arcAngle = (int) (Math.random() * 360 - startAngle); |
| g.drawArc(x, y, width, height, startAngle, arcAngle); |
| } |
| endTime = System.currentTimeMillis(); |
| recordTest("drawArc " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random filled arcs within the given dimensions. |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_fillArc(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| int minSize; |
| long startTime; |
| long endTime; |
| minSize = 10; |
| startTime = System.currentTimeMillis(); |
| for (int i = 0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int x = (int) (Math.random() * (size.width - minSize + 1)); |
| int y = (int) (Math.random() * (size.height - minSize + 1)); |
| int width = (int)(Math.random() * (size.width - x - minSize) + minSize); |
| int height = (int)(Math.random() * (size.height - y - minSize) + minSize); |
| int startAngle = (int)(Math.random() * 360); |
| int arcAngle = (int)(Math.random() * 360); |
| g.fillArc(x, y, width, height, startAngle, arcAngle); |
| |
| } |
| endTime = System.currentTimeMillis(); |
| recordTest("fillArc " + maxTests + " times", (endTime - startTime)); |
| } |
| |
| /** |
| * Draws random ovals within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_drawOval(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| int minSize; |
| long startTime; |
| long endTime; |
| minSize = 10; |
| startTime = System.currentTimeMillis(); |
| for (int i = 0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int x = (int)(Math.random() * (size.width - minSize + 1)); |
| int y = (int)(Math.random() * (size.height - minSize + 1)); |
| int width = (int)(Math.random() * (size.width - x - minSize) + minSize); |
| int height = (int)(Math.random() * (size.height - y - minSize) + minSize); |
| g.drawOval(x, y, Math.min(width, height), Math.min(width, height)); |
| } |
| endTime = System.currentTimeMillis(); |
| recordTest("drawOval " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random filled ovals within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_fillOval(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| int minSize; |
| long startTime; |
| long endTime; |
| minSize = 10; |
| startTime = System.currentTimeMillis(); |
| for (int i = 0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int x = (int) (Math.random() * (size.width - minSize + 1)); |
| int y = (int) (Math.random() * (size.height - minSize + 1)); |
| int width = (int) (Math.random() * (size.width - x - minSize) + minSize); |
| int height = (int) (Math.random() * (size.height - y - minSize) + minSize); |
| g.fillOval(x, y, width,height); |
| } |
| endTime = System.currentTimeMillis(); |
| recordTest("fillOval " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random filled rounded rectangles within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_fillRoundRect(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| int minSize; |
| long startTime; |
| long endTime; |
| minSize = 10; |
| startTime = System.currentTimeMillis(); |
| for (int i=0; i < maxTests; i+=1) |
| { |
| g.setColor(getNextColor()); |
| int x = (int) (Math.random() * (size.width - minSize + 1)); |
| int y = (int) (Math.random() * (size.height - minSize + 1)); |
| int width = (int) (Math.random() * (size.width - x - minSize) + minSize); |
| int height = (int) (Math.random() * (size.height - y - minSize) + minSize); |
| int arcWidth = (int) (Math.random() * (width - 1) + 1); |
| int arcHeight = (int) (Math.random() * (height - 1) + 5); |
| g.fillRoundRect(x, y, width, height, arcWidth, arcHeight); |
| } |
| endTime = System.currentTimeMillis(); |
| recordTest("fillRoundRect " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random images within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_drawImage(Graphics g, Dimension size) |
| { |
| if (gifTestImage == null) |
| { |
| logger.logp(Level.WARNING, "AicasGraphicsBenchmark", "runTestSet", |
| "Skipping 'test_drawImage' due to missing resource."); |
| return; |
| } |
| |
| int maxTests = DEFAULT_TEST_SIZE / 2; |
| if(maxTests == 0) |
| maxTests = 1; |
| int imageWidth = gifTestImage.getWidth(this); |
| int imageHeight = gifTestImage.getHeight(this); |
| long startTime = System.currentTimeMillis(); |
| for (int i = 0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int x = (int) (Math.random() * (size.width - imageWidth + 1)); |
| int y = (int) (Math.random() * (size.height - imageHeight + 1)); |
| g.drawImage(gifTestImage, x, y, this); |
| } |
| long endTime = System.currentTimeMillis(); |
| recordTest("drawImage " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random transparent images within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_drawTransparentImage(Graphics g, Dimension size) |
| { |
| if (pngTestImage == null) |
| { |
| logger.logp(Level.WARNING, "AicasGraphicsBenchmark", "runTestSet", |
| "Skipping 'test_drawTransparentImage' due to missing resource."); |
| return; |
| } |
| |
| |
| int maxTests = DEFAULT_TEST_SIZE / 5; |
| if(maxTests == 0) |
| maxTests = 1; |
| int imageWidth = pngTestImage.getWidth(this); |
| int imageHeight = pngTestImage.getHeight(this); |
| long startTime = System.currentTimeMillis(); |
| for (int i = 0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| int x = (int) (Math.random() * (size.width - imageWidth + 1)); |
| int y = (int) (Math.random() * (size.height - imageHeight + 1)); |
| g.drawImage(pngTestImage, x, y, this); |
| } |
| long endTime = System.currentTimeMillis(); |
| recordTest("draw transparent image " + maxTests + " times", |
| (endTime-startTime)); |
| } |
| |
| /** |
| * Draws random strings within the given dimensions. |
| * |
| * @param g The Graphics object that is used to paint. |
| * @param size The size of the canvas. |
| */ |
| private void test_drawString(Graphics g, Dimension size) |
| { |
| int maxTests = DEFAULT_TEST_SIZE; |
| String testString = "HelloWorld"; |
| int stringWidth = g.getFontMetrics().stringWidth(testString); |
| int stringHeight = g.getFontMetrics().getHeight(); |
| |
| long startTime = System.currentTimeMillis(); |
| for(int i = 0; i < maxTests; i += 1) |
| { |
| g.setColor(getNextColor()); |
| g.drawString(testString, (int) (Math.random() * (size.width - stringWidth + 1)),(int)(Math.random() * (size.height - stringHeight + 1)) + stringHeight); |
| } |
| long endTime = System.currentTimeMillis(); |
| recordTest("drawString " + maxTests + " times", (endTime-startTime)); |
| } |
| |
| private class GraphicsTest extends Canvas implements Runnable |
| { |
| Thread paintThread; |
| boolean done = false; |
| boolean doPaint = false; |
| boolean withClipping = false; |
| |
| public GraphicsTest() |
| { |
| paintThread = new Thread(this); |
| paintThread.start(); |
| } |
| |
| public void run() |
| { |
| int runCount = 0; |
| while (!done) |
| { |
| runCount++; |
| |
| try |
| { |
| synchronized (this) |
| { |
| while (!doPaint) |
| { |
| try |
| { |
| wait(200); |
| } |
| catch (InterruptedException exception) |
| { |
| return; |
| } |
| } |
| } |
| |
| if (iterations != 0) |
| System.out.println("--- run...(" + runCount + "/" + iterations |
| + ") ------------------------------------------------------"); |
| |
| Graphics g = getGraphics(); |
| Dimension size = getSize(); |
| logger.logp(Level.INFO, "AicasGraphicsBenchmark.GraphicsTest", "run", |
| "Start testing non-double-buffered drawing"); |
| runSet_noClipping(g,size); |
| runSet_zeroClipping(g, size); |
| runSet_withClipping(g, size); |
| g.dispose(); |
| |
| if (doubleBufferFlag) |
| { |
| logger.logp(Level.INFO, "AicasGraphicsBenchmark.GraphicsTest", |
| "run", "Start testing double-buffered drawing"); |
| Graphics canvas = getGraphics(); |
| Image doublebuffer = createImage(size.width,size.height); |
| g = doublebuffer.getGraphics(); |
| runSet_noClipping(g,size); |
| g.dispose(); |
| canvas.drawImage(doublebuffer, 0, 0, this); |
| |
| g = doublebuffer.getGraphics(); |
| runSet_withClipping(g, size); |
| g.dispose(); |
| canvas.drawImage(doublebuffer, 0, 0, this); |
| |
| g = doublebuffer.getGraphics(); |
| runSet_zeroClipping(g, size); |
| g.dispose(); |
| canvas.drawImage(doublebuffer, 0, 0, this); |
| canvas.dispose(); |
| } |
| |
| printReport(); |
| |
| if (iterations != 0) |
| { |
| if (iterations != -1) |
| iterations--; |
| } |
| else |
| { |
| System.out.println("--- done --------------------------------------------------------"); |
| synchronized (this) |
| { |
| doPaint = false; |
| } |
| done = true; |
| } |
| } |
| catch (Error error) |
| { |
| System.err.println("Error: " + error); |
| System.exit(129); |
| } |
| } |
| System.exit(0); |
| } |
| |
| private void runSet_zeroClipping(Graphics g, Dimension size) |
| { |
| int clipped_width; |
| int clipped_height; |
| int clipped_x; |
| int clipped_y; |
| |
| clipped_width = 0; |
| clipped_height = 0; |
| clipped_x = (size.width) / 2; |
| clipped_y = (size.height) / 2; |
| g.setClip(0, 0, size.width, size.height); |
| g.setColor(Color.BLACK); |
| g.fillRect(0, 0, size.width, size.height); |
| g.setColor(Color.WHITE); |
| g.drawRect(0, 0, size.width - 1, size.height - 1); |
| g.fillRect(clipped_x - 1, clipped_y - 1, clipped_width + 2, clipped_height + 2); |
| |
| g.clipRect(clipped_x, clipped_y, clipped_width, clipped_height); |
| g.setColor(Color.BLACK); |
| g.fillRect(0, 0, size.width, size.height); |
| |
| setTestContext("clipping to zero"); |
| |
| runTestSet(g, size); |
| } |
| |
| private void runSet_withClipping(Graphics g, Dimension size) |
| { |
| int clipped_width = 2 * size.width / 3; |
| int clipped_height = 2 * size.height / 3; |
| int clipped_x = (size.width - clipped_width) / 2; |
| int clipped_y = (size.height - clipped_height) / 2; |
| |
| g.setClip(0,0,size.width,size.height); |
| |
| g.setColor(Color.BLACK); |
| g.fillRect(0, 0, size.width, size.height); |
| g.setColor(Color.GREEN); |
| g.drawRect(0, 0, size.width - 1, size.height - 1); |
| g.setColor(Color.WHITE); |
| g.fillRect(clipped_x - 1, clipped_y - 1, clipped_width + 2, clipped_height + 2); |
| |
| g.clipRect(clipped_x, clipped_y, clipped_width, clipped_height); |
| g.setColor(Color.BLACK); |
| g.fillRect(0, 0, size.width, size.height); |
| |
| setTestContext("with clipping"); |
| |
| runTestSet(g, size); |
| } |
| |
| public void runSet_noClipping(Graphics g, Dimension size) |
| { |
| g.setColor(Color.BLACK); |
| g.fillRect(0, 0, size.width, size.height); |
| |
| setTestContext("without clipping"); |
| |
| runTestSet(g, size); |
| } |
| |
| public void paint(Graphics g) |
| { |
| synchronized(this) |
| { |
| doPaint=true; |
| notify(); |
| } |
| } |
| } |
| } |
| |
| class TestContext |
| { |
| } |
| |
| class TestSet |
| { |
| private Map testsMap = new TreeMap(); |
| |
| public void putTest(String testName, TestRecorder recoder) |
| { |
| testsMap.put(testName,recoder); |
| } |
| |
| public TestRecorder getTest(String testName) |
| { |
| return (TestRecorder)testsMap.get(testName); |
| } |
| |
| public Iterator testIterator() |
| { |
| return testsMap.keySet().iterator(); |
| } |
| } |
| |
| class TestRecorder |
| { |
| String test; |
| long totalTime = 0; |
| long minTime = Long.MAX_VALUE; |
| long maxTime = Long.MIN_VALUE; |
| int runCount = 0; |
| |
| /** |
| * @return Returns the maxTime. |
| */ |
| public final long getMaxTime() |
| { |
| return maxTime; |
| } |
| |
| /** |
| * @return Returns the minTime. |
| */ |
| public final long getMinTime() |
| { |
| return minTime; |
| } |
| |
| /** |
| * @return Returns the test name. |
| */ |
| public final String getTestName() |
| { |
| return test; |
| } |
| |
| public final double getAverage() |
| { |
| return ((double)totalTime) / ((double)runCount); |
| } |
| |
| public TestRecorder(String testName) |
| { |
| test = testName; |
| } |
| |
| public void addRun(long time) |
| { |
| totalTime += time; |
| if(minTime > time) |
| minTime = time; |
| if(maxTime < time) |
| maxTime = time; |
| runCount += 1; |
| } |
| } |