--- /dev/null
+/* J2dBenchmark.java -- Benchmarking utility for java2d,
+ based on the Aicas AWT benchmarker
+ 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.java2d;
+
+import java.awt.AlphaComposite;
+import java.awt.BasicStroke;
+import java.awt.BorderLayout;
+import java.awt.Canvas;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Frame;
+import java.awt.GradientPaint;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.Insets;
+import java.awt.Label;
+import java.awt.MediaTracker;
+import java.awt.Panel;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.TexturePaint;
+import java.awt.Toolkit;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Arc2D;
+import java.awt.geom.CubicCurve2D;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Line2D;
+import java.awt.geom.QuadCurve2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.geom.RoundRectangle2D;
+import java.awt.image.BufferedImage;
+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 J2dBenchmark
+ extends Panel
+{
+ /**
+ * Default number of test-iterations.
+ */
+ protected static final int DEFAULT_TEST_SIZE = 1000;
+
+ /**
+ * Default screen size.
+ */
+ protected static final int DEFAULT_SCREEN_WIDTH = 320;
+
+ protected static final int DEFAULT_SCREEN_HEIGHT = 240;
+
+ /**
+ * Java2D tests.
+ */
+ protected static final int J2DTEST_ARC = 1 << 0;
+
+ protected static final int J2DTEST_CUBICCURVE = 1 << 1;
+
+ protected static final int J2DTEST_ELLIPSE = 1 << 2;
+
+ protected static final int J2DTEST_GENERALPATH = 1 << 3;
+
+ protected static final int J2DTEST_LINE = 1 << 4;
+
+ protected static final int J2DTEST_QUADCURVE = 1 << 5;
+
+ protected static final int J2DTEST_RECTANGLE = 1 << 6;
+
+ protected static final int J2DTEST_ROUNDRECTANGLE = 1 << 7;
+
+ protected static final int J2DTEST_IMAGE = 1 << 8;
+
+ protected static final int J2DTEST_NONE = 0;
+
+ /*
+ private static final int J2DTEST_ALL = J2DTEST_ARC | J2DTEST_CUBICCURVE
+ | J2DTEST_ELLIPSE
+ | J2DTEST_GENERALPATH | J2DTEST_LINE
+ | J2DTEST_QUADCURVE
+ | J2DTEST_RECTANGLE
+ | J2DTEST_ROUNDRECTANGLE
+ | J2DTEST_IMAGE;
+ */
+ private static final int J2DTEST_ALL = J2DTEST_ARC | J2DTEST_CUBICCURVE
+ | J2DTEST_ELLIPSE
+ | J2DTEST_LINE
+ | J2DTEST_QUADCURVE
+ | J2DTEST_RECTANGLE
+ | J2DTEST_ROUNDRECTANGLE
+ | J2DTEST_IMAGE;
+
+ int iterations = 1;
+
+ protected int screenWidth = DEFAULT_SCREEN_WIDTH;
+
+ protected int screenHeight = DEFAULT_SCREEN_HEIGHT;
+
+ protected boolean noClippingFlag = true;
+
+ protected boolean withClippingFlag = true;
+
+ protected boolean zeroClippingFlag = true;
+
+ protected boolean singleBufferFlag = true;
+
+ protected boolean doubleBufferFlag = true;
+
+ protected boolean gradientFlag = false;
+
+ protected String texture = null;
+
+ protected boolean strokeFlag = false;
+
+ protected float composite = 1;
+
+ protected int xtranslate = 0;
+
+ protected int ytranslate = 0;
+
+ protected double xshear = 0;
+
+ protected double yshear = 0;
+
+ protected double rotate = 0;
+
+ protected boolean antialiasFlag = false;
+
+ protected AffineTransform affineTransform = null;
+
+ protected int awtTests = J2DTEST_ALL;
+
+ protected int testSize = DEFAULT_TEST_SIZE;
+
+ private Label testLabel;
+
+ private String testContext = "";
+
+ Logger logger = Logger.getLogger("J2dGraphicsBenchmark");
+
+ private Image pngTestImage;
+
+ private Image gifTestImage;
+
+ protected BufferedImage textureImage;
+
+ protected TestSet testSetMap = new TestSet();
+
+ public String init()
+ {
+ boolean loadError = false;
+ pngTestImage = loadImage("aicas.png");
+ gifTestImage = loadImage("palme.gif");
+
+ if (texture != null)
+ {
+ textureImage = loadBufferedImage(texture);
+
+ if (textureImage == null)
+ {
+ logger.logp(Level.WARNING, "J2dGraphicsBenchmark", "init",
+ "Unable to load texture - defaulting "
+ + "to solid colours");
+ texture = null;
+ loadError = true;
+ }
+ }
+
+ setLayout(new BorderLayout());
+ testLabel = new Label();
+ add(testLabel, BorderLayout.NORTH);
+ add(new GraphicsTest(), BorderLayout.CENTER);
+
+ if (loadError)
+ return "Unable to load image";
+ else
+ return null;
+ }
+
+ void setTestContext(String testName)
+ {
+ logger.logp(Level.INFO, "J2dGraphicsBenchmark", "recordTest",
+ "--- Starting new test context: " + testName);
+ testContext = testName;
+ testLabel.setText(testName);
+ }
+
+ private void recordTest(String testName, long time)
+ {
+ logger.logp(Level.INFO, "J2dGraphicsBenchmark", "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() + "]");
+ }
+ }
+
+ void testComplete()
+ {
+ System.exit(0);
+ }
+
+ public static void main(String[] args)
+ {
+ int awtTests;
+ int i;
+ boolean endOfOptionsFlag;
+ J2dBenchmark speed = new J2dBenchmark();
+
+ // Parse arguments.
+ i = 0;
+ endOfOptionsFlag = false;
+ awtTests = J2DTEST_NONE;
+ while (i < args.length)
+ {
+ if (! endOfOptionsFlag)
+ {
+ if (args[i].equals("--help") || args[i].equals("-help")
+ || args[i].equals("-h"))
+ {
+ System.out.println("Usage: J2dBenchmark [<options>] [<test> ...]");
+ System.out.println("");
+ System.out.println("Options: -i|--iterations=<n|-1> - number of iterations (-1 is infinite; default "
+ + speed.iterations + ")");
+ 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(" -d|--noDoubleBuffer - disable double-buffering test");
+ System.out.println(" -s|--testsize=<n> - size of each test; default "
+ + DEFAULT_TEST_SIZE);
+ System.out.println(" -c|--noClipping - disable clipping test");
+ System.out.println(" -z|--noZeroClipping - disable clipping to zero test");
+ System.out.println("");
+ System.out.println("Additional options:");
+ System.out.println(" --with-gradients - enable gradients (not compatible with --texture)");
+ System.out.println(" --with-stroking - enable random stroking");
+ System.out.println(" --texture=<file> - enable texturing with this file (not compatible with --with-gradients)");
+ System.out.println(" --composite=<n|-1> - set alpha composite level; -1 for random; default 1.0 (no transparency)");
+ System.out.println(" --anti-alias=<on|off> - set anti-aliasing hint (not all implementations respect this); default off");
+ System.out.println(" --x-translate=<n> - set x-axis translation; default 0");
+ System.out.println(" --y-translate=<n> - set y-axis translation; default 0");
+ System.out.println(" --x-shear=<n> - set x-axis shear; default 0");
+ System.out.println(" --y-shear=<n> - set y-axis shear; default 0");
+ System.out.println(" --rotate=<n|-1> - set rotation (radians); -1 for random; default: 0 (none)");
+ System.out.println("");
+ System.out.println("Tests: arc");
+ System.out.println(" cubiccurve");
+ System.out.println(" ellipse");
+ // System.out.println(" generalpath");
+ System.out.println(" line");
+ System.out.println(" quadcurve");
+ System.out.println(" rectangle");
+ System.out.println(" roundrectangle");
+ 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("-d") || args[i].equals("--noDoubleBuffer")))
+ {
+ speed.doubleBufferFlag = false;
+ i += 1;
+ continue;
+ }
+ else if ((args[i].startsWith("-s=") || args[i].startsWith("--testsize=")))
+ {
+ if ((i + 1) >= args.length)
+ {
+ System.err.println("ERROR: No argument given for option '"
+ + args[i] + "'!");
+ System.exit(2);
+ }
+ speed.testSize = Integer.parseInt(args[i].substring(args[i].indexOf('=') + 1));
+ i += 1;
+ continue;
+ }
+ else if ((args[i].equals("-s") || args[i].equals("--testsize")))
+ {
+ if ((i + 1) >= args.length)
+ {
+ System.err.println("ERROR: No argument given for option '"
+ + args[i] + "'!");
+ System.exit(2);
+ }
+ speed.testSize = Integer.parseInt(args[i + 1]);
+ i += 2;
+ continue;
+ }
+ else if ((args[i].equals("-c") || args[i].equals("--noClipping")))
+ {
+ speed.noClippingFlag = false;
+ i += 1;
+ continue;
+ }
+ else if ((args[i].equals("-z") || args[i].equals("--noZeroClipping")))
+ {
+ speed.zeroClippingFlag = false;
+ i += 1;
+ continue;
+ }
+ else if (args[i].equals("--with-gradients"))
+ {
+ speed.gradientFlag = true;
+ i += 1;
+ continue;
+ }
+ else if (args[i].equals("--with-stroking"))
+ {
+ speed.strokeFlag = true;
+ i += 1;
+ continue;
+ }
+ else if (args[i].startsWith("--texture="))
+ {
+ speed.texture = args[i].substring(args[i].indexOf('=') + 1);
+ i += 1;
+ continue;
+ }
+ else if (args[i].startsWith("--composite="))
+ {
+ speed.composite = Float.parseFloat(args[i].substring(args[i].indexOf('=') + 1));
+ if (speed.composite != - 1
+ && (speed.composite < 0 || speed.composite > 1))
+ {
+ System.err.println("ERROR: Invalid value for composite (must be between 0 and 1, or -1 for random)");
+ System.exit(2);
+ }
+ i += 1;
+ continue;
+ }
+ else if (args[i].startsWith("--anti-alias="))
+ {
+ speed.antialiasFlag = (args[i].substring(args[i].indexOf('=') + 1).equals("on"));
+ i += 1;
+ continue;
+ }
+ else if (args[i].startsWith("--x-translate="))
+ {
+ speed.xtranslate = Integer.parseInt(args[i].substring(args[i].indexOf('=') + 1));
+ i += 1;
+ continue;
+ }
+ else if (args[i].startsWith("--y-translate="))
+ {
+ speed.ytranslate = Integer.parseInt(args[i].substring(args[i].indexOf('=') + 1));
+ i += 1;
+ continue;
+ }
+ else if (args[i].startsWith("--x-shear="))
+ {
+ speed.xshear = Double.parseDouble(args[i].substring(args[i].indexOf('=') + 1));
+ i += 1;
+ continue;
+ }
+ else if (args[i].startsWith("--y-shear="))
+ {
+ speed.yshear = Double.parseDouble(args[i].substring(args[i].indexOf('=') + 1));
+ i += 1;
+ continue;
+ }
+ else if (args[i].startsWith("--rotate="))
+ {
+ speed.rotate = Double.parseDouble(args[i].substring(args[i].indexOf('=') + 1));
+ 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("arc"))
+ awtTests |= J2DTEST_ARC;
+ else if (s.equals("cubiccurve"))
+ awtTests |= J2DTEST_CUBICCURVE;
+ else if (s.equals("ellipse"))
+ awtTests |= J2DTEST_ELLIPSE;
+ else if (s.equals("generalpath"))
+ awtTests |= J2DTEST_GENERALPATH;
+ else if (s.equals("line"))
+ awtTests |= J2DTEST_LINE;
+ else if (s.equals("quadcurve"))
+ awtTests |= J2DTEST_QUADCURVE;
+ else if (s.equals("rectangle"))
+ awtTests |= J2DTEST_RECTANGLE;
+ else if (s.equals("roundrectangle"))
+ awtTests |= J2DTEST_ROUNDRECTANGLE;
+ else if (s.equals("image"))
+ awtTests |= J2DTEST_IMAGE;
+ else
+ {
+ System.err.println("Unknown AWT test '" + s + "'!");
+ System.exit(2);
+ }
+ }
+ i += 1;
+ }
+ if (awtTests != J2DTEST_NONE)
+ speed.awtTests = awtTests;
+
+ // Create graphics.
+ speed.init();
+ final Frame frame = new Frame("J2dGraphicsBenchmark");
+
+ 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, "J2dGraphicsBenchmark", "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, "J2dGraphicsBenchmark", "loadImage",
+ "Could not locate image resource in class path: "
+ + imageName);
+ }
+ return result;
+ }
+
+ private BufferedImage loadBufferedImage(String imageName)
+ {
+ BufferedImage result = null;
+ logger.logp(Level.INFO, "J2dGraphicsBenchmark", "loadImage",
+ "Loading image: " + imageName);
+
+ // Try to load image out of classpath before trying an absolute filename
+ URL url = getClass().getResource(imageName);
+ Image img;
+ if (url != null)
+ img = Toolkit.getDefaultToolkit().getImage(url);
+ else
+ img = Toolkit.getDefaultToolkit().getImage(imageName);
+
+ if (img != null)
+ {
+ // Wait for image to load
+ try
+ {
+ MediaTracker tracker = new MediaTracker(this);
+ tracker.addImage(img, 1);
+ tracker.waitForAll();
+
+ prepareImage(img, this);
+ result = new BufferedImage(img.getWidth(this), img.getHeight(this),
+ BufferedImage.TYPE_INT_RGB);
+ result.createGraphics().drawImage(img, 0, 0, this);
+ }
+ catch (InterruptedException e)
+ {
+ }
+ catch (IllegalArgumentException e)
+ {
+ }
+ }
+
+ if (result == null)
+ {
+ logger.logp(Level.WARNING, "J2dGraphicsBenchmark", "loadBufferedImage",
+ "Could not locate image resource in class path: "
+ + imageName);
+ }
+ return result;
+ }
+
+ /**
+ * Executes the test methods.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ void runTestSet(Graphics2D g, Dimension size)
+ {
+ // Any user-specified options (ie set transforms, rendering hints)
+ prepareGraphics((Graphics2D) g);
+
+ if ((awtTests & J2DTEST_ARC) != 0)
+ {
+ test_drawArc(g, size);
+ test_fillArc(g, size);
+ }
+
+ if ((awtTests & J2DTEST_CUBICCURVE) != 0)
+ {
+ test_drawCubicCurve(g, size);
+ }
+
+ if ((awtTests & J2DTEST_ELLIPSE) != 0)
+ {
+ test_drawEllipse(g, size);
+ test_fillEllipse(g, size);
+ }
+
+ if ((awtTests & J2DTEST_GENERALPATH) != 0)
+ {
+ // Current implementation doesn't work
+ test_drawGeneralPath(g, size);
+ test_fillGeneralPath(g, size);
+ }
+
+ if ((awtTests & J2DTEST_LINE) != 0)
+ {
+ test_drawLine(g, size);
+ }
+
+ if ((awtTests & J2DTEST_QUADCURVE) != 0)
+ {
+ test_drawQuadCurve(g, size);
+ }
+
+ if ((awtTests & J2DTEST_RECTANGLE) != 0)
+ {
+ test_drawRectangle(g, size);
+ test_fillRectangle(g, size);
+ }
+
+ if ((awtTests & J2DTEST_ROUNDRECTANGLE) != 0)
+ {
+ test_drawRoundRectangle(g, size);
+ test_fillRoundRectangle(g, size);
+ }
+
+ if ((awtTests & J2DTEST_IMAGE) != 0)
+ {
+ test_drawImage(g, size);
+ test_drawTransparentImage(g, size);
+ }
+ }
+
+ /**
+ * Reset all graphics settings to the standard, default values
+ *
+ * @param g the object to apply settings to
+ */
+ private void resetGraphics(Graphics2D g)
+ {
+ g.setTransform(new AffineTransform());
+ g.setStroke(new BasicStroke());
+ g.setComposite(AlphaComposite.SrcOut);
+ }
+
+ /**
+ * Sets initial user graphics options
+ *
+ * @param g the object to apply settings to
+ */
+ private void prepareGraphics(Graphics2D g)
+ {
+ // Transforms
+ if (affineTransform != null)
+ g.setTransform(affineTransform);
+
+ else if (xtranslate != 0 || ytranslate != 0 || xshear != 0 || yshear != 0)
+ {
+ g.translate(xtranslate, ytranslate);
+ g.shear(xshear, yshear);
+ }
+
+ if (rotate > 0)
+ g.rotate(rotate * Math.PI, screenWidth / 2, screenHeight / 2);
+
+ // Composite (transparency)
+ if (composite > 0)
+ {
+ g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
+ composite));
+ }
+
+ // Textures
+ if (texture != null)
+ g.setPaint(new TexturePaint(textureImage,
+ new Rectangle(0, 0, textureImage.getWidth(),
+ textureImage.getHeight())));
+
+ // Anti-alias setting
+ if (antialiasFlag)
+ g.setRenderingHints(new RenderingHints(RenderingHints.KEY_ANTIALIASING,
+ RenderingHints.VALUE_ANTIALIAS_ON));
+ else
+ g.setRenderingHints(new RenderingHints(RenderingHints.KEY_ANTIALIASING,
+ RenderingHints.VALUE_ANTIALIAS_OFF));
+ }
+
+ /**
+ * Gets new random settings
+ *
+ * @param g the object to set parameters for
+ * @param size the screen size
+ */
+ private void setRandom(Graphics2D g, Dimension size)
+ {
+ // Set colour / paint
+ if (gradientFlag)
+ {
+ Color c1 = new Color((int) (Math.random() * 254) + 1,
+ (int) (Math.random() * 254) + 1,
+ (int) (Math.random() * 254) + 1);
+
+ Color c2 = new Color((int) (Math.random() * 254) + 1,
+ (int) (Math.random() * 254) + 1,
+ (int) (Math.random() * 254) + 1);
+
+ g.setPaint(new GradientPaint(0, 0, c1, screenWidth / 5,
+ screenHeight / 5, c2, true));
+ }
+
+ else if (texture == null)
+ g.setPaint(new Color((int) (Math.random() * 254) + 1,
+ (int) (Math.random() * 254) + 1,
+ (int) (Math.random() * 254) + 1));
+
+ // Set stroke width and options
+ if (strokeFlag)
+ {
+ int cap = (int) (Math.random() * 3 + 1);
+ if (cap == 1)
+ cap = BasicStroke.CAP_SQUARE;
+ else if (cap == 2)
+ cap = BasicStroke.CAP_BUTT;
+ else
+ cap = BasicStroke.CAP_ROUND;
+
+ int join = (int) (Math.random() * 3 + 1);
+ if (join == 1)
+ join = BasicStroke.JOIN_MITER;
+ else if (join == 2)
+ join = BasicStroke.JOIN_BEVEL;
+ else
+ join = BasicStroke.JOIN_ROUND;
+
+ float[] dashes = { 10, 10 };
+ g.setStroke(new BasicStroke((int) (Math.random() * 10), cap, join, 10f,
+ dashes, 0));
+ }
+
+ // Composite / transparency
+ if (composite == - 1)
+ {
+ g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
+ (float) Math.random()));
+ }
+
+ // Transformations
+ if (rotate == - 1)
+ g.rotate(Math.random() * Math.PI * 2);
+ }
+
+ /**
+ * Draws random arcs within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_drawArc(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize;
+ long startTime;
+ long endTime;
+ minSize = 10;
+ startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ 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);
+
+ Arc2D arc = new Arc2D.Double(x, y, width, height, startAngle, arcAngle,
+ Arc2D.OPEN);
+ g.draw(arc);
+ }
+ endTime = System.currentTimeMillis();
+ recordTest("draw(Arc2D.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random filled arcs within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_fillArc(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize;
+ long startTime;
+ long endTime;
+ minSize = 10;
+ startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ 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);
+
+ Arc2D arc = new Arc2D.Double(x, y, width, height, startAngle, arcAngle,
+ Arc2D.OPEN);
+ g.fill(arc);
+ }
+ endTime = System.currentTimeMillis();
+ recordTest("fill(Arc2D.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random cubic curves within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_drawCubicCurve(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize = 10;
+ long startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ int x1 = (int) (Math.random() * (size.width - minSize));
+ int y1 = (int) (Math.random() * (size.height - minSize));
+ int xc1 = (int) (Math.random() * (size.width - minSize));
+ int yc1 = (int) (Math.random() * (size.height - minSize));
+ int xc2 = (int) (Math.random() * (size.width - minSize));
+ int yc2 = (int) (Math.random() * (size.height - minSize));
+ int x2 = (int) (Math.random() * (size.width - minSize));
+ int y2 = (int) (Math.random() * (size.height - minSize));
+
+ CubicCurve2D curve = new CubicCurve2D.Double(x1, y1, xc1, yc1, xc2,
+ yc2, x2, y2);
+ g.draw(curve);
+ }
+ long endTime = System.currentTimeMillis();
+ recordTest("draw(CubicCurve2D.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random ellipses within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_drawEllipse(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize = 10;
+ long startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ 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));
+ Ellipse2D ellipse = new Ellipse2D.Double(x1, y1, x2, y2);
+ g.draw(ellipse);
+ }
+ long endTime = System.currentTimeMillis();
+ recordTest("draw(Ellipse.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random ellipses within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_fillEllipse(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize = 10;
+ long startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ 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));
+ Ellipse2D ellipse = new Ellipse2D.Double(x1, y1, x2, y2);
+ g.fill(ellipse);
+ }
+ long endTime = System.currentTimeMillis();
+ recordTest("fill(Ellipse.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ // TODO: fix the GeneralPath methods.
+ /**
+ * Draws random polygons within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_drawGeneralPath(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ long startTime = System.currentTimeMillis();
+
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ int points = (int) (Math.random() * 6) + 2;
+ GeneralPath shape = new GeneralPath();
+ shape.moveTo((float) Math.random() * (size.width),
+ (float) Math.random() * (size.height));
+ for (int j = 0; j < points; j += 1)
+ {
+ shape.lineTo((float) (Math.random() * (size.width)),
+ (float) (Math.random() * (size.height)));
+ }
+ g.draw(shape);
+ }
+ long endTime = System.currentTimeMillis();
+ recordTest("draw(GeneralPath) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random filled polygons within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_fillGeneralPath(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ long startTime = System.currentTimeMillis();
+
+ GeneralPath shape = new GeneralPath();
+ shape.moveTo((float) Math.random() * (size.width), (float) Math.random()
+ * (size.height));
+
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ int points = (int) (Math.random() * 6) + 2;
+ for (int j = 0; j < points; j += 1)
+ {
+ shape.lineTo((float) (Math.random() * (size.width)),
+ (float) (Math.random() * (size.height)));
+ }
+ g.fill(shape);
+ }
+ long endTime = System.currentTimeMillis();
+ recordTest("fill(GeneralPath) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random lines within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_drawLine(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize = 10;
+ long startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ 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));
+ Line2D line = new Line2D.Double(x1, y1, x2, y2);
+ g.draw(line);
+ }
+ long endTime = System.currentTimeMillis();
+ recordTest("draw(Line2D.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random quadratic curves within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_drawQuadCurve(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize = 10;
+ long startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ int x1 = (int) (Math.random() * (size.width - minSize));
+ int y1 = (int) (Math.random() * (size.height - minSize));
+ int xc = (int) (Math.random() * (size.width - minSize));
+ int yc = (int) (Math.random() * (size.height - minSize));
+ int x2 = (int) (Math.random() * (size.width - minSize));
+ int y2 = (int) (Math.random() * (size.height - minSize));
+
+ QuadCurve2D curve = new QuadCurve2D.Double(x1, y1, xc, yc, x2, y2);
+ g.draw(curve);
+ }
+ long endTime = System.currentTimeMillis();
+ recordTest("draw(QuadCurve2D.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random rectangles within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_drawRectangle(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize = 10;
+ long startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ 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));
+ Rectangle2D rect = new Rectangle2D.Double(x1, y1, x2, y2);
+ g.draw(rect);
+ }
+ long endTime = System.currentTimeMillis();
+ recordTest("draw(Rectangle.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random rectangles within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_fillRectangle(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize = 10;
+ long startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ 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));
+ Rectangle2D rect = new Rectangle2D.Double(x1, y1, x2, y2);
+ g.fill(rect);
+ }
+ long endTime = System.currentTimeMillis();
+ recordTest("fill(Rectangle.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random rounded rectangles within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_drawRoundRectangle(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize;
+ long startTime;
+ long endTime;
+ minSize = 10;
+ startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ 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);
+ RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width,
+ height, arcWidth,
+ arcHeight);
+ g.draw(rect);
+ }
+ endTime = System.currentTimeMillis();
+ recordTest("draw(RoundRectangle.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random filled rounded rectangles within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_fillRoundRectangle(Graphics2D g, Dimension size)
+ {
+ int maxTests = testSize;
+ int minSize;
+ long startTime;
+ long endTime;
+ minSize = 10;
+ startTime = System.currentTimeMillis();
+ for (int i = 0; i < maxTests; i += 1)
+ {
+ setRandom(g, size);
+ 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);
+ RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width,
+ height, arcWidth,
+ arcHeight);
+ g.fill(rect);
+ }
+ endTime = System.currentTimeMillis();
+ recordTest("fill(RoundRectangle.Double) " + maxTests + " times",
+ (endTime - startTime));
+ }
+
+ /**
+ * Draws random images within the given dimensions.
+ *
+ * @param g The Graphics2D object that is used to paint.
+ * @param size The size of the canvas.
+ */
+ private void test_drawImage(Graphics2D g, Dimension size)
+ {
+ if (gifTestImage == null)
+ {
+ logger.logp(Level.WARNING, "J2dGraphicsBenchmark", "runTestSet",
+ "Skipping 'test_drawImage' due to missing resource.");
+ return;
+ }
+
+ int maxTests = testSize / 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)
+ {
+ setRandom(g, size);
+ 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(Graphics2D g, Dimension size)
+ {
+ if (pngTestImage == null)
+ {
+ logger.logp(Level.WARNING, "AicasGraphicsBenchmark", "runTestSet",
+ "Skipping 'drawTransparentImage' due to missing resource.");
+ return;
+ }
+
+ int maxTests = testSize / 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)
+ {
+ setRandom(g, size);
+ 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));
+ }
+
+ 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();
+
+ if (singleBufferFlag)
+ {
+ logger.logp(Level.INFO, "J2dGraphicsBenchmark.GraphicsTest",
+ "run",
+ "Start testing non-double-buffered drawing");
+
+ if (noClippingFlag)
+ runSet_noClipping((Graphics2D) g, size, runCount);
+
+ if (withClippingFlag)
+ runSet_withClipping((Graphics2D) g, size, runCount);
+
+ if (zeroClippingFlag)
+ runSet_zeroClipping((Graphics2D) g, size, runCount);
+
+ g.dispose();
+ }
+
+ if (doubleBufferFlag)
+ {
+ logger.logp(Level.INFO, "J2dGraphicsBenchmark.GraphicsTest",
+ "run", "Start testing double-buffered drawing");
+ Graphics canvas = getGraphics();
+ Image doublebuffer = createImage(size.width, size.height);
+
+ if (noClippingFlag)
+ {
+ g = doublebuffer.getGraphics();
+ runSet_noClipping((Graphics2D) g, size,
+ "double buffering", runCount);
+ g.dispose();
+ canvas.drawImage(doublebuffer, 0, 0, this);
+ }
+
+ if (withClippingFlag)
+ {
+ g = doublebuffer.getGraphics();
+ runSet_withClipping((Graphics2D) g, size,
+ "double buffering", runCount);
+ g.dispose();
+ canvas.drawImage(doublebuffer, 0, 0, this);
+ }
+
+ if (zeroClippingFlag)
+ {
+ g = doublebuffer.getGraphics();
+ runSet_zeroClipping((Graphics2D) g, size,
+ "double buffering", runCount);
+ g.dispose();
+ canvas.drawImage(doublebuffer, 0, 0, this);
+ canvas.dispose();
+ }
+ }
+
+ printReport();
+
+ if (iterations != 1)
+ {
+ 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);
+ }
+ }
+ testComplete();
+ }
+
+ private void runSet_zeroClipping(Graphics2D g, Dimension size, int runCount)
+ {
+ runSet_zeroClipping(g, size, "", runCount);
+ }
+
+ private void runSet_zeroClipping(Graphics2D g, Dimension size,
+ String context, int runCount)
+ {
+ 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;
+
+ // Reset any transforms from past tests
+ resetGraphics(g);
+
+ Rectangle fullWindow = new Rectangle(0, 0, size.width, size.height);
+ g.setClip(fullWindow);
+ g.setPaint(Color.BLACK);
+ g.fill(fullWindow);
+
+ Rectangle windowBorder = new Rectangle(0, 0, size.width - 1,
+ size.width - 1);
+ g.setPaint(Color.WHITE);
+ g.draw(windowBorder);
+
+ Rectangle innerBorder = new Rectangle(clipped_x - 1, clipped_y - 1,
+ clipped_width + 2,
+ clipped_height + 2);
+ g.fill(innerBorder);
+
+ Rectangle innerBox = new Rectangle(clipped_x, clipped_y, clipped_width,
+ clipped_height);
+ g.clip(innerBox);
+ g.setPaint(Color.BLACK);
+ g.fill(fullWindow);
+
+ if (context.equals(""))
+ setTestContext("(" + runCount + ") clipping to zero");
+ else
+ setTestContext("(" + runCount + ") clipping to zero (" + context + ")");
+
+ runTestSet(g, size);
+ }
+
+ private void runSet_withClipping(Graphics2D g, Dimension size, int runCount)
+ {
+ runSet_withClipping(g, size, "", runCount);
+ }
+
+ private void runSet_withClipping(Graphics2D g, Dimension size,
+ String context, int runCount)
+ {
+ 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;
+
+ // Reset any transforms from past tests
+ resetGraphics(g);
+
+ Rectangle fullWindow = new Rectangle(0, 0, size.width, size.height);
+ g.setClip(fullWindow);
+
+ g.setPaint(Color.BLACK);
+ g.fill(fullWindow);
+
+ Rectangle windowBorder = new Rectangle(0, 0, size.width - 1,
+ size.height - 1);
+ g.setPaint(Color.GREEN);
+ g.draw(windowBorder);
+
+ Rectangle innerBorder = new Rectangle(clipped_x - 1, clipped_y - 1,
+ clipped_width + 2,
+ clipped_height + 2);
+ g.setPaint(Color.WHITE);
+ g.fill(innerBorder);
+
+ Rectangle innerBox = new Rectangle(clipped_x, clipped_y, clipped_width,
+ clipped_height);
+ g.clip(innerBox);
+
+ g.setPaint(Color.BLACK);
+ g.fill(fullWindow);
+
+ if (context.equals(""))
+ setTestContext("(" + runCount + ") with clipping ");
+ else
+ setTestContext("(" + runCount + ") with clipping (" + context + ")");
+
+ runTestSet(g, size);
+ }
+
+ private void runSet_noClipping(Graphics2D g, Dimension size, int runCount)
+ {
+ runSet_noClipping(g, size, "", runCount);
+ }
+
+ private void runSet_noClipping(Graphics2D g, Dimension size,
+ String context, int runCount)
+ {
+ // Reset any transforms from past tests
+ resetGraphics(g);
+
+ Rectangle fullWindow = new Rectangle(0, 0, size.width, size.height);
+ g.setPaint(Color.BLACK);
+ g.fill(fullWindow);
+
+ if (context.equals(""))
+ setTestContext("(" + runCount + ") without clipping");
+ else
+ setTestContext("(" + runCount + ") without clipping (" + context + ")");
+
+ 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 long getAverage()
+ {
+ return (totalTime / 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;
+ }
+}
OSDN Git Service
