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().toLowerCase());
  99             UUID u3 = UUID.fromString(u1.toString().toUpperCase());
 100             if (!u1.equals(u2) || !u1.equals(u3))
 101                 throw new Exception("UUID -> string -> UUID failed");
 102         }
 103 
 104         testFromStringError("-0");
 105         testFromStringError("x");
 106         testFromStringError("----");
 107         testFromStringError("-0-0-0-0");
 108         testFromStringError("0-0-0-0-");
 109         testFromStringError("0-0-0-0-0-");
 110         testFromStringError("0-0-0-0-x");
 111     }
 112 
 113     private static void testFromStringError(String str) {
 114         try {
 115             UUID test = UUID.fromString(str);
 116             throw new RuntimeException("Should have thrown IAE");
 117         } catch (IllegalArgumentException iae) {
 118             // pass
 119         }
 120     }
 121 
 122     private static void versionTest() throws Exception {
 123         UUID test = UUID.randomUUID();
 124         if (test.version() != 4)
 125             throw new Exception("randomUUID not type 4");
 126         Random byteSource = new Random();
 127         byte[] someBytes = new byte[12];
 128         byteSource.nextBytes(someBytes);
 129         test = UUID.nameUUIDFromBytes(someBytes);
 130         if (test.version() != 3)
 131             throw new Exception("nameUUIDFromBytes not type 3");
 132         test = UUID.fromString("9835451d-e2e0-1e41-8a5a-be785f17dcda");
 133         if (test.version() != 1)
 134             throw new Exception("wrong version fromString 1");
 135         test = UUID.fromString("9835451d-e2e0-2e41-8a5a-be785f17dcda");
 136         if (test.version() != 2)
 137             throw new Exception("wrong version fromString 2");
 138         test = UUID.fromString("9835451d-e2e0-3e41-8a5a-be785f17dcda");
 139         if (test.version() != 3)
 140             throw new Exception("wrong version fromString 3");
 141         test = UUID.fromString("9835451d-e2e0-4e41-8a5a-be785f17dcda");
 142         if (test.version() != 4)
 143             throw new Exception("wrong version fromString 4");
 144         test = new UUID(0x0000000000001000L, 55L);
 145         if (test.version() != 1)
 146             throw new Exception("wrong version from bit set to 1");
 147         test = new UUID(0x0000000000002000L, 55L);
 148         if (test.version() != 2)
 149             throw new Exception("wrong version from bit set to 2");
 150         test = new UUID(0x0000000000003000L, 55L);
 151         if (test.version() != 3)
 152             throw new Exception("wrong version from bit set to 3");
 153         test = new UUID(0x0000000000004000L, 55L);
 154         if (test.version() != 4)
 155             throw new Exception("wrong version from bit set to 4");
 156     }
 157 
 158     private static void variantTest() throws Exception {
 159         UUID test = UUID.randomUUID();
 160         if (test.variant() != 2)
 161             throw new Exception("randomUUID not variant 2");
 162         Random byteSource = new Random();
 163         byte[] someBytes = new byte[12];
 164         byteSource.nextBytes(someBytes);
 165         test = UUID.nameUUIDFromBytes(someBytes);
 166         if (test.variant() != 2)
 167             throw new Exception("nameUUIDFromBytes not variant 2");
 168         test = new UUID(55L, 0x0000000000001000L);
 169         if (test.variant() != 0)
 170             throw new Exception("wrong variant from bit set to 0");
 171         test = new UUID(55L, 0x8000000000001000L);
 172         if (test.variant() != 2)
 173             throw new Exception("wrong variant from bit set to 2");
 174        test = new UUID(55L, 0xc000000000001000L);
 175         if (test.variant() != 6)
 176             throw new Exception("wrong variant from bit set to 6");
 177        test = new UUID(55L, 0xe000000000001000L);
 178         if (test.variant() != 7)
 179             throw new Exception("wrong variant from bit set to 7");
 180     }
 181 
 182     private static void timestampTest() throws Exception {
 183         UUID test = UUID.randomUUID();
 184         try {
 185             test.timestamp();
 186             throw new Exception("Expected exception not thrown");
 187         } catch (UnsupportedOperationException uoe) {
 188             // Correct result
 189         }
 190         test = UUID.fromString("00000001-0000-1000-8a5a-be785f17dcda");
 191         if (test.timestamp() != 1)
 192             throw new Exception("Incorrect timestamp");
 193         test = UUID.fromString("00000400-0000-1000-8a5a-be785f17dcda");
 194         if (test.timestamp() != 1024)
 195             throw new Exception("Incorrect timestamp");
 196         test = UUID.fromString("FFFFFFFF-FFFF-1FFF-8a5a-be785f17dcda");
 197         if (test.timestamp() != Long.MAX_VALUE>>3)
 198             throw new Exception("Incorrect timestamp");
 199     }
 200 
 201     private static void clockSequenceTest() throws Exception {
 202         UUID test = UUID.randomUUID();
 203         try {
 204             test.clockSequence();
 205             throw new Exception("Expected exception not thrown");
 206         } catch (UnsupportedOperationException uoe) {
 207             // Correct result
 208         }
 209         test = UUID.fromString("00000001-0000-1000-8001-be785f17dcda");
 210         if (test.clockSequence() != 1)
 211             throw new Exception("Incorrect sequence");
 212         test = UUID.fromString("00000001-0000-1000-8002-be785f17dcda");
 213         if (test.clockSequence() != 2)
 214             throw new Exception("Incorrect sequence");
 215         test = UUID.fromString("00000001-0000-1000-8010-be785f17dcda");
 216         if (test.clockSequence() != 16)
 217             throw new Exception("Incorrect sequence");
 218         test = UUID.fromString("00000001-0000-1000-bFFF-be785f17dcda");
 219         if (test.clockSequence() != ((2L<<13)-1)) // 2^14 - 1
 220             throw new Exception("Incorrect sequence");
 221     }
 222 
 223     private static void nodeTest() throws Exception {
 224         UUID test = UUID.randomUUID();
 225         try {
 226             test.node();
 227             throw new Exception("Expected exception not thrown");
 228         } catch (UnsupportedOperationException uoe) {
 229             // Correct result
 230         }
 231         test = UUID.fromString("00000001-0000-1000-8001-000000000001");
 232         if (test.node() != 1)
 233             throw new Exception("Incorrect node");
 234         test = UUID.fromString("00000001-0000-1000-8002-FFFFFFFFFFFF");
 235         if (test.node() != ((2L<<47)-1)) // 2^48 - 1
 236             throw new Exception("Incorrect node");
 237     }
 238 
 239     private static void hashCodeEqualsTest() throws Exception {
 240         // If two UUIDs are equal they must have the same hashCode
 241         for (int i=0; i<100; i++) {
 242             UUID u1 = UUID.randomUUID();
 243             UUID u2 = UUID.fromString(u1.toString());
 244             if (u1.hashCode() != u2.hashCode())
 245                 throw new Exception("Equal UUIDs with different hashcodes");
 246         }
 247         // Test equality of UUIDs with tampered bits
 248         for (int i=0; i<1000; i++) {
 249             long l = generator.nextLong();
 250             long l2 = generator.nextLong();
 251             int position = generator.nextInt(64);
 252             UUID u1 = new UUID(l, l2);
 253             l = l ^ (1L << position);
 254             UUID u2 = new UUID(l, l2);
 255             if (u1.equals(u2))
 256                 throw new Exception("UUIDs with different bits equal");
 257         }
 258     }
 259 
 260     private static void compareTo() throws Exception {
 261         UUID id = new UUID(33L, 63L);
 262         UUID id2 = new UUID(34L, 62L);
 263         UUID id3 = new UUID(34L, 63L);
 264         UUID id4 = new UUID(34L, 64L);
 265         UUID id5 = new UUID(35L, 63L);
 266 
 267         if ((id.compareTo(id2) >= 0) ||
 268             (id2.compareTo(id3) >= 0) ||
 269             (id3.compareTo(id4) >= 0) ||
 270             (id4.compareTo(id5) >= 0))
 271             throw new RuntimeException("compareTo failure");
 272 
 273         if ((id5.compareTo(id4) <= 0) ||
 274             (id4.compareTo(id3) <= 0) ||
 275             (id3.compareTo(id2) <= 0) ||
 276             (id2.compareTo(id) <= 0))
 277             throw new RuntimeException("compareTo failure");
 278 
 279         if (id.compareTo(id) != 0)
 280             throw new RuntimeException("compareTo failure");
 281 
 282     }
 283 
 284 }
--- EOF ---