41         variantTest();
  42         timestampTest();
  43         clockSequenceTest();
  44         nodeTest();
  45         hashCodeEqualsTest();
  46         compareTo();
  47     }
  48 
  49     // Verify that list.contains detects UUID collisons
  50     private static void containsTest() throws Exception {
  51         List list = new LinkedList();
  52         list.add(new UUID(4,4));
  53         if (!list.contains(new UUID(4,4)))
  54             throw new Exception("contains test did not work as expected");
  55     }
  56 
  57     private static void randomUUIDTest() throws Exception {
  58         List list = new LinkedList();
  59         for (int i=0; i<100; i++) {
  60             UUID u1 = UUID.randomUUID();






  61             if (list.contains(u1))
  62                 throw new Exception("random UUID collision very unlikely");
  63             list.add(u1);
  64         }
  65     }
  66 
  67     private static void nameUUIDFromBytesTest() throws Exception {
  68         Random byteSource = new Random();
  69         byte[] someBytes = new byte[12];
  70         List list = new LinkedList();
  71         for (int i=0; i<100; i++) {
  72             byteSource.nextBytes(someBytes);
  73             UUID test = UUID.nameUUIDFromBytes(someBytes);
  74             if (list.contains(test))






  75                 throw new Exception("byte UUID collision very unlikely");
  76             list.add(test);
  77         }
  78     }
  79 
  80     private static void stringTest() throws Exception {
  81         for (int i=0; i<100; i++) {
  82             UUID u1 = UUID.randomUUID();
  83             UUID u2 = UUID.fromString(u1.toString());
  84             if (!u1.equals(u2))
  85                 throw new Exception("UUID -> string -> UUID failed");
  86         }
  87     }
  88 
  89     private static void versionTest() throws Exception {
  90         UUID test = UUID.randomUUID();
  91         if (test.version() != 4)
  92             throw new Exception("randomUUID not type 4");
  93         Random byteSource = new Random();
  94         byte[] someBytes = new byte[12];
  95         byteSource.nextBytes(someBytes);
  96         test = UUID.nameUUIDFromBytes(someBytes);

  41         variantTest();
  42         timestampTest();
  43         clockSequenceTest();
  44         nodeTest();
  45         hashCodeEqualsTest();
  46         compareTo();
  47     }
  48 
  49     // Verify that list.contains detects UUID collisons
  50     private static void containsTest() throws Exception {
  51         List list = new LinkedList();
  52         list.add(new UUID(4,4));
  53         if (!list.contains(new UUID(4,4)))
  54             throw new Exception("contains test did not work as expected");
  55     }
  56 
  57     private static void randomUUIDTest() throws Exception {
  58         List list = new LinkedList();
  59         for (int i=0; i<100; i++) {
  60             UUID u1 = UUID.randomUUID();
  61             if(4 != u1.version()) {
  62                 throw new Exception("bad version");
  63             }
  64             if(2 != u1.variant()) {
  65                 throw new Exception("bad variant");
  66             }
  67             if (list.contains(u1))
  68                 throw new Exception("random UUID collision very unlikely");
  69             list.add(u1);
  70         }
  71     }
  72 
  73     private static void nameUUIDFromBytesTest() throws Exception {
  74         Random byteSource = new Random();
  75         byte[] someBytes = new byte[12];
  76         List list = new LinkedList();
  77         for (int i=0; i<100; i++) {
  78             byteSource.nextBytes(someBytes);
  79             UUID u1 = UUID.nameUUIDFromBytes(someBytes);
  80             if(3 != u1.version()) {
  81                 throw new Exception("bad version");
  82             }
  83             if(2 != u1.variant()) {
  84                 throw new Exception("bad variant");
  85             }
  86             if (list.contains(u1))
  87                 throw new Exception("byte UUID collision very unlikely");
  88             list.add(u1);
  89         }
  90     }
  91 
  92     private static void stringTest() throws Exception {
  93         for (int i=0; i<100; i++) {
  94             UUID u1 = UUID.randomUUID();
  95             UUID u2 = UUID.fromString(u1.toString());
  96             if (!u1.equals(u2))
  97                 throw new Exception("UUID -> string -> UUID failed");
  98         }
  99     }
 100 
 101     private static void versionTest() throws Exception {
 102         UUID test = UUID.randomUUID();
 103         if (test.version() != 4)
 104             throw new Exception("randomUUID not type 4");
 105         Random byteSource = new Random();
 106         byte[] someBytes = new byte[12];
 107         byteSource.nextBytes(someBytes);
 108         test = UUID.nameUUIDFromBytes(someBytes);