aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java')
-rw-r--r--gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java1018
1 files changed, 1018 insertions, 0 deletions
diff --git a/gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java b/gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java
new file mode 100644
index 000000000..5bb4ec48a
--- /dev/null
+++ b/gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java
@@ -0,0 +1,1018 @@
+/* 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("../icons/aicas.png");
+ gifTestImage = loadImage("../icons/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;
+ }
+}