rev 58210 : 8196334: Optimize UUID#fromString
Reviewed-by: TBD
Contributed-by: plokhotnyuk@gmail.com, jon.chambers@gmail.com, claes.redestad@oracle.com

   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 }
--- EOF ---