392 lines
13 KiB
Java
392 lines
13 KiB
Java
/*
|
|
* Copyright (c) 2003, 2023, 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 4173528 5068772 8148936 8196334 8308803
|
|
* @summary Unit tests for java.util.UUID
|
|
* @key randomness
|
|
* @library /test/lib
|
|
* @build jdk.test.lib.RandomFactory
|
|
* @run main/othervm -Xmx1g -XX:+CompactStrings UUIDTest
|
|
* @run main/othervm -Xmx1g -XX:-CompactStrings UUIDTest
|
|
*/
|
|
|
|
import java.util.*;
|
|
import java.util.stream.IntStream;
|
|
import jdk.test.lib.RandomFactory;
|
|
|
|
public class UUIDTest {
|
|
|
|
// Single UUID instance is ~32 bytes, 1M instances take ~256M in the set
|
|
private static final int COUNT = 1_000_000;
|
|
|
|
static final Random generator = RandomFactory.getRandom();
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
negativeTest();
|
|
randomUUIDTest();
|
|
randomUUIDTest_Multi();
|
|
nameUUIDFromBytesTest();
|
|
stringTest();
|
|
versionTest();
|
|
variantTest();
|
|
timestampTest();
|
|
clockSequenceTest();
|
|
nodeTest();
|
|
hashCodeEqualsTest();
|
|
compareTo();
|
|
}
|
|
|
|
private static void negativeTest() throws Exception {
|
|
Set<UUID> set = new HashSet<>();
|
|
set.add(new UUID(4, 4));
|
|
if (set.add(new UUID(4, 4))) {
|
|
throw new Exception("Contains test does not work as expected");
|
|
}
|
|
}
|
|
|
|
private static void randomUUIDTest() throws Exception {
|
|
List<UUID> collisions = new ArrayList<>();
|
|
|
|
Set<UUID> set = new HashSet<>();
|
|
for (int i = 0; i < COUNT; i++) {
|
|
UUID u = UUID.randomUUID();
|
|
if (u.version() != 4) {
|
|
throw new Exception("Bad version: " + u);
|
|
}
|
|
if (u.variant() != 2) {
|
|
throw new Exception("Bad variant: " + u);
|
|
}
|
|
if (!set.add(u)) {
|
|
collisions.add(u);
|
|
}
|
|
}
|
|
|
|
if (!collisions.isEmpty()) {
|
|
// This is extremely unlikely to happen. If you see this failure,
|
|
// this highly likely points to the implementation bug, rather than
|
|
// the odd chance.
|
|
throw new Exception("UUID collisions detected: " + collisions);
|
|
}
|
|
}
|
|
|
|
private static void randomUUIDTest_Multi() throws Exception {
|
|
List<UUID> uuids = IntStream.range(0, COUNT).parallel()
|
|
.mapToObj(i -> UUID.randomUUID())
|
|
.toList();
|
|
|
|
List<UUID> collisions = new ArrayList<>();
|
|
|
|
Set<UUID> set = new HashSet<>();
|
|
for (UUID u : uuids) {
|
|
if (u.version() != 4) {
|
|
throw new Exception("Bad version: " + u);
|
|
}
|
|
if (u.variant() != 2) {
|
|
throw new Exception("Bad variant: " + u);
|
|
}
|
|
if (!set.add(u)) {
|
|
collisions.add(u);
|
|
}
|
|
}
|
|
|
|
if (!collisions.isEmpty()) {
|
|
// This is extremely unlikely to happen. If you see this failure,
|
|
// this highly likely points to the implementation bug, rather than
|
|
// the odd chance.
|
|
throw new Exception("UUID collisions detected: " + collisions);
|
|
}
|
|
}
|
|
|
|
|
|
private static void nameUUIDFromBytesTest() throws Exception {
|
|
List<UUID> collisions = new ArrayList<>();
|
|
|
|
byte[] someBytes = new byte[12];
|
|
Set<UUID> set = new HashSet<>();
|
|
for (int i = 0; i < COUNT; i++) {
|
|
generator.nextBytes(someBytes);
|
|
UUID u = UUID.nameUUIDFromBytes(someBytes);
|
|
if (u.version() != 3) {
|
|
throw new Exception("Bad version: " + u);
|
|
}
|
|
if (u.variant() != 2) {
|
|
throw new Exception("Bad variant: " + u);
|
|
}
|
|
if (!set.add(u)) {
|
|
collisions.add(u);
|
|
}
|
|
}
|
|
|
|
if (!collisions.isEmpty()) {
|
|
// This is extremely unlikely to happen. If you see this failure,
|
|
// this highly likely points to the implementation bug, rather than
|
|
// the odd chance.
|
|
throw new Exception("UUID collisions detected: " + collisions);
|
|
}
|
|
}
|
|
|
|
private static void stringTest() throws Exception {
|
|
for (int i = 0; i < COUNT; i++) {
|
|
UUID u1 = UUID.randomUUID();
|
|
UUID u2 = UUID.fromString(u1.toString().toLowerCase());
|
|
UUID u3 = UUID.fromString(u1.toString().toUpperCase());
|
|
if (!u1.equals(u2) || !u1.equals(u3)) {
|
|
throw new Exception("UUID -> string -> UUID failed: " + u1 + " -> " + u2 + " -> " + u3);
|
|
}
|
|
}
|
|
|
|
testFromStringError("-0");
|
|
testFromStringError("x");
|
|
testFromStringError("----");
|
|
testFromStringError("-0-0-0-0");
|
|
testFromStringError("0-0-0-0-");
|
|
testFromStringError("0-0-0-0-0-");
|
|
testFromStringError("0-0-0-0-x");
|
|
}
|
|
|
|
private static void testFromStringError(String str) {
|
|
try {
|
|
UUID test = UUID.fromString(str);
|
|
throw new RuntimeException("Should have thrown IAE");
|
|
} catch (IllegalArgumentException iae) {
|
|
// pass
|
|
}
|
|
}
|
|
|
|
private static void versionTest() throws Exception {
|
|
UUID test = UUID.randomUUID();
|
|
if (test.version() != 4) {
|
|
throw new Exception("randomUUID not type 4: " + test);
|
|
}
|
|
|
|
byte[] someBytes = new byte[12];
|
|
generator.nextBytes(someBytes);
|
|
test = UUID.nameUUIDFromBytes(someBytes);
|
|
if (test.version() != 3) {
|
|
throw new Exception("nameUUIDFromBytes not type 3: " + test);
|
|
}
|
|
|
|
test = UUID.fromString("9835451d-e2e0-1e41-8a5a-be785f17dcda");
|
|
if (test.version() != 1) {
|
|
throw new Exception("wrong version fromString 1");
|
|
}
|
|
|
|
test = UUID.fromString("9835451d-e2e0-2e41-8a5a-be785f17dcda");
|
|
if (test.version() != 2) {
|
|
throw new Exception("wrong version fromString 2");
|
|
}
|
|
|
|
test = UUID.fromString("9835451d-e2e0-3e41-8a5a-be785f17dcda");
|
|
if (test.version() != 3) {
|
|
throw new Exception("wrong version fromString 3");
|
|
}
|
|
|
|
test = UUID.fromString("9835451d-e2e0-4e41-8a5a-be785f17dcda");
|
|
if (test.version() != 4) {
|
|
throw new Exception("wrong version fromString 4");
|
|
}
|
|
|
|
test = new UUID(0x0000000000001000L, 55L);
|
|
if (test.version() != 1) {
|
|
throw new Exception("wrong version from bit set to 1");
|
|
}
|
|
|
|
test = new UUID(0x0000000000002000L, 55L);
|
|
if (test.version() != 2) {
|
|
throw new Exception("wrong version from bit set to 2");
|
|
}
|
|
|
|
test = new UUID(0x0000000000003000L, 55L);
|
|
if (test.version() != 3) {
|
|
throw new Exception("wrong version from bit set to 3");
|
|
}
|
|
|
|
test = new UUID(0x0000000000004000L, 55L);
|
|
if (test.version() != 4) {
|
|
throw new Exception("wrong version from bit set to 4");
|
|
}
|
|
}
|
|
|
|
private static void variantTest() throws Exception {
|
|
UUID test = UUID.randomUUID();
|
|
if (test.variant() != 2) {
|
|
throw new Exception("randomUUID not variant 2");
|
|
}
|
|
|
|
byte[] someBytes = new byte[12];
|
|
generator.nextBytes(someBytes);
|
|
test = UUID.nameUUIDFromBytes(someBytes);
|
|
if (test.variant() != 2) {
|
|
throw new Exception("nameUUIDFromBytes not variant 2");
|
|
}
|
|
|
|
test = new UUID(55L, 0x0000000000001000L);
|
|
if (test.variant() != 0) {
|
|
throw new Exception("wrong variant from bit set to 0");
|
|
}
|
|
|
|
test = new UUID(55L, 0x8000000000001000L);
|
|
if (test.variant() != 2) {
|
|
throw new Exception("wrong variant from bit set to 2");
|
|
}
|
|
|
|
test = new UUID(55L, 0xc000000000001000L);
|
|
if (test.variant() != 6) {
|
|
throw new Exception("wrong variant from bit set to 6");
|
|
}
|
|
|
|
test = new UUID(55L, 0xe000000000001000L);
|
|
if (test.variant() != 7) {
|
|
throw new Exception("wrong variant from bit set to 7");
|
|
}
|
|
}
|
|
|
|
private static void timestampTest() throws Exception {
|
|
UUID test = UUID.randomUUID();
|
|
try {
|
|
test.timestamp();
|
|
throw new Exception("Expected exception not thrown");
|
|
} catch (UnsupportedOperationException uoe) {
|
|
// Correct result
|
|
}
|
|
|
|
test = UUID.fromString("00000001-0000-1000-8a5a-be785f17dcda");
|
|
if (test.timestamp() != 1) {
|
|
throw new Exception("Incorrect timestamp");
|
|
}
|
|
|
|
test = UUID.fromString("00000400-0000-1000-8a5a-be785f17dcda");
|
|
if (test.timestamp() != 1024) {
|
|
throw new Exception("Incorrect timestamp");
|
|
}
|
|
|
|
test = UUID.fromString("FFFFFFFF-FFFF-1FFF-8a5a-be785f17dcda");
|
|
if (test.timestamp() != (Long.MAX_VALUE >> 3)) {
|
|
throw new Exception("Incorrect timestamp");
|
|
}
|
|
}
|
|
|
|
private static void clockSequenceTest() throws Exception {
|
|
UUID test = UUID.randomUUID();
|
|
try {
|
|
test.clockSequence();
|
|
throw new Exception("Expected exception not thrown");
|
|
} catch (UnsupportedOperationException uoe) {
|
|
// Correct result
|
|
}
|
|
|
|
test = UUID.fromString("00000001-0000-1000-8001-be785f17dcda");
|
|
if (test.clockSequence() != 1) {
|
|
throw new Exception("Incorrect sequence");
|
|
}
|
|
|
|
test = UUID.fromString("00000001-0000-1000-8002-be785f17dcda");
|
|
if (test.clockSequence() != 2) {
|
|
throw new Exception("Incorrect sequence");
|
|
}
|
|
|
|
test = UUID.fromString("00000001-0000-1000-8010-be785f17dcda");
|
|
if (test.clockSequence() != 16) {
|
|
throw new Exception("Incorrect sequence");
|
|
}
|
|
|
|
test = UUID.fromString("00000001-0000-1000-bFFF-be785f17dcda");
|
|
if (test.clockSequence() != ((1L << 14) - 1)) {
|
|
throw new Exception("Incorrect sequence");
|
|
}
|
|
}
|
|
|
|
private static void nodeTest() throws Exception {
|
|
UUID test = UUID.randomUUID();
|
|
try {
|
|
test.node();
|
|
throw new Exception("Expected exception not thrown");
|
|
} catch (UnsupportedOperationException uoe) {
|
|
// Correct result
|
|
}
|
|
|
|
test = UUID.fromString("00000001-0000-1000-8001-000000000001");
|
|
if (test.node() != 1) {
|
|
throw new Exception("Incorrect node");
|
|
}
|
|
|
|
test = UUID.fromString("00000001-0000-1000-8002-FFFFFFFFFFFF");
|
|
if (test.node() != ((1L << 48) - 1)) {
|
|
throw new Exception("Incorrect node");
|
|
}
|
|
}
|
|
|
|
private static void hashCodeEqualsTest() throws Exception {
|
|
// If two UUIDs are equal they must have the same hashCode
|
|
for (int i = 0; i < COUNT; i++) {
|
|
UUID u1 = UUID.randomUUID();
|
|
UUID u2 = UUID.fromString(u1.toString());
|
|
if (u1.hashCode() != u2.hashCode()) {
|
|
throw new Exception("Equal UUIDs with different hash codes: " + u1 + "(" + u1.hashCode() + ") " +
|
|
"and " + u2 + "(" + u2.hashCode() + ")");
|
|
}
|
|
}
|
|
|
|
// Test equality of UUIDs with tampered bits
|
|
for (int i = 0; i < COUNT; i++) {
|
|
long l = generator.nextLong();
|
|
long l2 = generator.nextLong();
|
|
int position = generator.nextInt(64);
|
|
UUID u1 = new UUID(l, l2);
|
|
l = l ^ (1L << position);
|
|
UUID u2 = new UUID(l, l2);
|
|
if (u1.equals(u2)) {
|
|
throw new Exception("UUIDs with different bits equal: " + u1 + " and " + u2);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void compareTo() throws Exception {
|
|
UUID id = new UUID(33L, 63L);
|
|
UUID id2 = new UUID(34L, 62L);
|
|
UUID id3 = new UUID(34L, 63L);
|
|
UUID id4 = new UUID(34L, 64L);
|
|
UUID id5 = new UUID(35L, 63L);
|
|
|
|
if ((id.compareTo(id2) >= 0) ||
|
|
(id2.compareTo(id3) >= 0) ||
|
|
(id3.compareTo(id4) >= 0) ||
|
|
(id4.compareTo(id5) >= 0)) {
|
|
throw new RuntimeException("compareTo failure");
|
|
}
|
|
|
|
if ((id5.compareTo(id4) <= 0) ||
|
|
(id4.compareTo(id3) <= 0) ||
|
|
(id3.compareTo(id2) <= 0) ||
|
|
(id2.compareTo(id) <= 0)) {
|
|
throw new RuntimeException("compareTo failure");
|
|
}
|
|
|
|
if (id.compareTo(id) != 0) {
|
|
throw new RuntimeException("compareTo failure");
|
|
}
|
|
}
|
|
|
|
}
|