1 /* 2 * Copyright (c) 2003, 2012, 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 24 /* @test 25 * @bug 4173528 5068772 8148936 26 * @summary Unit tests for java.util.UUID 27 * @key randomness 28 * @run main/othervm -XX:+CompactStrings UUIDTest 29 * @run main/othervm -XX:-CompactStrings UUIDTest 30 */ 31 32 import java.util.*; 33 34 public class UUIDTest { 35 36 static Random generator = new Random(); 37 38 public static void main(String[] args) throws Exception { 39 containsTest(); 40 randomUUIDTest(); 41 nameUUIDFromBytesTest(); 42 stringTest(); 43 versionTest(); 44 variantTest(); 45 timestampTest(); 46 clockSequenceTest(); 47 nodeTest(); 48 hashCodeEqualsTest(); 49 compareTo(); 50 } 51 52 // Verify that list.contains detects UUID collisons 53 private static void containsTest() throws Exception { 54 List list = new LinkedList(); 55 list.add(new UUID(4,4)); 56 if (!list.contains(new UUID(4,4))) 57 throw new Exception("contains test did not work as expected"); 58 } 59 60 private static void randomUUIDTest() throws Exception { 61 List list = new LinkedList(); 62 for (int i=0; i<100; i++) { 63 UUID u1 = UUID.randomUUID(); 64 if (4 != u1.version()) { 65 throw new Exception("bad version"); 66 } 67 if (2 != u1.variant()) { 68 throw new Exception("bad variant"); 69 } 70 if (list.contains(u1)) 71 throw new Exception("random UUID collision very unlikely"); 72 list.add(u1); 73 } 74 } 75 76 private static void nameUUIDFromBytesTest() throws Exception { 77 Random byteSource = new Random(); 78 byte[] someBytes = new byte[12]; 79 List list = new LinkedList(); 80 for (int i=0; i<100; i++) { 81 byteSource.nextBytes(someBytes); 82 UUID u1 = UUID.nameUUIDFromBytes(someBytes); 83 if (3 != u1.version()) { 84 throw new Exception("bad version"); 85 } 86 if (2 != u1.variant()) { 87 throw new Exception("bad variant"); 88 } 89 if (list.contains(u1)) 90 throw new Exception("byte UUID collision very unlikely"); 91 list.add(u1); 92 } 93 } 94 95 private static void stringTest() throws Exception { 96 for (int i=0; i<100; i++) { 97 UUID u1 = UUID.randomUUID(); 98 UUID u2 = UUID.fromString(u1.toString()); 99 if (!u1.equals(u2)) 100 throw new Exception("UUID -> string -> UUID failed"); 101 } 102 103 testFromStringError("-0"); 104 testFromStringError("x"); 105 testFromStringError("----"); 106 testFromStringError("-0-0-0-0"); 107 testFromStringError("0-0-0-0-"); 108 testFromStringError("0-0-0-0-0-"); 109 testFromStringError("0-0-0-0-x"); 110 } 111 112 private static void testFromStringError(String str) { 113 try { 114 UUID test = UUID.fromString(str); 115 throw new RuntimeException("Should have thrown IAE"); 116 } catch (IllegalArgumentException iae) { 117 // pass 118 } 119 } 120 121 private static void versionTest() throws Exception { 122 UUID test = UUID.randomUUID(); 123 if (test.version() != 4) 124 throw new Exception("randomUUID not type 4"); 125 Random byteSource = new Random(); 126 byte[] someBytes = new byte[12]; 127 byteSource.nextBytes(someBytes); 128 test = UUID.nameUUIDFromBytes(someBytes); 129 if (test.version() != 3) 130 throw new Exception("nameUUIDFromBytes not type 3"); 131 test = UUID.fromString("9835451d-e2e0-1e41-8a5a-be785f17dcda"); 132 if (test.version() != 1) 133 throw new Exception("wrong version fromString 1"); 134 test = UUID.fromString("9835451d-e2e0-2e41-8a5a-be785f17dcda"); 135 if (test.version() != 2) 136 throw new Exception("wrong version fromString 2"); 137 test = UUID.fromString("9835451d-e2e0-3e41-8a5a-be785f17dcda"); 138 if (test.version() != 3) 139 throw new Exception("wrong version fromString 3"); 140 test = UUID.fromString("9835451d-e2e0-4e41-8a5a-be785f17dcda"); 141 if (test.version() != 4) 142 throw new Exception("wrong version fromString 4"); 143 test = new UUID(0x0000000000001000L, 55L); 144 if (test.version() != 1) 145 throw new Exception("wrong version from bit set to 1"); 146 test = new UUID(0x0000000000002000L, 55L); 147 if (test.version() != 2) 148 throw new Exception("wrong version from bit set to 2"); 149 test = new UUID(0x0000000000003000L, 55L); 150 if (test.version() != 3) 151 throw new Exception("wrong version from bit set to 3"); 152 test = new UUID(0x0000000000004000L, 55L); 153 if (test.version() != 4) 154 throw new Exception("wrong version from bit set to 4"); 155 } 156 157 private static void variantTest() throws Exception { 158 UUID test = UUID.randomUUID(); 159 if (test.variant() != 2) 160 throw new Exception("randomUUID not variant 2"); 161 Random byteSource = new Random(); 162 byte[] someBytes = new byte[12]; 163 byteSource.nextBytes(someBytes); 164 test = UUID.nameUUIDFromBytes(someBytes); 165 if (test.variant() != 2) 166 throw new Exception("nameUUIDFromBytes not variant 2"); 167 test = new UUID(55L, 0x0000000000001000L); 168 if (test.variant() != 0) 169 throw new Exception("wrong variant from bit set to 0"); 170 test = new UUID(55L, 0x8000000000001000L); 171 if (test.variant() != 2) 172 throw new Exception("wrong variant from bit set to 2"); 173 test = new UUID(55L, 0xc000000000001000L); 174 if (test.variant() != 6) 175 throw new Exception("wrong variant from bit set to 6"); 176 test = new UUID(55L, 0xe000000000001000L); 177 if (test.variant() != 7) 178 throw new Exception("wrong variant from bit set to 7"); 179 } 180 181 private static void timestampTest() throws Exception { 182 UUID test = UUID.randomUUID(); 183 try { 184 test.timestamp(); 185 throw new Exception("Expected exception not thrown"); 186 } catch (UnsupportedOperationException uoe) { 187 // Correct result 188 } 189 test = UUID.fromString("00000001-0000-1000-8a5a-be785f17dcda"); 190 if (test.timestamp() != 1) 191 throw new Exception("Incorrect timestamp"); 192 test = UUID.fromString("00000400-0000-1000-8a5a-be785f17dcda"); 193 if (test.timestamp() != 1024) 194 throw new Exception("Incorrect timestamp"); 195 test = UUID.fromString("FFFFFFFF-FFFF-1FFF-8a5a-be785f17dcda"); 196 if (test.timestamp() != Long.MAX_VALUE>>3) 197 throw new Exception("Incorrect timestamp"); 198 } 199 200 private static void clockSequenceTest() throws Exception { 201 UUID test = UUID.randomUUID(); 202 try { 203 test.clockSequence(); 204 throw new Exception("Expected exception not thrown"); 205 } catch (UnsupportedOperationException uoe) { 206 // Correct result 207 } 208 test = UUID.fromString("00000001-0000-1000-8001-be785f17dcda"); 209 if (test.clockSequence() != 1) 210 throw new Exception("Incorrect sequence"); 211 test = UUID.fromString("00000001-0000-1000-8002-be785f17dcda"); 212 if (test.clockSequence() != 2) 213 throw new Exception("Incorrect sequence"); 214 test = UUID.fromString("00000001-0000-1000-8010-be785f17dcda"); 215 if (test.clockSequence() != 16) 216 throw new Exception("Incorrect sequence"); 217 test = UUID.fromString("00000001-0000-1000-bFFF-be785f17dcda"); 218 if (test.clockSequence() != ((2L<<13)-1)) // 2^14 - 1 219 throw new Exception("Incorrect sequence"); 220 } 221 222 private static void nodeTest() throws Exception { 223 UUID test = UUID.randomUUID(); 224 try { 225 test.node(); 226 throw new Exception("Expected exception not thrown"); 227 } catch (UnsupportedOperationException uoe) { 228 // Correct result 229 } 230 test = UUID.fromString("00000001-0000-1000-8001-000000000001"); 231 if (test.node() != 1) 232 throw new Exception("Incorrect node"); 233 test = UUID.fromString("00000001-0000-1000-8002-FFFFFFFFFFFF"); 234 if (test.node() != ((2L<<47)-1)) // 2^48 - 1 235 throw new Exception("Incorrect node"); 236 } 237 238 private static void hashCodeEqualsTest() throws Exception { 239 // If two UUIDs are equal they must have the same hashCode 240 for (int i=0; i<100; i++) { 241 UUID u1 = UUID.randomUUID(); 242 UUID u2 = UUID.fromString(u1.toString()); 243 if (u1.hashCode() != u2.hashCode()) 244 throw new Exception("Equal UUIDs with different hashcodes"); 245 } 246 // Test equality of UUIDs with tampered bits 247 for (int i=0; i<1000; i++) { 248 long l = generator.nextLong(); 249 long l2 = generator.nextLong(); 250 int position = generator.nextInt(64); 251 UUID u1 = new UUID(l, l2); 252 l = l ^ (1L << position); 253 UUID u2 = new UUID(l, l2); 254 if (u1.equals(u2)) 255 throw new Exception("UUIDs with different bits equal"); 256 } 257 } 258 259 private static void compareTo() throws Exception { 260 UUID id = new UUID(33L, 63L); 261 UUID id2 = new UUID(34L, 62L); 262 UUID id3 = new UUID(34L, 63L); 263 UUID id4 = new UUID(34L, 64L); 264 UUID id5 = new UUID(35L, 63L); 265 266 if ((id.compareTo(id2) >= 0) || 267 (id2.compareTo(id3) >= 0) || 268 (id3.compareTo(id4) >= 0) || 269 (id4.compareTo(id5) >= 0)) 270 throw new RuntimeException("compareTo failure"); 271 272 if ((id5.compareTo(id4) <= 0) || 273 (id4.compareTo(id3) <= 0) || 274 (id3.compareTo(id2) <= 0) || 275 (id2.compareTo(id) <= 0)) 276 throw new RuntimeException("compareTo failure"); 277 278 if (id.compareTo(id) != 0) 279 throw new RuntimeException("compareTo failure"); 280 281 } 282 283 }