diff --git a/src/main/java/com/fasterxml/uuid/Jug.java b/src/main/java/com/fasterxml/uuid/Jug.java index 3b9a71f..b019447 100644 --- a/src/main/java/com/fasterxml/uuid/Jug.java +++ b/src/main/java/com/fasterxml/uuid/Jug.java @@ -47,7 +47,7 @@ public class Jug OPTIONS.put("verbose", "v"); } - protected static void printUsage() + protected void printUsage() { String clsName = Jug.class.getName(); System.err.println("Usage: java "+clsName+" [options] type"); @@ -75,7 +75,7 @@ protected static void printUsage() System.err.println(" epoch-based / e: generate UUID based on current time (as 'epoch') and random number"); } - private static void printMap(Map m, PrintStream out, boolean option) + private void printMap(Map m, PrintStream out, boolean option) { int i = 0; int len = m.size(); @@ -102,6 +102,10 @@ private static void printMap(Map m, PrintStream out, boolean opti public static void main(String[] args) { + new Jug().run(args); + } + + public void run(String[] args) { if (args.length == 0) { printUsage(); return; @@ -123,7 +127,7 @@ public static void main(String[] args) if (tmp == null) { if (!TYPES.containsValue(type)) { System.err.println("Unrecognized UUID generation type '"+ - type+"'; currently available ones are:"); + type+"'; currently available ones are:"); printMap(TYPES, System.err, false); System.err.println(); System.exit(1); @@ -136,7 +140,7 @@ public static void main(String[] args) NoArgGenerator noArgGenerator = null; // random- or time-based StringArgGenerator nameArgGenerator = null; // name-based - + for (int i = 0; i < count; ++i) { String opt = args[i]; @@ -170,46 +174,46 @@ public static void main(String[] args) try { String next; switch (option) { - case 'c': - // Need a number now: - next = args[++i]; - try { - genCount = Integer.parseInt(next); - } catch (NumberFormatException nex) { - System.err.println("Invalid number argument for option '"+opt+"', exiting."); - System.exit(1); - } - if (genCount < 1) { - System.err.println("Invalid number argument for option '"+opt+"'; negative numbers not allowed, ignoring (defaults to 1)."); - } - break; - case 'e': - // Need the ethernet address: - next = args[++i]; - try { - addr = EthernetAddress.valueOf(next); - } catch (NumberFormatException nex) { - System.err.println("Invalid ethernet address for option '"+opt+"', error: "+nex.toString()); - System.exit(1); - } - break; - case 'h': - printUsage(); - return; - case 'n': - // Need the name - name = args[++i]; - break; - case 'p': // performance: - performance = true; - break; - case 's': - // Need the namespace id - nameSpace = args[++i]; - break; - case 'v': - verbose = true; - break; + case 'c': + // Need a number now: + next = args[++i]; + try { + genCount = Integer.parseInt(next); + } catch (NumberFormatException nex) { + System.err.println("Invalid number argument for option '"+opt+"', exiting."); + System.exit(1); + } + if (genCount < 1) { + System.err.println("Invalid number argument for option '"+opt+"'; negative numbers not allowed, ignoring (defaults to 1)."); + } + break; + case 'e': + // Need the ethernet address: + next = args[++i]; + try { + addr = EthernetAddress.valueOf(next); + } catch (NumberFormatException nex) { + System.err.println("Invalid ethernet address for option '"+opt+"', error: "+nex.toString()); + System.exit(1); + } + break; + case 'h': + printUsage(); + return; + case 'n': + // Need the name + name = args[++i]; + break; + case 'p': // performance: + performance = true; + break; + case 's': + // Need the namespace id + nameSpace = args[++i]; + break; + case 'v': + verbose = true; + break; } } catch (IndexOutOfBoundsException ie) { // We get here when an arg is missing... @@ -227,80 +231,80 @@ public static void main(String[] args) boolean usesRnd = false; switch (typeC) { - case 't': // time-based - case 'o': // reordered-time-based (Version 6) - // 30-Jun-2022, tatu: Is this true? My former self must have had his - // reasons so leaving as is but... odd. - usesRnd = true; - // No address specified? Need a dummy one... - if (addr == null) { - if (verbose) { - System.out.print("(no address specified, generating dummy address: "); + case 't': // time-based + case 'o': // reordered-time-based (Version 6) + // 30-Jun-2022, tatu: Is this true? My former self must have had his + // reasons so leaving as is but... odd. + usesRnd = true; + // No address specified? Need a dummy one... + if (addr == null) { + if (verbose) { + System.out.print("(no address specified, generating dummy address: "); + } + addr = EthernetAddress.constructMulticastAddress(new java.util.Random(System.currentTimeMillis())); + if (verbose) { + System.out.print(addr.toString()); + System.out.println(")"); + } } - addr = EthernetAddress.constructMulticastAddress(new java.util.Random(System.currentTimeMillis())); - if (verbose) { - System.out.print(addr.toString()); - System.out.println(")"); + noArgGenerator = (typeC == 't') + ? Generators.timeBasedGenerator(addr) + : Generators.timeBasedReorderedGenerator(addr); + break; + case 'r': // random-based + usesRnd = true; + { + SecureRandom r = new SecureRandom(); + if (verbose) { + System.out.print("(using secure random generator, info = '"+r.getProvider().getInfo()+"')"); + } + noArgGenerator = Generators.randomBasedGenerator(r); } - } - noArgGenerator = (typeC == 't') - ? Generators.timeBasedGenerator(addr) - : Generators.timeBasedReorderedGenerator(addr); - break; - case 'r': // random-based - usesRnd = true; - { - SecureRandom r = new SecureRandom(); - if (verbose) { - System.out.print("(using secure random generator, info = '"+r.getProvider().getInfo()+"')"); + break; + case 'e': // epoch-time-based + usesRnd = true; + { + SecureRandom r = new SecureRandom(); + if (verbose) { + System.out.print("(using secure random generator, info = '"+r.getProvider().getInfo()+"')"); + } + noArgGenerator = Generators.timeBasedEpochGenerator(r); } - noArgGenerator = Generators.randomBasedGenerator(r); - } - break; - case 'e': // epoch-time-based - usesRnd = true; - { - SecureRandom r = new SecureRandom(); - if (verbose) { - System.out.print("(using secure random generator, info = '"+r.getProvider().getInfo()+"')"); + break; + case 'm': // random-epoch-time-based + usesRnd = true; + { + SecureRandom r = new SecureRandom(); + if (verbose) { + System.out.print("(using secure random generator, info = '"+r.getProvider().getInfo()+"')"); + } + noArgGenerator = Generators.timeBasedEpochRandomGenerator(r); } - noArgGenerator = Generators.timeBasedEpochGenerator(r); - } - break; - case 'm': // random-epoch-time-based - usesRnd = true; - { - SecureRandom r = new SecureRandom(); - if (verbose) { - System.out.print("(using secure random generator, info = '"+r.getProvider().getInfo()+"')"); + break; + case 'n': // name-based + if (nameSpace == null) { + System.err.println("--name-space (-s) - argument missing when using method that requires it, exiting."); + System.exit(1); } - noArgGenerator = Generators.timeBasedEpochRandomGenerator(r); - } - break; - case 'n': // name-based - if (nameSpace == null) { - System.err.println("--name-space (-s) - argument missing when using method that requires it, exiting."); - System.exit(1); - } - if (name == null) { - System.err.println("--name (-n) - argument missing when using method that requires it, exiting."); - System.exit(1); - } - if (typeC == 'n') { - String orig = nameSpace; - nameSpace = nameSpace.toLowerCase(); - if (nameSpace.equals("url")) { - nsUUID = NameBasedGenerator.NAMESPACE_URL; - } else if (nameSpace.equals("dns")) { - nsUUID = NameBasedGenerator.NAMESPACE_DNS; - } else { - System.err.println("Unrecognized namespace '"+orig - +"'; only DNS and URL allowed for name-based generation."); + if (name == null) { + System.err.println("--name (-n) - argument missing when using method that requires it, exiting."); System.exit(1); } - } - nameArgGenerator = Generators.nameBasedGenerator(nsUUID); - break; + if (typeC == 'n') { + String orig = nameSpace; + nameSpace = nameSpace.toLowerCase(); + if (nameSpace.equals("url")) { + nsUUID = NameBasedGenerator.NAMESPACE_URL; + } else if (nameSpace.equals("dns")) { + nsUUID = NameBasedGenerator.NAMESPACE_DNS; + } else { + System.err.println("Unrecognized namespace '"+orig + +"'; only DNS and URL allowed for name-based generation."); + System.exit(1); + } + } + nameArgGenerator = Generators.nameBasedGenerator(nsUUID); + break; } // And then let's rock: diff --git a/src/test/java/com/fasterxml/uuid/JugNamedTest.java b/src/test/java/com/fasterxml/uuid/JugNamedTest.java new file mode 100644 index 0000000..2352a94 --- /dev/null +++ b/src/test/java/com/fasterxml/uuid/JugNamedTest.java @@ -0,0 +1,178 @@ +package com.fasterxml.uuid; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.lang.reflect.Array; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.UUID; + +import static org.hamcrest.core.StringContains.containsString; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; + +@RunWith(Parameterized.class) +public class JugNamedTest { + @Parameterized.Parameter + public UseCase useCase; + + private PrintStream oldStrOut; + private PrintStream oldStrErr; + + private final ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + private final ByteArrayOutputStream errContent = new ByteArrayOutputStream(); + private Jug jug_underTest; + + @Before + public void setup() { + jug_underTest = new Jug();oldStrOut = System.out; + oldStrErr = System.err; + PrintStream stubbedStream = new PrintStream(outContent); + System.setOut(stubbedStream); + PrintStream stubbedErrStream = new PrintStream(errContent); + System.setErr(stubbedErrStream); + } + + @After + public void cleanup() { + System.setOut(oldStrOut); + System.setErr(oldStrErr); + } + + @Test + public void run_shouldProduceUUID() { + // given + + // when + List arguments = useCase.getArgs(); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then - if it is a UUID then we should be able to parse it back out + String actualUuid = outContent.toString(); + assertEquals('\n', actualUuid.charAt(actualUuid.length() - 1)); + + assertEquals(UUID.class, + UUID.fromString(actualUuid.substring(0, actualUuid.length() - 1)).getClass()); + } + + @Test + public void run_givenCount3_shouldProduceUUID() { + // given + + // when + List arguments = useCase.getArgs(); + arguments.add(0, "-c"); + arguments.add(1, "3"); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then - if it is a UUID then we should be able to parse it back out + String[] actualUuids = outContent.toString().split("\n"); + for(String actualUuid: actualUuids) { + assertEquals(UUID.class, + UUID.fromString(actualUuid).getClass()); + } + } + + @Test + public void run_givenPerformance_shouldProducePerformanceInfo() { + // given + + // when + List arguments = useCase.getArgs(); + arguments.add(0, "-p"); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then + String actualOutput = outContent.toString(); + + assertThat(actualOutput, containsString("Performance: took")); + } + @Test + public void run_givenHelp_shouldProduceHelpInfo() { + // given + + // when + List arguments = useCase.getArgs(); + arguments.add(0, "-h"); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then + String actualOutput = errContent.toString(); + + assertThat(actualOutput, containsString("Usage: java")); + } + + @Test + public void run_givenVerbose_shouldProduceExtraInfo() { + // given + + // when + List arguments = useCase.getArgs(); + arguments.add(0, "-v"); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then + String actualOutput = outContent.toString(); + + assertThat(actualOutput, containsString("Done.")); + } + + @Test + public void run_givenVerboseAndPerformance_shouldProduceExtraInfo() { + // given + + // when + List arguments = useCase.getArgs(); + arguments.add(0, "-v"); + arguments.add(1, "-p"); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then + String actualOutput = outContent.toString(); + + assertThat(actualOutput, containsString("Done.")); + assertThat(actualOutput, containsString("Performance: took")); + } + + @Parameterized.Parameters(name = "{index} -> {0}") + public static List useCases() { + return Arrays.asList( + new UseCase("n", "-n", "world", "-s", "url"), + new UseCase("n", "-n", "world", "-s", "dns") + ); + } + + private static class UseCase { + private final String type; + private String[] options = new String[]{}; + + public UseCase(String type, String...options) { + this.type = type; + if (options != null) { + this.options = options; + } + } + + public List getArgs() { + List arguments = new ArrayList<>(Arrays.asList(options)); + arguments.add(type); + return arguments; + } + + @Override + public String toString() { + if (options.length == 0) { + return String.format("type: %s, options: no options", type); + } else { + return String.format("type: %s, options: %s", type, String.join(", ", options)); + } + } + } +} \ No newline at end of file diff --git a/src/test/java/com/fasterxml/uuid/JugNoArgsTest.java b/src/test/java/com/fasterxml/uuid/JugNoArgsTest.java new file mode 100644 index 0000000..d000105 --- /dev/null +++ b/src/test/java/com/fasterxml/uuid/JugNoArgsTest.java @@ -0,0 +1,217 @@ +package com.fasterxml.uuid; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.lang.reflect.Array; +import java.util.*; + +import static org.hamcrest.core.StringContains.containsString; +import static org.junit.Assert.*; + +@RunWith(Parameterized.class) +public class JugNoArgsTest { + @Parameterized.Parameter + public String useCase; + + private PrintStream oldStrOut; + private PrintStream oldStrErr; + + private final ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + private final ByteArrayOutputStream errContent = new ByteArrayOutputStream(); + private Jug jug_underTest; + + @Before + public void setup() { + jug_underTest = new Jug(); + oldStrOut = System.out; + oldStrErr = System.err; + PrintStream stubbedStream = new PrintStream(outContent); + System.setOut(stubbedStream); + PrintStream stubbedErrStream = new PrintStream(errContent); + System.setErr(stubbedErrStream); + } + + @After + public void cleanup() { + System.setOut(oldStrOut); + System.setErr(oldStrErr); + } + + @Test + public void run_givenNoOptions_shouldProduceUUID() { + // given + + // when + jug_underTest.run(new String[]{useCase}); + + // then - if it is a UUID then we should be able to parse it back out + String actualUuid = outContent.toString(); + assertEquals('\n', actualUuid.charAt(actualUuid.length() - 1)); + + assertEquals(UUID.class, + UUID.fromString(actualUuid.substring(0, actualUuid.length() - 1)).getClass()); + } + + @Test + public void run_givenCount1_shouldProduceUUID() { + // given + + // when + List arguments = new ArrayList<>(Arrays.asList("-c", "1")); + arguments.add(useCase); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then - if it is a UUID then we should be able to parse it back out + String actualUuid = outContent.toString(); + assertEquals('\n', actualUuid.charAt(actualUuid.length() - 1)); + + assertEquals(UUID.class, + UUID.fromString(actualUuid.substring(0, actualUuid.length() - 1)).getClass()); + } + + @Test + public void run_givenCount2_shouldProduce2UUIDs() { + // given + + // when + List arguments = new ArrayList<>(Arrays.asList("-c", "2")); + arguments.add(useCase); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then - if it is a UUID then we should be able to parse it back out + String[] actualUuids = outContent.toString().split("\n"); + assertEquals(2, actualUuids.length); + + for(String actualUuid: actualUuids) { + assertEquals(UUID.class, + UUID.fromString(actualUuid).getClass()); + } + } + + @Test + public void run_givenEthernet_shouldProduceUUID() { + // given + + // when + List arguments = new ArrayList<>(Arrays.asList("-e", ":::::")); + arguments.add(useCase); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then - if it is a UUID then we should be able to parse it back out + String actualUuid = outContent.toString(); + assertEquals('\n', actualUuid.charAt(actualUuid.length() - 1)); + + assertEquals(UUID.class, + UUID.fromString(actualUuid.substring(0, actualUuid.length() - 1)).getClass()); + } + + @Test + public void run_givenName_shouldProduceUUID() { + // given + + // when + List arguments = new ArrayList<>(Arrays.asList("-n", "hello")); + arguments.add(useCase); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then - if it is a UUID then we should be able to parse it back out + String actualUuid = outContent.toString(); + assertEquals('\n', actualUuid.charAt(actualUuid.length() - 1)); + + assertEquals(UUID.class, + UUID.fromString(actualUuid.substring(0, actualUuid.length() - 1)).getClass()); + } + + @Test + public void run_givenDnsNameSpace_shouldProduceUUID() { + // given + + // when + List arguments = new ArrayList<>(Arrays.asList("-s", "dns")); + arguments.add(useCase); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then - if it is a UUID then we should be able to parse it back out + String actualUuid = outContent.toString(); + assertEquals('\n', actualUuid.charAt(actualUuid.length() - 1)); + + assertEquals(UUID.class, + UUID.fromString(actualUuid.substring(0, actualUuid.length() - 1)).getClass()); + } + + @Test + public void run_givenUrlNameSpace_shouldProduceUUID() { + // given + + // when + List arguments = new ArrayList<>(Arrays.asList("-s", "url")); + arguments.add(useCase); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then - if it is a UUID then we should be able to parse it back out + String actualUuid = outContent.toString(); + assertEquals('\n', actualUuid.charAt(actualUuid.length() - 1)); + + assertEquals(UUID.class, + UUID.fromString(actualUuid.substring(0, actualUuid.length() - 1)).getClass()); + } + + @Test + public void run_givenPerformance_shouldProducePerformanceInfo() { + // given + + // when + List arguments = Arrays.asList("-p", useCase); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then + String actualOutput = outContent.toString(); + + assertThat(actualOutput, containsString("Performance: took")); + } + + @Test + public void run_givenHelp_shouldProduceHelpInfo() { + // given + + // when + List arguments = Arrays.asList("-h", useCase); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then + String actualOutput = errContent.toString(); + + assertThat(actualOutput, containsString("Usage: java")); + } + + @Test + public void run_givenVerbose_shouldProduceExtraInfo() { + // given + + // when + List arguments = Arrays.asList("-v", useCase); + jug_underTest.run(arguments.toArray((String[]) Array.newInstance(String.class, 0))); + + // then + String actualOutput = outContent.toString(); + + assertThat(actualOutput, containsString("Done.")); + } + + @Parameterized.Parameters(name = "{index} -> type: {0}") + public static List useCases() { + return Arrays.asList( + "t", + "o", + "r", + "e", + "m" + ); + } +} \ No newline at end of file