harmony-tests/src/test/java/org/apache/harmony/tests/java/util/UUIDTest.java - platform/libcore - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */

 package org.apache.harmony.tests.java.util;

 import java.util.UUID;

 import org.apache.harmony.testframework.serialization.SerializationTest;

 import junit.framework.TestCase;

 public class UUIDTest extends TestCase {

     /**
      * @see UUID#UUID(long, long)
      */
     public void test_ConstructorJJ() {
         UUID uuid = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
         assertEquals(2, uuid.variant());
         assertEquals(1, uuid.version());
         assertEquals(0x1d07decf81d4faeL, uuid.timestamp());
         assertEquals(130742845922168750L, uuid.timestamp());
         assertEquals(0x2765, uuid.clockSequence());
         assertEquals(0xA0C91E6BF6L, uuid.node());
     }

     /**
      * @see UUID#getLeastSignificantBits()
      */
     public void test_getLeastSignificantBits() {
         UUID uuid = new UUID(0, 0);
         assertEquals(0, uuid.getLeastSignificantBits());
         uuid = new UUID(0, Long.MIN_VALUE);
         assertEquals(Long.MIN_VALUE, uuid.getLeastSignificantBits());
         uuid = new UUID(0, Long.MAX_VALUE);
         assertEquals(Long.MAX_VALUE, uuid.getLeastSignificantBits());
     }

     /**
      * @see UUID#getMostSignificantBits()
      */
     public void test_getMostSignificantBits() {
         UUID uuid = new UUID(0, 0);
         assertEquals(0, uuid.getMostSignificantBits());
         uuid = new UUID(Long.MIN_VALUE, 0);
         assertEquals(Long.MIN_VALUE, uuid.getMostSignificantBits());
         uuid = new UUID(Long.MAX_VALUE, 0);
         assertEquals(Long.MAX_VALUE, uuid.getMostSignificantBits());
     }

     /**
      * @see UUID#version()
      */
     public void test_version() {
         UUID uuid = new UUID(0, 0);
         assertEquals(0, uuid.version());
         uuid = new UUID(0x0000000000001000L, 0);
         assertEquals(1, uuid.version());
         uuid = new UUID(0x0000000000002000L, 0);
         assertEquals(2, uuid.version());
         uuid = new UUID(0x0000000000003000L, 0);
         assertEquals(3, uuid.version());
         uuid = new UUID(0x0000000000004000L, 0);
         assertEquals(4, uuid.version());
         uuid = new UUID(0x0000000000005000L, 0);
         assertEquals(5, uuid.version());
     }

     /**
      * @see UUID#variant()
      */
     public void test_variant() {
         UUID uuid = new UUID(0, 0x0000000000000000L);
         assertEquals(0, uuid.variant());
         uuid = new UUID(0, 0x7000000000000000L);
         assertEquals(0, uuid.variant());
         uuid = new UUID(0, 0x3000000000000000L);
         assertEquals(0, uuid.variant());
         uuid = new UUID(0, 0x1000000000000000L);
         assertEquals(0, uuid.variant());

         uuid = new UUID(0, 0x8000000000000000L);
         assertEquals(2, uuid.variant());
         uuid = new UUID(0, 0xB000000000000000L);
         assertEquals(2, uuid.variant());
         uuid = new UUID(0, 0xA000000000000000L);
         assertEquals(2, uuid.variant());
         uuid = new UUID(0, 0x9000000000000000L);
         assertEquals(2, uuid.variant());

         uuid = new UUID(0, 0xC000000000000000L);
         assertEquals(6, uuid.variant());
         uuid = new UUID(0, 0xD000000000000000L);
         assertEquals(6, uuid.variant());

         uuid = new UUID(0, 0xE000000000000000L);
         assertEquals(7, uuid.variant());
         uuid = new UUID(0, 0xF000000000000000L);
         assertEquals(7, uuid.variant());
     }

     /**
      * @see UUID#timestamp()
      */
     public void test_timestamp() {
         UUID uuid = new UUID(0x0000000000001000L, 0x8000000000000000L);
         assertEquals(0x0, uuid.timestamp());

         uuid = new UUID(0x7777777755551333L, 0x8000000000000000L);
         assertEquals(0x333555577777777L, uuid.timestamp());

         uuid = new UUID(0x0000000000000000L, 0x8000000000000000L);
         try {
             uuid.timestamp();
             fail("No UnsupportedOperationException");
         } catch (UnsupportedOperationException e) {}

         uuid = new UUID(0x0000000000002000L, 0x8000000000000000L);
         try {
             uuid.timestamp();
             fail("No UnsupportedOperationException");
         } catch (UnsupportedOperationException e) {}
     }

     /**
      * @see UUID#clockSequence()
      */
     public void test_clockSequence() {
         UUID uuid = new UUID(0x0000000000001000L, 0x8000000000000000L);
         assertEquals(0x0, uuid.clockSequence());

         uuid = new UUID(0x0000000000001000L, 0x8FFF000000000000L);
         assertEquals(0x0FFF, uuid.clockSequence());

         uuid = new UUID(0x0000000000001000L, 0xBFFF000000000000L);
         assertEquals(0x3FFF, uuid.clockSequence());

         uuid = new UUID(0x0000000000000000L, 0x8000000000000000L);
         try {
             uuid.clockSequence();
             fail("No UnsupportedOperationException");
         } catch (UnsupportedOperationException e) {}

         uuid = new UUID(0x0000000000002000L, 0x8000000000000000L);
         try {
             uuid.clockSequence();
             fail("No UnsupportedOperationException");
         } catch (UnsupportedOperationException e) {}
     }

     /**
      * @see UUID#node()
      */
     public void test_node() {
         UUID uuid = new UUID(0x0000000000001000L, 0x8000000000000000L);
         assertEquals(0x0, uuid.node());

         uuid = new UUID(0x0000000000001000L, 0x8000FFFFFFFFFFFFL);
         assertEquals(0xFFFFFFFFFFFFL, uuid.node());

         uuid = new UUID(0x0000000000000000L, 0x8000000000000000L);
         try {
             uuid.node();
             fail("No UnsupportedOperationException");
         } catch (UnsupportedOperationException e) {}

         uuid = new UUID(0x0000000000002000L, 0x8000000000000000L);
         try {
             uuid.node();
             fail("No UnsupportedOperationException");
         } catch (UnsupportedOperationException e) {}
     }

     /**
      * @see UUID#compareTo(UUID)
      */
     public void test_compareTo() {
         UUID uuid1 = new UUID(0, 0);
         assertEquals(0, uuid1.compareTo(uuid1));
         UUID uuid2 = new UUID(1, 0);
         assertEquals(-1, uuid1.compareTo(uuid2));
         assertEquals(1, uuid2.compareTo(uuid1));

         uuid2 = new UUID(0, 1);
         assertEquals(-1, uuid1.compareTo(uuid2));
         assertEquals(1, uuid2.compareTo(uuid1));
     }

     /**
      * @see UUID#hashCode()
      */
     public void test_hashCode() {
         UUID uuid = new UUID(0, 0);
         assertEquals(0, uuid.hashCode());
         uuid = new UUID(123, 123);
         UUID uuidClone = new UUID(123, 123);
         assertEquals(uuid.hashCode(), uuidClone.hashCode());
     }

     /**
      * @see UUID#equals(Object)
      */
     public void test_equalsObject() {
         UUID uuid1 = new UUID(0, 0);
         assertEquals(uuid1, uuid1);
         assertFalse(uuid1.equals(null));
         assertFalse(uuid1.equals("NOT A UUID"));
         UUID uuid2 = new UUID(0, 0);
         assertEquals(uuid1, uuid2);
         assertEquals(uuid2, uuid1);

         uuid1 = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
         uuid2 = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
         assertEquals(uuid1, uuid2);
         assertEquals(uuid2, uuid1);

         uuid2 = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf7L);
         assertFalse(uuid1.equals(uuid2));
         assertFalse(uuid2.equals(uuid1));
     }

     /**
      * @see UUID#toString()
      */
     public void test_toString() {
         UUID uuid = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
         String actual = uuid.toString();
         assertEquals("f81d4fae-7dec-11d0-a765-00a0c91e6bf6", actual);

         uuid = new UUID(0x0000000000001000L, 0x8000000000000000L);
         actual = uuid.toString();
         assertEquals("00000000-0000-1000-8000-000000000000", actual);
     }

     /**
      * @tests serialization/deserialization.
      */
     public void testSerializationSelf() throws Exception {
         SerializationTest.verifySelf(new UUID(0xf81d4fae7dec11d0L,
                 0xa76500a0c91e6bf6L));
     }

     /**
      * @tests serialization/deserialization compatibility with RI.
      */
     public void testSerializationCompatibility() throws Exception {
         SerializationTest.verifyGolden(this, new UUID(0xf81d4fae7dec11d0L,
                 0xa76500a0c91e6bf6L));
     }

     /**
      * @see UUID#randomUUID()
      */
     public void test_randomUUID() {
         UUID uuid = UUID.randomUUID();
         assertEquals(2, uuid.variant());
         assertEquals(4, uuid.version());
     }

     /**
      * @see UUID#nameUUIDFromBytes(byte[])
      */
     public void test_nameUUIDFromBytes() throws Exception {
         byte[] name = { (byte) 0x6b, (byte) 0xa7, (byte) 0xb8, (byte) 0x11,
                 (byte) 0x9d, (byte) 0xad, (byte) 0x11, (byte) 0xd1,
                 (byte) 0x80, (byte) 0xb4, (byte) 0x00, (byte) 0xc0,
                 (byte) 0x4f, (byte) 0xd4, (byte) 0x30, (byte) 0xc8 };

         UUID uuid = UUID.nameUUIDFromBytes(name);

         assertEquals(2, uuid.variant());
         assertEquals(3, uuid.version());

         assertEquals(0xaff565bc2f771745L, uuid.getLeastSignificantBits());
         assertEquals(0x14cdb9b4de013faaL, uuid.getMostSignificantBits());

         uuid = UUID.nameUUIDFromBytes(new byte[0]);
         assertEquals(2, uuid.variant());
         assertEquals(3, uuid.version());

         assertEquals(0xa9800998ecf8427eL, uuid.getLeastSignificantBits());
         assertEquals(0xd41d8cd98f003204L, uuid.getMostSignificantBits());

         try {
             UUID.nameUUIDFromBytes(null);
             fail("No NPE");
         } catch (NullPointerException e) {}
     }

     /**
      * @see UUID#fromString(String)
      */
     public void test_fromString() {
         UUID actual = UUID.fromString("f81d4fae-7dec-11d0-a765-00a0c91e6bf6");
         UUID expected = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
         assertEquals(expected, actual);

         assertEquals(2, actual.variant());
         assertEquals(1, actual.version());
         assertEquals(130742845922168750L, actual.timestamp());
         assertEquals(10085, actual.clockSequence());
         assertEquals(690568981494L, actual.node());

         actual = UUID.fromString("00000000-0000-1000-8000-000000000000");
         expected = new UUID(0x0000000000001000L, 0x8000000000000000L);
         assertEquals(expected, actual);

         assertEquals(2, actual.variant());
         assertEquals(1, actual.version());
         assertEquals(0L, actual.timestamp());
         assertEquals(0, actual.clockSequence());
         assertEquals(0L, actual.node());

         try {
             UUID.fromString(null);
             fail("No NPE");
         } catch (NullPointerException e) {}

         try {
             UUID.fromString("");
             fail("No IAE");
         } catch (IllegalArgumentException e) {}

         try {
             UUID.fromString("f81d4fae_7dec-11d0-a765-00a0c91e6bf6");
             fail("No IAE");
         } catch (IllegalArgumentException e) {}

         try {
             UUID.fromString("f81d4fae-7dec_11d0-a765-00a0c91e6bf6");
             fail("No IAE");
         } catch (IllegalArgumentException e) {}

         try {
             UUID.fromString("f81d4fae-7dec-11d0_a765-00a0c91e6bf6");
             fail("No IAE");
         } catch (IllegalArgumentException e) {}

         try {
             UUID.fromString("f81d4fae-7dec-11d0-a765_00a0c91e6bf6");
             fail("No IAE");
         } catch (IllegalArgumentException e) {}
     }

 	/**
 	 * @tests java.util.UUID#fromString(String)
 	 */
 	public void test_fromString_LString_Exception() {

 		UUID uuid = UUID.fromString("0-0-0-0-0");

 		try {
 			uuid = UUID.fromString("0-0-0-0-");
 			fail("should throw IllegalArgumentException");
 		} catch (IllegalArgumentException e) {
 			// expected
 		}

 		try {
 			uuid = UUID.fromString("-0-0-0-0-0");
 			fail("should throw IllegalArgumentException");
 		} catch (IllegalArgumentException e) {
 			// expected
 		}

 		try {
 			uuid = UUID.fromString("-0-0-0-0");
 			fail("should throw IllegalArgumentException");
 		} catch (IllegalArgumentException e) {
 			// expected
 		}

 		try {
 			uuid = UUID.fromString("-0-0-0-");
 			fail("should throw IllegalArgumentException");
 		} catch (IllegalArgumentException e) {
 			// expected
 		}

 		try {
 			uuid = UUID.fromString("0--0-0-0");
 			fail("should throw IllegalArgumentException");
 		} catch (IllegalArgumentException e) {
 			// expected
 		}

 		try {
 			uuid = UUID.fromString("0-0-0-0-");
 			fail("should throw IllegalArgumentException");
 		} catch (IllegalArgumentException e) {
 			// expected
 		}

 		try {
 			uuid = UUID.fromString("-1-0-0-0-0");
 			fail("should throw IllegalArgumentException");
 		} catch (IllegalArgumentException e) {
 			// expected
 		}

 		uuid = UUID.fromString("123456789-0-0-0-0");
 		assertEquals(0x2345678900000000L, uuid.getMostSignificantBits());
 		assertEquals(0x0L, uuid.getLeastSignificantBits());

 		uuid = UUID.fromString("111123456789-0-0-0-0");
 		assertEquals(0x2345678900000000L, uuid.getMostSignificantBits());
 		assertEquals(0x0L, uuid.getLeastSignificantBits());

 		uuid = UUID.fromString("7fffffffffffffff-0-0-0-0");
 		assertEquals(0xffffffff00000000L, uuid.getMostSignificantBits());
 		assertEquals(0x0L, uuid.getLeastSignificantBits());

 		try {
 			uuid = UUID.fromString("8000000000000000-0-0-0-0");
 			fail("should throw NumberFormatException");
 		} catch (NumberFormatException e) {
 			// expected
 		}

 		uuid = UUID
 				.fromString("7fffffffffffffff-7fffffffffffffff-7fffffffffffffff-0-0");
 		assertEquals(0xffffffffffffffffL, uuid.getMostSignificantBits());
 		assertEquals(0x0L, uuid.getLeastSignificantBits());

 		uuid = UUID.fromString("0-0-0-7fffffffffffffff-7fffffffffffffff");
 		assertEquals(0x0L, uuid.getMostSignificantBits());
 		assertEquals(0xffffffffffffffffL, uuid.getLeastSignificantBits());

 		try {
 			uuid = UUID.fromString("0-0-0-8000000000000000-0");
 			fail("should throw NumberFormatException");
 		} catch (NumberFormatException e) {
 			// expected
 		}

 		try {
 			uuid = UUID.fromString("0-0-0-0-8000000000000000");
 			fail("should throw NumberFormatException");
 		} catch (NumberFormatException e) {
 			// expected
 		}
 	}
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/

	package org.apache.harmony.tests.java.util;

	import java.util.UUID;

	import org.apache.harmony.testframework.serialization.SerializationTest;

	import junit.framework.TestCase;

	public class UUIDTest extends TestCase {

	/**
	* @see UUID#UUID(long, long)
	*/
	public void test_ConstructorJJ() {
	UUID uuid = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
	assertEquals(2, uuid.variant());
	assertEquals(1, uuid.version());
	assertEquals(0x1d07decf81d4faeL, uuid.timestamp());
	assertEquals(130742845922168750L, uuid.timestamp());
	assertEquals(0x2765, uuid.clockSequence());
	assertEquals(0xA0C91E6BF6L, uuid.node());
	}

	/**
	* @see UUID#getLeastSignificantBits()
	*/
	public void test_getLeastSignificantBits() {
	UUID uuid = new UUID(0, 0);
	assertEquals(0, uuid.getLeastSignificantBits());
	uuid = new UUID(0, Long.MIN_VALUE);
	assertEquals(Long.MIN_VALUE, uuid.getLeastSignificantBits());
	uuid = new UUID(0, Long.MAX_VALUE);
	assertEquals(Long.MAX_VALUE, uuid.getLeastSignificantBits());
	}

	/**
	* @see UUID#getMostSignificantBits()
	*/
	public void test_getMostSignificantBits() {
	UUID uuid = new UUID(0, 0);
	assertEquals(0, uuid.getMostSignificantBits());
	uuid = new UUID(Long.MIN_VALUE, 0);
	assertEquals(Long.MIN_VALUE, uuid.getMostSignificantBits());
	uuid = new UUID(Long.MAX_VALUE, 0);
	assertEquals(Long.MAX_VALUE, uuid.getMostSignificantBits());
	}

	/**
	* @see UUID#version()
	*/
	public void test_version() {
	UUID uuid = new UUID(0, 0);
	assertEquals(0, uuid.version());
	uuid = new UUID(0x0000000000001000L, 0);
	assertEquals(1, uuid.version());
	uuid = new UUID(0x0000000000002000L, 0);
	assertEquals(2, uuid.version());
	uuid = new UUID(0x0000000000003000L, 0);
	assertEquals(3, uuid.version());
	uuid = new UUID(0x0000000000004000L, 0);
	assertEquals(4, uuid.version());
	uuid = new UUID(0x0000000000005000L, 0);
	assertEquals(5, uuid.version());
	}

	/**
	* @see UUID#variant()
	*/
	public void test_variant() {
	UUID uuid = new UUID(0, 0x0000000000000000L);
	assertEquals(0, uuid.variant());
	uuid = new UUID(0, 0x7000000000000000L);
	assertEquals(0, uuid.variant());
	uuid = new UUID(0, 0x3000000000000000L);
	assertEquals(0, uuid.variant());
	uuid = new UUID(0, 0x1000000000000000L);
	assertEquals(0, uuid.variant());

	uuid = new UUID(0, 0x8000000000000000L);
	assertEquals(2, uuid.variant());
	uuid = new UUID(0, 0xB000000000000000L);
	assertEquals(2, uuid.variant());
	uuid = new UUID(0, 0xA000000000000000L);
	assertEquals(2, uuid.variant());
	uuid = new UUID(0, 0x9000000000000000L);
	assertEquals(2, uuid.variant());

	uuid = new UUID(0, 0xC000000000000000L);
	assertEquals(6, uuid.variant());
	uuid = new UUID(0, 0xD000000000000000L);
	assertEquals(6, uuid.variant());

	uuid = new UUID(0, 0xE000000000000000L);
	assertEquals(7, uuid.variant());
	uuid = new UUID(0, 0xF000000000000000L);
	assertEquals(7, uuid.variant());
	}

	/**
	* @see UUID#timestamp()
	*/
	public void test_timestamp() {
	UUID uuid = new UUID(0x0000000000001000L, 0x8000000000000000L);
	assertEquals(0x0, uuid.timestamp());

	uuid = new UUID(0x7777777755551333L, 0x8000000000000000L);
	assertEquals(0x333555577777777L, uuid.timestamp());

	uuid = new UUID(0x0000000000000000L, 0x8000000000000000L);
	try {
	uuid.timestamp();
	fail("No UnsupportedOperationException");
	} catch (UnsupportedOperationException e) {}

	uuid = new UUID(0x0000000000002000L, 0x8000000000000000L);
	try {
	uuid.timestamp();
	fail("No UnsupportedOperationException");
	} catch (UnsupportedOperationException e) {}
	}

	/**
	* @see UUID#clockSequence()
	*/
	public void test_clockSequence() {
	UUID uuid = new UUID(0x0000000000001000L, 0x8000000000000000L);
	assertEquals(0x0, uuid.clockSequence());

	uuid = new UUID(0x0000000000001000L, 0x8FFF000000000000L);
	assertEquals(0x0FFF, uuid.clockSequence());

	uuid = new UUID(0x0000000000001000L, 0xBFFF000000000000L);
	assertEquals(0x3FFF, uuid.clockSequence());

	uuid = new UUID(0x0000000000000000L, 0x8000000000000000L);
	try {
	uuid.clockSequence();
	fail("No UnsupportedOperationException");
	} catch (UnsupportedOperationException e) {}

	uuid = new UUID(0x0000000000002000L, 0x8000000000000000L);
	try {
	uuid.clockSequence();
	fail("No UnsupportedOperationException");
	} catch (UnsupportedOperationException e) {}
	}

	/**
	* @see UUID#node()
	*/
	public void test_node() {
	UUID uuid = new UUID(0x0000000000001000L, 0x8000000000000000L);
	assertEquals(0x0, uuid.node());

	uuid = new UUID(0x0000000000001000L, 0x8000FFFFFFFFFFFFL);
	assertEquals(0xFFFFFFFFFFFFL, uuid.node());

	uuid = new UUID(0x0000000000000000L, 0x8000000000000000L);
	try {
	uuid.node();
	fail("No UnsupportedOperationException");
	} catch (UnsupportedOperationException e) {}

	uuid = new UUID(0x0000000000002000L, 0x8000000000000000L);
	try {
	uuid.node();
	fail("No UnsupportedOperationException");
	} catch (UnsupportedOperationException e) {}
	}

	/**
	* @see UUID#compareTo(UUID)
	*/
	public void test_compareTo() {
	UUID uuid1 = new UUID(0, 0);
	assertEquals(0, uuid1.compareTo(uuid1));
	UUID uuid2 = new UUID(1, 0);
	assertEquals(-1, uuid1.compareTo(uuid2));
	assertEquals(1, uuid2.compareTo(uuid1));

	uuid2 = new UUID(0, 1);
	assertEquals(-1, uuid1.compareTo(uuid2));
	assertEquals(1, uuid2.compareTo(uuid1));
	}

	/**
	* @see UUID#hashCode()
	*/
	public void test_hashCode() {
	UUID uuid = new UUID(0, 0);
	assertEquals(0, uuid.hashCode());
	uuid = new UUID(123, 123);
	UUID uuidClone = new UUID(123, 123);
	assertEquals(uuid.hashCode(), uuidClone.hashCode());
	}

	/**
	* @see UUID#equals(Object)
	*/
	public void test_equalsObject() {
	UUID uuid1 = new UUID(0, 0);
	assertEquals(uuid1, uuid1);
	assertFalse(uuid1.equals(null));
	assertFalse(uuid1.equals("NOT A UUID"));
	UUID uuid2 = new UUID(0, 0);
	assertEquals(uuid1, uuid2);
	assertEquals(uuid2, uuid1);

	uuid1 = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
	uuid2 = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
	assertEquals(uuid1, uuid2);
	assertEquals(uuid2, uuid1);

	uuid2 = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf7L);
	assertFalse(uuid1.equals(uuid2));
	assertFalse(uuid2.equals(uuid1));
	}

	/**
	* @see UUID#toString()
	*/
	public void test_toString() {
	UUID uuid = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
	String actual = uuid.toString();
	assertEquals("f81d4fae-7dec-11d0-a765-00a0c91e6bf6", actual);

	uuid = new UUID(0x0000000000001000L, 0x8000000000000000L);
	actual = uuid.toString();
	assertEquals("00000000-0000-1000-8000-000000000000", actual);
	}

	/**
	* @tests serialization/deserialization.
	*/
	public void testSerializationSelf() throws Exception {
	SerializationTest.verifySelf(new UUID(0xf81d4fae7dec11d0L,
	0xa76500a0c91e6bf6L));
	}

	/**
	* @tests serialization/deserialization compatibility with RI.
	*/
	public void testSerializationCompatibility() throws Exception {
	SerializationTest.verifyGolden(this, new UUID(0xf81d4fae7dec11d0L,
	0xa76500a0c91e6bf6L));
	}

	/**
	* @see UUID#randomUUID()
	*/
	public void test_randomUUID() {
	UUID uuid = UUID.randomUUID();
	assertEquals(2, uuid.variant());
	assertEquals(4, uuid.version());
	}

	/**
	* @see UUID#nameUUIDFromBytes(byte[])
	*/
	public void test_nameUUIDFromBytes() throws Exception {
	byte[] name = { (byte) 0x6b, (byte) 0xa7, (byte) 0xb8, (byte) 0x11,
	(byte) 0x9d, (byte) 0xad, (byte) 0x11, (byte) 0xd1,
	(byte) 0x80, (byte) 0xb4, (byte) 0x00, (byte) 0xc0,
	(byte) 0x4f, (byte) 0xd4, (byte) 0x30, (byte) 0xc8 };

	UUID uuid = UUID.nameUUIDFromBytes(name);

	assertEquals(2, uuid.variant());
	assertEquals(3, uuid.version());

	assertEquals(0xaff565bc2f771745L, uuid.getLeastSignificantBits());
	assertEquals(0x14cdb9b4de013faaL, uuid.getMostSignificantBits());

	uuid = UUID.nameUUIDFromBytes(new byte[0]);
	assertEquals(2, uuid.variant());
	assertEquals(3, uuid.version());

	assertEquals(0xa9800998ecf8427eL, uuid.getLeastSignificantBits());
	assertEquals(0xd41d8cd98f003204L, uuid.getMostSignificantBits());

	try {
	UUID.nameUUIDFromBytes(null);
	fail("No NPE");
	} catch (NullPointerException e) {}
	}

	/**
	* @see UUID#fromString(String)
	*/
	public void test_fromString() {
	UUID actual = UUID.fromString("f81d4fae-7dec-11d0-a765-00a0c91e6bf6");
	UUID expected = new UUID(0xf81d4fae7dec11d0L, 0xa76500a0c91e6bf6L);
	assertEquals(expected, actual);

	assertEquals(2, actual.variant());
	assertEquals(1, actual.version());
	assertEquals(130742845922168750L, actual.timestamp());
	assertEquals(10085, actual.clockSequence());
	assertEquals(690568981494L, actual.node());

	actual = UUID.fromString("00000000-0000-1000-8000-000000000000");
	expected = new UUID(0x0000000000001000L, 0x8000000000000000L);
	assertEquals(expected, actual);

	assertEquals(2, actual.variant());
	assertEquals(1, actual.version());
	assertEquals(0L, actual.timestamp());
	assertEquals(0, actual.clockSequence());
	assertEquals(0L, actual.node());

	try {
	UUID.fromString(null);
	fail("No NPE");
	} catch (NullPointerException e) {}

	try {
	UUID.fromString("");
	fail("No IAE");
	} catch (IllegalArgumentException e) {}

	try {
	UUID.fromString("f81d4fae_7dec-11d0-a765-00a0c91e6bf6");
	fail("No IAE");
	} catch (IllegalArgumentException e) {}

	try {
	UUID.fromString("f81d4fae-7dec_11d0-a765-00a0c91e6bf6");
	fail("No IAE");
	} catch (IllegalArgumentException e) {}

	try {
	UUID.fromString("f81d4fae-7dec-11d0_a765-00a0c91e6bf6");
	fail("No IAE");
	} catch (IllegalArgumentException e) {}

	try {
	UUID.fromString("f81d4fae-7dec-11d0-a765_00a0c91e6bf6");
	fail("No IAE");
	} catch (IllegalArgumentException e) {}
	}

	/**
	* @tests java.util.UUID#fromString(String)
	*/
	public void test_fromString_LString_Exception() {

	UUID uuid = UUID.fromString("0-0-0-0-0");

	try {
	uuid = UUID.fromString("0-0-0-0-");
	fail("should throw IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	// expected
	}

	try {
	uuid = UUID.fromString("-0-0-0-0-0");
	fail("should throw IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	// expected
	}

	try {
	uuid = UUID.fromString("-0-0-0-0");
	fail("should throw IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	// expected
	}

	try {
	uuid = UUID.fromString("-0-0-0-");
	fail("should throw IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	// expected
	}

	try {
	uuid = UUID.fromString("0--0-0-0");
	fail("should throw IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	// expected
	}

	try {
	uuid = UUID.fromString("0-0-0-0-");
	fail("should throw IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	// expected
	}

	try {
	uuid = UUID.fromString("-1-0-0-0-0");
	fail("should throw IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	// expected
	}

	uuid = UUID.fromString("123456789-0-0-0-0");
	assertEquals(0x2345678900000000L, uuid.getMostSignificantBits());
	assertEquals(0x0L, uuid.getLeastSignificantBits());

	uuid = UUID.fromString("111123456789-0-0-0-0");
	assertEquals(0x2345678900000000L, uuid.getMostSignificantBits());
	assertEquals(0x0L, uuid.getLeastSignificantBits());

	uuid = UUID.fromString("7fffffffffffffff-0-0-0-0");
	assertEquals(0xffffffff00000000L, uuid.getMostSignificantBits());
	assertEquals(0x0L, uuid.getLeastSignificantBits());

	try {
	uuid = UUID.fromString("8000000000000000-0-0-0-0");
	fail("should throw NumberFormatException");
	} catch (NumberFormatException e) {
	// expected
	}

	uuid = UUID
	.fromString("7fffffffffffffff-7fffffffffffffff-7fffffffffffffff-0-0");
	assertEquals(0xffffffffffffffffL, uuid.getMostSignificantBits());
	assertEquals(0x0L, uuid.getLeastSignificantBits());

	uuid = UUID.fromString("0-0-0-7fffffffffffffff-7fffffffffffffff");
	assertEquals(0x0L, uuid.getMostSignificantBits());
	assertEquals(0xffffffffffffffffL, uuid.getLeastSignificantBits());

	try {
	uuid = UUID.fromString("0-0-0-8000000000000000-0");
	fail("should throw NumberFormatException");
	} catch (NumberFormatException e) {
	// expected
	}

	try {
	uuid = UUID.fromString("0-0-0-0-8000000000000000");
	fail("should throw NumberFormatException");
	} catch (NumberFormatException e) {
	// expected
	}
	}
	}