8290973: In AffineTransform, equals(Object) is inconsistent with hashCode()

Reviewed-by: prr

Author: desruisseaux

src/java.desktop/share/classes/java/awt/geom/AffineTransform.java

@@ -3902,15 +3902,25 @@ public Object clone() {
      * @since 1.2
      */
     public int hashCode() {
-        long bits = Double.doubleToLongBits(m00);
-        bits = bits * 31 + Double.doubleToLongBits(m01);
-        bits = bits * 31 + Double.doubleToLongBits(m02);
-        bits = bits * 31 + Double.doubleToLongBits(m10);
-        bits = bits * 31 + Double.doubleToLongBits(m11);
-        bits = bits * 31 + Double.doubleToLongBits(m12);
+        long bits = hash(m00);
+        bits = bits * 31 + hash(m01);
+        bits = bits * 31 + hash(m02);
+        bits = bits * 31 + hash(m10);
+        bits = bits * 31 + hash(m11);
+        bits = bits * 31 + hash(m12);
         return (((int) bits) ^ ((int) (bits >> 32)));
     }
 
+    /**
+     * Returns a hash code for the given value, with negative zero
+     * collapsed to the single positive zero.
+     */
+    private static long hash(double m) {
+        long h = Double.doubleToLongBits(m);
+        if (h == 0x8000000000000000L) h = 0;    // Replace -0 by +0.
+        return h;
+    }
+
     /**
      * Returns {@code true} if this {@code AffineTransform}
      * represents the same affine coordinate transform as the specified
@@ -3928,8 +3938,17 @@ public boolean equals(Object obj) {
 
         AffineTransform a = (AffineTransform)obj;
 
-        return ((m00 == a.m00) && (m01 == a.m01) && (m02 == a.m02) &&
-                (m10 == a.m10) && (m11 == a.m11) && (m12 == a.m12));
+        return equals(m00, a.m00) && equals(m01, a.m01) &&
+               equals(m02, a.m02) && equals(m10, a.m10) &&
+               equals(m11, a.m11) && equals(m12, a.m12);
+    }
+
+    /**
+     * Compares the given floating point values, with negative zero
+     * considered equals to positive zero.
+     */
+    private static boolean equals(double a, double b) {
+        return (a == b) || (Double.isNaN(a) && Double.isNaN(b));
     }
 
     /* Serialization support.  A readObject method is neccessary because

test/jdk/java/awt/geom/AffineTransform/EqualsAndHashCode.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2022, 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
+ * @summary Tests that equals(Object) is consistent with hashCode(),
+ *          in particular regarding negative versus positive zeros and
+ *          NaN values.
+ */
+
+import java.awt.geom.AffineTransform;
+
+public class EqualsAndHashCode {
+    private static boolean failed;
+
+    public static void main(String arg[]) {
+        checkReflexiveEquals();
+        checkZeros();
+        checkNotEqual();
+        if (failed) {
+            throw new RuntimeException("Some tests failed.");
+        }
+    }
+
+    private static void checkReflexiveEquals() {
+        AffineTransform t = new AffineTransform(1, 0, 0, 1, Double.NaN, 0);
+        if (!t.equals(t)) {
+            System.err.println("Transform should be equal to itself.");
+            failed = true;
+        }
+        if (!t.equals(t.clone())) {
+            System.err.println("Transform should be equal to its clone.");
+            failed = true;
+        }
+    }
+
+    private static void checkZeros() {
+        AffineTransform positive = new AffineTransform(2, 0, 0, 3, 0, +0.0);
+        AffineTransform negative = new AffineTransform(2, 0, 0, 3, 0, -0.0);
+        if (!positive.equals(negative)) {
+            System.err.println("Transforms should be equal despite the sign difference in zero values.");
+            failed = true;
+        } else if (positive.hashCode() != negative.hashCode()) {
+            System.err.println("Equal transforms should have the same hash code value.");
+            failed = true;
+        }
+    }
+
+    private static void checkNotEqual() {
+        AffineTransform t1 = new AffineTransform(2, 0, 0, 3, 2, 0);
+        AffineTransform t2 = new AffineTransform(2, 0, 0, 3, 2, 4);
+        if (t1.equals(t2)) {
+            System.err.println("Expected non-equal transforms.");
+            failed = true;
+        }
+        if (t1.hashCode() == t2.hashCode()) {
+            System.err.println("Expected different hash codes.");
+            failed = true;
+        }
+    }
+}