Quelle  NonFiniteTests.java

/*
 * 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);
        }
    }
}