test/jdk/java/awt/geom/EqualsHashcode.java

/*
 * Copyright (c) 2005, 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 6210287
 * @summary Verifies that the various utility shapes implement
 *          the equals(Object) and hashCode methods adequately
 */

import java.awt.geom.Arc2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.util.Vector;

public class EqualsHashcode {
    public static final int NUMTESTS = 1000;

    public static void main(String argv[]) {
        new FloatRectangleTester().test();
        new DoubleRectangleTester().test();

        new FloatEllipseTester().test();
        new DoubleEllipseTester().test();

        new FloatArcTester().test();
        new DoubleArcTester().test();

        new FloatRoundRectTester().test();
        new DoubleRoundRectTester().test();
    }

    /**
     * Base utility class for random parameters for testing
     */
    public static abstract class Val {
        protected String name;

        protected Val(String name) {
            this.name = name;
        }

        public abstract Object save();
        public abstract void restore(Object save);

        public abstract void randomize();
        public abstract void perturb();
    }

    /**
     * Base subclass for parameters with "special" values (Infinity, NaN, etc.)
     */
    public static abstract class SpecialVal extends Val {
        protected SpecialVal(String name) {
            super(name);
        }

        public abstract void setSpecial();

        public abstract boolean isNaN();
    }

    /**
     * Floating point parameter
     */
    public static class FloatVal extends SpecialVal {
        private float v;

        public FloatVal(String name) {
            super(name);
        }

        public float getVal() {
            return v;
        }

        public String toString() {
            return name+" = "+v+" (flt)";
        }

        public Object save() {
            return new Float(v);
        }

        public void restore(Object o) {
            v = ((Float) o).floatValue();
        }

        public void randomize() {
            v = (float) (Math.random() * 100);
        }

        public void perturb() {
            v = v + 1;
        }

        public boolean hasSpecialCases() {
            return true;
        }

        public void setSpecial() {
            switch ((int) (Math.random() * 3)) {
            case 0:
                v = Float.NaN;
                break;
            case 1:
                v = Float.POSITIVE_INFINITY;
                break;
            case 2:
                v = Float.NEGATIVE_INFINITY;
                break;
            default:
                throw new InternalError();
            }
        }

        public boolean isNaN() {
            return (v != v);
        }
    }

    /**
     * Double precision parameter
     */
    public static class DoubleVal extends SpecialVal {
        private double v;

        public DoubleVal(String name) {
            super(name);
        }

        public double getVal() {
            return v;
        }

        public String toString() {
            return name+" = "+v+" (dbl)";
        }

        public Object save() {
            return new Double(v);
        }

        public void restore(Object o) {
            v = ((Double) o).doubleValue();
        }

        public void randomize() {
            v = Math.random() * 100;
        }

        public void perturb() {
            v = v + 1;
        }

        public boolean hasSpecialCases() {
            return true;
        }

        public void setSpecial() {
            switch ((int) (Math.random() * 3)) {
            case 0:
                v = Double.NaN;
                break;
            case 1:
                v = Double.POSITIVE_INFINITY;
                break;
            case 2:
                v = Double.NEGATIVE_INFINITY;
                break;
            default:
                throw new InternalError();
            }
        }

        public boolean isNaN() {
            return (v != v);
        }
    }

    /**
     * Integer value with a specified min/max range.
     */
    public static class IntRangeVal extends Val {
        public int v;
        public int min;
        public int max;

        public IntRangeVal(String name, int min, int max) {
            super(name);
            this.min = min;
            this.max = max;
        }

        public int getVal() {
            return v;
        }

        public String toString() {
            return name+" = "+v;
        }

        public Object save() {
            return new Integer(v);
        }

        public void restore(Object o) {
            v = ((Integer) o).intValue();
        }

        public void randomize() {
            v = min + (int) (Math.random() * (max-min+1));
        }

        public void perturb() {
            v = v + 1;
            if (v > max) {
                v = min;
            }
        }
    }

    /**
     * Base class for testing a given type of shape.
     * Subclasses must register all of their "parameters" which
     * need to be randomized, specialized, and perturbed for
     * testing.
     * Subclasses must also implement makeShape() which makes
     * a new shape object according to the current values of
     * all of their parameters.
     */
    public static abstract class ShapeTester {
        public Vector params = new Vector();

        public void addParam(Val v) {
            params.add(v);
        }

        public Val[] getParamArray() {
            Val ret[] = new Val[params.size()];
            for (int i = 0; i < params.size(); i++) {
                ret[i] = (Val) params.get(i);
            }
            return ret;
        }

        public void error(String desc) {
            Val params[] = getParamArray();
            for (int j = 0; j < params.length; j++) {
                System.err.println(params[j]);
            }
            throw new RuntimeException(desc);
        }

        public abstract Object makeShape();

        public void test() {
            Val params[] = getParamArray();
            for (int i = 0; i < NUMTESTS; i++) {
                // First, randomize all parameters
                for (int j = 0; j < params.length; j++) {
                    params[j].randomize();
                }

                // Now make 2 copies from the same params and verify equals()
                Object o1 = makeShape();
                if (!o1.equals(o1)) {
                    error("Shapes not equal to itself!");
                }
                Object o2 = makeShape();
                if (!o1.equals(o2)) {
                    error("Identical shapes not equal!");
                }
                if (o1.hashCode() != o2.hashCode()) {
                    error("Identical hashes not equal!");
                }

                // Now perturb the params 1 by 1 and verify !equals()
                for (int j = 0; j < params.length; j++) {
                    Val param = params[j];
                    Object save = param.save();

                    param.perturb();
                    Object o3 = makeShape();
                    if (o1.equals(o3)) {
                        error("Perturbed shape still equal!");
                    }

                    // If param has "special values", test them as well
                    if (param instanceof SpecialVal) {
                        SpecialVal sparam = (SpecialVal) param;
                        sparam.setSpecial();
                        Object o4 = makeShape();
                        if (o1.equals(o4)) {
                            error("Specialized shape still equal!");
                        }
                        Object o5 = makeShape();
                        // objects equal iff param is not a NaN
                        if (o4.equals(o5) == sparam.isNaN()) {
                            error("Identical specialized shapes not equal!");
                        }
                        // hash codes always equal, even if NaN
                        // (Note: equals()/hashCode() contract allows this)
                        if (o4.hashCode() != o5.hashCode()) {
                            error("Identical specialized hashes not equal!");
                        }
                    }

                    // Restore original value of param and make sure
                    param.restore(save);
                    Object o6 = makeShape();
                    if (!o1.equals(o6)) {
                        error("Restored shape not equal!");
                    }
                    if (o1.hashCode() != o6.hashCode()) {
                        error("Restored hash not equal!");
                    }
                }
            }
        }
    }

    /**
     * Base tester class for objects with floating point xywh bounds
     */
    public static abstract class FloatBoundedShape extends ShapeTester {
        public FloatVal x = new FloatVal("x");
        public FloatVal y = new FloatVal("y");
        public FloatVal w = new FloatVal("w");
        public FloatVal h = new FloatVal("h");

        public FloatBoundedShape() {
            addParam(x);
            addParam(y);
            addParam(w);
            addParam(h);
        }
    }

    /**
     * Base tester class for objects with double precision xywh bounds
     */
    public static abstract class DoubleBoundedShape extends ShapeTester {
        public DoubleVal x = new DoubleVal("x");
        public DoubleVal y = new DoubleVal("y");
        public DoubleVal w = new DoubleVal("w");
        public DoubleVal h = new DoubleVal("h");

        public DoubleBoundedShape() {
            addParam(x);
            addParam(y);
            addParam(w);
            addParam(h);
        }
    }

    public static class FloatRectangleTester extends FloatBoundedShape {
        public Object makeShape() {
            return new Rectangle2D.Float(x.getVal(), y.getVal(),
                                         w.getVal(), h.getVal());
        }
    }

    public static class DoubleRectangleTester extends DoubleBoundedShape {
        public Object makeShape() {
            return new Rectangle2D.Double(x.getVal(), y.getVal(),
                                          w.getVal(), h.getVal());
        }
    }

    public static class FloatEllipseTester extends FloatBoundedShape {
        public Object makeShape() {
            return new Ellipse2D.Float(x.getVal(), y.getVal(),
                                       w.getVal(), h.getVal());
        }
    }

    public static class DoubleEllipseTester extends DoubleBoundedShape {
        public Object makeShape() {
            return new Ellipse2D.Double(x.getVal(), y.getVal(),
                                        w.getVal(), h.getVal());
        }
    }

    public static class FloatArcTester extends FloatBoundedShape {
        public FloatVal start = new FloatVal("start");
        public FloatVal extent = new FloatVal("extent");
        public IntRangeVal type = new IntRangeVal("type", 0, 2);

        public FloatArcTester() {
            addParam(start);
            addParam(extent);
            addParam(type);
        }

        public Object makeShape() {
            return new Arc2D.Float(x.getVal(), y.getVal(),
                                   w.getVal(), h.getVal(),
                                   start.getVal(), extent.getVal(),
                                   type.getVal());
        }
    }

    public static class DoubleArcTester extends DoubleBoundedShape {
        public DoubleVal start = new DoubleVal("start");
        public DoubleVal extent = new DoubleVal("extent");
        public IntRangeVal type = new IntRangeVal("type", 0, 2);

        public DoubleArcTester() {
            addParam(start);
            addParam(extent);
            addParam(type);
        }

        public Object makeShape() {
            return new Arc2D.Double(x.getVal(), y.getVal(),
                                    w.getVal(), h.getVal(),
                                    start.getVal(), extent.getVal(),
                                    type.getVal());
        }
    }

    public static class FloatRoundRectTester extends FloatBoundedShape {
        public FloatVal arcw = new FloatVal("arcw");
        public FloatVal arch = new FloatVal("arch");

        public FloatRoundRectTester() {
            addParam(arcw);
            addParam(arch);
        }

        public Object makeShape() {
            return new RoundRectangle2D.Float(x.getVal(), y.getVal(),
                                              w.getVal(), h.getVal(),
                                              arcw.getVal(), arch.getVal());
        }
    }

    public static class DoubleRoundRectTester extends DoubleBoundedShape {
        public DoubleVal arcw = new DoubleVal("arcw");
        public DoubleVal arch = new DoubleVal("arch");

        public DoubleRoundRectTester() {
            addParam(arcw);
            addParam(arch);
        }

        public Object makeShape() {
            return new RoundRectangle2D.Double(x.getVal(), y.getVal(),
                                               w.getVal(), h.getVal(),
                                               arcw.getVal(), arch.getVal());
        }
    }
}