commit-classpath
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[commit-cp] classpath ChangeLog examples/gnu/classpath/exam...


From: Roman Kennke
Subject: [commit-cp] classpath ChangeLog examples/gnu/classpath/exam...
Date: Wed, 14 Jun 2006 14:56:16 +0000

CVSROOT:        /cvsroot/classpath
Module name:    classpath
Changes by:     Roman Kennke <rabbit78> 06/06/14 14:56:16

Modified files:
        .              : ChangeLog 
Added files:
        examples/gnu/classpath/examples/awt: AicasGraphicsBenchmark.java 
                                             aicas.png palme.gif 

Log message:
        2006-06-14  Roman Kennke  <address@hidden>
        
                * 
examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java:
                New file. This is a benchmark for AWT 1.1 style graphics 
operations.
                * examples/gnu/classpath/examples/awt/palme.gif: New file.
                * examples/gnu/classpath/examples/awt/aicas.gif: New file.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/classpath/ChangeLog?cvsroot=classpath&r1=1.7813&r2=1.7814
http://cvs.savannah.gnu.org/viewcvs/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java?cvsroot=classpath&rev=1.1
http://cvs.savannah.gnu.org/viewcvs/classpath/examples/gnu/classpath/examples/awt/aicas.png?cvsroot=classpath&rev=1.1
http://cvs.savannah.gnu.org/viewcvs/classpath/examples/gnu/classpath/examples/awt/palme.gif?cvsroot=classpath&rev=1.1

Patches:
Index: ChangeLog
===================================================================
RCS file: /cvsroot/classpath/classpath/ChangeLog,v
retrieving revision 1.7813
retrieving revision 1.7814
diff -u -b -r1.7813 -r1.7814
--- ChangeLog   14 Jun 2006 14:47:47 -0000      1.7813
+++ ChangeLog   14 Jun 2006 14:56:15 -0000      1.7814
@@ -1,3 +1,10 @@
+2006-06-14  Roman Kennke  <address@hidden>
+
+       * examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java:
+       New file. This is a benchmark for AWT 1.1 style graphics operations.
+       * examples/gnu/classpath/examples/awt/palme.gif: New file.
+       * examples/gnu/classpath/examples/awt/aicas.gif: New file.
+
 2006-06-14  Tom Tromey  <address@hidden>
 
        * java/io/File.java (getParent): Javadoc fix.

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

Index: examples/gnu/classpath/examples/awt/aicas.png
===================================================================
RCS file: examples/gnu/classpath/examples/awt/aicas.png
diff -N examples/gnu/classpath/examples/awt/aicas.png
Binary files /dev/null and /tmp/cvsiwjjf1 differ

Index: examples/gnu/classpath/examples/awt/palme.gif
===================================================================
RCS file: examples/gnu/classpath/examples/awt/palme.gif
diff -N examples/gnu/classpath/examples/awt/palme.gif
Binary files /dev/null and /tmp/cvsRhrISZ differ




reply via email to

[Prev in Thread] Current Thread [Next in Thread]