| /* |
| * Copyright (c) 2006, 2018, 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 |
| * @bug 6409478 |
| * @summary Tests all hit testing methods of GeneralPath and Path2D |
| * for graceful (i.e. non-infinite-loop) returns when any |
| * of the path coordinates or test coordinates are |
| * NaN or Infinite or even very large numbers. |
| * @run main/timeout=15 NonFiniteTests |
| */ |
| |
| import java.awt.geom.GeneralPath; |
| import java.awt.geom.Path2D; |
| import java.awt.geom.PathIterator; |
| |
| public class NonFiniteTests { |
| public static final double DBL_NaN = Double.NaN; |
| public static final double DBL_POS_INF = Double.POSITIVE_INFINITY; |
| public static final double DBL_NEG_INF = Double.NEGATIVE_INFINITY; |
| public static final double DBL_MAX = Double.MAX_VALUE; |
| public static final double DBL_MIN = -Double.MAX_VALUE; |
| public static final double FLT_MAX = Float.MAX_VALUE; |
| public static final double FLT_MIN = -Float.MAX_VALUE; |
| |
| public static final int SEG_MOVETO = PathIterator.SEG_MOVETO; |
| public static final int SEG_LINETO = PathIterator.SEG_LINETO; |
| public static final int SEG_QUADTO = PathIterator.SEG_QUADTO; |
| public static final int SEG_CUBICTO = PathIterator.SEG_CUBICTO; |
| public static final int SEG_CLOSE = PathIterator.SEG_CLOSE; |
| |
| public static int types[] = { |
| SEG_MOVETO, |
| SEG_LINETO, |
| SEG_QUADTO, |
| SEG_CUBICTO, |
| SEG_CLOSE, |
| }; |
| |
| public static double coords[] = { |
| // SEG_MOVETO coords |
| 0.0, 0.0, |
| |
| // SEG_LINETO coords |
| 50.0, 10.0, |
| |
| // SEG_QUADTO coords |
| 100.0, 20.0, |
| 100.0, 100.0, |
| |
| // SEG_CUBICTO coords |
| 50.0, 150.0, |
| 0.0, 100.0, |
| -50.0, 50.0, |
| |
| // SEG_CLOSE coords |
| }; |
| |
| public static double testpoints[] = { |
| -100, -100, |
| 0, 0, |
| 50, 50, |
| DBL_NaN, DBL_NaN, |
| DBL_POS_INF, DBL_POS_INF, |
| DBL_NEG_INF, DBL_NEG_INF, |
| DBL_POS_INF, DBL_NEG_INF, |
| DBL_NEG_INF, DBL_POS_INF, |
| }; |
| |
| public static double testrects[] = { |
| -100, -100, 10, 10, |
| 0, 0, 10, 10, |
| 50, 50, 10, 10, |
| DBL_NaN, DBL_NaN, 10, 10, |
| 10, 10, DBL_NaN, DBL_NaN, |
| DBL_NaN, DBL_NaN, DBL_NaN, DBL_NaN, |
| 10, 10, DBL_POS_INF, DBL_POS_INF, |
| 10, 10, DBL_NEG_INF, DBL_NEG_INF, |
| 10, 10, DBL_POS_INF, DBL_NEG_INF, |
| 10, 10, DBL_NEG_INF, DBL_POS_INF, |
| DBL_NEG_INF, DBL_NEG_INF, DBL_POS_INF, DBL_POS_INF, |
| DBL_POS_INF, DBL_POS_INF, 10, 10, |
| DBL_NEG_INF, DBL_NEG_INF, 10, 10, |
| DBL_POS_INF, DBL_NEG_INF, 10, 10, |
| DBL_NEG_INF, DBL_POS_INF, 10, 10, |
| }; |
| |
| public static double replacecoords[] = { |
| DBL_NEG_INF, |
| DBL_MIN, |
| FLT_MIN, |
| DBL_NaN, |
| FLT_MAX, |
| DBL_MAX, |
| DBL_POS_INF, |
| }; |
| |
| public static void main(String argv[]) { |
| test(types, coords); |
| testNonFinites(types, coords, 2); |
| } |
| |
| public static void testNonFinites(int types[], double coords[], |
| int numvalues) |
| { |
| if (numvalues == 0) { |
| test(types, coords); |
| return; |
| } |
| numvalues--; |
| for (int i = 0; i < coords.length; i++) { |
| double savedval = coords[i]; |
| |
| //System.out.println("replacing coord #"+i); |
| for (int j = 0; j < replacecoords.length; j++) { |
| coords[i] = replacecoords[j]; |
| testNonFinites(types, coords, numvalues); |
| } |
| |
| coords[i] = savedval; |
| } |
| } |
| |
| public static void test(int types[], double coords[]) { |
| testGP(new GeneralPath(), types, coords); |
| try { |
| P2DTest.test(types, coords); |
| } catch (NoClassDefFoundError e) { |
| // Skip Path2D tests on older runtimes... |
| } |
| } |
| |
| public static void testGP(GeneralPath gp, int types[], double coords[]) { |
| int ci = 0; |
| for (int i = 0; i < types.length; i++) { |
| switch (types[i]) { |
| case SEG_MOVETO: |
| gp.moveTo((float) coords[ci++], (float) coords[ci++]); |
| break; |
| case SEG_LINETO: |
| gp.lineTo((float) coords[ci++], (float) coords[ci++]); |
| break; |
| case SEG_QUADTO: |
| gp.quadTo((float) coords[ci++], (float) coords[ci++], |
| (float) coords[ci++], (float) coords[ci++]); |
| break; |
| case SEG_CUBICTO: |
| gp.curveTo((float) coords[ci++], (float) coords[ci++], |
| (float) coords[ci++], (float) coords[ci++], |
| (float) coords[ci++], (float) coords[ci++]); |
| break; |
| case SEG_CLOSE: |
| gp.closePath(); |
| break; |
| } |
| } |
| testGP(gp); |
| } |
| |
| public static void testGP(GeneralPath gp) { |
| for (int i = 0; i < testpoints.length; i += 2) { |
| gp.contains(testpoints[i+0], testpoints[i+1]); |
| } |
| |
| for (int i = 0; i < testrects.length; i += 4) { |
| gp.contains(testrects[i+0], testrects[i+1], |
| testrects[i+2], testrects[i+3]); |
| gp.intersects(testrects[i+0], testrects[i+1], |
| testrects[i+2], testrects[i+3]); |
| } |
| } |
| |
| public static class P2DTest { |
| public static void test(int types[], double coords[]) { |
| testPath(new Path2D.Float(), types, coords); |
| testPath(new Path2D.Double(), types, coords); |
| } |
| |
| public static void testPath(Path2D p2d, int types[], double coords[]) { |
| int ci = 0; |
| for (int i = 0; i < types.length; i++) { |
| switch (types[i]) { |
| case SEG_MOVETO: |
| p2d.moveTo(coords[ci++], coords[ci++]); |
| break; |
| case SEG_LINETO: |
| p2d.lineTo(coords[ci++], coords[ci++]); |
| break; |
| case SEG_QUADTO: |
| p2d.quadTo(coords[ci++], coords[ci++], |
| coords[ci++], coords[ci++]); |
| break; |
| case SEG_CUBICTO: |
| p2d.curveTo(coords[ci++], coords[ci++], |
| coords[ci++], coords[ci++], |
| coords[ci++], coords[ci++]); |
| break; |
| case SEG_CLOSE: |
| p2d.closePath(); |
| break; |
| } |
| } |
| testPath(p2d); |
| } |
| |
| public static void testPath(Path2D p2d) { |
| // contains point |
| for (int i = 0; i < testpoints.length; i += 2) { |
| p2d.contains(testpoints[i+0], testpoints[i+1]); |
| contains(p2d, testpoints[i+0], testpoints[i+1]); |
| } |
| |
| for (int i = 0; i < testrects.length; i += 4) { |
| p2d.contains(testrects[i+0], testrects[i+1], |
| testrects[i+2], testrects[i+3]); |
| contains(p2d, |
| testrects[i+0], testrects[i+1], |
| testrects[i+2], testrects[i+3]); |
| p2d.intersects(testrects[i+0], testrects[i+1], |
| testrects[i+2], testrects[i+3]); |
| intersects(p2d, |
| testrects[i+0], testrects[i+1], |
| testrects[i+2], testrects[i+3]); |
| } |
| } |
| |
| public static boolean contains(Path2D p2d, double x, double y) { |
| return Path2D.contains(p2d.getPathIterator(null), x, y); |
| } |
| |
| public static boolean contains(Path2D p2d, |
| double x, double y, double w, double h) |
| { |
| return Path2D.contains(p2d.getPathIterator(null), x, y, w, h); |
| } |
| |
| public static boolean intersects(Path2D p2d, |
| double x, double y, double w, double h) |
| { |
| return Path2D.intersects(p2d.getPathIterator(null), x, y, w, h); |
| } |
| } |
| } |