undefect. CWE-407 — 63 sites patched across 27 ecosystems
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com Patches, unit tests, benchmarks, whitepaper, and outreach briefs. Public domain — no copyright claimed. Use freely.
This commit is contained in:
commit
0a580b313d
70422 changed files with 17213626 additions and 0 deletions
505
test/jdk/java/awt/Graphics/LineClipTest.java
Normal file
505
test/jdk/java/awt/Graphics/LineClipTest.java
Normal file
|
|
@ -0,0 +1,505 @@
|
|||
/*
|
||||
* Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code 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
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @test
|
||||
* @key headful
|
||||
* @bug 4780022 4862193 7179526
|
||||
* @summary Tests that clipped lines are drawn over the same pixels
|
||||
* as unclipped lines (within the clip bounds)
|
||||
* @run main/timeout=600/othervm -Dsun.java2d.ddforcevram=true LineClipTest
|
||||
* @run main/timeout=600/othervm LineClipTest
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* This app tests whether we are drawing clipped lines the same
|
||||
* as unclipped lines. The problem occurred when we started
|
||||
* clipping d3d lines using simple integer clipping, which did not
|
||||
* account for sub-pixel precision and ended up drawing very different
|
||||
* pixels than the same line drawn unclipped. A supposed fix
|
||||
* to that problem used floating-point clipping instead, but there
|
||||
* was some problem with very limited precision inside of d3d
|
||||
* (presumably in hardware) that caused some variation in pixels.
|
||||
* We decided that whatever the fix was, we needed a serious
|
||||
* line check test to make sure that all kinds of different
|
||||
* lines would be drawn exactly the same inside the clip area,
|
||||
* regardless of whether clipping was enabled. This test should
|
||||
* check all kinds of different cases, such as lines that fall
|
||||
* completely outside, completely inside, start outside and
|
||||
* end inside, etc., and lines should end and originate in
|
||||
* all quadrants of the space divided up by the clip box.
|
||||
*
|
||||
* The test works as follows:
|
||||
* We create nine quadrants using the spaces bisected by the
|
||||
* edges of the clip bounds (note that only one of these
|
||||
* quadrants is actually visible when clipping is enabled).
|
||||
* We create several points in each of these quadrants
|
||||
* (three in each of the invisible quadrants, nine in the
|
||||
* center/visible quadrant). Our resulting grid looks like
|
||||
* this:
|
||||
*
|
||||
* x x|x x x|x x
|
||||
* | |
|
||||
* | |
|
||||
* | |
|
||||
* | |
|
||||
* | |
|
||||
* x | | x
|
||||
* -----------------------------------
|
||||
* x |x x x| x
|
||||
* | |
|
||||
* | |
|
||||
* x |x x x| x
|
||||
* | |
|
||||
* | |
|
||||
* x |x x x| x
|
||||
* -----------------------------------
|
||||
* x | | x
|
||||
* | |
|
||||
* | |
|
||||
* | |
|
||||
* | |
|
||||
* | |
|
||||
* x x|x x x|x x
|
||||
*
|
||||
* The test then draws lines from every point to every other
|
||||
* point. First, we draw unclipped lines in blue and
|
||||
* then we draw clipped lines in red.
|
||||
* At certain times (after every point during the default
|
||||
* test, after every quadrant of lines if you run with the -quick
|
||||
* option), we check for errors and draw the current image
|
||||
* to the screen. Error checking consists of copying the
|
||||
* VolatileImage to a BufferedImage (because we need access
|
||||
* to the pixels directly) and checking every pixel in the
|
||||
* image. The check is simple: everything outside the
|
||||
* clip bounds should be blue (or the background color) and
|
||||
* everything inside the clip bounds should be red (or the
|
||||
* background color). So any blue pixel inside or red
|
||||
* pixel outside means that there was a drawing error and
|
||||
* the test fails.
|
||||
* There are 4 modes that the test can run in (dynamic mode is
|
||||
* exclusive to the other modes, but the other modes are combinable):
|
||||
*
|
||||
* (default): the clip is set
|
||||
* to a default size (100x100) and the test is run.
|
||||
*
|
||||
* -quick: The error
|
||||
* check is run only after every quadrant of lines is
|
||||
* drawn. This speeds up the test considerably with
|
||||
* some less accuracy in error checking (because pixels
|
||||
* from some lines may overdrawn pixels from other lines
|
||||
* before we have verified the correctness of those
|
||||
* pixels).
|
||||
*
|
||||
* -dynamic: There is no error checking, but this version
|
||||
* of the test automatically resizes the clip bounds and
|
||||
* reruns the test over and over. Nothing besides the
|
||||
* visual check verifies that the test is running correctly.
|
||||
*
|
||||
* -rect: Instead of drawing lines, the test draws rectangles
|
||||
* to/from all points in all quadrants. This tests similar
|
||||
* clipping functionality for drawRect().
|
||||
*
|
||||
* n (where "n" is a number): sets the clip size to the
|
||||
* given value. Just like the default test except that
|
||||
* the clip size is as specified.
|
||||
*
|
||||
* Note: this test must be run with the -Dsun.java2d.ddforcevram=true
|
||||
* option to force the test image to stay in VRAM. We currently
|
||||
* punt VRAM images to system memory when we detect lots of
|
||||
* reads. Since we read the whole buffer on every error check
|
||||
* to copy it to the BufferedImage), this causes us to punt the
|
||||
* buffer. A system memory surface will have no d3d capabilities,
|
||||
* thus we are not testing the d3d line quality when this happens.
|
||||
* By using the ddforcevram flag, we make sure the buffer
|
||||
* stays put in VRAM and d3d is used to draw the lines.
|
||||
*/
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
|
||||
|
||||
public class LineClipTest extends Component implements Runnable {
|
||||
|
||||
int clipBumpVal = 5;
|
||||
static int clipSize = 100;
|
||||
int clipX1;
|
||||
int clipY1;
|
||||
static final int NUM_QUADS = 9;
|
||||
Point quadrants[][] = new Point[NUM_QUADS][];
|
||||
static boolean dynamic = false;
|
||||
BufferedImage imageChecker = null;
|
||||
Color unclippedColor = Color.blue;
|
||||
Color clippedColor = Color.red;
|
||||
int testW = -1, testH = -1;
|
||||
VolatileImage testImage = null;
|
||||
static boolean keepRunning = false;
|
||||
static boolean quickTest = false;
|
||||
static boolean rectTest = false;
|
||||
static boolean runTestDone = false;
|
||||
static Frame f = null;
|
||||
|
||||
/**
|
||||
* Check for errors in the grid. This error check consists of
|
||||
* copying the buffer into a BufferedImage and reading all pixels
|
||||
* in that image. No pixel outside the clip bounds should be
|
||||
* of the color clippedColor and no pixel inside should be
|
||||
* of the color unclippedColor. Any wrong color returns an error.
|
||||
*/
|
||||
boolean gridError(Graphics g) {
|
||||
boolean error = false;
|
||||
if (imageChecker == null || (imageChecker.getWidth() != testW) ||
|
||||
(imageChecker.getHeight() != testH))
|
||||
{
|
||||
// Recreate BufferedImage as necessary
|
||||
GraphicsConfiguration gc = getGraphicsConfiguration();
|
||||
ColorModel cm = gc.getColorModel();
|
||||
WritableRaster wr =
|
||||
cm.createCompatibleWritableRaster(getWidth(), getHeight());
|
||||
imageChecker =
|
||||
new BufferedImage(cm, wr,
|
||||
cm.isAlphaPremultiplied(), null);
|
||||
}
|
||||
// Copy buffer to BufferedImage
|
||||
Graphics gChecker = imageChecker.getGraphics();
|
||||
gChecker.drawImage(testImage, 0, 0, this);
|
||||
|
||||
// Set up pixel colors to check against
|
||||
int clippedPixelColor = clippedColor.getRGB();
|
||||
int unclippedPixelColor = unclippedColor.getRGB();
|
||||
int wrongPixelColor = clippedPixelColor;
|
||||
boolean insideClip = false;
|
||||
for (int row = 0; row < getHeight(); ++row) {
|
||||
for (int col = 0; col < getWidth(); ++col) {
|
||||
if (row >= clipY1 && row < (clipY1 + clipSize) &&
|
||||
col >= clipX1 && col < (clipX1 + clipSize))
|
||||
{
|
||||
// Inside clip bounds - should not see unclipped color
|
||||
wrongPixelColor = unclippedPixelColor;
|
||||
} else {
|
||||
// Outside clip - should not see clipped color
|
||||
wrongPixelColor = clippedPixelColor;
|
||||
}
|
||||
int pixel = imageChecker.getRGB(col, row);
|
||||
if (pixel == wrongPixelColor) {
|
||||
System.out.println("FAILED: pixel = " +
|
||||
Integer.toHexString(pixel) +
|
||||
" at (x, y) = " + col + ", " + row);
|
||||
// Draw magenta rectangle around problem pixel in buffer
|
||||
// for visual feedback to user
|
||||
g.setColor(Color.magenta);
|
||||
g.drawRect(col - 1, row - 1, 2, 2);
|
||||
error = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw all test lines and check for errors (unless running
|
||||
* with -dynamic option)
|
||||
*/
|
||||
void drawLineGrid(Graphics screenGraphics, Graphics g) {
|
||||
// Fill buffer with background color
|
||||
g.setColor(Color.white);
|
||||
g.fillRect(0, 0, getWidth(), getHeight());
|
||||
|
||||
// Now, iterate through all quadrants
|
||||
for (int srcQuad = 0; srcQuad < NUM_QUADS; ++srcQuad) {
|
||||
// Draw lines to all other quadrants
|
||||
for (int dstQuad = 0; dstQuad < NUM_QUADS; ++dstQuad) {
|
||||
for (int srcPoint = 0;
|
||||
srcPoint < quadrants[srcQuad].length;
|
||||
++srcPoint)
|
||||
{
|
||||
// For every point in the source quadrant
|
||||
int sx = quadrants[srcQuad][srcPoint].x;
|
||||
int sy = quadrants[srcQuad][srcPoint].y;
|
||||
for (int dstPoint = 0;
|
||||
dstPoint < quadrants[dstQuad].length;
|
||||
++dstPoint)
|
||||
{
|
||||
int dx = quadrants[dstQuad][dstPoint].x;
|
||||
int dy = quadrants[dstQuad][dstPoint].y;
|
||||
if (!rectTest) {
|
||||
// Draw unclipped/clipped lines to every
|
||||
// point in the dst quadrant
|
||||
g.setColor(unclippedColor);
|
||||
g.drawLine(sx, sy, dx, dy);
|
||||
g.setClip(clipX1, clipY1, clipSize, clipSize);
|
||||
g.setColor(clippedColor);
|
||||
g.drawLine(sx,sy, dx, dy);
|
||||
} else {
|
||||
// Draw unclipped/clipped rectangles to every
|
||||
// point in the dst quadrant
|
||||
g.setColor(unclippedColor);
|
||||
int w = dx - sx;
|
||||
int h = dy - sy;
|
||||
g.drawRect(sx, sy, w, h);
|
||||
g.setClip(clipX1, clipY1, clipSize, clipSize);
|
||||
g.setColor(clippedColor);
|
||||
g.drawRect(sx, sy, w, h);
|
||||
}
|
||||
g.setClip(null);
|
||||
}
|
||||
if (!dynamic) {
|
||||
// Draw screen update for visual feedback
|
||||
screenGraphics.drawImage(testImage, 0, 0, this);
|
||||
// On default test, check for errors after every
|
||||
// src point
|
||||
if (!quickTest && gridError(g)) {
|
||||
throw new java.lang.RuntimeException("Failed");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!dynamic && quickTest && gridError(g)) {
|
||||
// On quick test, check for errors only after every
|
||||
// src quadrant
|
||||
throw new java.lang.RuntimeException("Failed");
|
||||
//return;
|
||||
}
|
||||
}
|
||||
if (!dynamic) {
|
||||
System.out.println("PASSED");
|
||||
if (!keepRunning) {
|
||||
f.dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* If we have not yet run the test, or if the window size has
|
||||
* changed, or if we are running the test in -dynamic mode,
|
||||
* run the test. Then draw the test buffer to the screen
|
||||
*/
|
||||
public void paint(Graphics g) {
|
||||
if (dynamic || testImage == null ||
|
||||
getWidth() != testW || getHeight() != testH)
|
||||
{
|
||||
runTest(g);
|
||||
}
|
||||
if (testImage != null) {
|
||||
g.drawImage(testImage, 0, 0, this);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Create the quadrant of points and run the test to draw all the lines
|
||||
*/
|
||||
public void runTest(Graphics screenGraphics) {
|
||||
if (getWidth() == 0 || getHeight() == 0) {
|
||||
// May get here before window is really ready
|
||||
return;
|
||||
}
|
||||
clipX1 = (getWidth() - clipSize) / 2;
|
||||
clipY1 = (getHeight() - clipSize) / 2;
|
||||
int clipX2 = clipX1 + clipSize;
|
||||
int clipY2 = clipY1 + clipSize;
|
||||
int centerX = getWidth()/2;
|
||||
int centerY = getHeight()/2;
|
||||
int leftX = 0;
|
||||
int topY = 0;
|
||||
int rightX = getWidth() - 1;
|
||||
int bottomY = getHeight() - 1;
|
||||
int quadIndex = 0;
|
||||
// Offsets are used to force diagonal (versus hor/vert) lines
|
||||
int xOffset = 0;
|
||||
int yOffset = 0;
|
||||
|
||||
if (quadrants[0] == null) {
|
||||
for (int i = 0; i < 9; ++i) {
|
||||
int numPoints = (i == 4) ? 9 : 3;
|
||||
quadrants[i] = new Point[numPoints];
|
||||
}
|
||||
}
|
||||
// Upper-left
|
||||
quadrants[quadIndex] = new Point[] {
|
||||
new Point(leftX + xOffset, clipY1 - 1 - yOffset),
|
||||
new Point(leftX + xOffset, topY + yOffset),
|
||||
new Point(clipX1 - 1 - xOffset, topY + yOffset),
|
||||
};
|
||||
|
||||
quadIndex++;
|
||||
yOffset++;
|
||||
// Upper-middle
|
||||
quadrants[quadIndex] = new Point[] {
|
||||
new Point(clipX1 + 1 + xOffset, topY + yOffset),
|
||||
new Point(centerX + xOffset, topY + yOffset),
|
||||
new Point(clipX2 - 1 - xOffset, topY + yOffset),
|
||||
};
|
||||
|
||||
quadIndex++;
|
||||
++yOffset;
|
||||
// Upper-right
|
||||
quadrants[quadIndex] = new Point[] {
|
||||
new Point(clipX2 + 1 + xOffset, topY + yOffset),
|
||||
new Point(rightX - xOffset, topY + yOffset),
|
||||
new Point(rightX - xOffset, clipY1 - 1 - yOffset),
|
||||
};
|
||||
|
||||
quadIndex++;
|
||||
yOffset = 0;
|
||||
++xOffset;
|
||||
// Middle-left
|
||||
quadrants[quadIndex] = new Point[] {
|
||||
new Point(leftX + xOffset, clipY1 + 1 + yOffset),
|
||||
new Point(leftX + xOffset, centerY + yOffset),
|
||||
new Point(leftX + xOffset, clipY2 - 1 - yOffset),
|
||||
};
|
||||
|
||||
quadIndex++;
|
||||
++yOffset;
|
||||
// Middle-middle
|
||||
quadrants[quadIndex] = new Point[] {
|
||||
new Point(clipX1 + 1 + xOffset, clipY1 + 1 + yOffset),
|
||||
new Point(centerX + xOffset, clipY1 + 1 + yOffset),
|
||||
new Point(clipX2 - 1 - xOffset, clipY1 + 1 + yOffset),
|
||||
new Point(clipX1 + 1 + xOffset, centerY + yOffset),
|
||||
new Point(centerX + xOffset, centerY + yOffset),
|
||||
new Point(clipX2 - 1 - xOffset, centerY + yOffset),
|
||||
new Point(clipX1 + 1 + xOffset, clipY2 - 1 - yOffset),
|
||||
new Point(centerX + xOffset, clipY2 - 1 - yOffset),
|
||||
new Point(clipX2 - 1 - xOffset, clipY2 - 1 - yOffset),
|
||||
};
|
||||
|
||||
quadIndex++;
|
||||
++yOffset;
|
||||
// Middle-right
|
||||
quadrants[quadIndex] = new Point[] {
|
||||
new Point(rightX - xOffset, clipY1 + 1 + yOffset),
|
||||
new Point(rightX - xOffset, centerY + yOffset),
|
||||
new Point(rightX - xOffset, clipY2 - 1 - yOffset),
|
||||
};
|
||||
|
||||
quadIndex++;
|
||||
yOffset = 0;
|
||||
++xOffset;
|
||||
// Lower-left
|
||||
quadrants[quadIndex] = new Point[] {
|
||||
new Point(leftX + xOffset, clipY2 + 1 + yOffset),
|
||||
new Point(leftX + xOffset, bottomY - yOffset),
|
||||
new Point(clipX1 - 1 - xOffset, bottomY - yOffset),
|
||||
};
|
||||
|
||||
quadIndex++;
|
||||
++yOffset;
|
||||
// Lower-middle
|
||||
quadrants[quadIndex] = new Point[] {
|
||||
new Point(clipX1 + 1 + xOffset, bottomY - yOffset),
|
||||
new Point(centerX + xOffset, bottomY - yOffset),
|
||||
new Point(clipX2 - 1 - xOffset, bottomY - yOffset),
|
||||
};
|
||||
|
||||
quadIndex++;
|
||||
++yOffset;
|
||||
// Lower-right
|
||||
quadrants[quadIndex] = new Point[] {
|
||||
new Point(clipX2 + 1 + xOffset, bottomY - yOffset),
|
||||
new Point(rightX - xOffset, bottomY - yOffset),
|
||||
new Point(rightX - xOffset, clipY2 + 1 + yOffset),
|
||||
};
|
||||
|
||||
|
||||
if (testImage != null) {
|
||||
testImage.flush();
|
||||
}
|
||||
testW = getWidth();
|
||||
testH = getHeight();
|
||||
testImage = createVolatileImage(testW, testH);
|
||||
Graphics g = testImage.getGraphics();
|
||||
do {
|
||||
int valCode = testImage.validate(getGraphicsConfiguration());
|
||||
if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
|
||||
testImage.flush();
|
||||
testImage = createVolatileImage(testW, testH);
|
||||
g = testImage.getGraphics();
|
||||
}
|
||||
drawLineGrid(screenGraphics, g);
|
||||
} while (testImage.contentsLost());
|
||||
if (dynamic) {
|
||||
// Draw clip box if dynamic
|
||||
g.setClip(null);
|
||||
g.setColor(Color.black);
|
||||
g.drawRect(clipX1, clipY1, clipSize, clipSize);
|
||||
screenGraphics.drawImage(testImage, 0, 0, this);
|
||||
}
|
||||
runTestDone = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* When running -dynamic, resize the clip bounds and run the test
|
||||
* over and over
|
||||
*/
|
||||
public void run() {
|
||||
while (true) {
|
||||
clipSize += clipBumpVal;
|
||||
if (clipSize > getWidth() || clipSize < 0) {
|
||||
clipBumpVal = -clipBumpVal;
|
||||
clipSize += clipBumpVal;
|
||||
}
|
||||
update(getGraphics());
|
||||
try {
|
||||
Thread.sleep(50);
|
||||
} catch (Exception e) {}
|
||||
}
|
||||
}
|
||||
|
||||
public static void main(String args[]) {
|
||||
for (int i = 0; i < args.length; ++i) {
|
||||
if (args[i].equals("-dynamic")) {
|
||||
dynamic = true;
|
||||
} else if (args[i].equals("-rect")) {
|
||||
rectTest = true;
|
||||
} else if (args[i].equals("-quick")) {
|
||||
quickTest = true;
|
||||
} else if (args[i].equals("-keep")) {
|
||||
keepRunning = true;
|
||||
} else {
|
||||
// could be clipSize
|
||||
try {
|
||||
clipSize = Integer.parseInt(args[i]);
|
||||
} catch (Exception e) {}
|
||||
}
|
||||
}
|
||||
f = new Frame();
|
||||
f.setSize(500, 500);
|
||||
LineClipTest test = new LineClipTest();
|
||||
f.add(test);
|
||||
if (dynamic) {
|
||||
Thread t = new Thread(test);
|
||||
t.start();
|
||||
}
|
||||
f.setVisible(true);
|
||||
while (!runTestDone) {
|
||||
// need to make sure jtreg doesn't exit before the
|
||||
// test is done...
|
||||
try {
|
||||
Thread.sleep(50);
|
||||
} catch (Exception e) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue