1 /*

     2  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 #include "precompiled.hpp"

    24 #include "classfile/altHashing.hpp"

    25 #include "unittest.hpp"

    26 

    27 // Internal test for alternate hashing.  Translated from JDK version

    28 // test/sun/misc/Hashing.java

    29 static const jbyte ONE_BYTE[] = {(jbyte) 0x80};

    30 static const jbyte TWO_BYTE[] = {(jbyte) 0x80, (jbyte) 0x81};

    31 static const jchar ONE_CHAR[] = {(jchar) 0x8180};

    32 static const jbyte THREE_BYTE[] = {(jbyte) 0x80, (jbyte) 0x81, (jbyte) 0x82};

    33 static const jbyte FOUR_BYTE[] = {(jbyte) 0x80, (jbyte) 0x81, (jbyte) 0x82, (jbyte) 0x83};

    34 static const jchar TWO_CHAR[] = {(jchar) 0x8180, (jchar) 0x8382};

    35 static const jint ONE_INT[] = {(jint) 0x83828180};

    36 static const jbyte SIX_BYTE[] = {(jbyte) 0x80, (jbyte) 0x81, (jbyte) 0x82, (jbyte) 0x83, (jbyte) 0x84, (jbyte) 0x85};

    37 static const jchar THREE_CHAR[] = {(jchar) 0x8180, (jchar) 0x8382, (jchar) 0x8584};

    38 static const jbyte EIGHT_BYTE[] = {

    39   (jbyte) 0x80, (jbyte) 0x81, (jbyte) 0x82,

    40   (jbyte) 0x83, (jbyte) 0x84, (jbyte) 0x85,

    41   (jbyte) 0x86, (jbyte) 0x87

    42 };

    43 static const jchar FOUR_CHAR[] = {

    44   (jchar) 0x8180, (jchar) 0x8382,

    45   (jchar) 0x8584, (jchar) 0x8786

    46 };

    47 

    48 static const jint TWO_INT[] = {(jint) 0x83828180, (jint) 0x87868584};

    49 static const juint MURMUR3_32_X86_CHECK_VALUE = 0xB0F57EE3;

    50 

    51 class AltHashingTest : public ::testing::Test {

    52  public:

    53 

    54   static juint murmur3_32(const int* data, int len) {

    55     return AltHashing::murmur3_32(data, len);

    56   }

    57 };

    58 

    59 TEST_F(AltHashingTest, murmur3_32_byte_array_test) {

    60   jbyte vector[256];

    61   jbyte hashes[4 * 256];

    62 

    63   for (int i = 0; i < 256; i++) {

    64     vector[i] = (jbyte) i;

    65   }

    66 

    67   // Hash subranges {}, {0}, {0,1}, {0,1,2}, ..., {0,...,255}

    68   for (int i = 0; i < 256; i++) {

    69     juint hash = AltHashing::murmur3_32(256 - i, vector, i);

    70     hashes[i * 4] = (jbyte) hash;

    71     hashes[i * 4 + 1] = (jbyte) (hash >> 8);

    72     hashes[i * 4 + 2] = (jbyte) (hash >> 16);

    73     hashes[i * 4 + 3] = (jbyte) (hash >> 24);

    74   }

    75 

    76   // hash to get const result.

    77   juint final_hash = AltHashing::murmur3_32(0, hashes, 4 * 256);

    78 

    79   ASSERT_EQ(MURMUR3_32_X86_CHECK_VALUE, final_hash)

    80           << "Calculated hash result not as expected.";

    81 }

    82 

    83 TEST_F(AltHashingTest, equivalent_hashes_test) {

    84   juint jbytes, jchars, ints;

    85 

    86   jbytes = AltHashing::murmur3_32(0, TWO_BYTE, 2);

    87   jchars = AltHashing::murmur3_32(0, ONE_CHAR, 1);

    88   ASSERT_EQ(jbytes, jchars) << "Hashes did not match.";

    89 

    90   jbytes = AltHashing::murmur3_32(0, FOUR_BYTE, 4);

    91   jchars = AltHashing::murmur3_32(0, TWO_CHAR, 2);

    92   ints = AltHashingTest::murmur3_32(ONE_INT, 1);

    93 

    94   ASSERT_EQ(jbytes, jchars) << "Hashes did not match.";

    95   ASSERT_EQ(jbytes, ints) << "Hashes did not match.";

    96 

    97   jbytes = AltHashing::murmur3_32(0, SIX_BYTE, 6);

    98   jchars = AltHashing::murmur3_32(0, THREE_CHAR, 3);

    99   ASSERT_EQ(jbytes, jchars) << "Hashes did not match.";

   100 

   101   jbytes = AltHashing::murmur3_32(0, EIGHT_BYTE, 8);

   102   jchars = AltHashing::murmur3_32(0, FOUR_CHAR, 4);

   103   ints = AltHashingTest::murmur3_32(TWO_INT, 2);

   104 

   105   ASSERT_EQ(jbytes, jchars) << "Hashes did not match.";

   106   ASSERT_EQ(jbytes, ints) << "Hashes did not match.";

   107 }