java-uuid-generator-java-uuid-generator-3.1.5/000077500000000000000000000000001324315460500212435ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/.gitignore000066400000000000000000000002021324315460500232250ustar00rootroot00000000000000# Skip maven 'target' directory target # plus eclipse crap .classpath .project .settings # plus IDEA crap *.iml *.ipr .idea *~ java-uuid-generator-java-uuid-generator-3.1.5/README.md000066400000000000000000000072741324315460500225340ustar00rootroot00000000000000# Java Uuid Generator (JUG) JUG is a set of Java classes for working with UUIDs: generating UUIDs using any of standard methods, outputting efficiently, sorting and so on. It generates UUIDs according to the [UUID specification (RFC-4122)](https://tools.ietf.org/html/rfc4122) (also see [Wikipedia UUID page](http://en.wikipedia.org/wiki/UUID) for more explanation) JUG was written by Tatu Saloranta () originally in 2002 and has been updated over years. In addition, many other individuals have helped fix bugs and implement new features: please see `release-notes/CREDITS` for the complete list. JUG is licensed under [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0.html). ## Usage JUG can be used as a command-line tool (via class 'com.fasterxml.uuid.Jug`), or as a pluggable component. Maven coordinates are: ```xml com.fasterxml.uuid java-uuid-generator 3.1.3 ``` For direct downloads, check out [Project Wiki](../../wiki). Generation itself is done by first selecting a kind of generator to use, and then calling its `generate()` method, for example: ```java UUID uuid = Generators.randomBasedGenerator().generate(); UUID uuid = Generators.timeBasedGenerator().generate(); ``` If you want customize generators, you may also just want to hold on to generator instance, for example: ```java TimeBasedGenerator gen = Generators.timeBasedGenerator(EthernetAddress.fromInterface()); UUID uuid = gen.generate(); UUID anotherUuid = gen.generate(); ``` Generators are fully thread-safe, so a single instance may be shared among multiple threads. JavaDocs for project can be found from [Project Wiki](../../wiki). ## Compatibility JUG version 3.1 requires JDK 1.6 to work, mostly to be able to access local Ethernet MAC address. Earlier versions (3.0 and before) worked on 1.4 (which introduced `java.util.UUID`). ## Known Issues JDK's `java.util.UUID` has flawed implementation of `compareTo()`, which uses naive comparison of 64-bit values. This does NOT work as expected, given that underlying content is for all purposes unsigned. For example two UUIDs: ``` 7f905a0b-bb6e-11e3-9e8f-000000000000 8028f08c-bb6e-11e3-9e8f-000000000000 ``` would be ordered with second one first, due to sign extension (second value is considered to be negative, and hence "smaller"). Because of this, you should always use external comparator, such as `com.fasterxml.uuid.UUIDComparator`, which implements expected sorting order that is simple unsigned sorting, which is also same as lexicographic (alphabetic) sorting of UUIDs (when assuming uniform capitalization). ## Alternative JVM UUID generators There are many other publicly available UUID generators. For example: * [Apache Commons IO](http://commons.apache.org/sandbox/commons-id/uuid.html) has UUID generator * [eaio-uuid](http://stephenc.github.io/eaio-uuid/) * JDK has included `java.util.UUID` since 1.4, but omits generation methods (esp. time/location based ones), has sub-standard performance for many operations and implements comparison in useless way * [ohannburkard.de UUID generator](http://johannburkard.de/software/uuid/) Note that although some packages claim to be faster than others, it is not clear whether: 1. Claims have been properly verified (or, if they have, can be independently verified), AND 2. It is not likely that performance differences truly matter: JUG, for example, can generate a millions of UUID per second per core (sometimes hitting the theoretical limit of 10 million per second), and it seems unlikely that generation will be bottleneck for about any use case so it is often best to choose based on stability of packages and API. java-uuid-generator-java-uuid-generator-3.1.5/index.html000066400000000000000000000057461324315460500232540ustar00rootroot00000000000000 cowtowncoder/java-uuid-generator @ GitHub Fork me on GitHub

java-uuid-generator by cowtowncoder

Java Uuid Generator (JUG)

Java Uuid Generator (JUG) is a library for generating all (3) types of UUIDs on Java. And perhaps .NET/Mono as well: MUG is in the making!

License

Apache License 2.0 or LGPL 2.1

Authors

Tatu Saloranta

Contact

Tatu Saloranta (tsaloranta@gmail.com)

Download

You can download this project in either zip or tar formats.

You can also clone the project with Git by running: 

$ git clone git://github.com/cowtowncoder/java-uuid-generator

get the source code on GitHub : cowtowncoder/java-uuid-generator
java-uuid-generator-java-uuid-generator-3.1.5/pom.xml000066400000000000000000000154111324315460500225620ustar00rootroot00000000000000 4.0.0 com.fasterxml oss-parent 31 com.fasterxml.uuid java-uuid-generator bundle Java UUID Generator 3.1.5 Java UUID Generator (JUG) is a Java library for generating Universally Unique IDentifiers, UUIDs (see http://en.wikipedia.org/wiki/UUID). It can be used either as a component in a bigger application, or as a standalone command line tool. JUG generates UUIDs according to the IETF UUID draft specification. JUG supports all 3 official UUID generation methods. scm:git:git://github.com/cowtowncoder/java-uuid-generator.git scm:git:git@github.com:cowtowncoder/java-uuid-generator.git scm:git:git@github.com:cowtowncoder/java-uuid-generator.git java-uuid-generator-3.1.5 cowtowncoder Tatu Saloranta tatu.saloranta@iki.fi http://wiki.fasterxml.com/JugHome http://github.com/cowtowncoder/java-uuid-generator/issues 2.2.1 UTF-8 1.2.13 The Apache Software License, Version 2.0 http://www.apache.org/licenses/LICENSE-2.0.txt repo FasterXML.com http://fasterxml.com log4j log4j ${log4j.version} provided junit junit 4.12 test org.apache.maven.plugins maven-compiler-plugin 3.1 1.6 1.6 org.apache.maven.plugins maven-source-plugin 2.1.2 attach-sources jar org.apache.maven.plugins maven-javadoc-plugin ${version.plugin.javadoc} attach-javadocs verify jar org.apache.felix maven-bundle-plugin true ${project.name} ${project.artifactId} ${project.description} FasterXML.com com.fasterxml.uuid;version="${project.version}", com.fasterxml.uuid.ext;version="${project.version}", com.fasterxml.uuid.impl;version="${project.version}" com.fasterxml.uuid;version="[${project.version},${project.version}]", com.fasterxml.uuid.ext;version="[${project.version},${project.version}]", com.fasterxml.uuid.impl;version="[${project.version},${project.version}]" org.apache.log4j;version="[${log4j.version},1.3)" org.apache.maven.plugins maven-release-plugin forked-path release-sign-artifacts performRelease true org.apache.maven.plugins maven-gpg-plugin 1.1 sign-artifacts verify sign java-uuid-generator-java-uuid-generator-3.1.5/release-notes/000077500000000000000000000000001324315460500240115ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/release-notes/CREDITS000066400000000000000000000070751324315460500250420ustar00rootroot00000000000000Here are people who have contributed to JUG development: Tatu Saloranta, tatu.saloranta@iki.fi: Author Leonid Kunin: suggested adding 2 constructors (that were missing); needed when storing binary representations of UUIDs (added to v0.9.2) [0.9.2] Paul Blankenbaker: provided the native code for accessing Ethernet MAC-addresses (on linux/x86, Solaris/sparc, Windows); first included in 1.0.0 release. [1.0.0] Gernot Koller: pointed out a bug in UUID.toByteArray() method; was not using offset (fixed in 1.0.1) [1.0.1] Dominique Jean-Prost: Suggested that there should be alternate method of loading native libs (implemented in 1.0.2). Also pointed out that method 'setLibDir' should be public, not protected (fixed in 1.0.2). [1.0.2] Jeff Woodward: Pointed and fixed a bug in UUID.toByteArray() method (not sure if Gernot's fix was somehow overwritten in codebase or what...). [1.0.3] D.J Hagberg: Submitted native code to use with Mac OS X, to use for accessing MAC address of primary network interface (code should also work with *BSDs?). Also contributed improvements to Ant's build.xml. [1.0.3] G�ran L�wkrantz: Submitted native code for FreeBSD/x86 [1.1] Eric Bie: Wrote full unit test suite, using JUnit! Really REALLY useful addition (old ad hoc tests needed replacement). Also cleaned up ant build file significantly. [1.1] Bill Sarra: Pointed out and fix Windows native code bug that would under some circumstances cause infinite looping when trying to access MAC addresses of all interfaces. [1.1] Ralf S. Engelschall: Pointed out and fixed a bug in generating dummy broadcast ethernet addresses; interpretation of LSB/MSB was incorrect with respect to ethernet broadcast & structs. [1.1] Wolfgang Hoschek: Suggested useful improvement to random UUIDs; there's no requirement for API to enforce use of SecureRandom. Thus, code now only expects Random, although still creates SecureRandom if no explicit generator is passed. This can help in reducing startup time of generator, as well as max. rate of UUID generation, depending on how quickly Random instance can be initialized & generates new numbers. Jonas F�gedi: Contributed the patch to check for FreeBSD platform (which actually was part of an earlier patch that I somehow had managed not to get in... :-/ ) [1.1.1] David Pawson: Pointed out that the jar file was missing the necessary Main-Class definition, which prevented it from being invoked from command line using -jar switch. [1.1.2] Pekka Enberg: Pointed out a bug in Linux JNI code; the socket was not properly closed [2.0.0] Thomas Wernitz: Pointed out a problem with MacOS JNI code; wasn't properly looping through the interfaces [2.0.0] Asher Glynn: Suggested usefulness of external file-based synchronization, to ensure that system clock moving backwards during reboot does not compromise uniqueness of produced UUIDs (which is obviously also mentioned in UUID specs, but previously not implemented in Jug). [2.0.0] Wim Deblauwe: Pointed out problems with 2.0rc3 jars (missing com.ccg.net.ethernet package, no downloadable JNI code). [2.0rc3] Klaus Rheinwald: Contributed non-netbios Windows JNI code for accessing Ethernet addresses [2.0rc5] Fran�ois Berenger: Pointed out a method signature problem that prevent unit test compilation [2.1] Tarusawa Hiroyuki: Reported missing Maven(2) jars for JUG. Ed Anuff: Reported Issue #7: Bytes of clock sequence were switched (unlikely to cause problems, but incorrect -- regression from 2.x) [3.1.3] java-uuid-generator-java-uuid-generator-3.1.5/release-notes/FAQ000066400000000000000000000154071324315460500243520ustar00rootroot00000000000000== Java Uuid Generator ("JUG") == === 1. Why JUG? Don't we already have "uuidgen"? === Some do, some don't. :-) Most platforms have variations of uuidgen command line tool, but not all do. Additionally, accessing uuidgen from Java may be tricky (since its location in native OS filesystem depends on OS and possibly other factors). So, portability is one benefit; JUG works if you have Java 1.2 (version 2.0) or Java 1.6 (version 3.0). Performance may be another benefit when using JUG from Java. Interfacing to native functionality (either via uuidgen or directly to libuuigen) is likely to be slower than calling JUG methods, even if generation itself was faster. === 2. Why NOT use JUG? === If you are paranoid about duplicate UUIDs (esp. when using time-based algorithm), there's no way to guarantee that multiple UUID- generators don't produce same UUID. It's still unlikely to happen (due to clock sequence field etc), but potentially a problem. Uuidgen usually solves this by having a system-wide global lock to prevent possibility of using same timestamps; but with Java the best JUG can guarantee is that there's always max. 1 JUG instance per JVM; other JVMs may have their own copies. [note: in theory it would be possible to add native support for locking, for platforms that have locking functionality... but then it might also be easy to just use native uuidgen functionality as well] Note, though, that with random- and name-based methods multiple instance of JUG are not a problem; name-based methods base the uniqueness on the name, not timing, and random-based method is based on quality of the random number generator. In latter case it all depends on how random one considers SecureRandom to be. Additionally, although generating UUIDs is straight-forward, JUG has not been extensively tested; it just seems to generate unique UUIDs as is. :-) === 3. What is the fastest method to use for generating UUIDs? === It depends on your system, random number generators used etc. etc., But here are some numbers, running on a MacBook (2.5 GHz dual CPU) Time-based: 5 million/second Random-based: 0.25 million/second (when using SecureRandom) Name-based: 1 million/second (depends on length, namespace etc; this with MD5) So with default settings, time-based algorithm is by far the fastest; usually followed by name/hash based alternative (for short/medium names at least), and random-based variant being slowest. Finally, if performance _really_ is very important for you, there is a further complication when using time-based algorithm; Java's system clock has max. resolution of 1 millisecond, instead of 100ns required by UUID specification. This is solved by using additional counter (in JUG), but the downside is that for each separate Java 'time slice' (time period when system clock returns same timestamp) can produce at most 10000 UUIDs. If JDK on the platform does advance in 1 msec ticks, this is good enough for generating up to 10 million UUIDs per second, but on some platforms resolution is coarser: on Windows granularity used to be 55 msec, meaning max. rate would be 180 kUUIDs per second. ... which all means that for generating more than, say, hundred thousand UUIDs per second, you may need to look at native implementations. But often with system like that you aren't really using Java in the first place. === 4. Which one should I use, assuming performance is not important? === If you can access the ethernet card address it might be good idea to use time-based algorithm, if you will only be generating UUIDs from single JVM (and won't be using other UUID-tools at the same time). If so, uniqueness is pretty much guaranteed and algorithm is fast as well. One potential drawback is that in case you consider giving out ethernet address a security problem (which in theory it could be, although there probably aren't any major immediate problems), this method is not for you, since ether address is stored as is in last 6 bytes of UUID (this could be partially solved by hashing the ethernet address, but the standard doesn't mention this solution so it's not implemented yet) If there will be multiple UUID generators (different JVMs, using native uuidgen), using random-based method may be the best option; although there is a file-locking base synchronizer available for time-based generation. This works with multiple JVMs, but may not be applicable to synchronize with non-Java generators. Random-number based variant should be safe to use, as long as the underlying random number generator is good (which SecureRandom by JDK should be). Finally, if it's easy to generate unique names from system (say, URL combined with a sequence number guaranteed to be unique), and especially if these 'human readable' identifiers (such as tagURIs) are otherwise used, it may be a good idea to use one of the name-based algorithms. It's easy to generate UUIDs from tag-URIs, so one-way conversions can be done on-the-fly. === 5. How can I obtain the Ethernet MAC-address of the machine JUG runs on? === Easiest way with version 3.x and above is to use EthernetAddress class, which internally uses method that JDK 1.6 introduced. Earlier versions of JUG relied on JNI-access native libraries. === 6. What if system clock/time goes backward? === In general, it is unlikely that the system clock (as observed by Java code via System.currentTimeMillis()) will go backwards (daylight savings etc. do not change this "absolute" UTC time value), it can occur. Before version 2.0, JUG only ensured that such events do not cause problem within a JVM session, but not between consequtive runs. Thus, it was theoretically possible that if time moved backwards after JVM was shutdown (or class loader create a new UUIDGenerator instance etc), timestamps could overlap. While this was unlikely to happen (due to additional randomness injected via clock sequence field eetc.), this potential problem can now be resolved in JUG 2.0 and onwards using external synchronization. UUIDGenerator can be configured with TimestampSynchronizer instances; the default implementation, FileBasedTimestampSynchronizer works by using 2 files that are used to store timestamp values used for generation. They are read when UUIDGenerator needs to initialize timestaps (when synchronization enabled), and updated when necessary. An additional benefit is that these files are also locked using NIO, which means that it is now also possible to prevent multiple JVMs (or, multiple instances of UUIDGenerator loaded using separate classloaders -- this can happen with application servers on context reloads) from running concurrently (assuming they are configured to use same files). === 7. How do I configure (or disable) logging === Starting with 2.0 release, JUG now has a simple configurable logging sub-system. You can start by looking at javadocs for: com.fasterxml.uuid.Logger class. java-uuid-generator-java-uuid-generator-3.1.5/release-notes/USAGE000066400000000000000000000053251324315460500246050ustar00rootroot00000000000000== "JUG" - Java Uuid Generator == === Generic === JUG can be used as a command-line tool (via class org.safehaus.uuid.Jug), or as a pluggable component. === Pluggable component === As a pluggable component, UUID generator instances are created through factory methods in com.fasterxml.uuid.Generators. Returned generators are by default properly synchronized to avoid duplicate UUID generation within a single JVM. If separate JVMs are used (with their own UUIDGenerators) it's best to either use time-based UUID generation with external synchronization (look at 'ext' package, TimestampSyncronizer), or to give them separate ethernet addresses (possibly including using one or more dummy addresses). UUIDs can be converted to and from strings, can be compared for equality, and should hash nicely so they can be used as keys in hash tables (same applies to class EthernetAddress). === Running unit tests === Components can be unit tested using 'maven' build tool (which is also needed for compiling JUG from sources). Before submitting patches, unit tests need to be run succesfully, to minimize risk of unintended bugs. Similarly, for all new functionality (if any), new unit tests should be added. === Command-line tool === To get list of options and arguments, you can start the command line tool without any arguments, something like: java -jar java-uuid-generator-VERSION.jar or java -cp java-uuid-generator-3.1.0.jar com.fasterxml.uuid.Jug This lists actual usage information. When used as a command-line tool there are some caveats, because of the way a new JVM is usually instantiated between calls: * Generating the first UUID can be remarkably slow. This is because a new secure random number generator is initialized at that time (if using random number based variant) Subsequent calls are faster, but this has to be done using --count command-line argument, to create multiple UUIDs with same invocation. * Generating time-based UUIDs is not as secure due to JVM being re-initialized between calls. However, as long as timer resolution JVM has is granular enough, this shouldn't be a problem in practice; clock should have different value between invocations (and inside one invocation clock counter is used to guarantee uniqueness). * If you want to generate UUIDs that can be 'verified', use name-based UUID generation. In this case UUID generation is actually just used to produce 128-bit hash value of name and namespace arguments. If you want more information about specific configuration of UUID generation, you can use --version - option with command-line tool. This will output additional information about random number generator, hashing algorithm and the dummy ethernet address used (wherever applicable). java-uuid-generator-java-uuid-generator-3.1.5/release-notes/VERSION000066400000000000000000000120741324315460500250650ustar00rootroot00000000000000Project: java-uuid-generator ============================================================================ Releases ============================================================================ 3.1.5 (21-Feb-2018) #19: LICENSE file refers to the Java Classmate library instead of Java UUID Generator (JUG) (reported by Roger Aird, rogeraird@github) #22: UUIDTimer is not extendable which is not consistent with it's Javadoc (reported by Spikhalskiy@github, mazurkin@github) 3.1.4 (15-Dec-2014) #4: Add LICENSE file in resulting jar. #15: Please make log4j "provided" rather than compile if it's really optionally (requested by ymenager@github) 3.1.3 (04-Nov-2011) * [#3] Make sure UUIDUtil has convenience factory methods, conversions, to make it easier to work with java.util.UUID. * [#7] Bytes of clock sequence were switched (unlikely to cause problems, but incorrect -- regressions from 2.x) (reported by Ed A) * [#8] A potential race condition for RandomBasedGenerator (reported by "facboy") 3.1.2 (25-Jun-2011): * Fixed a packaging problem (missing sources) 3.1.1 (05-Apr-2011): * [#5]: NPE when calling "Generators.randomBasedGenerator().generate()" second time (reported by oswaldo) 3.1.0 (14-Oct-2010): Rewrite of Java Uuid Generator, to bring it up to date. Changes include: * Use Maven for build * Jars built as OSGi bundles with appropriate metadata * Converted to use java.util.UUID as the UUID value type * Change from using static UUIDGenerator into typed generator instances accessed via com.fasterxml.uuid.Generators factory class * Allow using JDK 1.6 Ethernet address access code (exposed via EthernetAddress class) * Made generators fully synchronized 2.0.0 (29-Oct-2005): The official 2.0 release. No functional changes since rc6, just documentation updates. 2.0-rc6: (25-Sep-2005): Added simple logger wrappers for log4j and java.util.logging: now it should be trivial to make JUG use either of these logging sub-systems, when integrating it to an existing system. 2.0-rc5: (05-Sep-2005): Integrated non-NetBIOS-based JNI Windows code, contributed by Klaus R. Also, improved src/c/makefile a bit, which lead to name change of the JNI libraries (due to my inexperience with make files, had to make some system-dependant parts lower-case). 2.0-rc4: (16-Aug-2005), 2.0-rc3: (09-Aug-2005) Cleanup; integrating last minor fixes to JNI code, compiled macos and linux modules, added missing classes to jar. 2.0-rc2: New functionality: - Simple configurable logging sub-system - External synchronization for time-stamp persistence, as well as file-locking based multi-JVM-safe locking. Can prevent running Jug from multiple JVMs, as well as all are configured to properly use shared locking file(s). 2.0-rc1: Changes: - Renamed package 'org.doomdark.uuid' to 'org.safehaus.uuid' as part of the transition to become one of official Safehaus projects (at http://jug.safehaus.org). Fixes: - JNI fix on Linux code: now properly frees socket data structure on all use cases - Fix to MacOsX (and thus BSD) code: will not get into infinite loop when trying to access multiple interfaces. 1.1.2: Minor fix: - Added Main-Class definition to jar manifest, to allow normal invocation (of Jug command-line functionality) from jar. 1.1.1: Minor fixes: - Added FreeBSD recognition check suggested by Jonas F�gedi. 1.1: Better native support, full unit test suite. - Fixed a bug in Windows MAC address access, which would cause infinite loop under some conditions on Win9x/2K/XP. - Added FreeBSD/x86 native code. - Added full unit test suite. - Fixed a bug in dummy ethernet broadcast generation code. - Changed API to allow using any Random implementation, not just SecureRandom or its subclasses. 1.0.3: Better native support, a minor bugfix. - Bug fix to UUID.java class (another bug in toByteArray(), or potentially regressed first one?) - Mac OS X native MAC address access support (for primary interface) - Small improvements Ant build definitions (need to include targets for doing JavaDocs and source distribution - Added BUGS file that contains known problems. 1.0.2: Minor updates: - Native code can now be loaded either from application specific location (default case, supported since 1.0.0), or from system-dependant standard lib location (new to 1.0.2) - Trying to add ant build support to replace make. Not yet fully done. 1.0.1: Minor fixes: - UUID.java class (bug in toByteArray() fixed) - Updated README file to contain reference to a new IETF draft: http://www.ietf.org/internet-drafts/draft-mealling-uuid-urn-00.txt which describes UUIDs as well as presents a suggested way for 'encapsulating' UUIDs in a URN name space. 1.0.0: Added native modules for obtaining Ethernet MAC address (see CREDITS for details about source of these sources) ----- Note: release notes for versions prior to 1.0 removed; refer to version 1.1.2 for those versions for details. java-uuid-generator-java-uuid-generator-3.1.5/release-notes/asl/000077500000000000000000000000001324315460500245705ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/release-notes/asl/ASL2.0000066400000000000000000000261361324315460500253620ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed 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. java-uuid-generator-java-uuid-generator-3.1.5/release-notes/asl/LICENSE000066400000000000000000000006701324315460500256000ustar00rootroot00000000000000This copy of Java Uuid/guid Generator (JUG) is licensed under the Apache (Software) License, version 2.0 ("the License"). See the License for details about distribution rights, and the specific rights regarding derivate works. You may obtain a copy of the License at: http://www.apache.org/licenses/ A copy is also included in the downloadable source code package containing JUG, in file "ASL2.0", under the same directory as this file. java-uuid-generator-java-uuid-generator-3.1.5/run.sh000077500000000000000000000000551324315460500224060ustar00rootroot00000000000000#!/bin/sh java -classpath target/classes $* java-uuid-generator-java-uuid-generator-3.1.5/src/000077500000000000000000000000001324315460500220325ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/000077500000000000000000000000001324315460500227565ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/000077500000000000000000000000001324315460500236775ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/000077500000000000000000000000001324315460500244555ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/000077500000000000000000000000001324315460500264625ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/000077500000000000000000000000001324315460500274305ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/EthernetAddress.java000066400000000000000000000402751324315460500333670ustar00rootroot00000000000000/* JUG Java Uuid Generator * * Copyright (c) 2002 Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import java.io.Serializable; import java.net.NetworkInterface; import java.security.SecureRandom; import java.util.Enumeration; import java.util.Random; /** * EthernetAddress encapsulates the 6-byte MAC address defined in * IEEE 802.1 standard. */ public class EthernetAddress implements Serializable, Cloneable, Comparable { private static final long serialVersionUID = 1L; private final static char[] HEX_CHARS = "0123456789abcdefABCDEF".toCharArray(); /** * We may need a random number generator, for creating dummy ethernet * address if no real interface is found. */ protected static Random _rnd; /** * 48-bit MAC address, stored in 6 lowest-significant bytes (in * big endian notation) */ protected final long _address; /** * Lazily-constructed String serialization */ private volatile String _asString; /* /********************************************************************** /* Instance construction /********************************************************************** */ /** * String constructor; given a 'standard' ethernet MAC address string * (like '00:C0:F0:3D:5B:7C'), constructs an EthernetAddress instance. * * Note that string is case-insensitive, and also that leading zeroes * may be omitted. Thus '00:C0:F0:3D:5B:7C' and '0:c0:f0:3d:5b:7c' are * equivalent, and a 'null' address could be passed as ':::::' as well * as '00:00:00:00:00:00' (or any other intermediate combination). * * @param addrStr String representation of the ethernet address */ public EthernetAddress(String addrStr) throws NumberFormatException { int len = addrStr.length(); long addr = 0L; /* Ugh. Although the most logical format would be the 17-char one * (12 hex digits separated by colons), apparently leading zeroes * can be omitted. Thus... Can't just check string length. :-/ */ for (int i = 0, j = 0; j < 6; ++j) { if (i >= len) { // Is valid if this would have been the last byte: if (j == 5) { addr <<= 8; break; } throw new NumberFormatException("Incomplete ethernet address (missing one or more digits"); } char c = addrStr.charAt(i); ++i; int value; // The whole number may be omitted (if it was zero): if (c == ':') { value = 0; } else { // No, got at least one digit? if (c >= '0' && c <= '9') { value = (c - '0'); } else if (c >= 'a' && c <= 'f') { value = (c - 'a' + 10); } else if (c >= 'A' && c <= 'F') { value = (c - 'A' + 10); } else { throw new NumberFormatException("Non-hex character '"+c+"'"); } // How about another one? if (i < len) { c = addrStr.charAt(i); ++i; if (c != ':') { value = (value << 4); if (c >= '0' && c <= '9') { value |= (c - '0'); } else if (c >= 'a' && c <= 'f') { value |= (c - 'a' + 10); } else if (c >= 'A' && c <= 'F') { value |= (c - 'A' + 10); } else { throw new NumberFormatException("Non-hex character '"+c+"'"); } } } } addr = (addr << 8) | value; if (c != ':') { if (i < len) { if (addrStr.charAt(i) != ':') { throw new NumberFormatException("Expected ':', got ('"+ addrStr.charAt(i)+"')"); } ++i; } else if (j < 5) { throw new NumberFormatException("Incomplete ethernet address (missing one or more digits"); } } } _address = addr; } /** * Binary constructor that constructs an instance given the 6 byte * (48-bit) address. Useful if an address is saved in binary format * (for saving space for example). */ public EthernetAddress(byte [] addr) throws NumberFormatException { if (addr.length != 6) { throw new NumberFormatException("Ethernet address has to consist of 6 bytes"); } long l = addr[0] & 0xFF; for (int i = 1; i < 6; ++i) { l = (l << 8) | (addr[i] & 0xFF); } _address = l; } /** * Another binary constructor; constructs an instance from the given * long argument; the lowest 6 bytes contain the address. * * @param addr long that contains the MAC address in 6 least significant * bytes. */ public EthernetAddress(long addr) { _address = addr; } /** * Default cloning behaviour (bitwise copy) is just fine... */ public Object clone() { return new EthernetAddress(_address); } /** * Constructs a new EthernetAddress given the byte array that contains * binary representation of the address. * * Note that calling this method returns the same result as would * using the matching constructor. * * @param addr Binary representation of the ethernet address * * @throws NumberFormatException if addr is invalid (less or more than * 6 bytes in array) */ public static EthernetAddress valueOf(byte[] addr) throws NumberFormatException { return new EthernetAddress(addr); } /** * Constructs a new EthernetAddress given the byte array that contains * binary representation of the address. * * Note that calling this method returns the same result as would * using the matching constructor. * * @param addr Binary representation of the ethernet address * * @throws NumberFormatException if addr is invalid (less or more than * 6 ints in array) */ public static EthernetAddress valueOf(int[] addr) throws NumberFormatException { byte[] bAddr = new byte[addr.length]; for (int i = 0; i < addr.length; ++i) { bAddr[i] = (byte) addr[i]; } return new EthernetAddress(bAddr); } /** * Constructs a new EthernetAddress given a string representation of * the ethernet address. * * Note that calling this method returns the same result as would * using the matching constructor. * * @param addrStr String representation of the ethernet address * * @throws NumberFormatException if addr representation is invalid */ public static EthernetAddress valueOf(String addrStr) throws NumberFormatException { return new EthernetAddress(addrStr); } /** * Constructs a new EthernetAddress given the long int value (64-bit) * representation of the ethernet address (of which 48 LSB contain * the definition) * * Note that calling this method returns the same result as would * using the matching constructor. * * @param addr Long int representation of the ethernet address */ public static EthernetAddress valueOf(long addr) { return new EthernetAddress(addr); } /** * Factory method that locates a network interface that has * a suitable mac address (ethernet cards, and things that * emulate one), and return that address. If there are multiple * applicable interfaces, one of them is returned; which one * is returned is not specified. * Method is meant for accessing an address needed to construct * generator for time+location based UUID generation method. * * @return Ethernet address of one of interfaces system has; * not including local or loopback addresses; if one exists, * null if no such interfaces are found. */ public static EthernetAddress fromInterface() { try { Enumeration en = NetworkInterface.getNetworkInterfaces(); while (en.hasMoreElements()) { NetworkInterface nint = en.nextElement(); if (!nint.isLoopback()) { byte[] data = nint.getHardwareAddress(); if (data != null && data.length == 6) { return new EthernetAddress(data); } } } } catch (java.net.SocketException e) { // fine, let's take is as signal of not having any interfaces } return null; } /** * Factory method that can be used to construct a random multicast * address; to be used in cases where there is no "real" ethernet * address to use. Address to generate should be a multicase address * to avoid accidental collision with real manufacturer-assigned * MAC addresses. *

* Internally a {@link SecureRandom} instance is used for generating * random number to base address on. */ public static EthernetAddress constructMulticastAddress() { return constructMulticastAddress(_randomNumberGenerator()); } /** * Factory method that can be used to construct a random multicast * address; to be used in cases where there is no "real" ethernet * address to use. Address to generate should be a multicase address * to avoid accidental collision with real manufacturer-assigned * MAC addresses. *

* Address is created using specified random number generator. */ public static EthernetAddress constructMulticastAddress(Random rnd) { byte[] dummy = new byte[6]; synchronized (rnd) { rnd.nextBytes(dummy); } /* Need to set the broadcast bit to indicate it's not a real * address. */ /* 20-May-2010, tatu: Actually, we could use both second least-sig-bit * ("locally administered") or the LSB (multicast), as neither is * ever set for 'real' addresses. * Since UUID specs recommends latter, use that. */ dummy[0] |= (byte) 0x01; return new EthernetAddress(dummy); } /* /********************************************************************** /* Conversions to raw types /********************************************************************** */ /** * Returns 6 byte byte array that contains the binary representation * of this ethernet address; byte 0 is the most significant byte * (and so forth) * * @return 6 byte byte array that contains the binary representation */ public byte[] asByteArray() { byte[] result = new byte[6]; toByteArray(result); return result; } /** * Synonym to 'asByteArray()' * * @return 6 byte byte array that contains the binary representation */ public byte[] toByteArray() { return asByteArray(); } public void toByteArray(byte[] array) { if (array.length < 6) { throw new IllegalArgumentException("Too small array, need to have space for 6 bytes"); } toByteArray(array, 0); } public void toByteArray(byte[] array, int pos) { if (pos < 0 || (pos + 6) > array.length) { throw new IllegalArgumentException("Illegal offset ("+pos+"), need room for 6 bytes"); } int i = (int) (_address >> 32); array[pos++] = (byte) (i >> 8); array[pos++] = (byte) i; i = (int) _address; array[pos++] = (byte) (i >> 24); array[pos++] = (byte) (i >> 16); array[pos++] = (byte) (i >> 8); array[pos] = (byte) i; } public long toLong() { return _address; } /* /********************************************************************** /* Accessors /********************************************************************** */ /** * Method that can be used to check if this address refers * to a multicast address. * Such addresses are never assigned to individual network * cards. */ public boolean isMulticastAddress() { return (((int) (_address >> 40)) & 0x01) != 0; } /** * Method that can be used to check if this address refers * to a "locally administered address" * (see [http://en.wikipedia.org/wiki/MAC_address] for details). * Such addresses are not assigned to individual network * cards. */ public boolean isLocallyAdministeredAddress() { return (((int) (_address >> 40)) & 0x02) != 0; } /* /********************************************************************** /* Standard methods /********************************************************************** */ @Override public boolean equals(Object o) { if (o == this) return true; if (o == null) return false; if (o.getClass() != getClass()) return false; return ((EthernetAddress) o)._address == _address; } /** * Method that compares this EthernetAddress to one passed in as * argument. Comparison is done simply by comparing individual * address bytes in the order. * * @return negative number if this EthernetAddress should be sorted before the * parameter address if they are equal, os positive non-zero number if this address * should be sorted after parameter */ public int compareTo(EthernetAddress other) { long l = _address - other._address; if (l < 0L) return -1; return (l == 0L) ? 0 : 1; } /** * Returns the canonical string representation of this ethernet address. * Canonical means that all characters are lower-case and string length * is always 17 characters (ie. leading zeroes are not omitted). * * @return Canonical string representation of this ethernet address. */ @Override public String toString() { String str = _asString; if (str != null) { return str; } /* Let's not cache the output here (unlike with UUID), assuming * this won't be called as often: */ StringBuilder b = new StringBuilder(17); int i1 = (int) (_address >> 32); int i2 = (int) _address; _appendHex(b, i1 >> 8); b.append(':'); _appendHex(b, i1); b.append(':'); _appendHex(b, i2 >> 24); b.append(':'); _appendHex(b, i2 >> 16); b.append(':'); _appendHex(b, i2 >> 8); b.append(':'); _appendHex(b, i2); _asString = str = b.toString(); return str; } /* /********************************************************************** /* Internal methods /********************************************************************** */ /** * Helper method for accessing configured random number generator */ protected synchronized static Random _randomNumberGenerator() { if (_rnd == null) { _rnd = new SecureRandom(); } return _rnd; } private final void _appendHex(StringBuilder sb, int hex) { sb.append(HEX_CHARS[(hex >> 4) & 0xF]); sb.append(HEX_CHARS[(hex & 0x0f)]); } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/Generators.java000066400000000000000000000165531324315460500324160ustar00rootroot00000000000000/* JUG Java UUID Generator * * Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import java.io.*; import java.security.NoSuchAlgorithmException; import java.security.MessageDigest; import java.util.*; import com.fasterxml.uuid.impl.NameBasedGenerator; import com.fasterxml.uuid.impl.RandomBasedGenerator; import com.fasterxml.uuid.impl.TimeBasedGenerator; /** * Root factory class for constructing UUID generators. * * @author tatu * * @since 3.0 */ public class Generators { /** * If no explicit timer (and synchronizer it implicitly uses) is specified, * we will create and use a single lazily-constructed timer, which uses in-JVM * synchronization but no external file-based syncing. */ protected static UUIDTimer _sharedTimer; // // Random-based generation /** * Factory method for constructing UUID generator that uses default (shared) * random number generator for constructing UUIDs according to standard * method number 4. */ public static RandomBasedGenerator randomBasedGenerator() { return randomBasedGenerator(null); } /** * Factory method for constructing UUID generator that uses specified * random number generator for constructing UUIDs according to standard * method number 4. */ public static RandomBasedGenerator randomBasedGenerator(Random rnd) { return new RandomBasedGenerator(rnd); } // // Name-based generation /** * Factory method for constructing UUID generator that uses specified * random number generator for constructing UUIDs according to standard * method number 5, but without using a namespace. * Digester to use will be SHA-1 as recommened by UUID spec. */ public static NameBasedGenerator nameBasedGenerator() { return nameBasedGenerator(null); } /** * Factory method for constructing UUID generator that uses specified * random number generator for constructing UUIDs according to standard * method number 5, with specified namespace (or without one if null * is specified). * Digester to use will be SHA-1 as recommened by UUID spec. * * @param namespace UUID that represents namespace to use; see * {@link NameBasedGenerator} for 'standard' namespaces specified by * UUID specs */ public static NameBasedGenerator nameBasedGenerator(UUID namespace) { return nameBasedGenerator(namespace, null); } /** * Factory method for constructing UUID generator that uses specified * random number generator for constructing UUIDs according to standard * method number 3 or 5, with specified namespace (or without one if null * is specified), using specified digester. * If digester is passed as null, a SHA-1 digester will be constructed. * * @param namespace UUID that represents namespace to use; see * {@link NameBasedGenerator} for 'standard' namespaces specified by * UUID specs * @param digester Digester to use; should be a MD5 or SHA-1 digester. */ public static NameBasedGenerator nameBasedGenerator(UUID namespace, MessageDigest digester) { UUIDType type = null; if (digester == null) { try { digester = MessageDigest.getInstance("SHA-1"); type = UUIDType.NAME_BASED_SHA1; } catch (NoSuchAlgorithmException nex) { throw new IllegalArgumentException("Couldn't instantiate SHA-1 MessageDigest instance: "+nex.toString()); } } return new NameBasedGenerator(namespace, digester, type); } // // Time+location-based generation /** * Factory method for constructing UUID generator that generates UUID using * variant 1 (time+location based). * Since no Ethernet address is passed, a bogus broadcast address will be * constructed for purpose of UUID generation; usually it is better to * instead access one of host's NIC addresses using * {@link EthernetAddress#fromInterface} which will use one of available * MAC (Ethernet) addresses available. */ public static TimeBasedGenerator timeBasedGenerator() { return timeBasedGenerator(null); } /** * Factory method for constructing UUID generator that generates UUID using * variant 1 (time+location based), using specified Ethernet address * as the location part of UUID. * No additional external synchronization is used. */ public static TimeBasedGenerator timeBasedGenerator(EthernetAddress ethernetAddress) { return timeBasedGenerator(ethernetAddress, (UUIDTimer) null); } /** * Factory method for constructing UUID generator that generates UUID using * variant 1 (time+location based), using specified Ethernet address * as the location part of UUID, and specified synchronizer (which may add * additional restrictions to guarantee system-wide uniqueness). * * @param ethernetAddress (optional) MAC address to use; if null, a transient * random address is generated. * * @see com.fasterxml.uuid.ext.FileBasedTimestampSynchronizer */ public static TimeBasedGenerator timeBasedGenerator(EthernetAddress ethernetAddress, TimestampSynchronizer sync) { UUIDTimer timer; try { timer = new UUIDTimer(new Random(System.currentTimeMillis()), sync); } catch (IOException e) { throw new IllegalArgumentException("Failed to create UUIDTimer with specified synchronizer: "+e.getMessage(), e); } return timeBasedGenerator(ethernetAddress, timer); } /** * Factory method for constructing UUID generator that generates UUID using * variant 1 (time+location based), using specified Ethernet address * as the location part of UUID, and specified {@link UUIDTimer} instance * (which includes embedded synchronizer that defines synchronization behavior). */ public static TimeBasedGenerator timeBasedGenerator(EthernetAddress ethernetAddress, UUIDTimer timer) { if (timer == null) { timer = sharedTimer(); } return new TimeBasedGenerator(ethernetAddress, timer); } /* /********************************************************************** /* Internal methods /********************************************************************** */ private static synchronized UUIDTimer sharedTimer() { if (_sharedTimer == null) { try { _sharedTimer = new UUIDTimer(new java.util.Random(System.currentTimeMillis()), null); } catch (IOException e) { throw new IllegalArgumentException("Failed to create UUIDTimer with specified synchronizer: "+e.getMessage(), e); } } return _sharedTimer; } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/Jug.java000066400000000000000000000306061324315460500310250ustar00rootroot00000000000000/* JUG Java UUID Generator * * Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import java.io.*; import java.security.*; import java.util.*; import com.fasterxml.uuid.impl.NameBasedGenerator; /** * Simple command-line interface to UUID generation functionality. */ public class Jug { protected final static HashMap TYPES = new HashMap(); static { TYPES.put("time-based", "t"); TYPES.put("random-based", "r"); TYPES.put("name-based", "n"); } protected final static HashMap OPTIONS = new HashMap(); static { OPTIONS.put("count", "c"); OPTIONS.put("ethernet-address", "e"); OPTIONS.put("help", "h"); OPTIONS.put("namespace", "s"); OPTIONS.put("name", "n"); OPTIONS.put("performance", "p"); OPTIONS.put("verbose", "v"); } protected static void printUsage() { String clsName = Jug.class.getName(); System.err.println("Usage: java "+clsName+" [options] type"); System.err.println("Where options are:"); System.err.println(" --count / -c : will generate UUIDs (default: 1)"); System.err.println(" --ethernet-address / -e : defines the ethernet address"); System.err.println(" (in xx:xx:xx:xx:xx:xx notation, usually obtained using 'ifconfig' etc)"); System.err.println(" to use with time-based UUID generation"); System.err.println(" --help / -h: lists the usage (ie. what you see now)"); System.err.println(" --name / -n: specifies"); System.err.println(" o name for name-based UUID generation"); System.err.println(" o 'information' part of tag-URI for tag-URI UUID generation"); System.err.println(" --namespace / -s: specifies"); System.err.println(" o the namespace (DNS or URL) for name-based UUID generation"); System.err.println(" o 'authority' part of tag-URI for tag-URI UUID generation;"); System.err.println(" (fully-qualified domain name, email address)"); System.err.println(" --performance / -p: measure time it takes to generate UUID(s)."); System.err.println(" [note that UUIDs are not printed out unless 'verbose' is also specified]"); System.err.println(" --verbose / -v: lists additional information about UUID generation\n (by default only UUIDs are printed out (to make it usable in scripts)"); System.err.println("And type is one of:"); System.err.println(" time-based / t: generate UUID based on current time and optional\n location information (defined with -e option)"); System.err.println(" random-based / r: generate UUID based on the default secure random number generator"); System.err.println(" name-based / n: generate UUID based on the na the default secure random number generator"); } private static void printMap(Map m, PrintStream out, boolean option) { int i = 0; int len = m.size(); for (Map.Entry en : m.entrySet()) { if (++i > 1) { if (i < len) { out.print(", "); } else { out.print(" and "); } } if (option) { out.print("--"); } out.print(en.getKey()); out.print(" ("); if (option) { out.print("-"); } out.print(en.getValue()); out.print(")"); } } public static void main(String[] args) { if (args.length == 0) { printUsage(); return; } int count = args.length; String type = args[count-1]; boolean verbose = false; int genCount = 1; String name = null; String nameSpace = null; EthernetAddress addr = null; boolean performance = false; --count; // Type we recognize? String tmp = (String) TYPES.get(type); if (tmp == null) { if (!TYPES.containsValue(type)) { System.err.println("Unrecognized UUID generation type '"+ type+"'; currently available ones are:"); printMap(TYPES, System.err, false); System.err.println(); System.exit(1); } } else { // Long names get translated to shorter ones: type = tmp; } NoArgGenerator noArgGenerator = null; // random- or time-based StringArgGenerator nameArgGenerator = null; // name-based for (int i = 0; i < count; ++i) { String opt = args[i]; if (opt.length() == 0 || opt.charAt(0) != '-') { System.err.println("Unrecognized option '"+opt+"' (missing leading hyphen?), exiting."); System.exit(1); } char option = (char)0; if (opt.startsWith("--")) { String o = (String) OPTIONS.get(opt.substring(2)); // Let's translate longer names to simple names: if (o != null) { option = o.charAt(0); } } else { if (OPTIONS.containsValue(opt.substring(1))) { option = opt.charAt(1); } } if (option == (char) 0) { System.err.println("Unrecognized option '"+opt+"'; exiting."); System.err.print("[options currently available are: "); printMap(OPTIONS, System.err, true); System.err.println("]"); System.exit(1); } // K. Now we have one-letter options to handle: 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; } } catch (IndexOutOfBoundsException ie) { // We get here when an arg is missing... System.err.println("Missing argument for option '"+opt+"', exiting."); System.exit(1); } } // for (int i = 0....) /* Ok, args look ok so far. Now to the generation; some args/options * can't be validated without knowing the type: */ char typeC = type.charAt(0); UUID nsUUID = null; boolean usesRnd = false; switch (typeC) { case 't': // time-based 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(")"); } } noArgGenerator = Generators.timeBasedGenerator(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); } break; case 'n': // name-based if (name == 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."); System.exit(1); } } nameArgGenerator = Generators.nameBasedGenerator(nsUUID); break; } // And then let's rock: if (verbose) { System.out.println(); } /* When measuring performance, make sure that the random number * generator is initialized prior to measurements... */ long now = 0L; if (performance) { // No need to pre-initialize for name-based schemes? if (usesRnd) { if (verbose) { System.out.println("(initializing random number generator before UUID generation so that performance measurements are not skewed due to one-time init costs)"); } // should initialize by just calling it noArgGenerator.generate(); if (verbose) { System.out.println("(random number generator initialized ok)"); } } now = System.currentTimeMillis(); } for (int i = 0; i < genCount; ++i) { UUID uuid = (nameArgGenerator == null) ? noArgGenerator.generate() : nameArgGenerator.generate(name); if (verbose) { System.out.print("UUID: "); } if (!performance || verbose) { System.out.println(uuid.toString()); } } // for (int i = 0; ...) if (verbose) { System.out.println("Done."); } if (performance) { now = System.currentTimeMillis() - now; long avg = (now * 10 + (genCount / 2)) / genCount; System.out.println("Performance: took "+now+" milliseconds to generate (and print out) "+genCount+" UUIDs; average being "+(avg / 10)+"."+(avg%10)+" msec."); } } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/Logger.java000066400000000000000000000210251324315460500315120ustar00rootroot00000000000000/* JUG Java Uuid Generator * * Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import java.io.*; /** * This is the simple logging interface used by JUG package. It is meant * to provide a minimal but sufficient functionality for JUG to report * problems (warnings, errors), in a way that it can be sufficiently * customized (redirected, suppressed; even redefined), without forcing * overhead of a real * full-featured logging sub-system (like log4j or java.util.logging). * By being customizable, it is still possible to connect JUG logging into * real logging framework (log4j, java.util.logging) used by application * or system that uses JUG. *

* To keep things as light-weight as possible, we won't bother defining * separate interface or abstract class -- this class defines both API * and the default implementation. It can thus be extended to override * functionality to provide things like bridging to "real" logging systems. * For simple configuration (suppress all, redirect to another stream) * default implementation should be sufficient, however. *

* Note: package com.fasterxml.uuid.ext does contain * simple wrappers to connect JUG logging to log4j and java.util.logging: * * @see com.fasterxml.uuid.ext.Log4jLogger * @see com.fasterxml.uuid.ext.JavaUtilLogger */ public class Logger { /* ////////////////////////////////////////////////// // Constants ////////////////////////////////////////////////// */ public final static int LOG_ALL = 0; public final static int LOG_INFO_AND_ABOVE = 1; public final static int LOG_WARNING_AND_ABOVE = 2; public final static int LOG_ERROR_AND_ABOVE = 3; public final static int LOG_NOTHING = 4; /* /********************************************************************** /* Static objects /********************************************************************** */ /** * By default we'll use this default implementation; however, * it can be easily changed. */ private static Logger instance = new Logger(); /* /********************************************************************** /* Default impl. configuration /********************************************************************** */ /** * Threshold to use for outputting varius log statements. *

* Default is to low only warnings and errors */ protected int _logLevel = LOG_ALL; /** * Output object to use, if defined; initialized to * System.err. */ protected PrintStream _output1 = System.err; /** * Override output used to explicitly specify where to pass diagnostic * output, instead of System.err. Used if _output1 * is null; */ protected PrintWriter _output2 = null; /* /********************************************************************** /* Life-cycle /********************************************************************** */ protected Logger() { } /** * Method that can be used to completely re-define the logging * functionality JUG uses. When called, JUG will start using the * new instance; if instance passed is null, will basically suppress * all logging. * * @param inst Logger instance to use for all logging JUG does; can be * null, but if so, essentially disables all logging. */ public synchronized static void setLogger(Logger inst) { instance = inst; } /* /********************************************************************** /* Actual simple logging API /* (static dispatchers to instance methods) /********************************************************************** */ // // // Configuration /** * Method to set the minimum level of messages that will get logged * using currently specific logger instace. For example, if * {@link #LOG_WARNING_AND_ABOVE} is passed as the argument, warnings * and errors will be logged, but informational (INFO) messages will * not. *

* Note: exact functionality invoked depends on the logger instance: * sub-classes of this class may need to do mapping to some other * logging sub-system (log4j and JUL logging, for example, use their * own severity levels that while generally reasonably easy to map, * are nonetheless not one-to-one which the simple logger). */ public static void setLogLevel(int level) { Logger l = instance; if (l != null) { l.doSetLogLevel(level); } } /** * Method that will re-direct output of the logger using the specified * {@link PrintStream}. Null is allowed, and signifies that all the * output should be suppressed. *

* Note: exact functionality invoked depends on the logger instance. */ public static void setOutput(PrintStream str) { Logger l = instance; if (l != null) { l.doSetOutput(str); } } /** * Method that will re-direct output of the logger using the specified * {@link Writer}. Null is allowed, and signifies that all the * output should be suppressed. */ public static void setOutput(Writer w) { Logger l = instance; if (l != null) { l.doSetOutput(w); } } // // // Logging methods public static void logInfo(String msg) { Logger l = instance; if (l != null) { l.doLogInfo(msg); } } public static void logWarning(String msg) { Logger l = instance; if (l != null) { l.doLogWarning(msg); } } public static void logError(String msg) { Logger l = instance; if (l != null) { l.doLogError(msg); } } /* /********************************************************************** /* Overridable implementation/instance methods /********************************************************************** */ // // // Config protected void doSetLogLevel(int ll) { /* No need to sync for atomic value that's not used * for synced or critical things */ _logLevel = ll; } protected void doSetOutput(PrintStream str) { synchronized (this) { _output1 = str; _output2 = null; } } protected void doSetOutput(Writer w) { synchronized (this) { _output1 = null; _output2 = (w instanceof PrintWriter) ? (PrintWriter) w : new PrintWriter(w); } } // // // Logging methods protected void doLogInfo(String msg) { if (_logLevel <= LOG_INFO_AND_ABOVE && isEnabled()) { synchronized (this) { doWrite("INFO: "+msg); } } } protected void doLogWarning(String msg) { if (_logLevel <= LOG_WARNING_AND_ABOVE && isEnabled()) { synchronized (this) { doWrite("WARNING: "+msg); } } } protected void doLogError(String msg) { if (_logLevel <= LOG_ERROR_AND_ABOVE && isEnabled()) { synchronized (this) { doWrite("ERROR: "+msg); } } } /* /********************************************************************** /* Internal methods /********************************************************************** */ protected void doWrite(String msg) { if (_output1 != null) { _output1.println(msg); } else if (_output2 != null) { _output2.println(msg); } } /** * Internal method used to quickly check if the Logger's output * is suppressed or not. *

* Note: not synchronized since it's read-only method that's return * value can not be used for reliable syncing. */ protected boolean isEnabled() { return (_output1 != null) || (_output2 != null); } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/NoArgGenerator.java000066400000000000000000000005351324315460500331530ustar00rootroot00000000000000package com.fasterxml.uuid; import java.util.UUID; /** * Intermediate base class for UUID generators that do not take arguments for individual * calls. This includes random and time-based variants, but not name-based ones. * * @since 3.0 */ public abstract class NoArgGenerator extends UUIDGenerator { public abstract UUID generate(); } StringArgGenerator.java000066400000000000000000000012751324315460500337700ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuidpackage com.fasterxml.uuid; import java.util.UUID; /** * Intermediate base class for UUID generators that take one String argument for individual * calls. This includes name-based generators, but not random and time-based generators. * * @since 3.0 */ public abstract class StringArgGenerator extends UUIDGenerator { /** * Method for generating name-based UUIDs using specified name (serialized to * bytes using UTF-8 encoding) */ public abstract UUID generate(String name); /** * Method for generating name-based UUIDs using specified byte-serialization * of name. * * @since 3.1 */ public abstract UUID generate(byte[] nameBytes); } TimestampSynchronizer.java000066400000000000000000000064241324315460500346030ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/* JUG Java Uuid Generator * * Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import java.io.IOException; /** * This is the API for utility classes optionally used by {@link UUIDTimer} to * ensure that timestamp values used for generating time/location-based UUIDs * are monotonically increasing, as well as that only one such generator * is ever used on a single system, even in presence of multiple JVMs. *

* The default implementation used by JUG is * {@link com.fasterxml.uuid.ext.FileBasedTimestampSynchronizer}. */ public abstract class TimestampSynchronizer { protected TimestampSynchronizer() { } /** * Initialization method is will be called on an instance by * {@link UUIDTimer} right after it's been configured with one. * At this point the implementation instance should have been properly * configured, and should be able to determine the first legal timestamp * value (return value). Method should also initialize any locking that * it does (if any), such as locking files it needs. *

* Return value thus indicates the lowest initial time value that can * be used by the caller that can not have been used by previous * incarnations of the UUID generator (assuming instance was able to * find properly persisted data to figure that out). * However, caller also needs to make sure that it will * call {@link #update} when it actually needs the time stamp for the * first time, * since this method can not allocate timestamps beyond this initial * value at this point. * * @return First (and last) legal timestamp to use; 0L if it * can not * determine it and caller can use whatever value (current timestamp) * it has access to. */ protected abstract long initialize() throws IOException; /** * Method {@link UUIDTimer} will call if this synchronizer object is * being replaced by another synchronizer (or removed, that is, no * more synchronization is to be done). It will not be called if JVM * terminates. */ protected abstract void deactivate() throws IOException; /** * Method called by {@link UUIDTimer} to indicate that it has generated * a timestamp value that is beyond last legal timestamp value. * The method should only return once it has "locked" specified timestamp * value (and possible additional ones). * * @param now Timestamp value caller wants to use, and that the * synchronizer is asked to protect. * * @return First timestamp value that can NOT be used by the caller; * has to be higher than the input timestamp value */ protected abstract long update(long now) throws IOException; } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/UUIDComparator.java000066400000000000000000000051661324315460500331010ustar00rootroot00000000000000package com.fasterxml.uuid; import java.util.Comparator; import java.util.UUID; /** * Default {@link java.util.UUID} comparator is not very useful, since * it just does blind byte-by-byte comparison which does not work well * for time+location - based UUIDs. Additionally it also uses signed * comparisons for longs which can lead to unexpected behavior * This comparator does implement proper lexical ordering: starting with * type (different types are collated * separately), followed by time and location (for time/location based), * and simple lexical (byte-by-byte) ordering for name/hash and random * variants. * * @author tatu */ public class UUIDComparator implements Comparator { @Override public int compare(UUID u1, UUID u2) { return staticCompare(u1, u2); } /** * Static helper method that can be used instead of instantiating comparator * (used by unit tests, can be used by code too) */ public static int staticCompare(UUID u1, UUID u2) { // First: major sorting by types int type = u1.version(); int diff = type - u2.version(); if (diff != 0) { return diff; } // Second: for time-based variant, order by time stamp: if (type == UUIDType.TIME_BASED.raw()) { diff = compareULongs(u1.timestamp(), u2.timestamp()); if (diff == 0) { // or if that won't work, by other bits lexically diff = compareULongs(u1.getLeastSignificantBits(), u2.getLeastSignificantBits()); } } else { // note: java.util.UUIDs compares with sign extension, IMO that's wrong, so: diff = compareULongs(u1.getMostSignificantBits(), u2.getMostSignificantBits()); if (diff == 0) { diff = compareULongs(u1.getLeastSignificantBits(), u2.getLeastSignificantBits()); } } return diff; } protected final static int compareULongs(long l1, long l2) { int diff = compareUInts((int) (l1 >> 32), (int) (l2 >> 32)); if (diff == 0) { diff = compareUInts((int) l1, (int) l2); } return diff; } protected final static int compareUInts(int i1, int i2) { /* bit messier due to java's insistence on signed values: if both * have same sign, normal comparison (by subtraction) works fine; * but if signs don't agree need to resolve differently */ if (i1 < 0) { return (i2 < 0) ? (i1 - i2) : 1; } return (i2 < 0) ? -1 : (i1 - i2); } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/UUIDGenerator.java000066400000000000000000000027141324315460500327140ustar00rootroot00000000000000/* JUG Java UUID Generator * * Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; /** * Minimal "tag" base class from which all generator implementations * derive. Actual generation methods are not included since different * generators take different number of arguments. * * @since 3.0 */ public abstract class UUIDGenerator { /* /********************************************************** /* Life-cycle /********************************************************** */ /** * Constructor is private to enforce singleton access. */ protected UUIDGenerator() { } /* /********************************************************** /* Shared (minimal) API /********************************************************** */ /** * Accessor for determining type of UUIDs (variant) that this * generator instance will produce. */ public abstract UUIDType getType(); } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/UUIDTimer.java000066400000000000000000000356341324315460500320550ustar00rootroot00000000000000/* JUG Java Uuid Generator * * Copyright (c) 2002 Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import java.io.*; import java.util.*; import com.fasterxml.uuid.impl.UUIDUtil; /** * UUIDTimer produces the time stamps required for time-based UUIDs. * It works as outlined in the UUID specification, with following * implementation: *

    *
  • Java classes can only product time stamps with maximum resolution * of one millisecond (at least before JDK 1.5). * To compensate, an additional counter is used, * so that more than one UUID can be generated between java clock * updates. Counter may be used to generate up to 10000 UUIDs for * each distinct java clock value. *
  • Due to even lower clock resolution on some platforms (older * Windows versions use 55 msec resolution), timestamp value can * also advanced ahead of physical value within limits (by default, * up 100 millisecond ahead of reported), if necessary (ie. 10000 * instances created before clock time advances). *
  • As an additional precaution, counter is initialized not to 0 * but to a random 8-bit number, and each time clock changes, lowest * 8-bits of counter are preserved. The purpose it to make likelyhood * of multi-JVM multi-instance generators to collide, without significantly * reducing max. UUID generation speed. Note though that using more than * one generator (from separate JVMs) is strongly discouraged, so * hopefully this enhancement isn't needed. * This 8-bit offset has to be reduced from total max. UUID count to * preserve ordering property of UUIDs (ie. one can see which UUID * was generated first for given UUID generator); the resulting * 9500 UUIDs isn't much different from the optimal choice. *
  • Finally, as of version 2.0 and onwards, optional external timestamp * synchronization can be done. This is done similar to the way UUID * specification suggests; except that since there is no way to * lock the whole system, file-based locking is used. This works * between multiple JVMs and Jug instances. *
*

*Some additional assumptions about calculating the timestamp: *

    *
  • System.currentTimeMillis() is assumed to give time offset in UTC, * or at least close enough thing to get correct timestamps. The * alternate route would have to go through calendar object, use * TimeZone offset to get to UTC, and then modify. Using currentTimeMillis * should be much faster to allow rapid UUID creation. *
  • Similarly, the constant used for time offset between 1.1.1970 and * start of Gregorian calendar is assumed to be correct (which seems * to be the case when testing with Java calendars). *
*

* Note about synchronization: main synchronization point (as of version * 3.1.1 and above) is {@link #getTimestamp}, so caller need not * synchronize access explicitly. */ public class UUIDTimer { // // // Constants /** * Since System.longTimeMillis() returns time from january 1st 1970, * and UUIDs need time from the beginning of gregorian calendar * (15-oct-1582), need to apply the offset: */ private final static long kClockOffset = 0x01b21dd213814000L; /** * Also, instead of getting time in units of 100nsecs, we get something * with max resolution of 1 msec... and need the multiplier as well */ private final static int kClockMultiplier = 10000; private final static long kClockMultiplierL = 10000L; /** * Let's allow "virtual" system time to advance at most 100 milliseconds * beyond actual physical system time, before adding delays. */ private final static long kMaxClockAdvance = 100L; // // // Configuration /** * Object used to reliably ensure that no multiple JVMs * generate UUIDs, and also that the time stamp value used for * generating time-based UUIDs is monotonically increasing * even if system clock moves backwards over a reboot (usually * due to some system level problem). *

* See {@link TimestampSynchronizer} for details. */ protected final TimestampSynchronizer _syncer; /** * Random number generator used to generate additional information * to further reduce probability of collisions. */ protected final Random _random; // // // Clock state: /** * Additional state information used to protect against anomalous * cases (clock time going backwards, node id getting mixed up). * Third byte is actually used for seeding counter on counter * overflow. * Note that only lowermost 16 bits are actually used as sequence */ private int _clockSequence; /** * Last physical timestamp value System.currentTimeMillis() * returned: used to catch (and report) cases where system clock * goes backwards. Is also used to limit "drifting", that is, amount * timestamps used can differ from the system time value. This value * is not guaranteed to be monotonically increasing. */ private long _lastSystemTimestamp = 0L; /** * Timestamp value last used for generating a UUID (along with * {@link #_clockCounter}. Usually the same as * {@link #_lastSystemTimestamp}, but not always (system clock * moved backwards). Note that this value is guaranteed to be * monotonically increasing; that is, at given absolute time points * t1 and t2 (where t2 is after t1), t1 <= t2 will always hold true. */ private long _lastUsedTimestamp = 0L; /** * First timestamp that can NOT be used without synchronizing * using synchronization object ({@link #_syncer}). Only used when * external timestamp synchronization (and persistence) is used, * ie. when {@link #_syncer} is not null. */ private long _firstUnsafeTimestamp = Long.MAX_VALUE; /** * Counter used to compensate inadequate resolution of JDK system * timer. */ private int _clockCounter = 0; public UUIDTimer(Random rnd, TimestampSynchronizer sync) throws IOException { _random = rnd; _syncer = sync; initCounters(rnd); _lastSystemTimestamp = 0L; // This may get overwritten by the synchronizer _lastUsedTimestamp = 0L; /* Ok, now; synchronizer can tell us what is the first timestamp * value that definitely was NOT used by the previous incarnation. * This can serve as the last used time stamp, assuming it is not * less than value we are using now. */ if (sync != null) { long lastSaved = sync.initialize(); if (lastSaved > _lastUsedTimestamp) { _lastUsedTimestamp = lastSaved; } } /* Also, we need to make sure there are now no safe values (since * synchronizer is not yet requested to allocate any): */ _firstUnsafeTimestamp = 0L; // ie. will always trigger sync.update() } private void initCounters(Random rnd) { /* Let's generate the clock sequence field now; as with counter, * this reduces likelihood of collisions (as explained in UUID specs) */ _clockSequence = rnd.nextInt(); /* Ok, let's also initialize the counter... * Counter is used to make it slightly less likely that * two instances of UUIDGenerator (from separate JVMs as no more * than one can be created in one JVM) would produce colliding * time-based UUIDs. The practice of using multiple generators, * is strongly discouraged, of course, but just in case... */ _clockCounter = (_clockSequence >> 16) & 0xFF; } public int getClockSequence() { return (_clockSequence & 0xFFFF); } /** * Method that constructs unique timestamp suitable for use for * constructing UUIDs. Default implementation is fully synchronized; * sub-classes may choose to implemented alternate strategies * * @return 64-bit timestamp to use for constructing UUID */ public synchronized long getTimestamp() { long systime = System.currentTimeMillis(); /* Let's first verify that the system time is not going backwards; * independent of whether we can use it: */ if (systime < _lastSystemTimestamp) { Logger.logWarning("System time going backwards! (got value "+systime+", last "+_lastSystemTimestamp); // Let's write it down, still _lastSystemTimestamp = systime; } /* But even without it going backwards, it may be less than the * last one used (when generating UUIDs fast with coarse clock * resolution; or if clock has gone backwards over reboot etc). */ if (systime <= _lastUsedTimestamp) { /* Can we just use the last time stamp (ok if the counter * hasn't hit max yet) */ if (_clockCounter < kClockMultiplier) { // yup, still have room systime = _lastUsedTimestamp; } else { // nope, have to roll over to next value and maybe wait long actDiff = _lastUsedTimestamp - systime; long origTime = systime; systime = _lastUsedTimestamp + 1L; Logger.logWarning("Timestamp over-run: need to reinitialize random sequence"); /* Clock counter is now at exactly the multiplier; no use * just anding its value. So, we better get some random * numbers instead... */ initCounters(_random); /* But do we also need to slow down? (to try to keep virtual * time close to physical time; i.e. either catch up when * system clock has been moved backwards, or when coarse * clock resolution has forced us to advance virtual timer * too far) */ if (actDiff >= kMaxClockAdvance) { slowDown(origTime, actDiff); } } } else { /* Clock has advanced normally; just need to make sure counter is * reset to a low value (need not be 0; good to leave a small * residual to further decrease collisions) */ _clockCounter &= 0xFF; } _lastUsedTimestamp = systime; /* Ok, we have consistent clock (virtual or physical) value that * we can and should use. * But do we need to check external syncing now? */ if (_syncer != null && systime >= _firstUnsafeTimestamp) { try { _firstUnsafeTimestamp = _syncer.update(systime); } catch (IOException ioe) { throw new RuntimeException("Failed to synchronize timestamp: "+ioe); } } /* Now, let's translate the timestamp to one UUID needs, 100ns * unit offset from the beginning of Gregorian calendar... */ systime *= kClockMultiplierL; systime += kClockOffset; // Plus add the clock counter: systime += _clockCounter; // and then increase ++_clockCounter; return systime; } /* /********************************************************************** /* Test-support methods /********************************************************************** */ /* Method for accessing timestamp to use for creating UUIDs. * Used ONLY by unit tests, hence protected. */ protected final void getAndSetTimestamp(byte[] uuidBytes) { long timestamp = getTimestamp(); uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_SEQUENCE] = (byte) _clockSequence; uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_SEQUENCE+1] = (byte) (_clockSequence >> 8); // Time fields aren't nicely split across the UUID, so can't just // linearly dump the stamp: int clockHi = (int) (timestamp >>> 32); int clockLo = (int) timestamp; uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_HI] = (byte) (clockHi >>> 24); uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_HI+1] = (byte) (clockHi >>> 16); uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_MID] = (byte) (clockHi >>> 8); uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_MID+1] = (byte) clockHi; uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_LO] = (byte) (clockLo >>> 24); uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_LO+1] = (byte) (clockLo >>> 16); uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_LO+2] = (byte) (clockLo >>> 8); uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_LO+3] = (byte) clockLo; } /* /********************************************************************** /* Private methods /********************************************************************** */ private final static int MAX_WAIT_COUNT = 50; /** * Simple utility method to use to wait for couple of milliseconds, * to let system clock hopefully advance closer to the virtual * timestamps used. Delay is kept to just a millisecond or two, * to prevent excessive blocking; but that should be enough to * eventually synchronize physical clock with virtual clock values * used for UUIDs. * * @param msecs Number of milliseconds to wait for from current * time point */ protected static void slowDown(long startTime, long actDiff) { /* First, let's determine how long we'd like to wait. * This is based on how far ahead are we as of now. */ long ratio = actDiff / kMaxClockAdvance; long delay; if (ratio < 2L) { // 200 msecs or less delay = 1L; } else if (ratio < 10L) { // 1 second or less delay = 2L; } else if (ratio < 600L) { // 1 minute or less delay = 3L; } else { delay = 5L; } Logger.logWarning("Need to wait for "+delay+" milliseconds; virtual clock advanced too far in the future"); long waitUntil = startTime + delay; int counter = 0; do { try { Thread.sleep(delay); } catch (InterruptedException ie) { } delay = 1L; /* This is just a sanity check: don't want an "infinite" * loop if clock happened to be moved backwards by, say, * an hour... */ if (++counter > MAX_WAIT_COUNT) { break; } } while (System.currentTimeMillis() < waitUntil); } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/UUIDType.java000066400000000000000000000011541324315460500317040ustar00rootroot00000000000000package com.fasterxml.uuid; /** * Enumeration of different flavors of UUIDs: 5 specified by specs * (RFC-4122) * and one * virtual entry ("UNKNOWN") to represent invalid one that consists of * all zero bites */ public enum UUIDType { TIME_BASED(1), DCE(2), NAME_BASED_MD5(3), RANDOM_BASED(4), NAME_BASED_SHA1(5), UNKNOWN(0) ; private final int _raw; private UUIDType(int raw) { _raw = raw; } /** * Returns "raw" type constants, embedded within UUID bytes. */ public int raw() { return _raw; } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/ext/000077500000000000000000000000001324315460500302305ustar00rootroot00000000000000FileBasedTimestampSynchronizer.java000066400000000000000000000164571324315460500371510ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/ext/* JUG Java Uuid Generator * * Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid.ext; import com.fasterxml.uuid.Logger; import com.fasterxml.uuid.TimestampSynchronizer; import java.io.*; /** * Implementation of {@link TimestampSynchronizer}, which uses file system * as the storage and locking mechanism. *

* Synchronization is achieved by obtaining an exclusive file locks on two * specified lock files, and by using the files to store first "safe" timestamp * value that the generator can use; alternating between one to use to ensure * one of them always contains a valid timestamp. Latter is needed to guard * against system clock moving backwards after UUID generator restart. *

* Note: this class will only work on JDK 1.4 and above, since it requires * NIO package to do proper file locking (as well as new opening mode for * {@link RandomAccessFile}). *

* Also note that it is assumed that the caller has taken care to synchronize * access to method to be single-threaded. As such, none of the methods * is explicitly synchronized here. */ public final class FileBasedTimestampSynchronizer extends TimestampSynchronizer { // // // Constants: /** * The default update interval is 10 seconds, meaning that the * synchronizer "reserves" next 10 seconds for generation. This * also means that the lock files need to be accessed at most * once every ten second. */ final static long DEFAULT_UPDATE_INTERVAL = 10L * 1000L; protected final static String DEFAULT_LOCK_FILE_NAME1 = "uuid1.lck"; protected final static String DEFAULT_LOCK_FILE_NAME2 = "uuid2.lck"; // // // Configuration: protected long mInterval = DEFAULT_UPDATE_INTERVAL; protected final LockedFile mLocked1, mLocked2; // // // State: /** * Flag used to indicate which of timestamp files has the most * recently succesfully updated timestamp value. True means that * mFile1 is more recent; false that mFile2 * is. */ boolean mFirstActive = false; /** * Constructor that uses default values for names of files to use * (files will get created in the current working directory), as * well as for the update frequency value (10 seconds). */ public FileBasedTimestampSynchronizer() throws IOException { this(new File(DEFAULT_LOCK_FILE_NAME1), new File(DEFAULT_LOCK_FILE_NAME2)); } public FileBasedTimestampSynchronizer(File lockFile1, File lockFile2) throws IOException { this(lockFile1, lockFile2, DEFAULT_UPDATE_INTERVAL); } public FileBasedTimestampSynchronizer(File lockFile1, File lockFile2, long interval) throws IOException { mInterval = interval; mLocked1 = new LockedFile(lockFile1); boolean ok = false; try { mLocked2 = new LockedFile(lockFile2); ok = true; } finally { if (!ok) { mLocked1.deactivate(); } } // But let's leave reading up to initialization } /* ////////////////////////////////////////////////////////////// // Configuration ////////////////////////////////////////////////////////////// */ public void setUpdateInterval(long interval) { if (interval < 1L) { throw new IllegalArgumentException("Illegal value ("+interval+"); has to be a positive integer value"); } mInterval = interval; } /* ////////////////////////////////////////////////////////////// // Implementation of the API ////////////////////////////////////////////////////////////// */ /** * This method is to be called only once by * {@link com.fasterxml.uuid.UUIDTimer}. It * should fetch the persisted timestamp value, which indicates * first timestamp value that is guaranteed NOT to have used by * a previous incarnation. If it can not determine such value, it * is to return 0L as a marker. * * @return First timestamp value that was NOT locked by lock files; * 0L to indicate that no information was read. */ protected long initialize() throws IOException { long ts1 = mLocked1.readStamp(); long ts2 = mLocked2.readStamp(); long result; if (ts1 > ts2) { mFirstActive = true; result = ts1; } else { mFirstActive = false; result = ts2; } /* Hmmh. If we didn't get a time stamp (-> 0), or if written time is * ahead of current time, let's log something: */ if (result <= 0L) { Logger.logWarning("Could not determine safe timer starting point: assuming current system time is acceptable"); } else { long now = System.currentTimeMillis(); //long diff = now - result; /* It's more suspicious if old time was ahead... although with * longer iteration values, it can be ahead without errors. So * let's base check on current iteration value: */ if ((now + mInterval) < result) { Logger.logWarning("Safe timestamp read is "+(result - now)+" milliseconds in future, and is greater than the inteval ("+mInterval+")"); } /* Hmmh. Is there any way a suspiciously old timestamp could be * harmful? It can obviously be useless but... */ } return result; } public void deactivate() throws IOException { doDeactivate(mLocked1, mLocked2); } /** * @return Timestamp value that the caller can NOT use. That is, all * timestamp values prior to (less than) this value can be used * ok, but this value and ones after can only be used by first * calling update. */ public long update(long now) throws IOException { long nextAllowed = now + mInterval; /* We have to make sure to (over)write the one that is NOT * actively used, to ensure that we always have fully persisted * timestamp value, even if the write process gets interruped * half-way through. */ if (mFirstActive) { mLocked2.writeStamp(nextAllowed); } else { mLocked1.writeStamp(nextAllowed); } mFirstActive = !mFirstActive; return nextAllowed; } /* ////////////////////////////////////////////////////////////// // Internal methods ////////////////////////////////////////////////////////////// */ protected static void doDeactivate(LockedFile lf1, LockedFile lf2) { if (lf1 != null) { lf1.deactivate(); } if (lf2 != null) { lf2.deactivate(); } } } JavaUtilLogger.java000066400000000000000000000104331324315460500336740ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/ext/* JUG Java Uuid Generator * * Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid.ext; import java.io.*; //import com.fasterxml.uuid.Logger; /** * Simple wrapper that allows easy connecting of JUG logging into JDK 1.4+ * logging implementation (aka "java.util.logging" aka "JUL". *

* Note: using this class requires JDK 1.4 or above. */ public class JavaUtilLogger extends com.fasterxml.uuid.Logger { private java.util.logging.Logger mPeer; private JavaUtilLogger(java.util.logging.Logger peer) { mPeer = peer; } /** * Static method to call to make JUG use to proxy all of its logging * through the specified j.u.l Logger instance. *

* Method will create a simple wrapper, and call * {@link com.fasterxml.uuid.Logger#setLogger} with the wrapper as * the argument. This will then re-direct logging from the previously * defined Logger (which initially is the simple JUG logger) to the * new wrapper, which routes logging messages to the log4j peer Logger * instance. */ public static void connectToJavaUtilLogging(java.util.logging.Logger peer) { JavaUtilLogger logger = new JavaUtilLogger(peer); // This is static method of the base class... setLogger(logger); } /** * Static method to call to make JUG use a log4j proxy all of its logging * through a j.u.l Logger constructed to correspond with * com.fasterxml.uuid.Logger class (this generally determines * j.u.l category output etc settings). *

* Method will create a simple wrapper, and call * {@link com.fasterxml.uuid.Logger#setLogger} with the wrapper as * the argument. This will then re-direct logging from the previously * defined Logger (which initially is the simple JUG logger) to the * new wrapper, which routes logging messages to the j.u.l peer Logger * instance. */ public static void connectToJavaUtilLogging() { connectToJavaUtilLogging(java.util.logging.Logger.getLogger(com.fasterxml.uuid.Logger.class.getName())); } /* ///////////////////////////////////////////////////////////// // Overridable implementation/instance methods from // Logger base class ///////////////////////////////////////////////////////////// */ // // // Config // This is ok; let's just use base class functionality: //protected void doSetLogLevel(int ll); /** * Note: this method is meaningless with log4j, since it has more * advanced output mapping and filtering mechanisms. As such, it's * a no-op */ protected void doSetOutput(PrintStream str) { // Could also throw an Error.. but for now, let's log instead... mPeer.warning("doSetOutput(PrintStream) called on "+getClass()+" instance, ignoring."); } /** * Note: this method is meaningless with log4j, since it has more * advanced output mapping and filtering mechanisms. As such, it's * a no-op */ protected void doSetOutput(Writer w) { mPeer.warning("doSetOutput(Writer) called on "+getClass()+" instance, ignoring."); } // // // Logging methods protected void doLogInfo(String msg) { if (_logLevel <= LOG_INFO_AND_ABOVE) { mPeer.info(msg); } } protected void doLogWarning(String msg) { if (_logLevel <= LOG_WARNING_AND_ABOVE) { mPeer.warning(msg); } } protected void doLogError(String msg) { /* Hmmh. JUL doesn't have error... and SEVERE is bit drastic. But, * well, let's use that for ERRORs for now. */ if (_logLevel <= LOG_ERROR_AND_ABOVE) { mPeer.severe(msg); } } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/ext/LockedFile.java000066400000000000000000000215561324315460500331050ustar00rootroot00000000000000/* JUG Java Uuid Generator * * Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid.ext; import java.io.*; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.channels.FileLock; import com.fasterxml.uuid.Logger; /** * Utility class used by {@link FileBasedTimestampSynchronizer} to do * actual file access and locking. *

* Class stores simple timestamp values based on system time accessed * using System.currentTimeMillis(). A single timestamp * is stored into a file using {@link RandomAccessFile} in fully * synchronized mode. Value is written in ISO-Latin (ISO-8859-1) * encoding (superset of Ascii, 1 byte per char) as 16-digit hexadecimal * number, surrounded by brackets. As such, file produced should * always have exact size of 18 bytes. For extra robustness, slight * variations in number of digits are accepeted, as are white space * chars before and after bracketed value. */ class LockedFile { /** * Expected file length comes from hex-timestamp (16 digits), * preamble "[0x",(3 chars) and trailer "]\r\n" (2 chars, linefeed * to help debugging -- in some environments, missing trailing linefeed * causes problems: also, 2-char linefeed to be compatible with all * standard linefeeds on MacOS, Unix and Windows). */ final static int DEFAULT_LENGTH = 22; final static long READ_ERROR = 0L; // // // Configuration: final File mFile; // // // File state RandomAccessFile mRAFile; FileChannel mChannel; FileLock mLock; ByteBuffer mWriteBuffer = null; /** * Flag set if the original file (created before this instance was * created) had size other than default size and needs to be * truncated */ boolean mWeirdSize; /** * Marker used to ensure that the timestamps stored are monotonously * increasing. Shouldn't really be needed, since caller should take * care of it, but let's be bit paranoid here. */ long mLastTimestamp = 0L; LockedFile(File f) throws IOException { mFile = f; RandomAccessFile raf = null; FileChannel channel = null; FileLock lock = null; boolean ok = false; try { // let's just use a single block to share cleanup code raf = new RandomAccessFile(f, "rwd"); // Then lock them, if possible; if not, let's err out channel = raf.getChannel(); if (channel == null) { throw new IOException("Failed to access channel for '"+f+"'"); } lock = channel.tryLock(); if (lock == null) { throw new IOException("Failed to lock '"+f+"' (another JVM running UUIDGenerator?)"); } ok = true; } finally { if (!ok) { doDeactivate(f, raf, lock); } } mRAFile = raf; mChannel = channel; mLock = lock; } public void deactivate() { RandomAccessFile raf = mRAFile; mRAFile = null; FileLock lock = mLock; mLock = null; doDeactivate(mFile, raf, lock); } public long readStamp() { int size; try { size = (int) mChannel.size(); } catch (IOException ioe) { doLogError("Failed to read file size: "+ioe); return READ_ERROR; } mWeirdSize = (size != DEFAULT_LENGTH); // Let's check specifically empty files though if (size == 0) { doLogWarning("Missing or empty file, can not read timestamp value"); return READ_ERROR; } // Let's also allow some slack... but just a bit if (size > 100) { size = 100; } byte[] data = new byte[size]; try { mRAFile.readFully(data); } catch (IOException ie) { doLogError("Failed to read "+size+" bytes: "+ie); return READ_ERROR; } /* Ok, got data. Now, we could just directly parse the bytes (since * it is single-byte encoding)... but for convenience, let's create * the String (this is only called once per JVM session) */ char[] cdata = new char[size]; for (int i = 0; i < size; ++i) { cdata[i] = (char) (data[i] & 0xFF); } String dataStr = new String(cdata); // And let's trim leading (and trailing, who cares) dataStr = dataStr.trim(); long result = -1; String err = null; if (!dataStr.startsWith("[0") || dataStr.length() < 3 || Character.toLowerCase(dataStr.charAt(2)) != 'x') { err = "does not start with '[0x' prefix"; } else { int ix = dataStr.indexOf(']', 3); if (ix <= 0) { err = "does not end with ']' marker"; } else { String hex = dataStr.substring(3, ix); if (hex.length() > 16) { err = "length of the (hex) timestamp too long; expected 16, had "+hex.length()+" ('"+hex+"')"; } else { try { result = Long.parseLong(hex, 16); } catch (NumberFormatException nex) { err = "does not contain a valid hex timestamp; got '" +hex+"' (parse error: "+nex+")"; } } } } // Unsuccesful? if (result < 0L) { doLogError("Malformed timestamp file contents: "+err); return READ_ERROR; } mLastTimestamp = result; return result; } final static String HEX_DIGITS = "0123456789abcdef"; public void writeStamp(long stamp) throws IOException { // Let's do sanity check first: if (stamp <= mLastTimestamp) { /* same stamp is not dangerous, but pointless... so warning, * not an error: */ if (stamp == mLastTimestamp) { doLogWarning("Trying to re-write existing timestamp ("+stamp+")"); return; } throw new IOException(""+getFileDesc()+" trying to overwrite existing value ("+mLastTimestamp+") with an earlier timestamp ("+stamp+")"); } //System.err.println("!!!! Syncing ["+mFile+"] with "+stamp+" !!!"); // Need to initialize the buffer? if (mWriteBuffer == null) { mWriteBuffer = ByteBuffer.allocate(DEFAULT_LENGTH); mWriteBuffer.put(0, (byte) '['); mWriteBuffer.put(1, (byte) '0'); mWriteBuffer.put(2, (byte) 'x'); mWriteBuffer.put(19, (byte) ']'); mWriteBuffer.put(20, (byte) '\r'); mWriteBuffer.put(21, (byte) '\n'); } // Converting to hex is simple for (int i = 18; i >= 3; --i) { int val = (((int) stamp) & 0x0F); mWriteBuffer.put(i, (byte) HEX_DIGITS.charAt(val)); stamp = (stamp >> 4); } // and off we go: mWriteBuffer.position(0); // to make sure we always write it all mChannel.write(mWriteBuffer, 0L); if (mWeirdSize) { mRAFile.setLength(DEFAULT_LENGTH); mWeirdSize = false; } // This is probably not needed (as the random access file is supposedly synced)... but let's be safe: mChannel.force(false); // And that's it! } /* ////////////////////////////////////////////////////////////// // Internal methods ////////////////////////////////////////////////////////////// */ protected void doLogWarning(String msg) { Logger.logWarning("(file '"+getFileDesc()+"') "+msg); } protected void doLogError(String msg) { Logger.logError("(file '"+getFileDesc()+"') "+msg); } protected String getFileDesc() { return mFile.toString(); } protected static void doDeactivate(File f, RandomAccessFile raf, FileLock lock) { if (lock != null) { try { lock.release(); } catch (Throwable t) { Logger.logError("Failed to release lock (for file '"+f+"'): "+t); } } if (raf != null) { try { raf.close(); } catch (Throwable t) { Logger.logError("Failed to close file '"+f+"':"+t); } } } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/ext/Log4jLogger.java000066400000000000000000000101611324315460500332110ustar00rootroot00000000000000/* JUG Java Uuid Generator * * Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid.ext; import java.io.*; //import com.fasterxml.uuid.Logger; /** * Simple wrapper that allows easy connecting of JUG logging into log4j * logging subsystem. *

* Note: using this class implies all the dependencies that the log4j * subsystem in use requires (JDK 1.2 or above, in general) */ public class Log4jLogger extends com.fasterxml.uuid.Logger { private org.apache.log4j.Logger mPeer; private Log4jLogger(org.apache.log4j.Logger peer) { mPeer = peer; } /** * Static method to call to make JUG use to proxy all of its logging * through the specified log4j Logger instance. *

* Method will create a simple wrapper, and call * {@link com.fasterxml.uuid.Logger#setLogger} with the wrapper as * the argument. This will then re-direct logging from the previously * defined Logger (which initially is the simple JUG logger) to the * new wrapper, which routes logging messages to the log4j peer Logger * instance. */ public static void connectToLog4j(org.apache.log4j.Logger peer) { Log4jLogger logger = new Log4jLogger(peer); // This is static method of the base class... setLogger(logger); } /** * Static method to call to make JUG use a log4j proxy all of its logging * through a log4j Logger constructed to correspond with * com.fasterxml.uuid.Logger class (this generally determines * log4j category output etc settings). *

* Method will create a simple wrapper, and call * {@link com.fasterxml.uuid.Logger#setLogger} with the wrapper as * the argument. This will then re-direct logging from the previously * defined Logger (which initially is the simple JUG logger) to the * new wrapper, which routes logging messages to the log4j peer Logger * instance. */ public static void connectToLog4j() { connectToLog4j(org.apache.log4j.Logger.getLogger(com.fasterxml.uuid.Logger.class)); } /* ///////////////////////////////////////////////////////////// // Overridable implementation/instance methods from // Logger base class ///////////////////////////////////////////////////////////// */ // // // Config // This is ok; let's just use base class functionality: //protected void doSetLogLevel(int ll); /** * Note: this method is meaningless with log4j, since it has more * advanced output mapping and filtering mechanisms. As such, it's * a no-op */ protected void doSetOutput(PrintStream str) { // Could also throw an Error.. but for now, let's log instead... mPeer.warn("doSetOutput(PrintStream) called on "+getClass()+" instance, ignoring."); } /** * Note: this method is meaningless with log4j, since it has more * advanced output mapping and filtering mechanisms. As such, it's * a no-op */ protected void doSetOutput(Writer w) { mPeer.warn("doSetOutput(Writer) called on "+getClass()+" instance, ignoring."); } // // // Logging methods protected void doLogInfo(String msg) { if (_logLevel <= LOG_INFO_AND_ABOVE) { mPeer.info(msg); } } protected void doLogWarning(String msg) { if (_logLevel <= LOG_WARNING_AND_ABOVE) { mPeer.warn(msg); } } protected void doLogError(String msg) { if (_logLevel <= LOG_ERROR_AND_ABOVE) { mPeer.error(msg); } } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/ext/package.html000066400000000000000000000005111324315460500325060ustar00rootroot00000000000000 Package that contains optional Java UUID Generator classes; classes that:

  • Depend on optional external packages; like log4j or java.util.logging - based Logger adapters (java.util.logging itself was added in JDK 1.4)

Otherwise base JDK version requirement for these classes is 1.4.

java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/impl/000077500000000000000000000000001324315460500303715ustar00rootroot00000000000000GeneratorImplBase.java000066400000000000000000000002161324315460500345170ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/implpackage com.fasterxml.uuid.impl; /** * Shared base class for various UUID generator implementations. */ public class GeneratorImplBase { } NameBasedGenerator.java000066400000000000000000000104261324315460500346460ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/implpackage com.fasterxml.uuid.impl; import java.nio.charset.Charset; import java.security.MessageDigest; import java.util.UUID; import com.fasterxml.uuid.Logger; import com.fasterxml.uuid.StringArgGenerator; import com.fasterxml.uuid.UUIDType; /** * Implementation of UUID generator that uses one of name-based generation methods * (variants 3 (MD5) and 5 (SHA1)). *

* As all JUG provided implementations, this generator is fully thread-safe; access * to digester is synchronized as necessary. * * @since 3.0 */ public class NameBasedGenerator extends StringArgGenerator { public final static Charset _utf8; static { _utf8 = Charset.forName("UTF-8"); } /** * Namespace used when name is a DNS name. */ public final static UUID NAMESPACE_DNS = UUID.fromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8"); /** * Namespace used when name is a URL. */ public final static UUID NAMESPACE_URL = UUID.fromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8"); /** * Namespace used when name is an OID. */ public final static UUID NAMESPACE_OID = UUID.fromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8"); /** * Namespace used when name is an X500 identifier */ public final static UUID NAMESPACE_X500 = UUID.fromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8"); /* /********************************************************************** /* Configuration /********************************************************************** */ /** * Namespace to use as prefix. */ protected final UUID _namespace; /** * Message digesster to use for hash calculation */ protected final MessageDigest _digester; protected final UUIDType _type; /* /********************************************************************** /* Construction /********************************************************************** */ /** * @param namespace of the namespace, as defined by the * spec. UUID has 4 pre-defined "standard" name space strings * that can be passed to UUID constructor (see example below). * Note that this argument is optional; if no namespace is needed * (for example when name includes namespace prefix), null may be passed. * @param digester Hashing algorithm to use. */ public NameBasedGenerator(UUID namespace, MessageDigest digester, UUIDType type) { _namespace = namespace; // And default digester SHA-1 if (digester == null) { } if (type == null) { String typeStr = digester.getAlgorithm(); if (typeStr.startsWith("MD5")) { type = UUIDType.NAME_BASED_MD5; } else if (typeStr.startsWith("SHA")) { type = UUIDType.NAME_BASED_SHA1; } else { // Hmmh... error out? Let's default to SHA-1, but log a warning type = UUIDType.NAME_BASED_SHA1; Logger.logWarning("Could not determine type of Digester from '"+typeStr+"'; assuming 'SHA-1' type"); } } _digester = digester; _type = type; } /* /********************************************************************** /* Access to config /********************************************************************** */ @Override public UUIDType getType() { return _type; } public UUID getNamespace() { return _namespace; } /* /********************************************************************** /* UUID generation /********************************************************************** */ @Override public UUID generate(String name) { // !!! TODO: 14-Oct-2010, tatu: can repurpose faster UTF-8 encoding from Jackson return generate(name.getBytes(_utf8)); } @Override public UUID generate(byte[] nameBytes) { byte[] digest; synchronized (_digester) { _digester.reset(); if (_namespace != null) { _digester.update(UUIDUtil.asByteArray(_namespace)); } _digester.update(nameBytes); digest = _digester.digest(); } return UUIDUtil.constructUUID(_type, digest); } } RandomBasedGenerator.java000066400000000000000000000104241324315460500352040ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/implpackage com.fasterxml.uuid.impl; import java.security.SecureRandom; import java.util.Random; import java.util.UUID; import com.fasterxml.uuid.NoArgGenerator; import com.fasterxml.uuid.UUIDType; /** * Implementation of UUID generator that uses generation method 4. *

* Note on random number generation when using {@link SecureRandom} for random number * generation: the first time {@link SecureRandom} object is used, there is noticeable delay between * calling the method and getting the reply. This is because SecureRandom * has to initialize itself to reasonably random state. Thus, if you * want to lessen delay, it may be be a good idea to either get the * first random UUID asynchronously from a separate thread, or to * use the other generateRandomBasedUUID passing a previously initialized * SecureRandom instance. * * @since 3.0 */ public class RandomBasedGenerator extends NoArgGenerator { /** * Default shared random number generator, used if no random number generator * is explicitly specified for instance */ protected static Random _sharedRandom = null; /** * Random number generator that this generator uses. */ protected final Random _random; /** * Looks like {@link SecureRandom} implementation is more efficient * using single call access (compared to basic {@link java.util.Random}), * so let's use that knowledge to our benefit. */ protected final boolean _secureRandom; /** * @param rnd Random number generator to use for generating UUIDs; if null, * shared default generator is used. Note that it is strongly recommend to * use a good (pseudo) random number generator; for example, JDK's * {@link SecureRandom}. */ public RandomBasedGenerator(Random rnd) { if (rnd == null) { rnd = LazyRandom.sharedSecureRandom(); _secureRandom = true; } else { _secureRandom = (rnd instanceof SecureRandom); } _random = rnd; } /* /********************************************************************** /* Access to config /********************************************************************** */ @Override public UUIDType getType() { return UUIDType.RANDOM_BASED; } /* /********************************************************************** /* UUID generation /********************************************************************** */ @Override public UUID generate() { /* 14-Oct-2010, tatu: Surprisingly, variant for reading byte array is * tad faster for SecureRandom... so let's use that then */ long r1, r2; if (_secureRandom) { final byte[] buffer = new byte[16]; _random.nextBytes(buffer); r1 = _toLong(buffer, 0); r2 = _toLong(buffer, 1); } else { r1 = _random.nextLong(); r2 = _random.nextLong(); } return UUIDUtil.constructUUID(UUIDType.RANDOM_BASED, r1, r2); } /* /********************************************************************** /* Internal methods /********************************************************************** */ private final static long _toLong(byte[] buffer, int offset) { long l1 = _toInt(buffer, offset); long l2 = _toInt(buffer, offset+4); long l = (l1 << 32) + ((l2 << 32) >>> 32); return l; } private final static long _toInt(byte[] buffer, int offset) { return (buffer[offset] << 24) + ((buffer[++offset] & 0xFF) << 16) + ((buffer[++offset] & 0xFF) << 8) + (buffer[++offset] & 0xFF); } /* /********************************************************************** /* Helper classes /********************************************************************** */ /** * Trivial helper class that uses class loading as synchronization * mechanism for lazy instantation of the shared secure random * instance. */ private final static class LazyRandom { private final static SecureRandom shared = new SecureRandom(); public static SecureRandom sharedSecureRandom() { return shared; } } } TimeBasedGenerator.java000066400000000000000000000075751324315460500346770ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/implpackage com.fasterxml.uuid.impl; import java.util.UUID; import com.fasterxml.uuid.*; /** * Implementation of UUID generator that uses time/location based generation * method (variant 1). *

* As all JUG provided implementations, this generator is fully thread-safe. * Additionally it can also be made externally synchronized with other * instances (even ones running on other JVMs); to do this, * use {@link com.fasterxml.uuid.ext.FileBasedTimestampSynchronizer} * (or equivalent). * * @since 3.0 */ public class TimeBasedGenerator extends NoArgGenerator { /* /********************************************************************** /* Configuration /********************************************************************** */ protected final EthernetAddress _ethernetAddress; /** * Object used for synchronizing access to timestamps, to guarantee * that timestamps produced by this generator are unique and monotonically increasings. * Some implementations offer even stronger guarantees, for example that * same guarantee holds between instances running on different JVMs (or * with native code). */ protected final UUIDTimer _timer; /** * Base values for the second long (last 8 bytes) of UUID to construct */ protected final long _uuidL2; /* /********************************************************************** /* Construction /********************************************************************** */ /** * @param ethAddr Hardware address (802.1) to use for generating * spatially unique part of UUID. If system has more than one NIC, */ public TimeBasedGenerator(EthernetAddress ethAddr, UUIDTimer timer) { byte[] uuidBytes = new byte[16]; if (ethAddr == null) { ethAddr = EthernetAddress.constructMulticastAddress(); } // initialize baseline with MAC address info _ethernetAddress = ethAddr; _ethernetAddress.toByteArray(uuidBytes, 10); // and add clock sequence int clockSeq = timer.getClockSequence(); uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_SEQUENCE] = (byte) (clockSeq >> 8); uuidBytes[UUIDUtil.BYTE_OFFSET_CLOCK_SEQUENCE+1] = (byte) clockSeq; long l2 = UUIDUtil.gatherLong(uuidBytes, 8); _uuidL2 = UUIDUtil.initUUIDSecondLong(l2); _timer = timer; } /* /********************************************************************** /* Access to config /********************************************************************** */ @Override public UUIDType getType() { return UUIDType.TIME_BASED; } public EthernetAddress getEthernetAddress() { return _ethernetAddress; } /* /********************************************************************** /* UUID generation /********************************************************************** */ /* As timer is not synchronized (nor _uuidBytes), need to sync; but most * importantly, synchronize on timer which may also be shared between * multiple instances */ @Override public UUID generate() { final long rawTimestamp = _timer.getTimestamp(); // Time field components are kind of shuffled, need to slice: int clockHi = (int) (rawTimestamp >>> 32); int clockLo = (int) rawTimestamp; // and dice int midhi = (clockHi << 16) | (clockHi >>> 16); // need to squeeze in type (4 MSBs in byte 6, clock hi) midhi &= ~0xF000; // remove high nibble of 6th byte midhi |= 0x1000; // type 1 long midhiL = (long) midhi; midhiL = ((midhiL << 32) >>> 32); // to get rid of sign extension // and reconstruct long l1 = (((long) clockLo) << 32) | midhiL; // last detail: must force 2 MSB to be '10' return new UUID(l1, _uuidL2); } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/impl/UUIDUtil.java000066400000000000000000000242641324315460500326500ustar00rootroot00000000000000package com.fasterxml.uuid.impl; import java.util.UUID; import com.fasterxml.uuid.UUIDType; public class UUIDUtil { public final static int BYTE_OFFSET_CLOCK_LO = 0; public final static int BYTE_OFFSET_CLOCK_MID = 4; public final static int BYTE_OFFSET_CLOCK_HI = 6; // note: clock-hi and type occupy same byte (different bits) public final static int BYTE_OFFSET_TYPE = 6; // similarly, clock sequence and variant are multiplexed public final static int BYTE_OFFSET_CLOCK_SEQUENCE = 8; public final static int BYTE_OFFSET_VARIATION = 8; /* /********************************************************************** /* Construction (can instantiate, although usually not necessary) /********************************************************************** */ // note: left public just for convenience; all functionality available // via static methods public UUIDUtil() { } /* /********************************************************************** /* Factory methods /********************************************************************** */ /** * Factory method for creating UUIDs from the canonical string * representation. * * @param id String that contains the canonical representation of * the UUID to build; 36-char string (see UUID specs for details). * Hex-chars may be in upper-case too; UUID class will always output * them in lowercase. */ public static UUID uuid(String id) { if (id == null) { throw new NullPointerException(); } if (id.length() != 36) { throw new NumberFormatException("UUID has to be represented by the standard 36-char representation"); } long lo, hi; lo = hi = 0; for (int i = 0, j = 0; i < 36; ++j) { // Need to bypass hyphens: switch (i) { case 8: case 13: case 18: case 23: if (id.charAt(i) != '-') { throw new NumberFormatException("UUID has to be represented by the standard 36-char representation"); } ++i; } int curr; char c = id.charAt(i); if (c >= '0' && c <= '9') { curr = (c - '0'); } else if (c >= 'a' && c <= 'f') { curr = (c - 'a' + 10); } else if (c >= 'A' && c <= 'F') { curr = (c - 'A' + 10); } else { throw new NumberFormatException("Non-hex character at #"+i+": '"+c +"' (value 0x"+Integer.toHexString(c)+")"); } curr = (curr << 4); c = id.charAt(++i); if (c >= '0' && c <= '9') { curr |= (c - '0'); } else if (c >= 'a' && c <= 'f') { curr |= (c - 'a' + 10); } else if (c >= 'A' && c <= 'F') { curr |= (c - 'A' + 10); } else { throw new NumberFormatException("Non-hex character at #"+i+": '"+c +"' (value 0x"+Integer.toHexString(c)+")"); } if (j < 8) { hi = (hi << 8) | curr; } else { lo = (lo << 8) | curr; } ++i; } return new UUID(hi, lo); } /** * Factory method for constructing {@link java.util.UUID} instance from given * 16 bytes. * NOTE: since absolutely no validation is done for contents, this method should * only be used if contents are known to be valid. */ public static UUID uuid(byte[] bytes) { _checkUUIDByteArray(bytes, 0); long l1 = gatherLong(bytes, 0); long l2 = gatherLong(bytes, 8); return new UUID(l1, l2); } /** * Factory method for constructing {@link java.util.UUID} instance from given * 16 bytes. * NOTE: since absolutely no validation is done for contents, this method should * only be used if contents are known to be valid. * * @param bytes Array that contains sequence of 16 bytes that contain a valid UUID * @param offset Offset of the first of 16 bytes */ public static UUID uuid(byte[] bytes, int offset) { _checkUUIDByteArray(bytes, offset); return new UUID(gatherLong(bytes, offset), gatherLong(bytes, offset+8)); } /** * Helper method for constructing UUID instances with appropriate type */ public static UUID constructUUID(UUIDType type, byte[] uuidBytes) { // first, ensure type is ok int b = uuidBytes[BYTE_OFFSET_TYPE] & 0xF; // clear out high nibble b |= type.raw() << 4; uuidBytes[BYTE_OFFSET_TYPE] = (byte) b; // second, ensure variant is properly set too b = uuidBytes[UUIDUtil.BYTE_OFFSET_VARIATION] & 0x3F; // remove 2 MSB b |= 0x80; // set as '10' uuidBytes[BYTE_OFFSET_VARIATION] = (byte) b; return uuid(uuidBytes); } public static UUID constructUUID(UUIDType type, long l1, long l2) { // first, ensure type is ok l1 &= ~0xF000L; // remove high nibble of 6th byte l1 |= (long) (type.raw() << 12); // second, ensure variant is properly set too (8th byte; most-sig byte of second long) l2 = ((l2 << 2) >>> 2); // remove 2 MSB l2 |= (2L << 62); // set 2 MSB to '10' return new UUID(l1, l2); } public static long initUUIDFirstLong(long l1, UUIDType type) { return initUUIDFirstLong(l1, type.raw()); } public static long initUUIDFirstLong(long l1, int rawType) { l1 &= ~0xF000L; // remove high nibble of 6th byte l1 |= (long) (rawType << 12); return l1; } public static long initUUIDSecondLong(long l2) { l2 = ((l2 << 2) >>> 2); // remove 2 MSB l2 |= (2L << 62); // set 2 MSB to '10' return l2; } /* /*********************************************************************** /* Type introspection /*********************************************************************** */ /** * Method for determining which type of UUID given UUID is. * Returns null if type can not be determined. * * @param uuid UUID to check * * @return Null if UUID is null or type can not be determined (== invalid UUID); * otherwise type */ public static UUIDType typeOf(UUID uuid) { if (uuid == null) { return null; } // Ok: so 4 MSB of byte at offset 6... long l = uuid.getMostSignificantBits(); int typeNibble = (((int) l) >> 12) & 0xF; switch (typeNibble) { case 0: // possibly null? if (l == 0L && uuid.getLeastSignificantBits() == l) { return UUIDType.UNKNOWN; } break; case 1: return UUIDType.TIME_BASED; case 2: return UUIDType.DCE; case 3: return UUIDType.NAME_BASED_MD5; case 4: return UUIDType.RANDOM_BASED; case 5: return UUIDType.NAME_BASED_SHA1; } // not recognized: return null return null; } /* /*********************************************************************** /* Conversions to other types /*********************************************************************** */ public static byte[] asByteArray(UUID uuid) { long hi = uuid.getMostSignificantBits(); long lo = uuid.getLeastSignificantBits(); byte[] result = new byte[16]; _appendInt((int) (hi >> 32), result, 0); _appendInt((int) hi, result, 4); _appendInt((int) (lo >> 32), result, 8); _appendInt((int) lo, result, 12); return result; } public static void toByteArray(UUID uuid, byte[] buffer) { toByteArray(uuid, buffer, 0); } public static void toByteArray(UUID uuid, byte[] buffer, int offset) { _checkUUIDByteArray(buffer, offset); long hi = uuid.getMostSignificantBits(); long lo = uuid.getLeastSignificantBits(); _appendInt((int) (hi >> 32), buffer, offset); _appendInt((int) hi, buffer, offset+4); _appendInt((int) (lo >> 32), buffer, offset+8); _appendInt((int) lo, buffer, offset+12); } /* /******************************************************************************** /* Package helper methods /******************************************************************************** */ //private final static long MASK_LOW_INT = 0x0FFFFFFFF; protected final static long gatherLong(byte[] buffer, int offset) { long hi = ((long) _gatherInt(buffer, offset)) << 32; //long lo = ((long) _gatherInt(buffer, offset+4)) & MASK_LOW_INT; long lo = (((long) _gatherInt(buffer, offset+4)) << 32) >>> 32; return hi | lo; } /* /******************************************************************************** /* Internal helper methods /******************************************************************************** */ private final static void _appendInt(int value, byte[] buffer, int offset) { buffer[offset++] = (byte) (value >> 24); buffer[offset++] = (byte) (value >> 16); buffer[offset++] = (byte) (value >> 8); buffer[offset] = (byte) value; } private final static int _gatherInt(byte[] buffer, int offset) { return (buffer[offset] << 24) | ((buffer[offset+1] & 0xFF) << 16) | ((buffer[offset+2] & 0xFF) << 8) | (buffer[offset+3] & 0xFF); } private final static void _checkUUIDByteArray(byte[] bytes, int offset) { if (bytes == null) { throw new IllegalArgumentException("Invalid byte[] passed: can not be null"); } if (offset < 0) { throw new IllegalArgumentException("Invalid offset ("+offset+") passed: can not be negative"); } if ((offset + 16) > bytes.length) { throw new IllegalArgumentException("Invalid offset ("+offset+") passed: not enough room in byte array (need 16 bytes)"); } } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/com/fasterxml/uuid/package.html000066400000000000000000000012141324315460500317070ustar00rootroot00000000000000 Package that contains core (non-optional) Java UUID Generator API classes. Implementation classes can be found from under {@link com.fasterxml.uuid.impl}. These classes should be usable on JDK 1.4 and up, and have no external dependencies; except that any functionality that uses Ethernet-address discovery requires JDK 1.6.

The primary point is {@link com.fasterxml.uuid.Generators}, used to construct actual generators, based on method to use and some optional arguments.

Note: earlier JUG versions (up to 2.0) supported older JDKs (1.1); 1.4 is now needed since {@link java.util.UUID} is used as a core abstraction.

java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/perf/000077500000000000000000000000001324315460500246335ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/perf/MeasurePerformance.java000066400000000000000000000133431324315460500312650ustar00rootroot00000000000000package perf; import java.util.UUID; import com.fasterxml.uuid.*; import com.fasterxml.uuid.impl.RandomBasedGenerator; import com.fasterxml.uuid.impl.TimeBasedGenerator; /** * Simple micro-benchmark for evaluating performance of various UUID generation * techniques, including JDK's method as well as JUG's variants. *

* Notes: for name-based variant we will pass plain Strings, assuming this is the * most common use case; even though it is possible to also pass raw byte arrays. * JDK and Jug implementations have similar performance so this only changes * relative speeds of name- vs time-based variants. * * @since 3.1 */ public class MeasurePerformance { // Let's generate quarter million UUIDs per test private static final int ROUNDS = 250; private static final int COUNT = 1000; // also: let's just use a single name for name-based, to avoid extra overhead: final String NAME = "http://www.cowtowncoder.com/blog/blog.html"; final byte[] NAME_BYTES; public MeasurePerformance() throws java.io.IOException { NAME_BYTES = NAME.getBytes("UTF-8"); } public void test() throws Exception { int i = 0; final Object[] uuids = new Object[COUNT]; // can either use bogus address; or local one, no difference perf-wise EthernetAddress nic = EthernetAddress.fromInterface(); // Whether to include namespace? Depends on whether we compare with JDK (which does not) // UUID namespaceForNamed = NAMESPACE; UUID namespaceForNamed = null; final RandomBasedGenerator secureRandomGen = Generators.randomBasedGenerator(); final RandomBasedGenerator utilRandomGen = Generators.randomBasedGenerator(new java.util.Random(123)); final TimeBasedGenerator timeGenPlain = Generators.timeBasedGenerator(nic); final TimeBasedGenerator timeGenSynced = Generators.timeBasedGenerator(nic, new com.fasterxml.uuid.ext.FileBasedTimestampSynchronizer()); final StringArgGenerator nameGen = Generators.nameBasedGenerator(namespaceForNamed); while (true) { try { Thread.sleep(100L); } catch (InterruptedException ie) { } int round = (i++ % 7); long curr = System.currentTimeMillis(); String msg; boolean lf = (round == 0); switch (round) { case 0: msg = "JDK, random"; testJDK(uuids, ROUNDS); break; case 1: msg = "JDK, name"; testJDKNames(uuids, ROUNDS); break; case 2: msg = "Jug, time-based (non-sync)"; testTimeBased(uuids, ROUNDS, timeGenPlain); break; case 3: msg = "Jug, time-based (SYNC)"; testTimeBased(uuids, ROUNDS, timeGenSynced); break; case 4: msg = "Jug, SecureRandom"; testRandom(uuids, ROUNDS, secureRandomGen); break; case 5: msg = "Jug, java.util.Random"; testRandom(uuids, ROUNDS, utilRandomGen); break; case 6: msg = "Jug, name-based"; testNameBased(uuids, ROUNDS, nameGen); break; /* case 7: msg = "http://johannburkard.de/software/uuid/"; testUUID32(uuids, ROUNDS); break; */ default: throw new Error("Internal error"); } curr = System.currentTimeMillis() - curr; if (lf) { System.out.println(); } System.out.println("Test '"+msg+"' -> "+curr+" msecs; last UUID: "+uuids[COUNT-1]); } } // Test implementation from http://johannburkard.de/software/uuid/ /* private final void testUUID32(Object[] uuids, int rounds) { while (--rounds >= 0) { for (int i = 0, len = uuids.length; i < len; ++i) { uuids[i] = new com.eaio.uuid.UUID(); } } } */ private final void testJDK(Object[] uuids, int rounds) { while (--rounds >= 0) { for (int i = 0, len = uuids.length; i < len; ++i) { uuids[i] = UUID.randomUUID(); } } } private final void testJDKNames(Object[] uuids, int rounds) throws java.io.IOException { while (--rounds >= 0) { for (int i = 0, len = uuids.length; i < len; ++i) { final byte[] nameBytes = NAME.getBytes("UTF-8"); uuids[i] = UUID.nameUUIDFromBytes(nameBytes); } } } private final void testRandom(Object[] uuids, int rounds, RandomBasedGenerator uuidGen) { while (--rounds >= 0) { for (int i = 0, len = uuids.length; i < len; ++i) { uuids[i] = uuidGen.generate(); } } } private final void testTimeBased(Object[] uuids, int rounds, TimeBasedGenerator uuidGen) { while (--rounds >= 0) { for (int i = 0, len = uuids.length; i < len; ++i) { uuids[i] = uuidGen.generate(); } } } private final void testNameBased(Object[] uuids, int rounds, StringArgGenerator uuidGen) { while (--rounds >= 0) { for (int i = 0, len = uuids.length; i < len; ++i) { uuids[i] = uuidGen.generate(NAME); } } } public static void main(String[] args) throws Exception { new MeasurePerformance().test(); } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/test/000077500000000000000000000000001324315460500246565ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/java/test/FileSyncTest.java000066400000000000000000000025251324315460500301010ustar00rootroot00000000000000package test; import java.util.UUID; import com.fasterxml.uuid.*; import com.fasterxml.uuid.ext.*; import com.fasterxml.uuid.impl.TimeBasedGenerator; /** * Simple manual utility test class for manually checking whether file-based * synchronization seems to be working or not. */ public class FileSyncTest { public static void main(String[] args) throws Exception { FileBasedTimestampSynchronizer sync = new FileBasedTimestampSynchronizer(); // Let's stress-test it... sync.setUpdateInterval(2000L); // must have a NIC for this to work, should be ok: EthernetAddress eth = EthernetAddress.fromInterface(); TimeBasedGenerator gen = Generators.timeBasedGenerator(eth, sync); int counter = 1; while (true) { UUID uuid = gen.generate(); // Default one is for convenient output System.out.println("#"+counter+" -> "+uuid); /* This allows lexical sorting by uuid... (not very useful, * since 'real' UUID ordering is not lexical) */ System.out.println(""+uuid+" (#"+counter+")"); // And this can be used to ensure there are no dups: System.out.println(""+uuid); ++counter; try { Thread.sleep(120L); } catch (InterruptedException ie) { } } } } java-uuid-generator-java-uuid-generator-3.1.5/src/main/resources/000077500000000000000000000000001324315460500247705ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/resources/META-INF/000077500000000000000000000000001324315460500261305ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/main/resources/META-INF/LICENSE000066400000000000000000000004701324315460500271360ustar00rootroot00000000000000This copy of Java UUID Generator (JUG) library is licensed under Apache (Software) License, version 2.0 ("the License"). See the License for details about distribution rights, and the specific rights regarding derivate works. You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0 java-uuid-generator-java-uuid-generator-3.1.5/src/main/resources/META-INF/NOTICE000066400000000000000000000003611324315460500270340ustar00rootroot00000000000000Java UUID generator library has been written by Tatu Saloranta (tatu.saloranta@iki.fi) Other developers who have contributed code are: * Eric Bie contributed extensive unit test suite which has helped ensure high implementation quality java-uuid-generator-java-uuid-generator-3.1.5/src/test/000077500000000000000000000000001324315460500230115ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/000077500000000000000000000000001324315460500237325ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/com/000077500000000000000000000000001324315460500245105ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/com/fasterxml/000077500000000000000000000000001324315460500265155ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/com/fasterxml/uuid/000077500000000000000000000000001324315460500274635ustar00rootroot00000000000000EthernetAddressTest.java000066400000000000000000001751471324315460500342120ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/com/fasterxml/uuid/* JUG Java Uuid Generator * EthernetAddressTest.java * Created on July 16, 2003, 11:17 PM * * Copyright (c) 2003 Eric Bie * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; import junit.textui.TestRunner; import java.util.Arrays; import java.util.Random; import com.fasterxml.uuid.EthernetAddress; /** * JUnit Test class for the com.fasterxml.uuid.EthernetAddress class. * * @author Eric Bie * @author Tatu Saloranta (changes for version 3.0) */ public class EthernetAddressTest extends TestCase { // constant defining the length of a valid ethernet address byte array private static final int ETHERNET_ADDRESS_ARRAY_LENGTH = 6; // some strings for failure case tests private static final String IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_1 = "01f23:45:67:89:ab"; private static final String IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_2 = "01:23f45:67:89:ab"; private static final String IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_3 = "01:23:45f67:89:ab"; private static final String IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_4 = "01:23:45:67f89:ab"; private static final String IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_5 = "01:23:45:67:89fab"; private static final String IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_6 = "01f23f45f67f89fab"; private static final String NON_HEX_ETHERNET_ADDRESS_STRING = "NON-HEX0-FORSURE0"; private static final String RANDOM_PROPER_LENGTH_STRING = "Same LengthString"; // some valid strings for the various dropped digit cases private static final String FIRST_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING = "00:23:45:67:89:ab"; private static final String FIRST_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING = "0:23:45:67:89:ab"; private static final String FIRST_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING = ":23:45:67:89:ab"; private static final String SECOND_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING = "01:00:45:67:89:ab"; private static final String SECOND_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING = "01:0:45:67:89:ab"; private static final String SECOND_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING = "01::45:67:89:ab"; private static final String THIRD_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING = "01:23:00:67:89:ab"; private static final String THIRD_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING = "01:23:0:67:89:ab"; private static final String THIRD_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING = "01:23::67:89:ab"; private static final String FOURTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING = "01:23:45:00:89:ab"; private static final String FOURTH_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING = "01:23:45:0:89:ab"; private static final String FOURTH_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING = "01:23:45::89:ab"; private static final String FIFTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING = "01:23:45:67:00:ab"; private static final String FIFTH_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING = "01:23:45:67:0:ab"; private static final String FIFTH_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING = "01:23:45:67::ab"; private static final String SIXTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING = "01:23:45:67:89:00"; private static final String SIXTH_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING = "01:23:45:67:89:0"; private static final String SIXTH_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING = "01:23:45:67:89:"; private static final String MIXED_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING = "01:03:00:07:00:00"; private static final String MIXED_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING = "1:3:0:7:0:0"; private static final String MIXED_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING = "1:3::7::"; // here are some sets of good ethernet addresses in various forms private static final String NULL_ETHERNET_ADDRESS_STRING = "00:00:00:00:00:00"; private static final long NULL_ETHERNET_ADDRESS_LONG = 0x0000000000000000L; private static final byte[] NULL_ETHERNET_ADDRESS_BYTE_ARRAY = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH]; //private static final int[] NULL_ETHERNET_ADDRESS_INT_ARRAY = new int[ETHERNET_ADDRESS_ARRAY_LENGTH]; private static final EthernetAddress NULL_ETHERNET_ADDRESS = new EthernetAddress(0L); private static final String VALID_ETHERNET_ADDRESS_STRING = "87:f5:93:06:d3:0c"; private static final String MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING = "87:f5:93:06:D3:0c"; private static final String UPPER_CASE_VALID_ETHERNET_ADDRESS_STRING = "87:F5:93:06:D3:0C"; private static final String LOWER_CASE_VALID_ETHERNET_ADDRESS_STRING = VALID_ETHERNET_ADDRESS_STRING; private static final long VALID_ETHERNET_ADDRESS_LONG = 0x000087f59306d30cL; private static final byte[] VALID_ETHERNET_ADDRESS_BYTE_ARRAY = { (byte)0x87, (byte)0xf5, (byte)0x93, (byte)0x06, (byte)0xd3, (byte)0x0c }; private static final int[] VALID_ETHERNET_ADDRESS_INT_ARRAY = { 0x87, 0xf5, 0x93, 0x06, 0xd3, 0x0c }; private static final byte[] ANOTHER_VALID_ETHERNET_ADDRESS_BYTE_ARRAY = { (byte)0x4c, (byte)0xde, (byte)0xfb, (byte)0xba, (byte)0x5a, (byte)0x1c }; /* private static final EthernetAddress VALID_ETHERNET_ADDRESS = new EthernetAddress(VALID_ETHERNET_ADDRESS_LONG); private static final String ANOTHER_VALID_ETHERNET_ADDRESS_STRING = "4c:de:fb:ba:5a:1c"; private static final long ANOTHER_VALID_ETHERNET_ADDRESS_LONG = 0x00004cdefbba5a1cL; private static final int[] ANOTHER_VALID_ETHERNET_ADDRESS_INT_ARRAY = { 0x4c, 0xde, 0xfb, 0xba, 0x5a, 0x1c }; */ //private static final EthernetAddress ANOTHER_VALID_ETHERNET_ADDRESS = new EthernetAddress(ANOTHER_VALID_ETHERNET_ADDRESS_LONG); // some ethernet addresses for the ordering tests private static final EthernetAddress MAC0_ETHERNET_ADDRESS = new EthernetAddress(0x0000015ae2e61893L); private static final EthernetAddress MAC1_ETHERNET_ADDRESS = new EthernetAddress(0x00001f0f1b0e8e6eL); private static final EthernetAddress MAC2_ETHERNET_ADDRESS = new EthernetAddress(0x000022d8afb0b888L); private static final EthernetAddress MAC3_ETHERNET_ADDRESS = new EthernetAddress(0x00004cfdc9a5e86aL); private static final EthernetAddress MAC4_ETHERNET_ADDRESS = new EthernetAddress(0x000091038ffa38eeL); private static final EthernetAddress MAC5_ETHERNET_ADDRESS = new EthernetAddress(0x00009857e4f202a3L); private static final EthernetAddress MAC6_ETHERNET_ADDRESS = new EthernetAddress(0x0000a8c0600ccc69L); private static final EthernetAddress MAC7_ETHERNET_ADDRESS = new EthernetAddress(0x0000a9a18860d8fcL); private static final EthernetAddress MAC8_ETHERNET_ADDRESS = new EthernetAddress(0x0000c8b30f0b395aL); private static final EthernetAddress MAC9_ETHERNET_ADDRESS = new EthernetAddress(0x0000cf74d8ef49b8L); public EthernetAddressTest(java.lang.String testName) { super(testName); } public static Test suite() { TestSuite suite = new TestSuite(EthernetAddressTest.class); return suite; } public static void main(String[] args) { TestRunner.run(suite()); } /************************************************************************** * Begin Constructor tests *************************************************************************/ /** * Test of EthernetAddress(byte[]) constructor, * of class com.fasterxml.uuid.EthernetAddress. */ public void testByteArrayEthernetAddressConstructor() { // lets test some error cases // first, passing null try { /*EthernetAddress ethernet_address =*/ new EthernetAddress((byte[])null); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NullPointerException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an array that is too small try { /*EthernetAddress ethernet_address =*/ new EthernetAddress( new byte[ETHERNET_ADDRESS_ARRAY_LENGTH - 1]); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an array that is too big try { /*EthernetAddress ethernet_address =*/ new EthernetAddress( new byte[ETHERNET_ADDRESS_ARRAY_LENGTH + 1]); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // let's test that creating a EthernetAddress from an zero'd array // gives us a null EthernetAddress (definition of null EthernetAddress) EthernetAddress ethernet_address = new EthernetAddress(new byte[ETHERNET_ADDRESS_ARRAY_LENGTH]); assertEquals( "EthernetAddress(byte[]) did not create expected EthernetAddress", NULL_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); // let's test creating an array from a good byte array ethernet_address = new EthernetAddress(VALID_ETHERNET_ADDRESS_BYTE_ARRAY); assertEquals( "EthernetAddress(byte[]) did not create expected EthernetAddress", VALID_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); } /** * Test of EthernetAddress(long) constructor, * of class com.fasterxml.uuid.EthernetAddress. */ public void testLongEthernetAddressConstructor() { // let's test that creating a EthernetAddress from an zero long // gives us a null EthernetAddress (definition of null EthernetAddress) EthernetAddress ethernet_address = new EthernetAddress(0x0000000000000000L); assertEquals( "EthernetAddress(long) did not create expected EthernetAddress", NULL_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); // let's test creating an array from a good long ethernet_address = new EthernetAddress(VALID_ETHERNET_ADDRESS_LONG); assertEquals( "EthernetAddress(long) did not create expected EthernetAddress", VALID_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); } /** * Test of EthernetAddress(String) constructor, * of class com.fasterxml.uuid.EthernetAddress. */ public void testStringEthernetAddressConstructor() { // test a null string case try { /*EthernetAddress ethernet_address =*/ new EthernetAddress((String)null); fail("Expected exception not caught"); } catch (NullPointerException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // test some failure cases for the string constructor badStringEthernetAddressConstructorHelper( IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_1); badStringEthernetAddressConstructorHelper( IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_2); badStringEthernetAddressConstructorHelper( IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_3); badStringEthernetAddressConstructorHelper( IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_4); badStringEthernetAddressConstructorHelper( IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_5); badStringEthernetAddressConstructorHelper( IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_6); badStringEthernetAddressConstructorHelper( NON_HEX_ETHERNET_ADDRESS_STRING); badStringEthernetAddressConstructorHelper( RANDOM_PROPER_LENGTH_STRING); // some valid strings for the various dropped digit cases goodStringEthernetAddressConstructorHelper( FIRST_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, FIRST_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( FIRST_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, FIRST_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( FIRST_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, FIRST_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( SECOND_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, SECOND_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( SECOND_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, SECOND_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( SECOND_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, SECOND_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( THIRD_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, THIRD_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( THIRD_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, THIRD_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( THIRD_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, THIRD_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( FOURTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, FOURTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( FOURTH_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, FOURTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( FOURTH_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, FOURTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( FIFTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, FIFTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( FIFTH_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, FIFTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( FIFTH_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, FIFTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( SIXTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, SIXTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( SIXTH_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, SIXTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( SIXTH_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, SIXTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( MIXED_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, MIXED_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( MIXED_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, MIXED_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( MIXED_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, MIXED_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); // test the other good cases goodStringEthernetAddressConstructorHelper( NULL_ETHERNET_ADDRESS_STRING, NULL_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( UPPER_CASE_VALID_ETHERNET_ADDRESS_STRING, UPPER_CASE_VALID_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( LOWER_CASE_VALID_ETHERNET_ADDRESS_STRING, LOWER_CASE_VALID_ETHERNET_ADDRESS_STRING); goodStringEthernetAddressConstructorHelper( MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING, MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING); } /************************************************************************** * End Constructor tests *************************************************************************/ /** * Test of asByteArray method, of class com.fasterxml.uuid.EthernetAddress. */ public void testAsByteArray() { // we'll test making a couple EthernetAddresses and then check that // asByteArray returns the same value in long form as used to create it // first we'll test the null EthernetAddress EthernetAddress ethernet_address = new EthernetAddress(0L); assertEquals("Expected length of returned array wrong", ETHERNET_ADDRESS_ARRAY_LENGTH, ethernet_address.asByteArray().length); assertEthernetAddressArraysAreEqual( NULL_ETHERNET_ADDRESS_BYTE_ARRAY, 0, ethernet_address.asByteArray(), 0); // now test a non-null EthernetAddress ethernet_address = new EthernetAddress(VALID_ETHERNET_ADDRESS_LONG); assertEquals("Expected length of returned array wrong", ETHERNET_ADDRESS_ARRAY_LENGTH, ethernet_address.asByteArray().length); assertEthernetAddressArraysAreEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, ethernet_address.asByteArray(), 0); // let's make sure that changing the returned array doesn't mess with // the wrapped EthernetAddress's internals byte[] ethernet_address_byte_array = ethernet_address.asByteArray(); // we'll just stir it up a bit and then check that the original // EthernetAddress was not changed in the process. // The easiest stir is to sort it ;) Arrays.sort(ethernet_address_byte_array); assertEthernetAddressArraysAreNotEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, ethernet_address_byte_array, 0); assertEthernetAddressArraysAreNotEqual( ethernet_address.asByteArray(), 0, ethernet_address_byte_array, 0); assertEthernetAddressArraysAreEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, ethernet_address.asByteArray(), 0); } /** * Test of clone method, of class com.fasterxml.uuid.EthernetAddress. */ public void testClone() { // as lifted from the JDK Object JavaDoc for clone: // x.clone() Creates and returns a copy of x. // The precise meaning of "copy" may depend on // the class of the object. The general intent // is that, for any object x, the expression: // x.clone() != x // will be true, and that the expression: // x.clone().getClass() == x.getClass() // will be true, but these are not absolute requirements. // While it is typically the case that: // x.clone().equals(x) // will be true, this is not an absolute requirement. // For EthernetAddress, this test will check that all the above // ARE true in the case of EthernetAddress clone() because it is // the desired behavior. EthernetAddress x = new EthernetAddress(VALID_ETHERNET_ADDRESS_STRING); assertTrue("x.clone() != x did not return true", x.clone() != x); assertTrue("x.clone().getClass() == x.getClass() did not return true", x.clone().getClass() == x.getClass()); assertTrue("x.clone().equals(x) did not return true", x.clone().equals(x)); } /** * Test of compareTo method, of class com.fasterxml.uuid.EthernetAddress. */ public void testCompareTo() { // first, let's make sure calling compareTo with null // throws the appropriate NullPointerException try { // the 'null EthernetAddress' will be fine NULL_ETHERNET_ADDRESS.compareTo(null); fail("Expected exception not thrown"); } catch (NullPointerException ex) { // good, we caught the expected exception, so we passed } catch (Exception ex) { fail("Caught an unexpected exception: " + ex); } // now we'll test some simple base cases // 2 null EthernetAddresses always compare to 0 assertEthernetAddressEqualOrderHelper(NULL_ETHERNET_ADDRESS, new EthernetAddress(0L)); // 2 of the same value EthernetAddresses are always 0 assertEthernetAddressEqualOrderHelper(MAC0_ETHERNET_ADDRESS, new EthernetAddress(MAC0_ETHERNET_ADDRESS.toLong())); // the 'null EthernetAddress' always comes first in the ordering assertEthernetAddressGreaterOrderHelper(MAC0_ETHERNET_ADDRESS, NULL_ETHERNET_ADDRESS); // EthernetAddresses will always sort // with the 'numerically' greater MAC addresses coming later assertEthernetAddressGreaterOrderHelper(MAC4_ETHERNET_ADDRESS, MAC0_ETHERNET_ADDRESS); assertEthernetAddressGreaterOrderHelper(MAC9_ETHERNET_ADDRESS, MAC4_ETHERNET_ADDRESS); assertEthernetAddressGreaterOrderHelper(MAC9_ETHERNET_ADDRESS, MAC0_ETHERNET_ADDRESS); // now we will test a bigger case of the compareTo functionality // of the EthernetAddress class // easiest way to do this is to create an array of EthernetAddresses // and sort it then test that this array is in the expected order // before sort, the array contains (in psudo-random order) // 15 EthernetAddresses of this distribution: // 1 - null EthernetAddress // 2 - mac0 // 1 - mac1 // 1 - mac2 // 2 - mac3 // 2 - mac4 // 2 - mac5 // 1 - mac6 // 1 - mac7 // 1 - mac8 // 1 - mac9 EthernetAddress ethernet_address_array[] = new EthernetAddress[15]; ethernet_address_array[0] = MAC4_ETHERNET_ADDRESS; ethernet_address_array[1] = MAC6_ETHERNET_ADDRESS; ethernet_address_array[2] = MAC0_ETHERNET_ADDRESS; ethernet_address_array[3] = MAC5_ETHERNET_ADDRESS; ethernet_address_array[4] = MAC3_ETHERNET_ADDRESS; ethernet_address_array[5] = MAC5_ETHERNET_ADDRESS; ethernet_address_array[6] = MAC0_ETHERNET_ADDRESS; ethernet_address_array[7] = NULL_ETHERNET_ADDRESS; ethernet_address_array[8] = MAC8_ETHERNET_ADDRESS; ethernet_address_array[9] = MAC3_ETHERNET_ADDRESS; ethernet_address_array[10] = MAC4_ETHERNET_ADDRESS; ethernet_address_array[11] = MAC7_ETHERNET_ADDRESS; ethernet_address_array[12] = MAC1_ETHERNET_ADDRESS; ethernet_address_array[13] = MAC9_ETHERNET_ADDRESS; ethernet_address_array[14] = MAC2_ETHERNET_ADDRESS; Arrays.sort(ethernet_address_array); // now we should be able to see that the array is in order assertEthernetAddressesMatchHelper( NULL_ETHERNET_ADDRESS, ethernet_address_array[0]); assertEthernetAddressesMatchHelper( MAC0_ETHERNET_ADDRESS, ethernet_address_array[1]); assertEthernetAddressesMatchHelper( MAC0_ETHERNET_ADDRESS, ethernet_address_array[2]); assertEthernetAddressesMatchHelper( MAC1_ETHERNET_ADDRESS, ethernet_address_array[3]); assertEthernetAddressesMatchHelper( MAC2_ETHERNET_ADDRESS, ethernet_address_array[4]); assertEthernetAddressesMatchHelper( MAC3_ETHERNET_ADDRESS, ethernet_address_array[5]); assertEthernetAddressesMatchHelper( MAC3_ETHERNET_ADDRESS, ethernet_address_array[6]); assertEthernetAddressesMatchHelper( MAC4_ETHERNET_ADDRESS, ethernet_address_array[7]); assertEthernetAddressesMatchHelper( MAC4_ETHERNET_ADDRESS, ethernet_address_array[8]); assertEthernetAddressesMatchHelper( MAC5_ETHERNET_ADDRESS, ethernet_address_array[9]); assertEthernetAddressesMatchHelper( MAC5_ETHERNET_ADDRESS, ethernet_address_array[10]); assertEthernetAddressesMatchHelper( MAC6_ETHERNET_ADDRESS, ethernet_address_array[11]); assertEthernetAddressesMatchHelper( MAC7_ETHERNET_ADDRESS, ethernet_address_array[12]); assertEthernetAddressesMatchHelper( MAC8_ETHERNET_ADDRESS, ethernet_address_array[13]); assertEthernetAddressesMatchHelper( MAC9_ETHERNET_ADDRESS, ethernet_address_array[14]); } /** * Test of equals method, of class com.fasterxml.uuid.EthernetAddress. */ public void testEquals() { // test passing null to equals returns false // (as specified in the JDK docs for Object) EthernetAddress x = new EthernetAddress(VALID_ETHERNET_ADDRESS_BYTE_ARRAY); assertFalse("equals(null) didn't return false", x.equals((Object)null)); // test passing an object which is not a EthernetAddress returns false assertFalse("x.equals(non_EthernetAddress_object) didn't return false", x.equals(new Object())); // test a case where two EthernetAddresss are definitly not equal EthernetAddress w = new EthernetAddress(ANOTHER_VALID_ETHERNET_ADDRESS_BYTE_ARRAY); assertFalse("x == w didn't return false", x == w); assertFalse("x.equals(w) didn't return false", x.equals(w)); // test refelexivity assertTrue("x.equals(x) didn't return true", x.equals(x)); // test symmetry EthernetAddress y = new EthernetAddress(VALID_ETHERNET_ADDRESS_BYTE_ARRAY); assertFalse("x == y didn't return false", x == y); assertTrue("y.equals(x) didn't return true", y.equals(x)); assertTrue("x.equals(y) didn't return true", x.equals(y)); // now we'll test transitivity EthernetAddress z = new EthernetAddress(VALID_ETHERNET_ADDRESS_BYTE_ARRAY); assertFalse("x == y didn't return false", x == y); assertFalse("x == y didn't return false", y == z); assertFalse("x == y didn't return false", x == z); assertTrue("x.equals(y) didn't return true", x.equals(y)); assertTrue("y.equals(z) didn't return true", y.equals(z)); assertTrue("x.equals(z) didn't return true", x.equals(z)); // test consistancy (this test is just calling equals multiple times) assertFalse("x == y didn't return false", x == y); assertTrue("x.equals(y) didn't return true", x.equals(y)); assertTrue("x.equals(y) didn't return true", x.equals(y)); assertTrue("x.equals(y) didn't return true", x.equals(y)); } /** * Test of toByteArray method, of class com.fasterxml.uuid.EthernetAddress. */ public void testToByteArray() { // we'll test making a couple EthernetAddresses and then check that the // toByteArray returns the same value in byte form as used to create it // first we'll test the null EthernetAddress EthernetAddress ethernet_address = new EthernetAddress(0L); assertEquals("Expected length of returned array wrong", ETHERNET_ADDRESS_ARRAY_LENGTH, ethernet_address.toByteArray().length); assertEthernetAddressArraysAreEqual( NULL_ETHERNET_ADDRESS_BYTE_ARRAY, 0, ethernet_address.toByteArray(), 0); // now test a non-null EthernetAddress ethernet_address = new EthernetAddress(VALID_ETHERNET_ADDRESS_LONG); assertEquals("Expected length of returned array wrong", ETHERNET_ADDRESS_ARRAY_LENGTH, ethernet_address.toByteArray().length); assertEthernetAddressArraysAreEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, ethernet_address.toByteArray(), 0); // let's make sure that changing the returned array doesn't mess with // the wrapped EthernetAddress's internals byte[] ethernet_address_byte_array = ethernet_address.toByteArray(); // we'll just stir it up a bit and then check that the original // EthernetAddress was not changed in the process. // The easiest stir is to sort it ;) Arrays.sort(ethernet_address_byte_array); assertEthernetAddressArraysAreNotEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, ethernet_address_byte_array, 0); assertEthernetAddressArraysAreNotEqual( ethernet_address.toByteArray(), 0, ethernet_address_byte_array, 0); assertEthernetAddressArraysAreEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, ethernet_address.toByteArray(), 0); } /** * Test of toByteArray(byte[]) method, * of class com.fasterxml.uuid.EthernetAddress. */ public void testToByteArrayDest() { // constant for use in this test final int EXTRA_DATA_LENGTH = 9; // lets test some error cases // first, passing null try { EthernetAddress ethernet_address = new EthernetAddress(0L); ethernet_address.toByteArray((byte[])null); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NullPointerException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an array that is too small try { EthernetAddress ethernet_address = new EthernetAddress(0L); byte[] ethernet_address_byte_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH - 1]; ethernet_address.toByteArray(ethernet_address_byte_array); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // we'll test making a couple EthernetAddresses and then check that // toByteArray returns the same value in byte form as used to create it // here we'll test the null EthernetAddress EthernetAddress ethernet_address = new EthernetAddress(0L); byte[] test_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH]; Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array); assertEthernetAddressArraysAreEqual( NULL_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, 0); // now test a non-null EthernetAddress ethernet_address = new EthernetAddress(MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING); Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array); assertEthernetAddressArraysAreEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, 0); // now test a null EthernetAddress case with extra data in the array ethernet_address = new EthernetAddress(0L); test_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array); assertEthernetAddressArraysAreEqual(NULL_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, 0); for (int i = 0; i < EXTRA_DATA_LENGTH; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i + ETHERNET_ADDRESS_ARRAY_LENGTH]); } // now test a good EthernetAddress case with extra data in the array ethernet_address = new EthernetAddress(MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING); test_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array); assertEthernetAddressArraysAreEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, 0); for (int i = 0; i < EXTRA_DATA_LENGTH; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i + ETHERNET_ADDRESS_ARRAY_LENGTH]); } } /** * Test of toByteArray(byte[], int) method, * of class com.fasterxml.uuid.EthernetAddress. */ public void testToByteArrayDestOffset() { // constant value for use in this test final int EXTRA_DATA_LENGTH = 9; // lets test some error cases // first, passing null and 0 try { EthernetAddress ethernet_address = new EthernetAddress(0L); ethernet_address.toByteArray((byte[])null, 0); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NullPointerException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an array that is too small try { EthernetAddress ethernet_address = new EthernetAddress(0L); byte[] ethernet_address_byte_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH - 1]; ethernet_address.toByteArray(ethernet_address_byte_array, 0); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an index that is negative try { EthernetAddress ethernet_address = new EthernetAddress(0L); byte[] ethernet_address_byte_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH]; ethernet_address.toByteArray(ethernet_address_byte_array, -1); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an index that is too big try { EthernetAddress ethernet_address = new EthernetAddress(0L); byte[] ethernet_address_byte_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH]; ethernet_address.toByteArray( ethernet_address_byte_array, ETHERNET_ADDRESS_ARRAY_LENGTH); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an index that is in the array, // but without enough bytes to read ETHERNET_ADDRESS_ARRAY_LENGTH try { EthernetAddress ethernet_address = new EthernetAddress(0L); byte[] ethernet_address_byte_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH]; ethernet_address.toByteArray(ethernet_address_byte_array, 1); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // we'll test making a couple EthernetAddresss and then check // that toByteArray // returns the same value in byte form as used to create it // here we'll test the null EthernetAddress at offset 0 EthernetAddress ethernet_address = new EthernetAddress(0L); byte[] test_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH]; Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array, 0); assertEthernetAddressArraysAreEqual( NULL_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, 0); // now test a non-null EthernetAddress ethernet_address = new EthernetAddress(MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING); Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array); assertEthernetAddressArraysAreEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, 0); // now test a null EthernetAddress case with extra data in the array ethernet_address = new EthernetAddress(0L); test_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array, 0); assertEthernetAddressArraysAreEqual( NULL_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, 0); for (int i = 0; i < EXTRA_DATA_LENGTH; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i + ETHERNET_ADDRESS_ARRAY_LENGTH]); } // now test a null EthernetAddress case with extra data in the array ethernet_address = new EthernetAddress(0L); test_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array, EXTRA_DATA_LENGTH/2); assertEthernetAddressArraysAreEqual( NULL_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, EXTRA_DATA_LENGTH/2); for (int i = 0; i < EXTRA_DATA_LENGTH/2; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i]); assertEquals("Expected array fill value changed", (byte)'x', test_array[i + ETHERNET_ADDRESS_ARRAY_LENGTH + EXTRA_DATA_LENGTH/2]); } // now test a good EthernetAddress case with extra data in the array ethernet_address = new EthernetAddress(MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING); test_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array, 0); assertEthernetAddressArraysAreEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, 0); for (int i = 0; i < EXTRA_DATA_LENGTH; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i + ETHERNET_ADDRESS_ARRAY_LENGTH]); } // now test a good EthernetAddress case with extra data in the array ethernet_address = new EthernetAddress(MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING); test_array = new byte[ETHERNET_ADDRESS_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); ethernet_address.toByteArray(test_array, EXTRA_DATA_LENGTH/2); assertEthernetAddressArraysAreEqual( VALID_ETHERNET_ADDRESS_BYTE_ARRAY, 0, test_array, EXTRA_DATA_LENGTH/2); for (int i = 0; i < EXTRA_DATA_LENGTH/2; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i]); assertEquals("Expected array fill value changed", (byte)'x', test_array[i + ETHERNET_ADDRESS_ARRAY_LENGTH + EXTRA_DATA_LENGTH/2]); } } /** * Test of toLong method, of class com.fasterxml.uuid.EthernetAddress. */ public void testToLong() { // test making a couple EthernetAddresss and then check that the toLong // gives back the same value in long form that was used to create it // test the null EthernetAddress EthernetAddress ethernet_address = new EthernetAddress(0L); assertEquals("null EthernetAddress long and toLong did not match", NULL_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); // test a non-null EthernetAddress ethernet_address = new EthernetAddress(VALID_ETHERNET_ADDRESS_BYTE_ARRAY); assertEquals("EthernetAddress long and toLong results did not match", VALID_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); } /** * Test of toString method, of class com.fasterxml.uuid.EthernetAddress. */ public void testToString() { // test making a few EthernetAddresss and check that the toString // gives back the same value in string form that was used to create it // test the null EthernetAddress EthernetAddress ethernet_address = new EthernetAddress(0L); assertEquals("null EthernetAddress string and toString did not match", NULL_ETHERNET_ADDRESS_STRING.toLowerCase(), ethernet_address.toString().toLowerCase()); // test a non-null EthernetAddress ethernet_address = new EthernetAddress(VALID_ETHERNET_ADDRESS_BYTE_ARRAY); assertEquals( "EthernetAddress string and toString results did not match", MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING.toLowerCase(), ethernet_address.toString().toLowerCase()); // EthernetAddress implementation returns strings all lowercase. // Although relying on this behavior in code is not recommended, // here is a unit test which will break if this assumption // becomes bad. This will act as an early warning to anyone // who relies on this particular behavior. ethernet_address = new EthernetAddress(VALID_ETHERNET_ADDRESS_BYTE_ARRAY); assertFalse("mixed case EthernetAddress string and toString " + "matched (expected toString to be all lower case)", MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING.equals( ethernet_address.toString())); assertEquals("mixed case string toLowerCase and " + "toString results did not match (expected toString to " + "be all lower case)", MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING.toLowerCase(), ethernet_address.toString()); } /** * Test of valueOf(byte[]) method, * of class com.fasterxml.uuid.EthernetAddress. */ public void testValueOfByteArray() { // lets test some error cases // first, passing null try { /*EthernetAddress ethernet_address =*/ EthernetAddress.valueOf((byte[])null); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NullPointerException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an array that is too small try { /*EthernetAddress ethernet_address =*/ EthernetAddress.valueOf( new byte[ETHERNET_ADDRESS_ARRAY_LENGTH - 1]); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an array that is too big try { /*EthernetAddress ethernet_address =*/ EthernetAddress.valueOf( new byte[ETHERNET_ADDRESS_ARRAY_LENGTH + 1]); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // test that creating a EthernetAddress from an zero'd array // gives us a null EthernetAddress (definition of null EthernetAddress) EthernetAddress ethernet_address = EthernetAddress.valueOf(new byte[ETHERNET_ADDRESS_ARRAY_LENGTH]); assertEquals( "EthernetAddress.valueOf did not create expected EthernetAddress", NULL_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); // let's test creating an array from a good byte array ethernet_address = EthernetAddress.valueOf(VALID_ETHERNET_ADDRESS_BYTE_ARRAY); assertEquals( "EthernetAddress.valueOf did not create expected EthernetAddress", VALID_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); } /** * Test of valueOf(int[]) method, * of class com.fasterxml.uuid.EthernetAddress. */ public void testValueOfIntArray() { // lets test some error cases // first, passing null try { /*EthernetAddress ethernet_address =*/ EthernetAddress.valueOf((int[])null); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NullPointerException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an array that is too small try { /*EthernetAddress ethernet_address =*/ EthernetAddress.valueOf( new int[ETHERNET_ADDRESS_ARRAY_LENGTH - 1]); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an array that is too big try { /*EthernetAddress ethernet_address =*/ EthernetAddress.valueOf( new int[ETHERNET_ADDRESS_ARRAY_LENGTH + 1]); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // let's test that creating a EthernetAddress from an zero'd array // gives a null EthernetAddress (definition of a null EthernetAddress) EthernetAddress ethernet_address = EthernetAddress.valueOf(new int[ETHERNET_ADDRESS_ARRAY_LENGTH]); assertEquals( "EthernetAddress.valueOf did not create expected EthernetAddress", NULL_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); // let's test creating an array from a good int array ethernet_address = EthernetAddress.valueOf(VALID_ETHERNET_ADDRESS_INT_ARRAY); assertEquals( "EthernetAddress.valueOf did not create expected EthernetAddress", VALID_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); } /** * Test of valueOf(long) method, * of class com.fasterxml.uuid.EthernetAddress. */ public void testValueOfLong() { // let's test that creating a EthernetAddress from an zero long // gives a null EthernetAddress (definition of a null EthernetAddress) EthernetAddress ethernet_address = EthernetAddress.valueOf(0x0000000000000000L); assertEquals( "EthernetAddress.valueOf did not create expected EthernetAddress", NULL_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); // let's test creating an array from a good long ethernet_address = EthernetAddress.valueOf(VALID_ETHERNET_ADDRESS_LONG); assertEquals( "EthernetAddress.valueOf did not create expected EthernetAddress", VALID_ETHERNET_ADDRESS_LONG, ethernet_address.toLong()); } /** * Test of valueOf(String) method, * of class com.fasterxml.uuid.EthernetAddress. */ public void testValueOfString() { // test a null string case try { /*EthernetAddress ethernet_address =*/ EthernetAddress.valueOf((String)null); fail("Expected exception not caught"); } catch (NullPointerException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // test some failure cases for the string constructor badStringValueOfHelper(IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_1); badStringValueOfHelper(IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_2); badStringValueOfHelper(IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_3); badStringValueOfHelper(IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_4); badStringValueOfHelper(IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_5); badStringValueOfHelper(IMPROPER_NUM_COLONS_ETHERNET_ADDRESS_STRING_6); badStringValueOfHelper(NON_HEX_ETHERNET_ADDRESS_STRING); badStringValueOfHelper(RANDOM_PROPER_LENGTH_STRING); // some valid strings for the various dropped digit cases goodStringValueOfHelper(FIRST_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, FIRST_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(FIRST_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, FIRST_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(FIRST_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, FIRST_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(SECOND_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, SECOND_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(SECOND_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, SECOND_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(SECOND_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, SECOND_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(THIRD_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, THIRD_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(THIRD_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, THIRD_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(THIRD_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, THIRD_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(FOURTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, FOURTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(FOURTH_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, FOURTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(FOURTH_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, FOURTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(FIFTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, FIFTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(FIFTH_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, FIFTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(FIFTH_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, FIFTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(SIXTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, SIXTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(SIXTH_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, SIXTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(SIXTH_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, SIXTH_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(MIXED_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING, MIXED_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(MIXED_GROUP_ONE_NUM_ETHERNET_ADDRESS_STRING, MIXED_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(MIXED_GROUP_NO_NUM_ETHERNET_ADDRESS_STRING, MIXED_GROUP_ALL_NUM_ETHERNET_ADDRESS_STRING); // test the other good cases goodStringValueOfHelper(NULL_ETHERNET_ADDRESS_STRING, NULL_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(UPPER_CASE_VALID_ETHERNET_ADDRESS_STRING, UPPER_CASE_VALID_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(LOWER_CASE_VALID_ETHERNET_ADDRESS_STRING, LOWER_CASE_VALID_ETHERNET_ADDRESS_STRING); goodStringValueOfHelper(MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING, MIXED_CASE_VALID_ETHERNET_ADDRESS_STRING); } /** * Ok; this test is bit non-kosher, as it assumes existence of a valid * interface * * @since 3.0 */ public void testFromInterface() throws Exception { EthernetAddress addr = EthernetAddress.fromInterface(); assertNotNull(addr); assertNotNull(addr.toString()); } public void testBogus() throws Exception { // First, two using pseudo-random; verify they are different Random r = new Random(123); EthernetAddress a1 = EthernetAddress.constructMulticastAddress(r); assertNotNull(a1); assertEquals(a1, a1); assertTrue(a1.isMulticastAddress()); EthernetAddress a2 = EthernetAddress.constructMulticastAddress(r); assertNotNull(a2); assertTrue(a2.isMulticastAddress()); assertEquals(a2, a2); assertFalse(a1.equals(a2)); // and then default, which uses SecureRandom EthernetAddress a3 = EthernetAddress.constructMulticastAddress(); assertNotNull(a3); assertNotNull(a3.toString()); } /************************************************************************** * Begin private helper functions for use in tests *************************************************************************/ private void badStringEthernetAddressConstructorHelper( String ethernetAddressString) { try { /*EthernetAddress ethernet_address =*/ new EthernetAddress(ethernetAddressString); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } } private void goodStringEthernetAddressConstructorHelper( String ethernetAddressString, String expectedEthernetAddressString) { EthernetAddress ethernet_address = null; try { ethernet_address = new EthernetAddress(ethernetAddressString); } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } assertEquals("EthernetAddresses were not equal", expectedEthernetAddressString.toLowerCase(), ethernet_address.toString().toLowerCase()); } private void badStringValueOfHelper(String ethernetAddressString) { try { /*EthernetAddress ethernet_address =*/ EthernetAddress.valueOf(ethernetAddressString); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } } private void goodStringValueOfHelper(String ethernetAddressString, String expectedEthernetAddressString) { EthernetAddress ethernet_address = null; try { ethernet_address = EthernetAddress.valueOf(ethernetAddressString); } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } assertEquals("EthernetAddresses were not equal", expectedEthernetAddressString.toLowerCase(), ethernet_address.toString().toLowerCase()); } private void assertEthernetAddressesMatchHelper(EthernetAddress expected, EthernetAddress actual) { assertEquals("EthernetAddresses in long form did not match", expected.toLong(), actual.toLong()); assertEquals("EthernetAddress equals did not match", expected, actual); } private void assertEthernetAddressEqualOrderHelper( EthernetAddress ethernetAddress1, EthernetAddress ethernetAddress2) { assertTrue(ethernetAddress1 + " did not test as equal to " + ethernetAddress2, 0 == ethernetAddress1.compareTo(ethernetAddress2)); assertTrue(ethernetAddress2 + " did not test as equal to " + ethernetAddress1, 0 == ethernetAddress2.compareTo(ethernetAddress1)); } private void assertEthernetAddressGreaterOrderHelper( EthernetAddress ethernetAddress1, EthernetAddress ethernetAddress2) { assertTrue(ethernetAddress1 + " did not test as larger then " + ethernetAddress2, 0 < ethernetAddress1.compareTo(ethernetAddress2)); assertTrue(ethernetAddress2 + " did not test as smaller then " + ethernetAddress1, 0 > ethernetAddress2.compareTo(ethernetAddress1)); } private void assertEthernetAddressArraysAreEqual(byte[] array1, int array1_start, byte[] array2, int array2_start) { assertTrue("Array1 start offset is invalid", 0 <= array1_start); assertTrue("Array2 start offset is invalid", 0 <= array2_start); assertTrue("Array1 is not long enough for the given start offset", array1.length >= ETHERNET_ADDRESS_ARRAY_LENGTH + array1_start); assertTrue("Array2 is not long enough for the given start offset", array2.length >= ETHERNET_ADDRESS_ARRAY_LENGTH + array2_start); for (int i = 0; i < ETHERNET_ADDRESS_ARRAY_LENGTH; i++) { assertEquals("Array1 and Array2 did not match (index #"+i+")", array1[i + array1_start], array2[i + array2_start]); } } private void assertEthernetAddressArraysAreNotEqual(byte[] array1, int array1_start, byte[] array2, int array2_start) { assertTrue("Array1 start offset is invalid", 0 <= array1_start); assertTrue("Array2 start offset is invalid", 0 <= array2_start); assertTrue("Array1 is not long enough for the given start offset", array1.length >= ETHERNET_ADDRESS_ARRAY_LENGTH + array1_start); assertTrue("Array2 is not long enough for the given start offset", array2.length >= ETHERNET_ADDRESS_ARRAY_LENGTH + array2_start); for (int i = 0; i < ETHERNET_ADDRESS_ARRAY_LENGTH; i++) { // as soon as we find a non-matching byte, // we know we're not equal, so return if (array1[i + array1_start] != array2[i + array2_start]) { return; } } fail("Array1 and Array2 matched"); } } SimpleGenerationTest.java000066400000000000000000000006541324315460500343610ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/com/fasterxml/uuidpackage com.fasterxml.uuid; import java.util.UUID; import junit.framework.TestCase; public class SimpleGenerationTest extends TestCase { public void testIssue5() throws Exception { UUID uuid = Generators.randomBasedGenerator().generate(); assertNotNull(uuid); // but second time's the charm... uuid = Generators.randomBasedGenerator().generate(); assertNotNull(uuid); } } UUIDComparatorTest.java000066400000000000000000000102521324315460500337050ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/com/fasterxml/uuid/* JUG Java UUID Generator * * Copyright (c) 2010 Tatu Saloranta * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import java.util.UUID; import junit.framework.TestCase; public class UUIDComparatorTest extends TestCase { public void testIntComp() { assertEquals(0, UUIDComparator.compareUInts(123, 123)); assertEquals(0, UUIDComparator.compareUInts(-9999, -9999)); assertEquals(0, UUIDComparator.compareUInts(0, 0)); assertEquals(0, UUIDComparator.compareUInts(Integer.MIN_VALUE, Integer.MIN_VALUE)); assertEquals(0, UUIDComparator.compareUInts(Integer.MAX_VALUE, Integer.MAX_VALUE)); assertTrue(UUIDComparator.compareUInts(0, 5) < 0); assertTrue(UUIDComparator.compareUInts(5, 0) > 0); assertTrue(UUIDComparator.compareUInts(4, 0xFFFFFFFE) < 0); assertTrue(UUIDComparator.compareUInts(0xFFFFFFFE, 129) > 0); assertTrue(UUIDComparator.compareUInts(0xFFFFFFFC, 0xFFFFFFFE) < 0); assertTrue(UUIDComparator.compareUInts(0xFFFFFFFE, 0xFFFFFFFC) > 0); assertTrue(UUIDComparator.compareUInts(0xFFFFFF17, 0xFFFFFF00) > 0); assertTrue(UUIDComparator.compareUInts(0xFFFFFF00, 0xFFFFFF17) < 0); } public void testLongComp() { assertEquals(0, UUIDComparator.compareULongs(123L, 123L)); assertEquals(0, UUIDComparator.compareULongs(-9999L, -9999L)); assertEquals(0, UUIDComparator.compareULongs(0L, 0L)); assertEquals(0, UUIDComparator.compareULongs(Long.MIN_VALUE, Long.MIN_VALUE)); assertEquals(0, UUIDComparator.compareULongs(Long.MAX_VALUE, Long.MAX_VALUE)); assertTrue(UUIDComparator.compareULongs(0L, 5L) < 0); assertTrue(UUIDComparator.compareULongs(5L, 0L) > 0); // Ok, repeat int values first assertTrue(UUIDComparator.compareULongs(4L, 0xFFFFFFFEL) < 0); assertTrue(UUIDComparator.compareULongs(0xFFFFFFFEL, 129L) > 0); assertTrue(UUIDComparator.compareULongs(0xFFFFFFFCL, 0xFFFFFFFEL) < 0); assertTrue(UUIDComparator.compareULongs(0xFFFFFF17L, 0xFFFFFF00L) > 0); assertTrue(UUIDComparator.compareULongs(1L, 0xffffffffFFFFFFFEL) < 0); assertTrue(UUIDComparator.compareULongs(0xffffffffFFFFFFFEL, 13L) > 0); assertTrue(UUIDComparator.compareULongs(0xffffffffFFFFFFFCL, 0xffffffffFFFFFFFEL) < 0); assertTrue(UUIDComparator.compareULongs(0xffffffffFFFFFFFEL, 0xffffffffFFFFFFFCL) > 0); assertTrue(UUIDComparator.compareULongs(0xffffffffFFFFFF17L, 0xffffffffFFFFFF00L) > 0); assertTrue(UUIDComparator.compareULongs(0xffffffffFFFFFF00L, 0xffffffffFFFFFF17L) < 0); } /* * [Issue#13] */ public void testSorting() { String[] src = new String[] { "7ef7c38a-bb6e-11e3-9e8f-000000000000", "7f905a0b-bb6e-11e3-9e8f-000000000000", "8028f08c-bb6e-11e3-9e8f-000000000000", "80c1870d-bb6e-11e3-9e8f-000000000000" }; /* 03-Apr-2014, tatu: NOTE: JDK's UUID.compareTo() is broken, and it can * NOT be used. Which is why we have "UUIDComparator" that does work. */ final UUIDComparator comp = new UUIDComparator(); for (int i = 0; i < src.length-1; ++i) { UUID u1 = UUID.fromString(src[i]); UUID u2 = UUID.fromString(src[i+1]); assertEquals(0, comp.compare(u1, u1)); assertEquals(0, comp.compare(u2, u2)); int x = comp.compare(u1, u2); if (x >= 0) { fail("Entry #"+i+" should have value < 0, had "+x); } int y = comp.compare(u2, u1); if (y <= 0) { fail("Entry #"+i+" should have value > 0, had "+y); } } } } UUIDGeneratorTest.java000066400000000000000000000554401324315460500335340ustar00rootroot00000000000000java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/com/fasterxml/uuid/* JUG Java Uuid Generator * UUIDGeneratorTest.java * Created on July 16, 2003, 11:17 PM * * Copyright (c) 2003 Eric Bie * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import java.security.MessageDigest; import java.util.*; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; import junit.textui.TestRunner; import com.fasterxml.uuid.EthernetAddress; import com.fasterxml.uuid.Generators; import com.fasterxml.uuid.UUIDType; import com.fasterxml.uuid.impl.UUIDUtil; import com.fasterxml.uuid.impl.NameBasedGenerator; import com.fasterxml.uuid.impl.RandomBasedGenerator; import com.fasterxml.uuid.impl.TimeBasedGenerator; /** * JUnit Test class for the com.fasterxml.uuid.UUIDGenerator class. * * @author Eric Bie */ public class UUIDGeneratorTest extends TestCase { // size of the arrays to create for tests using arrays of values private static final int SIZE_OF_TEST_ARRAY = 10000; public UUIDGeneratorTest(java.lang.String testName) { super(testName); } public static Test suite() { TestSuite suite = new TestSuite(UUIDGeneratorTest.class); return suite; } public static void main(String[] args) { TestRunner.run(suite()); } /** * Test of getDummyAddress method, * of class com.fasterxml.uuid.UUIDGenerator. */ public void testGetDummyAddress() { // this test will attempt to check for reasonable behavior of the // getDummyAddress method // for the random UUID generator, we will generate a bunch of // dummy ethernet addresses // NOTE: although creating a bunch of dummy ethernet addresses // is not the normal mode of operation, we'return testing for // generally good behavior, so we'll create a bunch to make sure the // general patterns are observed EthernetAddress ethernet_address_array[] = new EthernetAddress[SIZE_OF_TEST_ARRAY]; // now create the array of uuids Random rnd = new Random(123L); for (int i = 0; i < ethernet_address_array.length; i++) { ethernet_address_array[i] = EthernetAddress.constructMulticastAddress(rnd); } EthernetAddress null_ethernet_address = new EthernetAddress(0L); for (int i = 0; i < ethernet_address_array.length; i++) { byte[] ethernet_address = ethernet_address_array[i].asByteArray(); // check that none of the EthernetAddresses are null assertFalse("dummy EthernetAddress was null", Arrays.equals(null_ethernet_address.asByteArray(), ethernet_address)); // check that the "broadcast" bit is set in the created address /* 08-Feb-2004, TSa: Fixed as per fix to actual code; apparently * broadcast bit is LSB, not MSB. */ assertEquals("dummy EthernetAddress was not broadcast", 0x01, (ethernet_address[0] & 0x01)); } } /** * Test of generateRandomBasedUUID method, * of class com.fasterxml.uuid.UUIDGenerator. */ public void testGenerateRandomBasedUUID() { // this test will attempt to check for reasonable behavior of the // generateRandomBasedUUID method // we need a instance to use RandomBasedGenerator uuid_gen = Generators.randomBasedGenerator(); // for the random UUID generator, we will generate a bunch of // random UUIDs UUID uuid_array[] = new UUID[SIZE_OF_TEST_ARRAY]; // now create the array of uuids for (int i = 0; i < uuid_array.length; i++) { uuid_array[i] = uuid_gen.generate(); } // check that none of the UUIDs are null checkUUIDArrayForNonNullUUIDs(uuid_array); // check that all the uuids were correct variant and version (type-4) checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.RANDOM_BASED); // check that all uuids were unique // NOTE: technically, this test 'could' fail, but statistically // speaking it should be extremely unlikely unless the implementation // of (Secure)Random is bad checkUUIDArrayForUniqueness(uuid_array); } /** * Test of generateTimeBasedUUID() method, * of class com.fasterxml.uuid.UUIDGenerator. */ public void testGenerateTimeBasedUUID() { // this test will attempt to check for reasonable behavior of the // generateTimeBasedUUID method // we need a instance to use TimeBasedGenerator uuid_gen = Generators.timeBasedGenerator(); // first check that given a number of calls to generateTimeBasedUUID, // all returned UUIDs order after the last returned UUID // we'll check this by generating the UUIDs into one array and sorting // then in another and checking the order of the two match // change the number in the array statement if you want more or less // UUIDs to be generated and tested UUID uuid_array[] = new UUID[SIZE_OF_TEST_ARRAY]; // before we generate all the uuids, lets get the start time long start_time = System.currentTimeMillis(); // now create the array of uuids for (int i = 0; i < uuid_array.length; i++) { uuid_array[i] = uuid_gen.generate(); } // now capture the end time long end_time = System.currentTimeMillis(); // check that none of the UUIDs are null checkUUIDArrayForNonNullUUIDs(uuid_array); // check that all the uuids were correct variant and version (type-1) checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.TIME_BASED); // check that all the uuids were generated with correct order checkUUIDArrayForCorrectOrdering(uuid_array); // check that all uuids were unique checkUUIDArrayForUniqueness(uuid_array); // check that all uuids have timestamps between the start and end time checkUUIDArrayForCorrectCreationTime(uuid_array, start_time, end_time); } /** * Test of generateTimeBasedUUID(EthernetAddress) method, * of class com.fasterxml.uuid.UUIDGenerator. */ public void testGenerateTimeBasedUUIDWithEthernetAddress() { // this test will attempt to check for reasonable behavior of the // generateTimeBasedUUID(EthernetAddress) method EthernetAddress ethernet_address = new EthernetAddress("87:F5:93:06:D3:0C"); // we need a instance to use TimeBasedGenerator uuid_gen = Generators.timeBasedGenerator(ethernet_address); // check that given a number of calls to generateTimeBasedUUID, // all returned UUIDs order after the last returned UUID // we'll check this by generating the UUIDs into one array and sorting // then in another and checking the order of the two match // change the number in the array statement if you want more or less // UUIDs to be generated and tested UUID uuid_array[] = new UUID[SIZE_OF_TEST_ARRAY]; // before we generate all the uuids, lets get the start time long start_time = System.currentTimeMillis(); // now create the array of uuids for (int i = 0; i < uuid_array.length; i++) { uuid_array[i] = uuid_gen.generate(); } // now capture the end time long end_time = System.currentTimeMillis(); // check that none of the UUIDs are null checkUUIDArrayForNonNullUUIDs(uuid_array); // check that all the uuids were correct variant and version (type-1) checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.TIME_BASED); // check that all the uuids were generated with correct order checkUUIDArrayForCorrectOrdering(uuid_array); // check that all uuids were unique checkUUIDArrayForUniqueness(uuid_array); // check that all uuids have timestamps between the start and end time checkUUIDArrayForCorrectCreationTime(uuid_array, start_time, end_time); // check that all UUIDs have the correct ethernet address in the UUID checkUUIDArrayForCorrectEthernetAddress(uuid_array, ethernet_address); } /** * Test of generateNameBasedUUID(UUID, String) * method, of class com.fasterxml.uuid.UUIDGenerator. */ public void testGenerateNameBasedUUIDNameSpaceAndName() { // this test will attempt to check for reasonable behavior of the // generateNameBasedUUID method // we need a instance to use NameBasedGenerator uuid_gen = Generators.nameBasedGenerator(NameBasedGenerator.NAMESPACE_URL); UUID uuid_array[] = new UUID[SIZE_OF_TEST_ARRAY]; // now create the array of uuids for (int i = 0; i < uuid_array.length; i++) { uuid_array[i] = uuid_gen.generate("test name" + i); } // check that none of the UUIDs are null checkUUIDArrayForNonNullUUIDs(uuid_array); // check that all the uuids were correct variant and version checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.NAME_BASED_SHA1); // check that all uuids were unique checkUUIDArrayForUniqueness(uuid_array); // now create the array of uuids for (int i = 0; i < uuid_array.length; i++) { uuid_array[i] = uuid_gen.generate("test name" + i); } // check that none of the UUIDs are null checkUUIDArrayForNonNullUUIDs(uuid_array); // check that all the uuids were correct variant and version checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.NAME_BASED_SHA1); // check that all uuids were unique checkUUIDArrayForUniqueness(uuid_array); // now, lets make sure generating two sets of name based uuid with the // same args always gives the same result uuid_array = new UUID[SIZE_OF_TEST_ARRAY]; uuid_gen = Generators.nameBasedGenerator(NameBasedGenerator.NAMESPACE_URL); // now create the array of uuids for (int i = 0; i < uuid_array.length; i++) { uuid_array[i] = uuid_gen.generate("test name" + i); } UUID uuid_array2[] = new UUID[SIZE_OF_TEST_ARRAY]; uuid_gen = Generators.nameBasedGenerator(NameBasedGenerator.NAMESPACE_URL); // now create the array of uuids for (int i = 0; i < uuid_array2.length; i++) { uuid_array2[i] = uuid_gen.generate("test name" + i); } // check that none of the UUIDs are null checkUUIDArrayForNonNullUUIDs(uuid_array); checkUUIDArrayForNonNullUUIDs(uuid_array2); // check that all the uuids were correct variant and version checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.NAME_BASED_SHA1); checkUUIDArrayForCorrectVariantAndVersion(uuid_array2, UUIDType.NAME_BASED_SHA1); // check that all uuids were unique checkUUIDArrayForUniqueness(uuid_array); checkUUIDArrayForUniqueness(uuid_array2); // check that both arrays are equal to one another assertTrue("expected both arrays to be equal, they were not!", Arrays.equals(uuid_array, uuid_array2)); } /** * Test of generateNameBasedUUID(UUID, String, MessageDigest) * method, of class com.fasterxml.uuid.UUIDGenerator. */ public void testGenerateNameBasedUUIDNameSpaceNameAndMessageDigest() { MessageDigest MESSAGE_DIGEST = null; try { MESSAGE_DIGEST = MessageDigest.getInstance("MD5"); } catch (Exception ex) { fail("exception caught getting test digest : " + ex); } // this test will attempt to check for reasonable behavior of the // generateNameBasedUUID method NameBasedGenerator uuid_gen = Generators.nameBasedGenerator(NameBasedGenerator.NAMESPACE_URL, MESSAGE_DIGEST); UUID uuid_array[] = new UUID[SIZE_OF_TEST_ARRAY]; // now create the array of uuids for (int i = 0; i < uuid_array.length; i++) { uuid_array[i] = uuid_gen.generate("test name"+i); } // check that none of the UUIDs are null checkUUIDArrayForNonNullUUIDs(uuid_array); // check that all the uuids were correct variant and version checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.NAME_BASED_MD5); // check that all uuids were unique checkUUIDArrayForUniqueness(uuid_array); // now create the array of uuids for (int i = 0; i < uuid_array.length; i++) { uuid_array[i] = uuid_gen.generate("test name" + i); } // check that none of the UUIDs are null checkUUIDArrayForNonNullUUIDs(uuid_array); // check that all the uuids were correct variant and version checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.NAME_BASED_MD5); // check that all uuids were unique checkUUIDArrayForUniqueness(uuid_array); // now, lets make sure generating two sets of name based uuid with the // same args always gives the same result uuid_array = new UUID[SIZE_OF_TEST_ARRAY]; // now create the array of uuids for (int i = 0; i < uuid_array.length; i++) { uuid_array[i] = uuid_gen.generate("test name" + i); } UUID uuid_array2[] = new UUID[SIZE_OF_TEST_ARRAY]; // now create the array of uuids for (int i = 0; i < uuid_array2.length; i++) { uuid_array2[i] = uuid_gen.generate("test name" + i); } // check that none of the UUIDs are null checkUUIDArrayForNonNullUUIDs(uuid_array); checkUUIDArrayForNonNullUUIDs(uuid_array2); // check that all the uuids were correct variant and version checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.NAME_BASED_MD5); checkUUIDArrayForCorrectVariantAndVersion(uuid_array2, UUIDType.NAME_BASED_MD5); // check that all uuids were unique checkUUIDArrayForUniqueness(uuid_array); checkUUIDArrayForUniqueness(uuid_array2); // check that both arrays are equal to one another assertTrue("expected both arrays to be equal, they were not!", Arrays.equals(uuid_array, uuid_array2)); } /************************************************************************** * Begin Private Helper Methods for use in tests *************************************************************************/ private class ReverseOrderUUIDComparator implements Comparator { // this Comparator class has a compare which orders reverse of the // compareTo methond in UUID (so we can be sure our arrays below are // 'not ordered in sorted order' before we sort them. public int compare(UUID uuid1, UUID uuid2) { return -uuid1.compareTo(uuid2); } // we are only implementing equals because it's needed, super should do public boolean equals(Object o) { return super.equals(o); } } private void checkUUIDArrayForCorrectOrdering(UUID[] uuidArray) { // now we'll clone the array and reverse it UUID uuid_sorted_array[] = (UUID[])uuidArray.clone(); assertEquals("Cloned array length did not match", uuidArray.length, uuid_sorted_array.length); ReverseOrderUUIDComparator rev_order_uuid_comp = new ReverseOrderUUIDComparator(); Arrays.sort(uuid_sorted_array, rev_order_uuid_comp); // let's check that the array is actually reversed for (int i = 0; i < uuid_sorted_array.length; i++) { assertTrue( "Reverse order check on uuid arrays failed on element " + i, uuidArray[i].equals( uuid_sorted_array[uuid_sorted_array.length - (1 + i)])); } // now let's sort the reversed array and check that it // sorted to the same order as the original Arrays.sort(uuid_sorted_array); for (int i = 0; i < uuid_sorted_array.length; i++) { assertTrue( "Same order check on uuid arrays failed on element " + i, uuidArray[i].equals(uuid_sorted_array[i])); } } private void checkUUIDArrayForUniqueness(UUID[] uuidArray) { // here we'll assert that all elements in the list are not equal to // each other (aka, there should be no duplicates) we'll do this by // inserting all elements into a HashSet and making sure none of them //were already present (add will return false if it was already there) HashSet hash_set = new HashSet(); for (int i = 0; i < uuidArray.length; i++) { assertTrue("Uniqueness test failed on insert into HashSet: index "+i+", value "+uuidArray[i], hash_set.add(uuidArray[i])); assertFalse("Paranoia Uniqueness test failed (second insert)", hash_set.add(uuidArray[i])); } } private void checkUUIDArrayForCorrectVariantAndVersion(UUID[] uuidArray, UUIDType expectedType) { // let's check that all the UUIDs are valid type-X UUIDs with the // correct variant according to the specification. for (int i = 0; i < uuidArray.length; i++) { UUIDType actual = UUIDUtil.typeOf(uuidArray[i]); if (actual != expectedType) { fail("Expected version (type) did not match for UUID '"+uuidArray[i]+"' "+i+" (of "+uuidArray.length+"); expected " +expectedType+", got "+actual); } // now. let's double check the variant and type from the array byte[] temp_uuid = UUIDUtil.asByteArray(uuidArray[i]); // extract type from the UUID and check for correct type int type = (temp_uuid[UUIDUtil.BYTE_OFFSET_TYPE] & 0xFF) >> 4; assertEquals("Expected type did not match", expectedType.raw(), type); // extract variant from the UUID and check for correct variant int variant = (temp_uuid[UUIDUtil.BYTE_OFFSET_VARIATION] & 0xFF) >> 6; assertEquals("Expected variant did not match", 2, variant); } } private void checkUUIDArrayForCorrectCreationTime(UUID[] uuidArray, long startTime, long endTime) { // we need to convert from 100-nanosecond units (as used in UUIDs) // to millisecond units as used in UTC based time final long MILLI_CONVERSION_FACTOR = 10000L; // Since System.currentTimeMillis() returns time epoc time // (from 1-Jan-1970), and UUIDs use time from the beginning of // Gregorian calendar (15-Oct-1582) we have a offset for correction final long GREGORIAN_CALENDAR_START_TO_UTC_START_OFFSET = 122192928000000000L; assertTrue("start time was not before the end time", startTime < endTime); // let's check that all uuids in the array have a timestamp which lands // between the start and end time for (int i = 0; i < uuidArray.length; i++){ byte[] temp_uuid = UUIDUtil.asByteArray(uuidArray[i]); // first we'll collect the UUID time stamp which is // the number of 100-nanosecond intervals since // 00:00:00.00 15 October 1582 long uuid_time = 0L; uuid_time |= ((temp_uuid[3] & 0xF0L) << 0); uuid_time |= ((temp_uuid[2] & 0xFFL) << 8); uuid_time |= ((temp_uuid[1] & 0xFFL) << 16); uuid_time |= ((temp_uuid[0] & 0xFFL) << 24); uuid_time |= ((temp_uuid[5] & 0xFFL) << 32); uuid_time |= ((temp_uuid[4] & 0xFFL) << 40); uuid_time |= ((temp_uuid[7] & 0xFFL) << 48); uuid_time |= ((temp_uuid[6] & 0x0FL) << 56); // first we'll remove the gregorian offset uuid_time -= GREGORIAN_CALENDAR_START_TO_UTC_START_OFFSET; // and convert to milliseconds as the system clock is in millis uuid_time /= MILLI_CONVERSION_FACTOR; // now check that the times are correct assertTrue( "Start time: " + startTime + " was not before UUID timestamp: " + uuid_time, startTime <= uuid_time); assertTrue( "UUID timestamp: " + uuid_time + " was not before the start time: " + endTime, uuid_time <= endTime); } } private void checkUUIDArrayForCorrectEthernetAddress(UUID[] uuidArray, EthernetAddress ethernetAddress) { for (int i = 0; i < uuidArray.length; i++) { byte[] uuid_ethernet_address = new byte[6]; System.arraycopy(UUIDUtil.asByteArray(uuidArray[i]), 10, uuid_ethernet_address, 0, 6); byte[] ethernet_address = ethernetAddress.asByteArray(); assertTrue( "UUID ethernet address did not equal passed ethernetAddress", Arrays.equals(ethernet_address, uuid_ethernet_address)); } } private void checkUUIDArrayForNonNullUUIDs(UUID[] uuidArray) { for (int i = 0; i < uuidArray.length; i++) { if (UUIDUtil.typeOf(uuidArray[i]) == UUIDType.UNKNOWN) { fail("Entry #"+i+" was UNKNOWN UUID, shouldn't be"); } } } /************************************************************************** * End Private Helper Methods for use in tests *************************************************************************/ } java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/com/fasterxml/uuid/UUIDTest.java000066400000000000000000001350301324315460500317360ustar00rootroot00000000000000/* JUG Java Uuid Generator * UUIDTest.java * Created on July 16, 2003, 11:17 PM * * Copyright (c) 2003 Eric Bie * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; import junit.textui.TestRunner; import java.util.Arrays; import java.util.UUID; import com.fasterxml.uuid.UUIDType; import com.fasterxml.uuid.impl.UUIDUtil; /** * This class tests UUID for correct functionality. * * @author Eric Bie */ public class UUIDTest extends TestCase { final static UUID nullUUID = new UUID(0L, 0L); public UUIDTest(java.lang.String testName) { super(testName); } public static Test suite() { TestSuite suite = new TestSuite(UUIDTest.class); return suite; } public static void main(String[] args) { TestRunner.run(suite()); } /************************************************************************** * Begin constructor tests *************************************************************************/ /** * Test of UUID() constructor, of class com.fasterxml.uuid.UUID. */ public void testDefaultUUIDConstructor() { // this test technically relies on the toString() and toByteArray() // methods of the UUID class working properly. // If it fails, that is fine... the test only needs to indicate // proper working behavior or that it needs to be fixed. UUID uuid = nullUUID; assertEquals("Default constructor did not create expected null UUID", NULL_UUID_STRING, uuid.toString()); assertTrue("Expected array did not equal actual array", Arrays.equals(NULL_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); } /** * Test of UUID(byte[]) constructor, of class com.fasterxml.uuid.UUID. */ public void testByteArrayUUIDConstructor() { // passing array that is too small try { /*UUID uuid =*/ UUIDUtil.uuid(new byte[UUID_BYTE_ARRAY_LENGTH - 1]); fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // test that creating a uuid from an zero'd array // gives us a null UUID (definition of a null UUID) UUID uuid = UUIDUtil.uuid(new byte[UUID_BYTE_ARRAY_LENGTH]); assertEquals("constructor did not create expected null UUID", NULL_UUID_STRING, uuid.toString()); assertTrue("Expected array did not equal actual array", Arrays.equals(NULL_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); // test creating an array from a good byte array uuid = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertEquals("constructor did not create expected UUID", MIXED_CASE_VALID_UUID_STRING.toLowerCase(), uuid.toString().toLowerCase()); // test creating an array from a good byte array with extra data on end uuid = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY_WITH_EXTRA_END); assertEquals("constructor did not create expected UUID", MIXED_CASE_VALID_UUID_STRING.toLowerCase(), uuid.toString().toLowerCase()); } /** * Test of UUID(String) constructor, of class com.fasterxml.uuid.UUID. */ public void testStringUUIDConstructor() { // test a null string case try { /*UUID uuid =*/ UUIDUtil.uuid((String)null); fail("Expected exception not caught"); } catch (NullPointerException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // test some failure cases for the string constructor badStringUUIDConstructorHelper(IMPROPER_NUM_DASHES_UUID_STRING_1); badStringUUIDConstructorHelper(IMPROPER_NUM_DASHES_UUID_STRING_2); badStringUUIDConstructorHelper(IMPROPER_NUM_DASHES_UUID_STRING_3); badStringUUIDConstructorHelper(IMPROPER_NUM_DASHES_UUID_STRING_4); badStringUUIDConstructorHelper(IMPROPER_NUM_DASHES_UUID_STRING_5); badStringUUIDConstructorHelper(IMPROPER_NUM_DASHES_UUID_STRING_6); badStringUUIDConstructorHelper(NON_HEX_UUID_STRING); badStringUUIDConstructorHelper(RANDOM_PROPER_LENGTH_STRING); // test some good cases goodStringUUIDConstructorHelper(NULL_UUID_STRING); goodStringUUIDConstructorHelper(UPPER_CASE_VALID_UUID_STRING); goodStringUUIDConstructorHelper(LOWER_CASE_VALID_UUID_STRING); goodStringUUIDConstructorHelper(MIXED_CASE_VALID_UUID_STRING); } /************************************************************************** * End constructor tests *************************************************************************/ /** * Test of asByteArray method, of class com.fasterxml.uuid.UUID. */ public void testAsByteArray() { // we'll test making a couple UUIDs and then check that the asByteArray // gives back the same value in byte form that we used to create it // first we'll test the null uuid UUID uuid = nullUUID; assertEquals("Expected length of returned array wrong", UUID_BYTE_ARRAY_LENGTH, UUIDUtil.asByteArray(uuid).length); assertTrue("Expected array did not equal actual array", Arrays.equals(NULL_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); // now test a non-null uuid uuid = UUIDUtil.uuid(MIXED_CASE_VALID_UUID_STRING); assertEquals("Expected length of returned array wrong", UUID_BYTE_ARRAY_LENGTH, UUIDUtil.asByteArray(uuid).length); assertTrue("Expected array did not equal actual array", Arrays.equals(VALID_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); // let's make sure that changing the returned array doesn't mess with // the wrapped UUID's internals uuid = UUIDUtil.uuid(MIXED_CASE_VALID_UUID_STRING); assertEquals("Expected length of returned array wrong", UUID_BYTE_ARRAY_LENGTH, UUIDUtil.asByteArray(uuid).length); assertTrue("Expected array did not equal actual array", Arrays.equals(VALID_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); byte[] test_byte_array = UUIDUtil.asByteArray(uuid); // now stir it up a bit and then check that the original UUID was // not changed in the process. The easiest stir is to sort it ;) Arrays.sort(test_byte_array); assertFalse("Expected array was equal other array", Arrays.equals(VALID_UUID_BYTE_ARRAY, test_byte_array)); assertFalse("Expected array was equal other array", Arrays.equals(UUIDUtil.asByteArray(uuid), test_byte_array)); assertTrue("Expected array did not equal actual array", Arrays.equals(VALID_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); } /** * Test of compareTo method, of class com.fasterxml.uuid.UUID. */ public void testCompareTo() { // first, let's make sure calling compareTo with null // throws the appropriate NullPointerException try { NULL_UUID.compareTo(null); fail("Expected exception not thrown"); } catch (NullPointerException ex) { // good, we caught the expected exception, so we passed } catch (Exception ex) { fail("Caught an unexpected exception: " + ex); } // now we'll test some simple base cases // 2 null uuids always compare to 0 assertUUIDEqualOrderHelper(NULL_UUID, nullUUID); // 2 of the same value UUIDs are always 0 assertUUIDEqualOrderHelper(TIME3_MAC1_UUID, UUIDUtil.uuid(TIME3_MAC1_UUID.toString())); // the 'null UUID' always comes first in the ordering assertUUIDGreaterOrderHelper(TIME3_MAC1_UUID, NULL_UUID); // a UUID with a greater time is always comes after a lower time uuid // given the same MAC address assertUUIDGreaterOrderHelper(TIME3_MAC1_UUID, TIME1_MAC1_UUID); // a UUID with a greater time and a different MAC will always sort // with the greater time coming later assertUUIDGreaterOrderHelper(TIME3_MAC1_UUID, TIME1_MAC2_UUID); // a UUID with the same time stamp and different MAC will always sort // with the 'numerically' greater MAC coming later assertUUIDGreaterOrderHelper(TIME1_MAC2_UUID, TIME1_MAC1_UUID); // now we will test a bigger case of the compareTo functionality // of the UUID class // easiest way to do this is to create an array of UUIDs and sort it // then test that this array is in the expected order // first we'll try a MAC address homogeneous sort // before sort, the array contains (in psudo-random order) // 10 UUIDs of this distribution: // 2 - null uuid // 2 - time1_mac1 // 1 - time2_mac1 // 2 - time3_mac1 // 2 - time4_mac1 // 1 - time5_mac1 UUID test_uuid_array[] = new UUID[10]; test_uuid_array[0] = TIME3_MAC1_UUID; test_uuid_array[1] = TIME4_MAC1_UUID; test_uuid_array[2] = TIME1_MAC1_UUID; test_uuid_array[3] = NULL_UUID; test_uuid_array[4] = TIME3_MAC1_UUID; test_uuid_array[5] = TIME5_MAC1_UUID; test_uuid_array[6] = TIME2_MAC1_UUID; test_uuid_array[7] = TIME1_MAC1_UUID; test_uuid_array[8] = NULL_UUID; test_uuid_array[9] = TIME4_MAC1_UUID; Arrays.sort(test_uuid_array, new UUIDComparator()); // now we should be able to see that the array is in order assertUUIDsMatchHelper(NULL_UUID, test_uuid_array[0]); assertUUIDsMatchHelper(NULL_UUID, test_uuid_array[1]); assertUUIDsMatchHelper(TIME1_MAC1_UUID, test_uuid_array[2]); assertUUIDsMatchHelper(TIME1_MAC1_UUID, test_uuid_array[3]); assertUUIDsMatchHelper(TIME2_MAC1_UUID, test_uuid_array[4]); assertUUIDsMatchHelper(TIME3_MAC1_UUID, test_uuid_array[5]); assertUUIDsMatchHelper(TIME3_MAC1_UUID, test_uuid_array[6]); assertUUIDsMatchHelper(TIME4_MAC1_UUID, test_uuid_array[7]); assertUUIDsMatchHelper(TIME4_MAC1_UUID, test_uuid_array[8]); assertUUIDsMatchHelper(TIME5_MAC1_UUID, test_uuid_array[9]); // allow array to be GC'd (and make sure we don't somehow use the wrong // array below) test_uuid_array = null; // now lets try a MAC address heterogeneous case // before sort, the array contains (in psudo-random order) // 15 UUIDs of this distribution: // 1 - null uuid // 2 - time1_mac1 // 1 - time1_mac2 // 1 - time2_mac1 // 2 - time2_mac2 // 2 - time3_mac1 // 2 - time3_mac2 // 1 - time4_mac1 // 1 - time4_mac2 // 1 - time5_mac1 // 1 - time5_mac2 test_uuid_array = new UUID[15]; test_uuid_array[0] = TIME3_MAC1_UUID; test_uuid_array[1] = TIME4_MAC1_UUID; test_uuid_array[2] = TIME1_MAC1_UUID; test_uuid_array[3] = TIME3_MAC2_UUID; test_uuid_array[4] = TIME2_MAC2_UUID; test_uuid_array[5] = TIME3_MAC2_UUID; test_uuid_array[6] = TIME1_MAC1_UUID; test_uuid_array[7] = NULL_UUID; test_uuid_array[8] = TIME5_MAC1_UUID; test_uuid_array[9] = TIME2_MAC2_UUID; test_uuid_array[10] = TIME3_MAC1_UUID; test_uuid_array[11] = TIME4_MAC2_UUID; test_uuid_array[12] = TIME1_MAC2_UUID; test_uuid_array[13] = TIME5_MAC2_UUID; test_uuid_array[14] = TIME2_MAC1_UUID; Arrays.sort(test_uuid_array, new UUIDComparator()); // now we should be able to see that the array is in order assertUUIDsMatchHelper(NULL_UUID, test_uuid_array[0]); assertUUIDsMatchHelper(TIME1_MAC1_UUID, test_uuid_array[1]); assertUUIDsMatchHelper(TIME1_MAC1_UUID, test_uuid_array[2]); assertUUIDsMatchHelper(TIME1_MAC2_UUID, test_uuid_array[3]); assertUUIDsMatchHelper(TIME2_MAC1_UUID, test_uuid_array[4]); assertUUIDsMatchHelper(TIME2_MAC2_UUID, test_uuid_array[5]); assertUUIDsMatchHelper(TIME2_MAC2_UUID, test_uuid_array[6]); assertUUIDsMatchHelper(TIME3_MAC1_UUID, test_uuid_array[7]); assertUUIDsMatchHelper(TIME3_MAC1_UUID, test_uuid_array[8]); assertUUIDsMatchHelper(TIME3_MAC2_UUID, test_uuid_array[9]); assertUUIDsMatchHelper(TIME3_MAC2_UUID, test_uuid_array[10]); assertUUIDsMatchHelper(TIME4_MAC1_UUID, test_uuid_array[11]); assertUUIDsMatchHelper(TIME4_MAC2_UUID, test_uuid_array[12]); assertUUIDsMatchHelper(TIME5_MAC1_UUID, test_uuid_array[13]); assertUUIDsMatchHelper(TIME5_MAC2_UUID, test_uuid_array[14]); } /** * Test of equals method, of class com.fasterxml.uuid.UUID. */ public void testEquals() { // test passing null to equals returns false // (as specified in the JDK docs for Object) UUID x = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertFalse("equals(null) didn't return false", x.equals((Object)null)); // test that passing an object which is not a UUID returns false assertFalse("x.equals(non_UUID_object) didn't return false", x.equals(new Object())); // test a case where two UUIDs are definitly not equal UUID w = UUIDUtil.uuid(ANOTHER_VALID_UUID_BYTE_ARRAY); assertFalse("x.equals(w) didn't return false", x.equals(w)); // test refelexivity assertTrue("x.equals(x) didn't return true", x.equals(x)); // test symmetry UUID y = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertTrue("y.equals(x) didn't return true", y.equals(x)); assertTrue("x.equals(y) didn't return true", x.equals(y)); // now we'll test transitivity UUID z = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertTrue("x.equals(y) didn't return true", x.equals(y)); assertTrue("y.equals(z) didn't return true", y.equals(z)); assertTrue("x.equals(z) didn't return true", x.equals(z)); // test consistancy (this test is just calling equals multiple times) assertTrue("x.equals(y) didn't return true", x.equals(y)); assertTrue("x.equals(y) didn't return true", x.equals(y)); assertTrue("x.equals(y) didn't return true", x.equals(y)); } /** * Test of getNullUUID method, of class com.fasterxml.uuid.UUID. */ public void testGetNullUUID() { UUID uuid = nullUUID; assertEquals("getNullUUID did not create expected null UUID", NULL_UUID_STRING, uuid.toString()); assertTrue("Expected array did not equal actual array", Arrays.equals(NULL_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); // also, validate that getNullUUID is getting the same null each time UUID uuid2 = nullUUID; assertEquals("getNullUUID did not create expected null UUID", NULL_UUID_STRING, uuid2.toString()); assertTrue("Expected array did not equal actual array", Arrays.equals(NULL_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid2))); assertTrue("two returned null UUIDs were not the sam object instance", uuid == uuid2); } /** * Test of getType method, of class com.fasterxml.uuid.UUID. */ public void testGetType() { // here we will test that UUID's constructed with the right type // have the correct type returned from getType // test creating a null UUID UUID uuid = nullUUID; assertTrue("Expected array did not equal actual array", Arrays.equals(NULL_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); assertEquals("Expected type was not returned", UUIDUtil.typeOf(nullUUID), UUIDUtil.typeOf(uuid)); // test Random UUID in this case uuid = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertTrue("Expected array did not equal actual array", Arrays.equals(VALID_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); assertEquals("Expected type was not returned", UUIDType.RANDOM_BASED, UUIDUtil.typeOf(uuid)); // test time based UUID in this case uuid = UUIDUtil.uuid(UUIDUtil.asByteArray(TIME1_MAC1_UUID)); assertEquals("constructor did not create expected UUID", TIME1_MAC1_UUID.toString().toLowerCase(), uuid.toString().toLowerCase()); assertEquals("Expected type was not returned", UUIDType.TIME_BASED, UUIDUtil.typeOf(uuid)); // test name based UUID in this case uuid = UUIDUtil.uuid(NAME_BASED_UUID_STRING); assertTrue("Expected array did not equal actual array", Arrays.equals(NAME_BASED_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); assertEquals("Expected type was not returned", UUIDType.NAME_BASED_MD5, UUIDUtil.typeOf(uuid)); // test DCE based UUID in this case uuid = UUIDUtil.uuid(DCE_BASED_UUID_BYTE_ARRAY); assertTrue("Expected array did not equal actual array", Arrays.equals(DCE_BASED_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); assertEquals("Expected type was not returned", UUIDType.DCE, UUIDUtil.typeOf(uuid)); } /** * Test of hashCode method, of class com.fasterxml.uuid.UUID. */ public void testHashCode() { // as lifted from the JDK Object JavaDocs: // Whenever it is invoked on the same object more than once // during an execution of a Java application, the hashCode // method must consistently return the same integer, provided // no information used in equals comparisons on the object is // modified. This integer need not remain consistent from one // execution of an application to another execution of the // same application UUID x = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertTrue("x.equals(x) didn't return true", x.equals(x)); assertEquals("x.hashCode() didn't equal x.hashCode()", x.hashCode(), x.hashCode()); assertEquals("x.hashCode() didn't equal x.hashCode()", x.hashCode(), x.hashCode()); // as lifted from the JDK Object JavaDocs: // If two objects are equal according to the equals(Object) method, // then calling the hashCode method on each of the two objects // must produce the same integer result UUID y = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertFalse("x == y didn't return false", x == y); assertTrue("x.equals(y) didn't return true", x.equals(y)); assertEquals("x.hashCode() didn't equal y.hashCode()", x.hashCode(), y.hashCode()); // it is not REQUIRED that hashCode return different ints for different // objects where x.equals(z) is not true. // So, there is no test for that here } /** * Test of isNullUUID method, of class com.fasterxml.uuid.UUID. */ public void testIsNullUUID() { // this test will test isNullUUID using the five main ways you could // create a null UUID and test a case where it should NOT be true // test using default constructor UUID uuid = nullUUID; assertIsNullUUID(uuid); // test by string creation using null uuid represented in string form uuid = UUIDUtil.uuid(NULL_UUID_STRING); assertIsNullUUID(uuid); // test by byte[] creation using null uuid represented in byte[] form uuid = UUIDUtil.uuid(NULL_UUID_BYTE_ARRAY); assertIsNullUUID(uuid); // test by byte[] creation using null uuid represented in byte[] form // starting at an offset byte[] null_uuid_array = new byte[20]; Arrays.fill(null_uuid_array, 0, 3, (byte)'x'); uuid = UUIDUtil.uuid(null_uuid_array, 4); assertIsNullUUID(uuid); // test a not null case uuid = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertFalse(0L == uuid.getMostSignificantBits()); assertFalse(0L == uuid.getLeastSignificantBits()); } private void assertIsNullUUID(UUID uuid) { assertEquals(0L, uuid.getMostSignificantBits()); assertEquals(0L, uuid.getLeastSignificantBits()); } /** * Test of toByteArray() method, of class com.fasterxml.uuid.UUID. */ public void testToByteArray() { // we'll test making a couple UUIDs and then check that the toByteArray // gives back the same value in byte form that we used to create it // first we'll test the null uuid UUID uuid = nullUUID; assertEquals("Expected length of returned array wrong", UUID_BYTE_ARRAY_LENGTH, UUIDUtil.asByteArray(uuid).length); assertTrue("Expected array did not equal actual array", Arrays.equals(NULL_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); // now test a non-null uuid uuid = UUIDUtil.uuid(MIXED_CASE_VALID_UUID_STRING); assertEquals("Expected length of returned array wrong", UUID_BYTE_ARRAY_LENGTH, UUIDUtil.asByteArray(uuid).length); assertTrue("Expected array did not equal actual array", Arrays.equals(VALID_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); // let's make sure that changing the returned array doesn't mess with // the wrapped UUID's internals uuid = UUIDUtil.uuid(MIXED_CASE_VALID_UUID_STRING); assertEquals("Expected length of returned array wrong", UUID_BYTE_ARRAY_LENGTH, UUIDUtil.asByteArray(uuid).length); assertTrue("Expected array did not equal actual array", Arrays.equals(VALID_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); byte[] test_byte_array = UUIDUtil.asByteArray(uuid); // now stir it up a bit and then check that the original UUID was // not changed in the process. The easiest stir is to sort it ;) Arrays.sort(test_byte_array); assertFalse("Expected array was equal other array", Arrays.equals(VALID_UUID_BYTE_ARRAY, test_byte_array)); assertFalse("Expected array was equal other array", Arrays.equals(UUIDUtil.asByteArray(uuid), test_byte_array)); assertTrue("Expected array did not equal actual array", Arrays.equals(VALID_UUID_BYTE_ARRAY, UUIDUtil.asByteArray(uuid))); } /** * Test of toByteArray(byte[]) method, of class com.fasterxml.uuid.UUID. */ public void testToByteArrayDest() { // constant for use in this test final int EXTRA_DATA_LENGTH = 9; // lets test some error cases // first, passing null try { UUID test_uuid = nullUUID; UUIDUtil.toByteArray(test_uuid, (byte[])null); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an array that is too small try { UUID test_uuid = nullUUID; byte[] uuid_array = new byte[UUID_BYTE_ARRAY_LENGTH - 1]; UUIDUtil.toByteArray(test_uuid, uuid_array); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // we'll test making a couple UUIDs and then check that the toByteArray // gives back the same value in byte form that we used to create it // here we'll test the null uuid UUID test_uuid = nullUUID; byte[] test_array = new byte[UUID_BYTE_ARRAY_LENGTH]; UUIDUtil.toByteArray(test_uuid, test_array); assertTrue("Expected array did not equal actual array", Arrays.equals(NULL_UUID_BYTE_ARRAY, test_array)); // now test a non-null uuid test_uuid = UUIDUtil.uuid(MIXED_CASE_VALID_UUID_STRING); UUIDUtil.toByteArray(test_uuid, test_array); assertTrue("Expected array did not equal actual array", Arrays.equals(VALID_UUID_BYTE_ARRAY, test_array)); // now test a null uuid case with extra data in the array test_uuid = nullUUID; test_array = new byte[UUID_BYTE_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); UUIDUtil.toByteArray(test_uuid, test_array); for (int i = 0; i < UUID_BYTE_ARRAY_LENGTH; ++i) { assertEquals("Expected array values did not match", NULL_UUID_BYTE_ARRAY[i], test_array[i]); } for (int i = 0; i < EXTRA_DATA_LENGTH; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i + UUID_BYTE_ARRAY_LENGTH]); } // now test a good uuid case with extra data in the array test_uuid = UUIDUtil.uuid(MIXED_CASE_VALID_UUID_STRING); test_array = new byte[UUID_BYTE_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); UUIDUtil.toByteArray(test_uuid, test_array); for (int i = 0; i < UUID_BYTE_ARRAY_LENGTH; ++i) { assertEquals("Expected array values did not match", VALID_UUID_BYTE_ARRAY[i], test_array[i]); } for (int i = 0; i < EXTRA_DATA_LENGTH; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i + UUID_BYTE_ARRAY_LENGTH]); } } /** * Test of toByteArray(byte[], int) method, * of class com.fasterxml.uuid.UUID. */ public void testToByteArrayDestOffset() { // constant value for use in this test final int EXTRA_DATA_LENGTH = 9; // now an array that is too small try { UUID test_uuid = nullUUID; byte[] uuid_array = new byte[UUID_BYTE_ARRAY_LENGTH - 1]; UUIDUtil.toByteArray(test_uuid, uuid_array, 0); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an index that is negative try { UUID test_uuid = nullUUID; byte[] uuid_array = new byte[UUID_BYTE_ARRAY_LENGTH]; UUIDUtil.toByteArray(test_uuid, uuid_array, -1); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an index that is too big try { UUID test_uuid = nullUUID; byte[] uuid_array = new byte[UUID_BYTE_ARRAY_LENGTH]; UUIDUtil.toByteArray(test_uuid, uuid_array, UUID_BYTE_ARRAY_LENGTH); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // now an index that is in the array, // but without enough bytes to read UUID_BYTE_ARRAY_LENGTH try { UUID test_uuid = nullUUID; byte[] uuid_array = new byte[UUID_BYTE_ARRAY_LENGTH]; UUIDUtil.toByteArray(test_uuid, uuid_array, 1); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (IllegalArgumentException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } // we'll test making a couple UUIDs and then check that the toByteArray // gives back the same value in byte form that we used to create it // here we'll test the null uuid at offset 0 UUID test_uuid = nullUUID; byte[] test_array = new byte[UUID_BYTE_ARRAY_LENGTH]; UUIDUtil.toByteArray(test_uuid, test_array, 0); assertTrue("Expected array did not equal actual array", Arrays.equals(NULL_UUID_BYTE_ARRAY, test_array)); // now test a non-null uuid test_uuid = UUIDUtil.uuid(MIXED_CASE_VALID_UUID_STRING); UUIDUtil.toByteArray(test_uuid, test_array); assertTrue("Expected array did not equal actual array", Arrays.equals(VALID_UUID_BYTE_ARRAY, test_array)); // now test a null uuid case with extra data in the array test_uuid = nullUUID; test_array = new byte[UUID_BYTE_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); UUIDUtil.toByteArray(test_uuid, test_array, 0); for (int i = 0; i < UUID_BYTE_ARRAY_LENGTH; ++i) { assertEquals("Expected array values did not match", NULL_UUID_BYTE_ARRAY[i], test_array[i]); } for (int i = 0; i < EXTRA_DATA_LENGTH; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i + UUID_BYTE_ARRAY_LENGTH]); } // now test a null uuid case with extra data in the array test_uuid = nullUUID; test_array = new byte[UUID_BYTE_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); UUIDUtil.toByteArray(test_uuid, test_array, EXTRA_DATA_LENGTH/2); // first check the data (in the middle of the array) for (int i = 0; i < UUID_BYTE_ARRAY_LENGTH; ++i) { assertEquals("Expected array values did not match (offset "+i+")", NULL_UUID_BYTE_ARRAY[i], test_array[i + EXTRA_DATA_LENGTH/2]); } // and now check that the surrounding bytes were not changed for (int i = 0; i < EXTRA_DATA_LENGTH/2; ++i) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i]); assertEquals("Expected array fill value changed", (byte)'x', test_array[i + UUID_BYTE_ARRAY_LENGTH + EXTRA_DATA_LENGTH/2]); } // now test a good uuid case with extra data in the array test_uuid = UUIDUtil.uuid(MIXED_CASE_VALID_UUID_STRING); test_array = new byte[UUID_BYTE_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); UUIDUtil.toByteArray(test_uuid, test_array, 0); for (int i = 0; i < UUID_BYTE_ARRAY_LENGTH; ++i) { assertEquals("Expected array values did not match", VALID_UUID_BYTE_ARRAY[i], test_array[i]); } for (int i = 0; i < EXTRA_DATA_LENGTH; i++) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i + UUID_BYTE_ARRAY_LENGTH]); } // now test a good uuid case with extra data in the array // to make sure we aren't blowing the bounds of the buffer test_uuid = UUIDUtil.uuid(MIXED_CASE_VALID_UUID_STRING); test_array = new byte[UUID_BYTE_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); UUIDUtil.toByteArray(test_uuid, test_array, EXTRA_DATA_LENGTH/2); // first check the data (in the middle of the array) for (int i = 0; i < UUID_BYTE_ARRAY_LENGTH; ++i) { assertEquals("Expected array values did not match", VALID_UUID_BYTE_ARRAY[i], test_array[i + EXTRA_DATA_LENGTH/2]); } // and now check that the surrounding bytes were not changed for (int i = 0; i < EXTRA_DATA_LENGTH/2; ++i) { assertEquals("Expected array fill value changed", (byte)'x', test_array[i]); assertEquals("Expected array fill value changed", (byte)'x', test_array[i + UUID_BYTE_ARRAY_LENGTH + EXTRA_DATA_LENGTH/2]); } } /** * Test of toString method, of class com.fasterxml.uuid.UUID. */ public void testToString() { // test making a couple UUIDs and then check that the toString // gives back the same value in string form that was used to create it // test the null uuid UUID uuid = nullUUID; assertEquals("null uuid string and toString did not match", NULL_UUID_STRING.toLowerCase(), uuid.toString().toLowerCase()); // test a non-null uuid uuid = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertEquals("uuid string and toString results did not match", MIXED_CASE_VALID_UUID_STRING.toLowerCase(), uuid.toString().toLowerCase()); // The current UUID implementation returns strings all lowercase. // Although relying on this behavior in code is not recommended, // here is a unit test which will break if this assumption // becomes bad. This will act as an early warning to anyone // who relies on this particular behavior. uuid = UUIDUtil.uuid(VALID_UUID_BYTE_ARRAY); assertFalse("mixed case uuid string and toString " + "matched (expected toString to be all lower case)", MIXED_CASE_VALID_UUID_STRING.equals(uuid.toString())); assertEquals("mixed case string toLowerCase and " + "toString results did not match (expected toString to " + "be all lower case)", MIXED_CASE_VALID_UUID_STRING.toLowerCase(), uuid.toString()); } /** * Test of valueOf(String) method, of class com.fasterxml.uuid.UUID. */ public void testValueOfString() { // test some failure cases for the string constructor badStringValueOfHelper(IMPROPER_NUM_DASHES_UUID_STRING_1); badStringValueOfHelper(IMPROPER_NUM_DASHES_UUID_STRING_2); badStringValueOfHelper(IMPROPER_NUM_DASHES_UUID_STRING_3); badStringValueOfHelper(IMPROPER_NUM_DASHES_UUID_STRING_4); badStringValueOfHelper(IMPROPER_NUM_DASHES_UUID_STRING_5); badStringValueOfHelper(IMPROPER_NUM_DASHES_UUID_STRING_6); badStringValueOfHelper(NON_HEX_UUID_STRING); badStringValueOfHelper(RANDOM_PROPER_LENGTH_STRING); // test the good cases goodStringValueOfHelper(NULL_UUID_STRING); goodStringValueOfHelper(UPPER_CASE_VALID_UUID_STRING); goodStringValueOfHelper(LOWER_CASE_VALID_UUID_STRING); goodStringValueOfHelper(MIXED_CASE_VALID_UUID_STRING); } /************************************************************************** * Begin private helper functions for use in tests *************************************************************************/ private void badStringUUIDConstructorHelper(String uuidString) { try { /*UUID uuid =*/ UUIDUtil.uuid(uuidString); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } } private void goodStringUUIDConstructorHelper(String uuidString) { UUID temp_uuid = null; try { temp_uuid = UUIDUtil.uuid(uuidString); } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } assertEquals("uuid strings were not equal", uuidString.toLowerCase(), temp_uuid.toString().toLowerCase()); } private void badStringValueOfHelper(String uuidString) { try { /*UUID uuid =*/ UUIDUtil.uuid(uuidString); // if we reached here we failed because we didn't get an exception fail("Expected exception not caught"); } catch (NumberFormatException ex) { // this is the success case so do nothing } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } } private void goodStringValueOfHelper(String uuidString) { UUID temp_uuid = null; try { temp_uuid = UUIDUtil.uuid(uuidString); } catch (Exception ex) { fail("Caught unexpected exception: " + ex); } assertEquals("UUID strings were not equal", uuidString.toLowerCase(), temp_uuid.toString().toLowerCase()); } private void assertUUIDsMatchHelper(UUID expected, UUID actual) { // technically, toString will always return lowercase uuid strings, // but just to be paranoid, we will always do toLowerCase in this test assertEquals("UUID strings did not match", expected.toString().toLowerCase(), actual.toString().toLowerCase()); assertEquals("UUID equals did not match", expected, actual); } private void assertUUIDEqualOrderHelper(UUID uuid1, UUID uuid2) { assertTrue(uuid1 + " did not test as equal to " + uuid2, 0 == UUIDComparator.staticCompare(uuid1, uuid2)); assertTrue(uuid2 + " did not test as equal to " + uuid1, 0 == UUIDComparator.staticCompare(uuid2, uuid1)); } private void assertUUIDGreaterOrderHelper(UUID uuid1, UUID uuid2) { int diff = UUIDComparator.staticCompare(uuid1, uuid2); assertTrue(uuid1 + " did not test as larger than " + uuid2+", diff: "+diff, diff > 0); diff = UUIDComparator.staticCompare(uuid2, uuid1); assertTrue(uuid2 + " did not test as smaller than " + uuid1+", diff: "+diff, diff < 0); } /************************************************************************** * End private helper functions for use in tests *************************************************************************/ /************************************************************************** * Begin private constants for use in tests above *************************************************************************/ private static final int UUID_BYTE_ARRAY_LENGTH = 16; // some strings for failure case tests private static final String IMPROPER_NUM_DASHES_UUID_STRING_1 = "01234567089AB-CDEF-0123-456789ABCDEF"; private static final String IMPROPER_NUM_DASHES_UUID_STRING_2 = "01234567-89AB0CDEF-0123-456789ABCDEF"; private static final String IMPROPER_NUM_DASHES_UUID_STRING_3 = "01234567-89AB-CDEF00123-456789ABCDEF"; private static final String IMPROPER_NUM_DASHES_UUID_STRING_4 = "01234567-89AB-CDEF-01230456789ABCDEF"; private static final String IMPROPER_NUM_DASHES_UUID_STRING_5 = "01234567089AB0CDEF001230456789ABCDEF"; private static final String IMPROPER_NUM_DASHES_UUID_STRING_6 = "0123-4567-89AB-CDEF-0123-456789ABCDE"; private static final String NON_HEX_UUID_STRING = "01THISIS-ANON-HEX0-UUID-FORSURE01234"; private static final String RANDOM_PROPER_LENGTH_STRING = "String Of The Same Length as a UUID!"; // some strings and matching byte arrays for the success case tests private static final String NULL_UUID_STRING = "00000000-0000-0000-0000-000000000000"; private static final byte[] NULL_UUID_BYTE_ARRAY = new byte[UUID_BYTE_ARRAY_LENGTH]; private static final String UPPER_CASE_VALID_UUID_STRING = "4D687664-3A1E-4F30-ACC1-87F59306D30C"; private static final String MIXED_CASE_VALID_UUID_STRING = "4d687664-3A1e-4F30-aCc1-87F59306d30C"; private static final String LOWER_CASE_VALID_UUID_STRING = "4d687664-3a1e-4f30-acc1-87f59306d30c"; private static final byte[] VALID_UUID_BYTE_ARRAY = { (byte)0x4d, (byte)0x68, (byte)0x76, (byte)0x64, (byte)0x3a, (byte)0x1e, (byte)0x4f, (byte)0x30, (byte)0xac, (byte)0xc1, (byte)0x87, (byte)0xf5, (byte)0x93, (byte)0x06, (byte)0xd3, (byte)0x0c }; /* private static final byte[] VALID_UUID_BYTE_ARRAY_WITH_EXTRA_START = { 'e', 'x', 't', 'r', 'a', ' ', 'j', 'u', 'n', 'k', (byte)0x4d, (byte)0x68, (byte)0x76, (byte)0x64, (byte)0x3a, (byte)0x1e, (byte)0x4f, (byte)0x30, (byte)0xac, (byte)0xc1, (byte)0x87, (byte)0xf5, (byte)0x93, (byte)0x06, (byte)0xd3, (byte)0x0c }; */ private static final byte[] VALID_UUID_BYTE_ARRAY_WITH_EXTRA_END = { (byte)0x4d, (byte)0x68, (byte)0x76, (byte)0x64, (byte)0x3a, (byte)0x1e, (byte)0x4f, (byte)0x30, (byte)0xac, (byte)0xc1, (byte)0x87, (byte)0xf5, (byte)0x93, (byte)0x06, (byte)0xd3, (byte)0x0c, 'o', 'n', ' ', 't', 'h', 'e', ' ', 'e', 'n', 'd', ' ', 'a', 's', ' ', 'w', 'e', 'l', 'l' }; /* private static final byte[] VALID_UUID_BYTE_ARRAY_WITH_EXTRA_BOTH = { 'e', 'x', 't', 'r', 'a', ' ', 'j', 'u', 'n', 'k', (byte)0x4d, (byte)0x68, (byte)0x76, (byte)0x64, (byte)0x3a, (byte)0x1e, (byte)0x4f, (byte)0x30, (byte)0xac, (byte)0xc1, (byte)0x87, (byte)0xf5, (byte)0x93, (byte)0x06, (byte)0xd3, (byte)0x0c, 'o', 'n', ' ', 't', 'h', 'e', ' ', 'e', 'n', 'd', ' ', 'a', 's', ' ', 'w', 'e', 'l', 'l' }; */ //private static final String ANOTHER_VALID_UUID_STRING = "4aba2d17-08c9-4376-92fe-4cdefbba5a1c"; private static final byte[] ANOTHER_VALID_UUID_BYTE_ARRAY = { (byte)0x4a, (byte)0xba, (byte)0x2d, (byte)0x17, (byte)0x08, (byte)0xc9, (byte)0x43, (byte)0x76, (byte)0x92, (byte)0xfe, (byte)0x4c, (byte)0xde, (byte)0xfb, (byte)0xba, (byte)0x5a, (byte)0x1c }; // valid namespace based UUID string private static final String NAME_BASED_UUID_STRING = "71ee9b64-39d3-386c-bce3-c70549ca8829"; private static final byte[] NAME_BASED_UUID_BYTE_ARRAY = { (byte)0x71, (byte)0xee, (byte)0x9b, (byte)0x64, (byte)0x39, (byte)0xd3, (byte)0x38, (byte)0x6c, (byte)0xbc, (byte)0xe3, (byte)0xc7, (byte)0x05, (byte)0x49, (byte)0xca, (byte)0x88, (byte)0x29 }; // dummy DCE based UUID string since I have no real examples to use //private static final String DCE_BASED_UUID_STRING = "01234567-0123-2000-8000-0123456789ab"; private static final byte[] DCE_BASED_UUID_BYTE_ARRAY = { (byte)0x01, (byte)0x23, (byte)0x45, (byte)0x67, (byte)0x01, (byte)0x23, (byte)0x20, (byte)0x00, (byte)0x80, (byte)0x00, (byte)0x01, (byte)0x23, (byte)0x45, (byte)0x67, (byte)0x89, (byte)0xab }; // some strings for the "ordered" uuid test cases // notice that these uuid cases vary in the time portion and for each // "exact time" there is a case for two different MAC addresses // to insure the ordering test between different MAC addresses private static final UUID NULL_UUID = nullUUID; private static final UUID TIME1_MAC1_UUID = UUIDUtil.uuid("ebb8e8fe-b1b1-11d7-8adb-00b0d078fa18"); private static final UUID TIME1_MAC2_UUID = UUIDUtil.uuid("ebb8e8fe-b1b1-11d7-8adb-baa07db6d227"); private static final UUID TIME2_MAC1_UUID = UUIDUtil.uuid("ec3ffdda-b1b1-11d7-8adb-00b0d078fa18"); private static final UUID TIME2_MAC2_UUID = UUIDUtil.uuid("ec3ffdda-b1b1-11d7-8adb-baa07db6d227"); private static final UUID TIME3_MAC1_UUID = UUIDUtil.uuid("eca4c616-b1b1-11d7-8adb-00b0d078fa18"); private static final UUID TIME3_MAC2_UUID = UUIDUtil.uuid("eca4c616-b1b1-11d7-8adb-baa07db6d227"); private static final UUID TIME4_MAC1_UUID = UUIDUtil.uuid("ed17de08-b1b1-11d7-8adb-00b0d078fa18"); private static final UUID TIME4_MAC2_UUID = UUIDUtil.uuid("ed17de08-b1b1-11d7-8adb-baa07db6d227"); private static final UUID TIME5_MAC1_UUID = UUIDUtil.uuid("ed94244a-b1b1-11d7-8adb-00b0d078fa18"); private static final UUID TIME5_MAC2_UUID = UUIDUtil.uuid("ed94244a-b1b1-11d7-8adb-baa07db6d227"); /************************************************************************** * End private constants for use in tests above *************************************************************************/ } java-uuid-generator-java-uuid-generator-3.1.5/src/test/java/com/fasterxml/uuid/UUIDTimerTest.java000066400000000000000000000346621324315460500327500ustar00rootroot00000000000000/* JUG Java Uuid Generator * UUIDTimerTest.java * Created on July 28, 2003, 10:09 PM * * Copyright (c) 2003 Eric Bie * * Licensed under the License specified in the file LICENSE which is * included with the source code. * You may not use this file except in compliance with the License. * * 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 com.fasterxml.uuid; import java.io.IOException; import java.security.SecureRandom; import java.util.Arrays; import java.util.Comparator; import java.util.HashSet; import java.util.Set; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; import junit.textui.TestRunner; import com.fasterxml.uuid.UUIDTimer; /** * JUnit Test class for the com.fasterxml.uuid.UUIDTimer class. * * @author Eric Bie */ public class UUIDTimerTest extends TestCase { // constants for use in the tests private static final int UUID_TIMER_ARRAY_LENGTH = 10; private static final int SIZE_OF_TEST_ARRAY = 10000; public UUIDTimerTest(java.lang.String testName) { super(testName); } public static Test suite() { TestSuite suite = new TestSuite(UUIDTimerTest.class); return suite; } public static void main(String[] args) { TestRunner.run(suite()); } /************************************************************************** * Begin constructor tests *************************************************************************/ /** * Test of UUIDTimer(SecureRandom) constructor, * of class com.fasterxml.uuid.UUIDTimer. */ public void testSecureRandomUUIDTimerConstructor() throws IOException { // try passing a null SecureRandom argument try { /*UUIDTimer uuid_timer =*/ new UUIDTimer((SecureRandom)null, null); // if we reach here we didn't catch what we should have fail("Expected exception not caught"); } catch (NullPointerException ex) { // caught the expected exception, this is good, just go on } catch (Exception ex) { fail("Unexpected exception caught"); } // now construct a valid case SecureRandom secure_random = new SecureRandom(); UUIDTimer uuid_timer = new UUIDTimer(secure_random, null); // we'll do a simple run to see that it at least produces output byte[] test_array = new byte[UUID_TIMER_ARRAY_LENGTH]; uuid_timer.getAndSetTimestamp(test_array); // check that it's not all null assertArrayNotEqual(test_array, new byte[UUID_TIMER_ARRAY_LENGTH], UUID_TIMER_ARRAY_LENGTH); } /************************************************************************** * End constructor tests *************************************************************************/ /** * Test of getAndSetTimestamp method, of class com.fasterxml.uuid.UUIDTimer. */ public void testGetTimestamp() throws IOException { // constant for use in this test final int EXTRA_DATA_LENGTH = 9; // construct a UUIDTimer SecureRandom secure_random = new SecureRandom(); UUIDTimer uuid_timer = new UUIDTimer(secure_random, null); // test an array thats too small try { byte[] test_array = new byte[UUID_TIMER_ARRAY_LENGTH - 1]; uuid_timer.getAndSetTimestamp(test_array); // if we get here, we didn't catch the expected exception fail("Expected exception not caught"); } catch (ArrayIndexOutOfBoundsException ex) { // caught the expected exception, this is good, just go on } catch (Exception ex) { fail("Unexpected exception caught"); } // construct a valid array exactly big enough and see that it works byte[] test_array = new byte[UUID_TIMER_ARRAY_LENGTH]; uuid_timer.getAndSetTimestamp(test_array); // check that it's not all null assertArrayNotEqual(test_array, new byte[UUID_TIMER_ARRAY_LENGTH], UUID_TIMER_ARRAY_LENGTH); // construct a valid array bigger then we need // and make sure getAndSetTimeStamp only touches the begining part test_array = new byte[UUID_TIMER_ARRAY_LENGTH + EXTRA_DATA_LENGTH]; Arrays.fill(test_array, (byte)'x'); uuid_timer.getAndSetTimestamp(test_array); for (int i = 0; i < EXTRA_DATA_LENGTH; ++i) { assertEquals("test_array element was corrupted", (byte)'x', test_array[i + UUID_TIMER_ARRAY_LENGTH]); } // check that the timer portion is not all null assertArrayNotEqual(test_array, new byte[UUID_TIMER_ARRAY_LENGTH], UUID_TIMER_ARRAY_LENGTH); // now make a bunch of timer elements and validate that they are // are well behaved timer elements byte[][] array_of_uuid_timer_byte_arrays = new byte[SIZE_OF_TEST_ARRAY][UUID_TIMER_ARRAY_LENGTH]; // before generating all the uuid timer arrays, get the start time long start_time = System.currentTimeMillis(); // now create the array of uuid timer output arrays for (int i = 0; i < array_of_uuid_timer_byte_arrays.length; i++) { uuid_timer.getAndSetTimestamp(array_of_uuid_timer_byte_arrays[i]); } // now capture the end time long end_time = System.currentTimeMillis(); // convert the array into array of longs holding the numerical values Long[] uuid_timer_array_of_longs = convertArrayOfByteArraysToArrayOfLongs( array_of_uuid_timer_byte_arrays); // check that none of the UUID Timer arrays are all null checkUUIDTimerLongArrayForNonNullTimes(uuid_timer_array_of_longs); // check that all UUID Timers were generated with correct order checkUUIDTimerLongArrayForCorrectOrdering(uuid_timer_array_of_longs); // check that all UUID Timers were unique checkUUIDTimerLongArrayForUniqueness(uuid_timer_array_of_longs); // check that all timestamps are between the start and end time checkUUIDTimerLongArrayForCorrectCreationTime( uuid_timer_array_of_longs, start_time, end_time); } /************************************************************************** * Begin private helper functions for use in tests *************************************************************************/ private Long[] convertArrayOfByteArraysToArrayOfLongs( byte[][] uuidTimerArrayOfByteArrays) { Long[] array_of_longs = new Long[uuidTimerArrayOfByteArrays.length]; for (int i = 0; i < uuidTimerArrayOfByteArrays.length; i++) { // collect the UUID time stamp which is // the number of 100-nanosecond intervals since // 00:00:00.00 15 October 1582 long uuid_timer = 0L; uuid_timer |= ((uuidTimerArrayOfByteArrays[i][3] & 0xFFL) << 0); uuid_timer |= ((uuidTimerArrayOfByteArrays[i][2] & 0xFFL) << 8); uuid_timer |= ((uuidTimerArrayOfByteArrays[i][1] & 0xFFL) << 16); uuid_timer |= ((uuidTimerArrayOfByteArrays[i][0] & 0xFFL) << 24); uuid_timer |= ((uuidTimerArrayOfByteArrays[i][5] & 0xFFL) << 32); uuid_timer |= ((uuidTimerArrayOfByteArrays[i][4] & 0xFFL) << 40); uuid_timer |= ((uuidTimerArrayOfByteArrays[i][7] & 0xFFL) << 48); uuid_timer |= ((uuidTimerArrayOfByteArrays[i][6] & 0xFFL) << 56); array_of_longs[i] = new Long(uuid_timer); } return array_of_longs; } private class ReverseOrderUUIDTimerLongComparator implements Comparator { // this Comparator class has a compare which orders reverse of the // compare method in UUIDTimerArrayComparator (so we can be sure our // arrays below are 'not ordered in sorted order' // before we sort them). public int compare(Long uuid_timer_long1, Long uuid_timer_long2) { return -uuid_timer_long1.compareTo(uuid_timer_long2); } // we are only implementing equals because it's needed, super should do public boolean equals(Object o) { return super.equals(o); } } private void checkUUIDTimerLongArrayForCorrectOrdering( Long[] uuidTimerLongArray) { // now we'll clone the array and reverse it Long[] uuid_timer_sorted_arrays = (Long[])uuidTimerLongArray.clone(); assertEquals("Cloned array length did not match", uuidTimerLongArray.length, uuid_timer_sorted_arrays.length); ReverseOrderUUIDTimerLongComparator rev_order_uuid_timer_comp = new ReverseOrderUUIDTimerLongComparator(); Arrays.sort(uuid_timer_sorted_arrays, rev_order_uuid_timer_comp); // let's check that the array is actually reversed int sorted_arrays_length = uuid_timer_sorted_arrays.length; for (int i = 0; i < sorted_arrays_length; i++) { assertTrue( "Reverse order check on uuid timer arrays failed" + " on element " + i + ": " + uuidTimerLongArray[i].longValue() + " does not equal " + uuid_timer_sorted_arrays[ sorted_arrays_length - (1 + i)].longValue(), uuidTimerLongArray[i].equals( uuid_timer_sorted_arrays[sorted_arrays_length - (1 + i)])); } // now let's sort the reversed array and check that it sorted to // the same order as the original Arrays.sort(uuid_timer_sorted_arrays); for (int i = 0; i < sorted_arrays_length; i++) { assertTrue( "Same order check on uuid timer arrays failed on element " + i + ": " + uuidTimerLongArray[i].longValue() + " does not equal " + uuid_timer_sorted_arrays[i].longValue(), uuidTimerLongArray[i].equals(uuid_timer_sorted_arrays[i])); } } private void checkUUIDTimerLongArrayForUniqueness(Long[] uuidTimerLongArray) { // here we'll assert that all elements in the list are not equal to // each other (aka, there should be no duplicates) we'll do this by // inserting all elements into a Set and making sure none of them // were already present (add will return false if it was already there) Set set = new HashSet(); for (int i = 0; i < uuidTimerLongArray.length; i++) { assertTrue("Uniqueness test failed on insert into HashSet", set.add(uuidTimerLongArray[i])); assertFalse( "Paranoia Uniqueness test failed (second insert into HashSet)", set.add(uuidTimerLongArray[i])); } } private void checkUUIDTimerLongArrayForCorrectCreationTime( Long[] uuidTimerLongArray, long startTime, long endTime) { // we need to convert from 100-naonsecond units (as used in UUIDs) // to millisecond units as used in UTC based time final long MILLI_CONVERSION_FACTOR = 10000L; // Since System.currentTimeMillis() returns time epoc time // (from 1-Jan-1970), and UUIDs use time from the beginning of // Gregorian calendar (15-Oct-1582) we have a offset for correction final long GREGORIAN_CALENDAR_START_TO_UTC_START_OFFSET = 122192928000000000L; assertTrue("Start time was not before the end time", startTime < endTime); // let's check that all the uuid timer longs in the array have a // timestamp which lands between the start and end time for (int i = 0; i < uuidTimerLongArray.length; i++) { long uuid_time = uuidTimerLongArray[i].longValue(); // first we'll remove the gregorian offset uuid_time -= GREGORIAN_CALENDAR_START_TO_UTC_START_OFFSET; // and convert to milliseconds as the system clock is in millis uuid_time /= MILLI_CONVERSION_FACTOR; // now check that the times are correct assertTrue( "Start time: " + startTime + " was not before UUID timestamp: " + uuid_time, startTime <= uuid_time); assertTrue( "UUID timestamp: " + uuid_time + " was not before the end time: " + endTime, uuid_time <= endTime); } } private void checkUUIDTimerLongArrayForNonNullTimes( Long[] uuidTimerLongArray) { for (int i = 0; i < uuidTimerLongArray.length; i++) { assertFalse("Timer Long was null", 0 == uuidTimerLongArray[i].longValue()); } } private void assertArrayNotEqual(byte[] array1, byte[] array2, int length) { assertTrue("array1 was not equal or longer then length", array1.length >= length); assertTrue("array2 was not equal or longer then length", array2.length >= length); for (int i = 0; i < length; ++i) { // we know the arrays aren't equal the first time we // fine an array element that isn't equal. // in that case just return if (array1[i] != array2[i]) { return; } } // if we get out of the loop, both arrays were identical, so fail fail("All elements of Array1 were equal to all elements of Array2"); } /************************************************************************** * End private helper functions for use in tests *************************************************************************/ }