Backups/TwelveMonkeys
2
0
Fork 0
mirror of https://github.com/haraldk/TwelveMonkeys.git synced 2025-08-02 11:05:29 -04:00
Code Issues Projects Releases Wiki Activity

More fine-grained tests for UUIDFactory.

Browse Source
This commit is contained in:
Harald Kuhr 2012-03-20 12:13:17 +01:00
parent f7bc246bad
commit 6430841dcc
2 changed files with 80 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
sandbox/sandbox-common/src/main/java/com/twelvemonkeys/util/UUIDFactory.java
View File

@ -51,10 +51,9 @@ import java.util.*;
* <p>
* <a name="mac-node"></a>
* The node value for version 1 {@code UUID}s will, by default, reflect the IEEE 802 (mac) address of one of
* the network interfaces of the local computer.
* This node value can be manually overridden by setting
* the network interfaces of the local computer. This node value can be manually overridden by setting
* the system property {@code "com.twelvemonkeys.util.UUID.node"} to a valid IEEE 802 address, on the form
* {@code 12:34:56:78:9a:bc} or {@code 12-34-45-78-9a-bc}.
* {@code "12:34:56:78:9a:bc"} or {@code "12-34-45-78-9a-bc"}.
* </p>
* <p>
* <a name="random-node"></a>
@ -211,7 +210,7 @@ public final class UUIDFactory {
throw new IllegalStateException("Could not determine IEEE 802 (mac) address for node");
}
return new UUID(createTimeAndVersion(), createClockSeqAndNode(MAC_ADDRESS_NODE));
return createTimeBasedUUIDforNode(MAC_ADDRESS_NODE);
}
/**
@ -228,7 +227,11 @@ public final class UUIDFactory {
* @throws IllegalStateException if the IEEE 802 (mac) address of the computer (node) cannot be found.
*/
public static UUID timeRandomBasedUUID() {
return new UUID(createTimeAndVersion(), createClockSeqAndNode(SECURE_RANDOM_NODE));
return createTimeBasedUUIDforNode(SECURE_RANDOM_NODE);
}
private static UUID createTimeBasedUUIDforNode(final long node) {
return new UUID(createTimeAndVersion(), createClockSeqAndNode(node));
}
// TODO: Version 2 UUID?

107
sandbox/sandbox-common/src/test/java/com/twelvemonkeys/util/UUIDFactoryTest.java
View File

@ -7,6 +7,7 @@ import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@ -20,25 +21,33 @@ public class UUIDFactoryTest {
// Nil UUID
@Test
public void testNilUUID() {
UUID a = UUID.fromString("00000000-0000-0000-0000-000000000000");
UUID b = new UUID(0l, 0l);
assertEquals(UUIDFactory.NIL, b);
assertEquals(UUIDFactory.NIL, a);
assertEquals(a, b); // Sanity
public void testNilUUIDVariant() {
assertEquals(0, UUIDFactory.NIL.variant());
}
@Test
public void testNilUUIDVersion() {
assertEquals(0, UUIDFactory.NIL.version());
}
@Test
public void testNilUUIDFromStringRep() {
assertEquals(UUID.fromString("00000000-0000-0000-0000-000000000000"), UUIDFactory.NIL);
}
@Test
public void testNilUUIDFromLong() {
assertEquals(new UUID(0l, 0l), UUIDFactory.NIL);
}
// Version 3 UUIDs (for comparison with v5)
@Test
public void testVersion3NameBasedMD5VariantVersion() throws UnsupportedEncodingException {
UUID a = UUID.nameUUIDFromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8"));
assertEquals(2, a.variant());
assertEquals(3, a.version());
public void testVersion3NameBasedMD5Variant() throws UnsupportedEncodingException {
assertEquals(2, UUID.nameUUIDFromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8")).variant());
}
@Test
public void testVersion3NameBasedMD5Version() throws UnsupportedEncodingException {
assertEquals(3, UUID.nameUUIDFromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8")).version());
}
@Test
@ -51,7 +60,8 @@ public class UUIDFactoryTest {
@Test
public void testVersion3NameBasedMD5NotEqualSHA1() throws UnsupportedEncodingException {
UUID a = UUID.nameUUIDFromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8"));
assertFalse(a.equals(UUIDFactory.nameUUIDv5FromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8"))));
UUID b = UUIDFactory.nameUUIDv5FromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8"));
assertFalse(a.equals(b));
}
@Test
@ -63,9 +73,13 @@ public class UUIDFactoryTest {
// Version 5 UUIDs
@Test
public void testVersion5NameBasedSHA1VariantVersion() throws UnsupportedEncodingException {
public void testVersion5NameBasedSHA1Variant() throws UnsupportedEncodingException {
UUID a = UUIDFactory.nameUUIDv5FromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8"));
assertEquals(2, a.variant());
}
@Test
public void testVersion5NameBasedSHA1Version() throws UnsupportedEncodingException {
UUID a = UUIDFactory.nameUUIDv5FromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8"));
assertEquals(5, a.version());
}
@ -76,10 +90,29 @@ public class UUIDFactoryTest {
assertEquals(a, b);
}
@Test
public void testVersion5NameBasedSHA1Different() throws UnsupportedEncodingException {
Random random = new Random();
byte[] data = new byte[128];
random.nextBytes(data);
UUID a = UUIDFactory.nameUUIDv5FromBytes(data);
// Swap a random byte with its "opposite"
int i;
while (data[i = random.nextInt(data.length)] == data[data.length - 1 - i]) {}
data[i] = data[data.length - 1 - i];
UUID b = UUIDFactory.nameUUIDv5FromBytes(data);
assertFalse(a.equals(b));
}
@Test
public void testVersion5NameBasedSHA1NotEqualMD5() throws UnsupportedEncodingException {
UUID a = UUIDFactory.nameUUIDv5FromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8"));
assertFalse(a.equals(UUID.nameUUIDFromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8"))));
UUID b = UUID.nameUUIDFromBytes(EXAMPLE_COM_UUID.getBytes("UTF-8"));
assertFalse(a.equals(b));
}
@Test
@ -91,10 +124,19 @@ public class UUIDFactoryTest {
// Version 1 UUIDs
@Test
public void testVersion1NodeBasedVariantVersion() {
public void testVersion1NodeBasedVariant() {
assertEquals(2, UUIDFactory.timeNodeBasedUUID().variant());
}
@Test
public void testVersion1NodeBasedVersion() {
assertEquals(1, UUIDFactory.timeNodeBasedUUID().version());
}
@Test
public void testVersion1NodeBasedFromStringRep() {
UUID uuid = UUIDFactory.timeNodeBasedUUID();
assertEquals(2, uuid.variant());
assertEquals(1, uuid.version());
assertEquals(uuid, UUID.fromString(uuid.toString()));
}
@Test
@ -104,12 +146,6 @@ public class UUIDFactoryTest {
// TODO: Test that this is actually a Mac address from the local computer, or specified through system property?
}
@Test
public void testVersion1NodeBasedFromStringRep() {
UUID uuid = UUIDFactory.timeNodeBasedUUID();
assertEquals(uuid, UUID.fromString(uuid.toString()));
}
@Test
public void testVersion1NodeBasedClockSeq() {
UUID uuid = UUIDFactory.timeNodeBasedUUID();
@ -145,17 +181,13 @@ public class UUIDFactoryTest {
}
@Test
public void testVersion1SecureRandomVariantVersion() {
UUID uuid = UUIDFactory.timeRandomBasedUUID();
assertEquals(2, uuid.variant());
assertEquals(1, uuid.version());
public void testVersion1SecureRandomVariant() {
assertEquals(2, UUIDFactory.timeRandomBasedUUID().variant());
}
@Test
public void testVersion1SecureRandomNode() {
UUID uuid = UUIDFactory.timeRandomBasedUUID();
assertEquals(UUIDFactory.SECURE_RANDOM_NODE, uuid.node());
public void testVersion1SecureRandomVersion() {
assertEquals(1, UUIDFactory.timeRandomBasedUUID().version());
}
@Test
@ -164,6 +196,12 @@ public class UUIDFactoryTest {
assertEquals(uuid, UUID.fromString(uuid.toString()));
}
@Test
public void testVersion1SecureRandomNode() {
UUID uuid = UUIDFactory.timeRandomBasedUUID();
assertEquals(UUIDFactory.SECURE_RANDOM_NODE, uuid.node());
}
@Test
public void testVersion1SecureRandomClockSeq() {
UUID uuid = UUIDFactory.timeRandomBasedUUID();
@ -296,8 +334,7 @@ public class UUIDFactoryTest {
@Test(expected = NumberFormatException.class)
public void testParseNodeAddressesBadAddress4() {
long[] longs = UUIDFactory.parseMacAddressNodes("00:11:22:33:44:550");
System.err.println("Long: " + Long.toHexString(longs[0]));
UUIDFactory.parseMacAddressNodes("00:11:22:33:44:550");
}
@Test(expected = NumberFormatException.class)
@ -347,7 +384,7 @@ public class UUIDFactoryTest {
public void testComparatorRandom() {
final Comparator<UUID> comparator = UUIDFactory.comparator();
for (int i = 0; i < 1000; i++) {
for (int i = 0; i < 10000; i++) {
UUID one = UUID.randomUUID();
UUID two = UUID.randomUUID();