Skip to content

[J2Objc] Use ObjC-compatible integer hash code for better interoperability. #2798

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
copybara-service wants to merge 1 commit into
base: master
Choose a base branch
from
Open

[J2Objc] Use ObjC-compatible integer hash code for better interoperability. #2798

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 8 additions & 0 deletions jre_emul/Classes/com/google/j2objc/util/ReflectionUtil.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -66,4 +66,12 @@ public static boolean isJreReflectionStripped() {
// For more details about this behavior see {@link #matchClassNamePrefix}.
return Boolean.TRUE.getClass().getName().equals("JavaLangBoolean");
}

/**
* Checks if the given object is a NSNumber originating from ObjC by checking that it doesn't have
* class metadata. We use this for cross-language equality support, primarily for hashtable keys.
*/
public static native boolean isObjCNumber(Object obj) /*-[
return [obj isKindOfClass:[NSNumber class]] && [[obj java_getClass] getMetadata] == NULL;
]-*/;
}
10 changes: 5 additions & 5 deletions ...form/libcore/harmony-tests/src/test/java/org/apache/harmony/tests/java/lang/ByteTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -40,10 +40,10 @@ public void test_valueOfB() {
* java.lang.Byte#hashCode()
*/
public void test_hashCode() {
assertEquals(1, new Byte((byte) 1).hashCode());
assertEquals(2, new Byte((byte) 2).hashCode());
assertEquals(-1640531535, new Byte((byte) 1).hashCode());
assertEquals(1013871474, new Byte((byte) 2).hashCode());
assertEquals(0, new Byte((byte) 0).hashCode());
assertEquals(-1, new Byte((byte) -1).hashCode());
assertEquals(-1640531535, new Byte((byte) -1).hashCode());
}

/**
Expand Down Expand Up @@ -510,8 +510,8 @@ public void test_floatValue2() {
* java.lang.Byte#hashCode()
*/
public void test_hashCode2() {
// Test for method int java.lang.Byte.hashCode()
assertEquals("Incorrect hash returned", 127, new Byte((byte) 127).hashCode());
// Test for method int java.lang.Byte.hashCode()
assertEquals("Incorrect hash returned", 2118337775, new Byte((byte) 127).hashCode());
}

/**
Expand Down
180 changes: 90 additions & 90 deletions ...orm/libcore/harmony-tests/src/test/java/org/apache/harmony/tests/java/lang/FloatTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -207,16 +207,13 @@ public void test_floatValue() {
public void test_hashCode() {
// Test for method int java.lang.Float.hashCode()
Float f = new Float(1908.8786f);
assertTrue("Returned invalid hash code for 1908.8786f", f.hashCode() == Float
.floatToIntBits(1908.8786f));
assertEquals("Returned invalid hash code for 1908.8786f", 397309157, f.hashCode());

f = new Float(-1.112f);
assertTrue("Returned invalid hash code for -1.112", f.hashCode() == Float
.floatToIntBits(-1.112f));
assertEquals("Returned invalid hash code for -1.112", -987694671, f.hashCode());

f = new Float(0f);
assertTrue("Returned invalid hash code for 0", f.hashCode() == Float.floatToIntBits(0f));

assertEquals("Returned invalid hash code for 0", 0, f.hashCode());
}

/**
Expand Down Expand Up @@ -315,12 +312,14 @@ public void test_parseFloatLjava_lang_String() {
assertEquals("Incorrect float returned, expected minimum float.", Float.MIN_VALUE,
Float.parseFloat("7.0064923216240853546186479164496e-46"), 0.0);

doTestCompareRawBits(
"0.000000000000000000000000000000000000011754942807573642917278829910357665133228589927589904276829631184250030649651730385585324256680905818939208984375",
0x800000, "1.17549435E-38");
doTestCompareRawBits(
"0.00000000000000000000000000000000000001175494280757364291727882991035766513322858992758990427682963118425003064965173038558532425668090581893920898437499999f",
0x7fffff, "1.1754942E-38");
doTestCompareRawBits(
"0.000000000000000000000000000000000000011754942807573642917278829910357665133228589927589904276829631184250030649651730385585324256680905818939208984375",
0x800000,
"1.17549435E-38");
doTestCompareRawBits(
"0.00000000000000000000000000000000000001175494280757364291727882991035766513322858992758990427682963118425003064965173038558532425668090581893920898437499999f",
0x7fffff,
"1.1754942E-38");

/* Test a set of regular floats with exponents from -38 to +38 */
for (int i = 38; i > 3; i--) {
Expand Down Expand Up @@ -432,7 +431,9 @@ public void test_parseFloatLjava_lang_String() {
public void test_parseFloat_LString_Unusual() {
float actual;

actual = Float.parseFloat("0x00000000000000000000000000000000000000000.0000000000000000000000000000000000000p0000000000000000000000000000000000");
actual =
Float.parseFloat(
"0x00000000000000000000000000000000000000000.0000000000000000000000000000000000000p0000000000000000000000000000000000");
assertEquals("Returned incorrect value", 0.0f, actual, 0.0F);

actual = Float.parseFloat("+0Xfffff.fffffffffffffffffffffffffffffffp+99F");
Expand All @@ -444,10 +445,14 @@ public void test_parseFloat_LString_Unusual() {
actual = Float.parseFloat("-0X123456789abcdef.p+1f");
assertEquals("Returned incorrect value", -1.63971062E17f, actual, 0.0F);

actual = Float.parseFloat("-0X000000000000000000000000000001abcdef.0000000000000000000000000001abefp00000000000000000000000000000000000000000004f");
actual =
Float.parseFloat(
"-0X000000000000000000000000000001abcdef.0000000000000000000000000001abefp00000000000000000000000000000000000000000004f");
assertEquals("Returned incorrect value", -4.48585472E8f, actual, 0.0F);

actual = Float.parseFloat("0X0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234p600f");
actual =
Float.parseFloat(
"0X0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234p600f");
assertEquals("Returned incorrect value", 5.907252E33f, actual, 0.0F);

actual = Float.parseFloat("0x1.p9223372036854775807");
Expand Down Expand Up @@ -574,21 +579,20 @@ public void test_parseFloat_LString_MaxNormalBoundary() {
0xff800000,
};

String[] inputs = {
"0x1.fffffep127",
"0x1.fffffe000000000000000000000000000000000000000000000001p127",
"0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
"0x1.ffffffp127",
"0x1.ffffff000000000000000000000000000000000000000000000001p127",
"0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",

"-0x1.fffffep127",
"-0x1.fffffe000000000000000000000000000000000000000000000001p127",
"-0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
"-0x1.ffffffp127",
"-0x1.ffffff000000000000000000000000000000000000000000000001p127",
"-0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
};
String[] inputs = {
"0x1.fffffep127",
"0x1.fffffe000000000000000000000000000000000000000000000001p127",
"0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
"0x1.ffffffp127",
"0x1.ffffff000000000000000000000000000000000000000000000001p127",
"0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
"-0x1.fffffep127",
"-0x1.fffffe000000000000000000000000000000000000000000000001p127",
"-0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
"-0x1.ffffffp127",
"-0x1.ffffff000000000000000000000000000000000000000000000001p127",
"-0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
};

for (int i = 0; i < inputs.length; i++) {
float actual = Float.parseFloat(inputs[i]);
Expand Down Expand Up @@ -624,21 +628,20 @@ public void test_parseFloat_LString_MinNormalBoundary() {
0x80800001,
};

String inputs[] = {
"0x1.0p-126",
"0x1.00000000000000000000000000000000000000000000001p-126",
"0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"0x1.000001p-126",
"0x1.000001000000000000000000000000000000000000000001p-126",
"0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",

"-0x1.0p-126",
"-0x1.00000000000000000000000000000000000000000000001p-126",
"-0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x1.000001p-126",
"-0x1.000001000000000000000000000000000000000000000001p-126",
"-0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
};
String inputs[] = {
"0x1.0p-126",
"0x1.00000000000000000000000000000000000000000000001p-126",
"0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"0x1.000001p-126",
"0x1.000001000000000000000000000000000000000000000001p-126",
"0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x1.0p-126",
"-0x1.00000000000000000000000000000000000000000000001p-126",
"-0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x1.000001p-126",
"-0x1.000001000000000000000000000000000000000000000001p-126",
"-0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
};

for (int i = 0; i < inputs.length; i++) {
float actual = Float.parseFloat(inputs[i]);
Expand Down Expand Up @@ -674,21 +677,20 @@ public void test_parseFloat_LString_MaxSubNormalBoundary() {
0x80800000,
};

String inputs[] = {
"0x0.fffffep-126",
"0x0.fffffe000000000000000000000000000000000000000000000000000001p-126",
"0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"0x0.ffffffp-126",
"0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126",
"0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",

"-0x0.fffffep-126",
"-0x0.fffffe000000000000000000000000000000000000000000000000000001p-126",
"-0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x0.ffffffp-126",
"-0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126",
"-0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
};
String inputs[] = {
"0x0.fffffep-126",
"0x0.fffffe000000000000000000000000000000000000000000000000000001p-126",
"0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"0x0.ffffffp-126",
"0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126",
"0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x0.fffffep-126",
"-0x0.fffffe000000000000000000000000000000000000000000000000000001p-126",
"-0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x0.ffffffp-126",
"-0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126",
"-0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
};

for (int i = 0; i < inputs.length; i++) {
float actual = Float.parseFloat(inputs[i]);
Expand Down Expand Up @@ -724,21 +726,20 @@ public void test_parseFloat_LString_MinSubNormalBoundary() {
0x80000002,
};

String inputs[] = {
"0x0.000002p-126",
"0x0.00000200000000000000000000000000000000000001p-126",
"0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"0x0.000003p-126",
"0x0.000003000000000000000000000000000000000000001p-126",
"0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",

"-0x0.000002p-126",
"-0x0.00000200000000000000000000000000000000000001p-126",
"-0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x0.000003p-126",
"-0x0.000003000000000000000000000000000000000000001p-126",
"-0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
};
String inputs[] = {
"0x0.000002p-126",
"0x0.00000200000000000000000000000000000000000001p-126",
"0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"0x0.000003p-126",
"0x0.000003000000000000000000000000000000000000001p-126",
"0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x0.000002p-126",
"-0x0.00000200000000000000000000000000000000000001p-126",
"-0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x0.000003p-126",
"-0x0.000003000000000000000000000000000000000000001p-126",
"-0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
};

for (int i = 0; i < inputs.length; i++) {
float actual = Float.parseFloat(inputs[i]);
Expand Down Expand Up @@ -774,21 +775,20 @@ public void test_parseFloat_LString_ZeroBoundary() {
0x80000001,
};

String inputs[] = {
"0x0.000000000000000p-126",
"0x0.000000000000000000000000000000000000000000000001p-126",
"0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"0x0.000001p-126",
"0x0.000001000000000000000000000000000000000000000001p-126",
"0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",

"-0x0.000000000000000p-126",
"-0x0.000000000000000000000000000000000000000000000001p-126",
"-0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x0.000001p-126",
"-0x0.000001000000000000000000000000000000000000000001p-126",
"-0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
};
String inputs[] = {
"0x0.000000000000000p-126",
"0x0.000000000000000000000000000000000000000000000001p-126",
"0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"0x0.000001p-126",
"0x0.000001000000000000000000000000000000000000000001p-126",
"0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x0.000000000000000p-126",
"-0x0.000000000000000000000000000000000000000000000001p-126",
"-0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
"-0x0.000001p-126",
"-0x0.000001000000000000000000000000000000000000000001p-126",
"-0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
};

for (int i = 0; i < inputs.length; i++) {
float actual = Float.parseFloat(inputs[i]);
Expand Down
35 changes: 20 additions & 15 deletions ...m/libcore/harmony-tests/src/test/java/org/apache/harmony/tests/java/lang/IntegerTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,6 @@
package org.apache.harmony.tests.java.lang;

import java.util.Properties;

import junit.framework.TestCase;

public class IntegerTest extends TestCase {
Expand Down Expand Up @@ -283,8 +282,8 @@ public void test_hashCode2() {

Integer i1 = new Integer(1000);
Integer i2 = new Integer(-1000);
assertTrue("Returned incorrect hashcode", i1.hashCode() == 1000
&& (i2.hashCode() == -1000));
assertTrue(
"Returned incorrect hashcode", i1.hashCode() == 145972072 && (i2.hashCode() == 145972072));
}

/**
Expand Down Expand Up @@ -442,12 +441,16 @@ public void test_shortValue2() {
* java.lang.Integer#toBinaryString(int)
*/
public void test_toBinaryStringI() {
// Test for method java.lang.String
// java.lang.Integer.toBinaryString(int)
assertEquals("Incorrect string returned", "1111111111111111111111111111111", Integer.toBinaryString(
Integer.MAX_VALUE));
assertEquals("Incorrect string returned", "10000000000000000000000000000000", Integer.toBinaryString(
Integer.MIN_VALUE));
// Test for method java.lang.String
// java.lang.Integer.toBinaryString(int)
assertEquals(
"Incorrect string returned",
"1111111111111111111111111111111",
Integer.toBinaryString(Integer.MAX_VALUE));
assertEquals(
"Incorrect string returned",
"10000000000000000000000000000000",
Integer.toBinaryString(Integer.MIN_VALUE));
}

/**
Expand Down Expand Up @@ -516,7 +519,7 @@ public void test_toStringI2() {
assertEquals("Returned incorrect octal String", "0", Integer.toString(0));
assertEquals("Returned incorrect octal String", "708", Integer.toString(708));
assertEquals("Returned incorrect octal String", "-100", Integer.toString(-100));
assertEquals("Returned incorrect octal String", "-1000000008", Integer.toString(-1000000008));
assertEquals("Returned incorrect octal String", "-1000000008", Integer.toString(-1000000008));
assertEquals("Returned incorrect octal String", "2000000008", Integer.toString(2000000008));
}

Expand All @@ -530,8 +533,10 @@ public void test_toStringII() {
assertTrue("Returned incorrect hex string--wanted 7fffffff but got: "
+ Integer.toString(2147483647, 16), Integer.toString(
2147483647, 16).equals("7fffffff"));
assertEquals("Incorrect string returned", "1111111111111111111111111111111", Integer.toString(2147483647, 2)
);
assertEquals(
"Incorrect string returned",
"1111111111111111111111111111111",
Integer.toString(2147483647, 2));
assertEquals("Incorrect string returned", "2147483647", Integer
.toString(2147483647, 10));

Expand Down Expand Up @@ -688,10 +693,10 @@ public void test_valueOfI() {
* java.lang.Integer#hashCode()
*/
public void test_hashCode() {
assertEquals(1, new Integer(1).hashCode());
assertEquals(2, new Integer(2).hashCode());
assertEquals(-1640531535, new Integer(1).hashCode());
assertEquals(1013871474, new Integer(2).hashCode());
assertEquals(0, new Integer(0).hashCode());
assertEquals(-1, new Integer(-1).hashCode());
assertEquals(-1640531535, new Integer(-1).hashCode());
}

/**
Expand Down
Loading