Subversion Repositories openrisc

/* 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("../icons/aicas.png");
    gifTestImage = loadImage("../icons/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(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;
  }
}