From b094d6c4bf572654a031ecc4afe675154c886dc5 Mon Sep 17 00:00:00 2001 From: Jing Yu Date: Thu, 22 Jul 2010 14:03:48 -0700 Subject: commit gcc-4.4.3 which is used to build gcc-4.4.3 Android toolchain in master. The source is based on fsf gcc-4.4.3 and contains local patches which are recorded in gcc-4.4.3/README.google. Change-Id: Id8c6d6927df274ae9749196a1cc24dbd9abc9887 --- .../examples/awt/AicasGraphicsBenchmark.java | 1018 ++++++++++++++++++++ 1 file changed, 1018 insertions(+) create mode 100644 gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java (limited to 'gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java') diff --git a/gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java b/gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java new file mode 100644 index 000000000..5bb4ec48a --- /dev/null +++ b/gcc-4.4.3/libjava/classpath/examples/gnu/classpath/examples/awt/AicasGraphicsBenchmark.java @@ -0,0 +1,1018 @@ +/* AnimationApplet.java -- An example of an old-style AWT applet + Copyright (C) 2006 Free Software Foundation, Inc. + +This file is part of GNU Classpath examples. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. */ + +package gnu.classpath.examples.awt; + +import java.awt.BorderLayout; +import java.awt.Canvas; +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Frame; +import java.awt.Graphics; +import java.awt.Image; +import java.awt.Insets; +import java.awt.Label; +import java.awt.Panel; +import java.awt.Toolkit; +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; +import java.net.URL; +import java.util.Iterator; +import java.util.Map; +import java.util.StringTokenizer; +import java.util.TreeMap; +import java.util.logging.Level; +import java.util.logging.Logger; + +public class AicasGraphicsBenchmark extends Panel +{ + /** + * Default number of test-iterations. + */ + private static final int DEFAULT_TEST_SIZE = 1000; + + /** + * Default screen size. + */ + private static final int DEFAULT_SCREEN_WIDTH = 320; + private static final int DEFAULT_SCREEN_HEIGHT = 240; + + /** + * AWT tests. + */ + private static final int AWTTEST_LINES = 1 << 0; + private static final int AWTTEST_RECT = 1 << 1; + private static final int AWTTEST_POLYLINE = 1 << 2; + private static final int AWTTEST_POLYGON = 1 << 3; + private static final int AWTTEST_ARC = 1 << 4; + private static final int AWTTEST_OVAL = 1 << 5; + private static final int AWTTEST_ROUNDRECT = 1 << 6; + private static final int AWTTEST_STRING = 1 << 7; + private static final int AWTTEST_TRANSPARENTIMAGE = 1 << 8; + private static final int AWTTEST_IMAGE = 1 << 9; + + private static final int AWTTEST_NONE = 0; + private static final int AWTTEST_ALL = AWTTEST_LINES + | AWTTEST_RECT + | AWTTEST_POLYLINE + | AWTTEST_POLYGON + | AWTTEST_ARC + | AWTTEST_OVAL + | AWTTEST_ROUNDRECT + | AWTTEST_STRING + | AWTTEST_TRANSPARENTIMAGE + | AWTTEST_IMAGE + ; + + int iterations = 1; + private int screenWidth = DEFAULT_SCREEN_WIDTH; + private int screenHeight = DEFAULT_SCREEN_HEIGHT; + boolean doubleBufferFlag = true; + private int awtTests = AWTTEST_ALL; + + private Label testLabel; + + private String testContext = ""; + + Logger logger = Logger.getLogger("AicasGraphicsBenchmark"); + + private Image pngTestImage; + private Image gifTestImage; + + private TestSet testSetMap = new TestSet(); + + public AicasGraphicsBenchmark() + { + pngTestImage = loadImage("../icons/aicas.png"); + gifTestImage = loadImage("../icons/palme.gif"); + + setLayout(new BorderLayout()); + testLabel = new Label(); + add(testLabel,BorderLayout.NORTH); + add(new GraphicsTest(),BorderLayout.CENTER); + } + + void setTestContext(String testName) + { + logger.logp(Level.INFO, "AicasGraphicsBenchmark", "recordTest", + "--- Starting new test context: " + testName); + testContext = testName; + testLabel.setText(testName); + } + + private void recordTest(String testName, long time) + { + logger.logp(Level.INFO, "AicasGraphicsBenchmark", "recordTest", + testContext + ": " + testName + " duration (ms): " + time); + TestRecorder recorder = testSetMap.getTest(testName); + if (recorder == null) + { + recorder = new TestRecorder(testName); + testSetMap.putTest(testName,recorder); + } + recorder.addRun(time); + } + + void printReport() + { + for (Iterator i = testSetMap.testIterator(); i.hasNext(); ) + { + TestRecorder recorder = testSetMap.getTest((String)i.next()); + System.out.println("TEST " + recorder.getTestName() + ": average " + + recorder.getAverage() + "ms [" + + recorder.getMinTime() + "-" + recorder.getMaxTime() + + "]"); + } + } + + public static void main(String[] args) + { + int awtTests; + int i; + boolean endOfOptionsFlag; + AicasGraphicsBenchmark speed= new AicasGraphicsBenchmark(); + + // Parse arguments. + i = 0; + endOfOptionsFlag = false; + awtTests = AWTTEST_NONE; + while (i < args.length) + { + if (!endOfOptionsFlag) + { + if (args[i].equals("--help") || args[i].equals("-help") + || args[i].equals("-h")) + { + System.out.println("Usage: AicasGraphicsBenchmark [] [ ...]"); + System.out.println(""); + System.out.println("Options: -i|--iterations= - number of iterations (-1 is infinite)"); + System.out.println(" -w|--width= - screen width; default "+DEFAULT_SCREEN_WIDTH); + System.out.println(" -h|--height= - 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; + } +} -- cgit v1.2.3