[DEV] add v1.66.0

libs/uuid/Jamfile

@@ -0,0 +1,24 @@
+#  Boost.Uuid Library Jamfile
+#
+#  Copyright (c) 2017 James E. King, III
+#
+#  Use, modification, and distribution are subject to the
+#  Boost Software License, Version 1.0. (See accompanying file
+#  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+project libs/uuid
+    : requirements
+
+      <warnings>all
+
+      <toolset>clang:<cxxflags>-Wextra
+      <toolset>clang:<cxxflags>-ansi
+      <toolset>clang:<cxxflags>-pedantic
+
+      <toolset>gcc:<cxxflags>-Wextra
+      <toolset>gcc:<cxxflags>-ansi
+      <toolset>gcc:<cxxflags>-pedantic
+    ;
+
+# please order by name to ease maintenance
+build-project test ;

libs/uuid/README.md

@@ -0,0 +1,61 @@
+Uuid, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), provides a C++ wrapper around [RFC-4122](http://www.ietf.org/rfc/rfc4122.txt) UUIDs.
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+
+### Properties
+
+* C++03
+* Header-only
+
+### Build Status
+
+Branch          | Travis | Appveyor | Coverity Scan | codecov.io | Documentation | Regression Tests
+--------------- | ------ | -------- | ------------- | ---------- | ------------- | ----------------
+[master](https://github.com/boostorg/uuid/tree/master) | [![Build Status](https://travis-ci.org/boostorg/uuid.svg?branch=master)](https://travis-ci.org/boostorg/uuid) | [![Build status](https://ci.appveyor.com/api/projects/status/nuihr6s92fjb9gwy/branch/master?svg=true)](https://ci.appveyor.com/project/boostorg/uuid/branch/master) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/13982/badge.svg)](https://scan.coverity.com/projects/boostorg-uuid) | [![codecov](https://codecov.io/gh/boostorg/uuid/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/uuid/branch/master) | [![Documentation](https://img.shields.io/badge/documentation-master-brightgreen.svg)](http://www.boost.org/doc/libs/master/libs/uuid/doc/index.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/uuid.html)
+[develop](https://github.com/boostorg/uuid/tree/develop) | [![Build Status](https://travis-ci.org/boostorg/uuid.svg?branch=develop)](https://travis-ci.org/boostorg/uuid) | [![Build status](https://ci.appveyor.com/api/projects/status/nuihr6s92fjb9gwy/branch/develop?svg=true)](https://ci.appveyor.com/project/boostorg/uuid/branch/develop) | | [![codecov](https://codecov.io/gh/boostorg/uuid/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/uuid/branch/develop) | [![Documentation](https://img.shields.io/badge/documentation-develop-brightgreen.svg)](http://www.boost.org/doc/libs/develop/libs/uuid/doc/index.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/uuid.html)
+
+
+### Directories
+
+* **doc** - Dcumentation
+* **include** - Interface headers of Uuid
+* **test** - Uuid unit tests
+
+### More information
+
+* [Documentation](http://boost.org/libs/uuid)
+* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-uuid)
+* [Report bugs](https://github.com/boostorg/uuid/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
+* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+* Discussions about the library are held on the [Boost developers mailing list](http://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](http://www.boost.org/community/policy.html) before posting and add the `[uuid]` tag at the beginning of the subject line.
+
+### Code Example - UUID Generation
+
+    // Copyright 2017 James E. King, III
+    // Distributed under the Boost Software License, Version 1.0. 
+    // (See http://www.boost.org/LICENSE_1_0.txt)
+    // mkuuid.cpp example
+    
+    #include <boost/lexical_cast.hpp>
+    #include <boost/uuid/random_generator.hpp>
+    #include <boost/uuid/uuid_io.hpp>
+    #include <iostream>
+    
+    int main(void)
+    {
+        boost::uuids::random_generator gen;
+        std::cout << boost::lexical_cast<std::string>(gen()) << std::endl;
+        return 0;
+    }
+    
+    ----
+    
+    $ clang++ -ansi -Wall -Wextra -std=c++03 -O3 mkuuid.cpp -o mkuuid
+    $ ./mkuuid
+    2c186eb0-89cf-4a3c-9b97-86db1670d5f4
+    $ ./mkuuid
+    a9d3fbb9-0383-4389-a8a8-61f6629f90b6
+
+

libs/uuid/ci/build.sh

@@ -0,0 +1,19 @@
+#! /bin/bash
+#
+# Copyright 2017 James E. King, III
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+#      http://www.boost.org/LICENSE_1_0.txt)
+#
+# Bash script to run in travis to perform a bjam build
+# cwd should be $BOOST_ROOT/libs/$SELF before running
+#
+
+# default language level: c++03
+if [[ -z "$CXXSTD" ]]; then
+    CXXSTD=03
+fi
+
+echo "$BOOST_ROOT/b2 . toolset=$TOOLSET cxxstd=$CXXSTD $CXXFLAGS $LINKFLAGS $TESTFLAGS $B2_ADDRESS_MODEL $B2_LINK $B2_THREADING $B2_VARIANT -j3 $*"
+      $BOOST_ROOT/b2 . toolset=$TOOLSET cxxstd=$CXXSTD $CXXFLAGS $LINKFLAGS $TESTFLAGS $B2_ADDRESS_MODEL $B2_LINK $B2_THREADING $B2_VARIANT -j3 $*
+

libs/uuid/ci/codecov.sh

@@ -0,0 +1,44 @@
+#! /bin/bash
+#
+# Copyright 2017 James E. King, III
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+#      http://www.boost.org/LICENSE_1_0.txt)
+#
+# Bash script to run in travis to perform codecov.io integration
+#
+
+###
+### NOTE: Make sure you grab and customize .codecov.yml
+###
+
+# assumes cwd is the top level directory of the boost project
+# assumes an environment variable $SELF is the boost project name
+
+set -ex
+
+B2_VARIANT=debug
+ci/build.sh cxxflags=-fprofile-arcs cxxflags=-ftest-coverage linkflags=-fprofile-arcs linkflags=-ftest-coverage
+
+# switch back to the original source code directory
+# this ensures codecov doesn't get confused
+cd $TRAVIS_BUILD_DIR
+
+# get the version of lcov
+lcov --version
+
+# coverage files are in ../../b2 from this location
+lcov --gcov-tool=gcov-7 --rc lcov_branch_coverage=1 --base-directory `pwd` --directory "$BOOST_ROOT" --capture --output-file all.info
+
+# all.info contains all the coverage info for all projects - limit to ours
+lcov --gcov-tool=gcov-7 --extract all.info "*/boost/$SELF/*" --output-file coverage.info
+
+# dump a summary just for grins
+lcov --gcov-tool=gcov-7 --list coverage.info
+
+#
+# upload to codecov.io
+#
+curl -s https://codecov.io/bash > .codecov
+chmod +x .codecov
+./.codecov -f coverage.info -X gcov -x "gcov-7"

libs/uuid/ci/coverity.sh

@@ -0,0 +1,42 @@
+#! /bin/bash
+#
+# Copyright 2017 James E. King, III
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+#      http://www.boost.org/LICENSE_1_0.txt)
+#
+# Bash script to run in travis to perform a Coverity Scan build
+# To skip the coverity integration download (which is huge) if
+# you already have it from a previous run, add --skipdownload
+#
+
+#
+# Environment Variables
+#
+# COVERITY_SCAN_NOTIFICATION_EMAIL  - email address to notify
+# COVERITY_SCAN_TOKEN               - the Coverity Scan token (should be secure)
+# SELF                              - the boost libs directory name
+
+set -ex
+
+pushd /tmp
+if [[ "$1" != "--skipdownload" ]]; then
+  rm -rf coverity_tool.tgz cov-analysis*
+  wget https://scan.coverity.com/download/linux64 --post-data "token=$COVERITY_SCAN_TOKEN&project=boostorg/$SELF" -O coverity_tool.tgz
+  tar xzf coverity_tool.tgz
+fi
+COVBIN=$(echo $(pwd)/cov-analysis*/bin)
+export PATH=$COVBIN:$PATH
+popd
+
+ci/build.sh clean
+rm -rf cov-int/
+cov-build --dir cov-int ci/build.sh
+tar cJf cov-int.tar.xz cov-int/
+curl --form token="$COVERITY_SCAN_TOKEN" \
+     --form email="$COVERITY_SCAN_NOTIFICATION_EMAIL" \
+     --form file=@cov-int.tar.xz \
+     --form version="$(git describe --tags)" \
+     --form description="boostorg/$SELF" \
+     https://scan.coverity.com/builds?project="boostorg/$SELF"
+

libs/uuid/doc/index.html

@@ -0,0 +1,43 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<title>Boost Uuid Library</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<table border="1" bgcolor="#007F7F" cellpadding="2">
+  <tr>
+    <td bgcolor="#FFFFFF"><img src="../../boost.png" alt="boost.png (6897 bytes)" WIDTH="277" HEIGHT="86"></td>
+    <td><a href="../../index.htm"><font face="Arial" color="#FFFFFF"><big>Home </big></font></a></td>
+    <td><a href="../libraries.htm"><font face="Arial" color="#FFFFFF"><big>Libraries </big></font></a></td>
+    <td><a href="http://www.boost.org/users/people.html"><font face="Arial" color="#FFFFFF"><big>People </big></font></a></td>
+    <td><a href="http://www.boost.org/users/faq.html"><font face="Arial" color="#FFFFFF"><big>FAQ </big></font></a></td>
+    <td><a href="../../more/index.htm"><font face="Arial" color="#FFFFFF"><big>More </big></font></a></td>
+  </tr>
+</table>
+
+<h1>Uuid library</h1>
+
+<p>The header uuid.hpp provides an implementation of Universally Unique Identifiers.
+</p>
+
+<p>This implementation is intended for general use.</p>
+
+<ul>
+  <li><a href="uuid.html">Documentation</a> (HTML).</li>
+  <li>Header <a href="../../boost/uuid/uuid.hpp">uuid.hpp</a>.</li>
+  <li>See the <a href="uuid.html">documentation</a> for links to sample programs.</li>
+  <li>Submitted by Andy Tompkins</a>.</li>
+</ul>
+
+<p>Revised&nbsp; May 14, 2007</p>
+
+<hr>
+<p><EFBFBD> Copyright Andy Tompkins, 2006</p>
+<p> Distributed under the Boost Software 
+License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html>

libs/uuid/doc/uuid.html

@@ -0,0 +1,791 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<title>Uuid Library</title>
+<style type="text/css">
+    pre { margin: 1em; padding: 1em; border: 1px solid #ddd; }
+</style>
+</head>
+<body>
+<h1><img src="../../boost.png" alt="Boost" WIDTH="277" HEIGHT="86">Uuid</h1>
+
+<h2><a name="Contents">Contents</a></h2>
+
+<ol>
+    <li><a href="#Introduction">Introduction</a></li>
+    <li><a href="#Configuration">Configuration</a></li>
+    <li><a href="#Examples">Examples</a></li>
+    <ul>
+        <li><a href="#Tagging">Tagging</a></li>
+        <li><a href="#POD Efficiencies">POD Efficiencies</a></li>
+        <li><a href="#Byte Extraction">Byte Extraction</a></li>
+    </ul
+    <li><a href="#Reference">Reference</a></li>
+    <ul>
+        <li><a href="#boost/uuid/uuid.hpp">boost/uuid/uuid.hpp</a></li>
+        <ul>
+            <li><a href="#Synopsis">Synopsis</a></li>
+            <li><a href="#Size">Size</a></li>
+            <li><a href="#Iteration">Iteration</a></li>
+            <li><a href="#Nil">Nil uuid</a></li>
+            <li><a href="#Variant">Variant</a></li>
+            <li><a href="#Version">Version</a></li>
+            <li><a href="#Swap">Swap</a></li>
+            <li><a href="#Operators">Operators</a></li>
+            <li><a href="#Hash">Hash</a></li>
+        </ul>
+        <li><a href="#boost/uuid/uuid_generators.hpp">boost/uuid/uuid_generators.hpp</a></li>
+        <ul>
+            <li><a href="#Synopsis_generators">Synopsis</a></li>
+        </ul>
+        <li><a href="#boost/uuid/nil_generator.hpp">boost/uuid/nil_generator.hpp</a></li>
+        <ul>
+            <li><a href="#Synopsis_nil_generator">Synopsis</a></li>
+            <li><a href="#Nil Generator">Nil Generator</a></li>
+        </ul>
+        <li><a href="#boost/uuid/string_generator.hpp">boost/uuid/string_generator.hpp</a></li>
+        <ul>
+            <li><a href="#Synopsis_string_generator">Synopsis</a></li>
+            <li><a href="#String Generator">String Generator</a></li>
+        </ul>
+        <li><a href="#boost/uuid/name_generator.hpp">boost/uuid/name_generator.hpp</a></li>
+        <ul>
+            <li><a href="#Synopsis_name_generator">Synopsis</a></li>
+            <li><a href="#Name Generator">Name Generator</a></li>
+        </ul>
+        <li><a href="#boost/uuid/random_generator.hpp">boost/uuid/random_generator.hpp</a></li>
+        <ul>
+            <li><a href="#Synopsis_random_generator">Synopsis</a></li>
+            <li><a href="#Random Generator">Random Generator</a></li>
+        </ul>
+        <li><a href="#boost/uuid/uuid_io.hpp">boost/uuid/uuid_io.hpp</a></li>
+        <ul>
+            <li><a href="#Synopsis_io">Synopsis</a></li>
+            <li><a href="#Stream_operators">Stream Operators</a></li>
+            <li><a href="#to_string">To String</a></li>
+        </ul>
+        <li><a href="#boost/uuid/uuid_serialize.hpp">boost/uuid/uuid_serialize.hpp</a></li>
+        <ul>
+            <li><a href="#Synopsis_serialize">Synopsis</a></li>
+            <li><a href="#Serialization">Serialization</a></li>
+        </ul>
+    </ul>
+    <li><a href="#Concepts">Concepts</a></li>
+    <ul>
+        <li><a href="#Concept:NameHashProvider">NameHashProvider</a></li>
+    </ul>
+    <li><a href="#Design notes">Design notes</a></li>
+    <li><a href="#History and Acknowledgements">History and Acknowledgements</a></li>
+</ol>
+
+<h2><a name="Introduction">Introduction</a></h2>
+<p>
+A UUID, or Universally unique identifier, is intended to uniquely identify
+information in a distributed environment without significant central
+coordination.  It can be used to tag objects with very short lifetimes, or
+to reliably identify very persistent objects across a network.
+<p>
+A formal definition for UUID can be found in <A HREF="https://www.ietf.org/rfc/rfc4122.txt">RFC 4122</A>.
+<p>
+UUIDs have many applications.  Some examples follow:  Databases may use UUIDs
+to identify rows or records in order to ensure that they are unique across
+different databases, or for publication/subscription services.  Network messages
+may be identified with a UUID to ensure that different parts of a message are put
+back together again.  Distributed computing may use UUIDs to identify a remote
+procedure call.  Transactions and classes involved in serialization may be
+identified by UUIDs.  Microsoft's component object model (COM) uses UUIDs to
+distinguish different software component interfaces.  UUIDs are inserted into
+documents from Microsoft Office programs.  UUIDs identify audio or
+video streams in the Advanced Systems Format (ASF).  UUIDs are also a basis
+for OIDs (object identifiers), and URNs (uniform resource name).
+
+<p>
+An attractive feature of UUIDs when compared to alternatives is their relative
+small size, of 128-bits, or 16-bytes.  Another is that the creation of UUIDs
+does not require a centralized authority.
+
+<p>When UUIDs are generated by one of the defined
+mechanisms, they are either guaranteed to be unique, different from all other
+generated UUIDs (that is, it has never been generated before and it will
+never be generated again), or it is extremely likely to be unique (depending
+on the mechanism).
+
+<h2><a name="Configuration">Configuration</a></h2>
+
+<p>
+The library does not require building or any special configuration to be used.
+However, there are a few options that can be enabled by defining macros prior to
+including library headers. These macros are summarized in the following table.
+
+<p>
+<table border="1">
+<tr>
+<th>Macro</th><th>Description</th>
+</tr>
+<tr>
+<td><tt>BOOST_UUID_NO_SIMD</tt></td><td>If defined, disables any optimizations for <a href="http://en.wikipedia.org/wiki/SIMD">SIMD</a>-enabled processors. Generic versions of algorithms will be used instead. This may result in suboptimal performance. By default, optimized algorithms are used, when the library is able to detect the availability of SIMD extensions at compile time.</td>
+</tr>
+<tr>
+<td><tt>BOOST_UUID_USE_SSE2</tt></td><td>If defined, enables optimizations for <a href="http://en.wikipedia.org/wiki/SSE2">SSE2</a> exstensions available in modern x86 processors.</td>
+</tr>
+<tr>
+<td><tt>BOOST_UUID_USE_SSE3</tt></td><td>If defined, enables optimizations for <a href="http://en.wikipedia.org/wiki/SSE3">SSE3</a> exstensions available in modern x86 processors.</td>
+</tr>
+<tr>
+<td><tt>BOOST_UUID_USE_SSE41</tt></td><td>If defined, enables optimizations for <a href="http://en.wikipedia.org/wiki/SSE4#SSE4.1">SSE4.1</a> exstensions available in modern x86 processors.</td>
+</tr>
+</table>
+
+<p>
+By default the library attempts to detect the availability of SIMD extensions in the target CPU at compile time and automatically defines the appropriate macros if succeeded. The <tt>BOOST_UUID_USE_SSE*</tt> macros can be defined by users, if auto-detection fails and it is known that the target CPU will have the extension. Do not enable these extensions unless you're certain that they will always be available on any machine that will run your program. The library performs no run time checks, so if an extension is missing, the program will likely crash. Note that enabling more advanced extensions implies that more basic ones are also available.
+
+<h2><a name="Examples">Examples</a></h2>
+<h3><a name="Tagging">Tagging</a></h3>
+<pre>
+// example of tagging an object with a uuid
+// see <a href="./test/test_tagging.cpp"><tt>boost/libs/uuid/test/test_tagging.cpp</tt></a>
+
+#include &lt;<a href="./../../boost/uuid/uuid.hpp"><tt>boost/uuid/uuid.hpp</tt></a>&gt;
+#include &lt;<a href="./../../boost/uuid/uuid_generators.hpp"><tt>boost/uuid/uuid_generators.hpp</tt></a>&gt;
+
+class object
+{
+public:
+    object()
+        : tag(boost::uuids::random_generator()())
+        , state(0)
+    {}
+
+    explicit object(int state)
+        : tag(boost::uuids::random_generator()())
+        , state(state)
+    {}
+
+    object(object const&amp; rhs)
+        : tag(rhs.tag)
+        , state(rhs.state)
+    {}
+
+    bool operator==(object const&amp; rhs) const {
+        return tag == rhs.tag;
+    }
+
+    object&amp; operator=(object const&amp; rhs) {
+        tag = rhs.tag;
+        state = rhs.state;
+    }
+
+    int get_state() const { return state; }
+    void set_state(int new_state) { state = new_state; }
+
+private:
+    boost::uuids::uuid tag;
+
+    int state;
+};
+
+object o1(1);
+object o2 = o1;
+o2.set_state(2);
+assert(o1 == o2);
+
+object o3(3);
+assert(o1 != o3);
+assert(o2 != o3);
+</pre>
+
+<h3><a name="POD Efficiencies">POD Efficiencies</a></h3>
+<p>
+This library implements a UUID as a POD allowing a UUID
+to be used in the most efficient ways, including using memcpy,
+and aggregate initializers.  A drawback is that a POD can
+not have any constructors, and thus declaring a UUID will not
+initialize it to a value generated by one of the defined
+mechanisms.  But a class based on a UUID can be defined
+that does initialize itself to a value generated by one of
+the defined mechanisms.
+<p>
+Note that <tt>boost::is_pod</tt> is specialized for <tt>boost::uuids::uuid</tt>
+and depends on <a href="http://www.boost.org/libs/type_traits">Boost.TypeTraits</a>.
+Define <tt>BOOST_UUID_NO_TYPE_TRAITS</tt> before including <a href="./../../boost/uuid/uuid.hpp"><tt>boost/uuid/uuid.hpp</tt></a>
+to remove the dependency on <a href="http://www.boost.org/libs/type_traits">Boost.TypeTraits</a>.
+<pre>
+// example using memcpy and aggregate initializers
+// example of a class uuid see <a href="./test/test_uuid_class.cpp"><tt>boost/libs/uuid/test/test_uuid_class.cpp</tt></a>
+
+#include &lt;<a href="./../../boost/uuid/uuid.hpp"><tt>boost/uuid/uuid.hpp</tt></a>&gt;
+#include &lt;<a href="./../../boost/uuid/uuid_generators.hpp"><tt>boost/uuid/uuid_generators.hpp</tt></a>&gt;
+
+{ // example using memcpy
+    unsigned char uuid_data[16];
+    // fill uuid_data
+
+    boost::uuids::uuid u;
+
+    memcpy(&amp;u, uuid_data, 16);
+}
+
+{ // example using aggregate initializers
+    boost::uuids::uuid u =
+    { 0x12 ,0x34, 0x56, 0x78
+    , 0x90, 0xab
+    , 0xcd, 0xef
+    , 0x12, 0x34
+    , 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef
+    };
+}
+
+// example of creating a uuid class that
+// initializes the uuid in the constructor
+// using a defined mechanism
+
+class uuid_class : public boost::uuids::uuid
+{
+public:
+    uuid_class()
+        : boost::uuids::uuid(boost::uuids::random_generator()())
+    {}
+
+    explicit uuid_class(boost::uuids::uuid const&amp; u)
+        : boost::uuids::uuid(u)
+    {}
+
+    operator boost::uuids::uuid() {
+        return static_cast&lt;boost::uuids::uuid&amp;&gt;(*this);
+    }
+
+    operator boost::uuids::uuid() const {
+        return static_cast&lt;boost::uuids::uuid const&amp;&gt;(*this);
+    }
+};
+
+uuid_class u1;
+uuid_class u2;
+
+assert(u1 != u2);
+</pre>
+
+<h3><a name="Byte Extraction">Byte Extraction</a></h3>
+<p>It is sometimes useful to get at the 16 bytes of a <b>uuid</b> directly.
+Typical use is as follows:
+
+<pre>
+boost::uuids::uuid u;
+std::vector&lt;uint8_t&gt; v(u.size());
+std::copy(u.begin(), u.end(), v.begin());
+</pre>
+
+<p>Note: <tt>boost::uuids::uuid::size()</tt> always returns 16.
+
+<h2><a name="Reference">Reference</a></h2>
+<h3><a name="boost/uuid/uuid.hpp" href="./../../boost/uuid/uuid.hpp">boost/uuid/uuid.hpp</a></h3>
+<h4><a name="Synopsis">Synopsis</a></h4>
+<pre>
+namespace boost {
+namespace uuids {
+
+class uuid {
+public:
+    typedef uint8_t value_type;
+    typedef uint8_t&amp; reference;
+    typedef uint8_t const&amp; const_reference;
+    typedef uint8_t* iterator;
+    typedef uint8_t const* const_iterator;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    static constexpr size_type static_size() noexcept;
+
+    // iteration
+    iterator begin() noexcept;
+    iterator end() noexcept;
+    const_iterator begin() const noexcept;
+    const_iterator end() const noexcept;
+
+    constexpr size_type size() const noexcept;
+
+    bool is_nil() const noexcept;
+
+    enum variant_type {
+        variant_ncs, // NCS backward compatibility
+        variant_rfc_4122, // defined in RFC 4122 document
+        variant_microsoft, // Microsoft Corporation backward compatibility
+        variant_future // future definition
+    };
+    variant_type variant() const noexcept;
+
+    enum version_type {
+        version_unknown = -1,
+        version_time_based = 1,
+        version_dce_security = 2,
+        version_name_based_md5 = 3,
+        version_random_number_based = 4,
+        version_name_based_sha1 = 5
+    };
+    version_type version() const noexcept;
+
+    // Swap function
+    void swap(uuid&amp; rhs) noexcept;
+
+    uint8_t data[static_size()];
+};
+
+// standard operators
+bool operator==(uuid const&amp; lhs, uuid const&amp; rhs) noexcept;
+bool operator!=(uuid const&amp; lhs, uuid const&amp; rhs) noexcept;
+bool operator&lt;(uuid const&amp; lhs, uuid const&amp; rhs) noexcept;
+bool operator&gt;(uuid const&amp; lhs, uuid const&amp; rhs) noexcept;
+bool operator&lt;=(uuid const&amp; lhs, uuid const&amp; rhs) noexcept;
+bool operator&gt;=(uuid const&amp; lhs, uuid const&amp; rhs) noexcept;
+
+void swap(uuid&amp; lhs, uuid&amp; rhs) noexcept;
+
+std::size_t hash_value(uuid const&amp; u) noexcept;
+
+}} // namespace boost::uuids
+</pre>
+
+<h4><a name="Size">Size</a></h4>
+
+<p>The size of a <b>uuid</b> (in bytes) can be obtained either by
+calling the function <tt>boost::uuids::uuid::size()</tt> or by
+calling the static function <tt>boost::uuids::uuid::static_size()</tt>,
+both always return 16.
+<pre>
+    boost::uuids::uuid u;
+    assert(16 == u.size());
+    assert(16 == boost::uuids::uuid::static_size());
+</pre>
+
+<h4><a name="Iteration">Iteration</a></h4>
+
+<p>Both iterators and constant iterators are provided.
+<pre>
+    boost::uuids::uuid u;
+    for (boost::uuids::uuid::const_iterator it=u.begin(); it!=u.end(); ++it) {
+        boost::uuids::uuid::value_type v = *it;
+    }
+    for (boost::uuids::uuid::iterator it=u.begin(); it!=u.end(); ++it) {
+        *it = 0;
+    }
+</pre>
+
+<h4><a name="Nil">Nil uuid</a></h4>
+<p>The function, <tt>boost::uuids::uuid::is_nil()</tt> returns true if and
+only if the <b>uuid</b> is equal to {00000000-0000-0000-0000-000000000000}.
+</p>
+
+<h4><a name="Variant">Variant</a></h4>
+<p>Three bits of a <b>uuid</b> determine the variant.</p>
+<pre>
+    boost::uuids::uuid u;
+    boost::uuids::uuid::variant_type v = u.variant();
+</pre>
+
+<h4><a name="Version">Version</a></h4>
+<p>Four bits of a <b>uuid</b> determine the variant, that is the mechanism
+used to generate the <b>uuid</b>.
+</p>
+<pre>
+    boost::uuids::uuid u;
+    boost::uuids::uuid::version_type v = u.version();
+</pre>
+
+<h4><a name="Swap">Swap</a></h4>
+<p>Both <tt>boost::uuids::uuid::swap()</tt> and <tt>boost::uuids::swap()</tt>
+are provided.
+</p>
+<pre>
+    boost::uuids::uuid u1, u2;
+    u1.swap(u2);
+    swap(u1, u2);
+</pre>
+
+<h4><a name="Operators">Operators</a></h4>
+<p>
+All of the standard numeric operators are defined for the <b>uuid</b>
+class. These include:
+<pre>
+    operator==
+    operator!=
+    operator&lt;
+    operator&gt;
+    operator&lt;=
+    operator&gt;=
+</pre>
+
+<h4><a name="Hash">Hash Function</a></h4>
+<p>
+This function allows <b>uuid</b>s to be used with
+<a href="http://www.boost.org/doc/html/hash.html"><b>boost::hash</b></a>
+
+<pre>
+boost::hash&lt;boost::uuids::uuid&gt; uuid_hasher;
+std::size_t uuid_hash_value = uuid_hasher(boost::uuids::uuid());
+</pre>
+
+<h3><a name="boost/uuid/uuid_generators.hpp" href="./../../boost/uuid/uuid_generators.hpp">boost/uuid/uuid_generators.hpp</a></h3>
+<h4><a name="Synopsis_generators">Synopsis</a></h4>
+This file includes all the <b>uuid</b> generators for convenience.
+<pre>
+#include &lt;<a href="./../../boost/uuid/nil_generator.hpp"><tt>boost/uuid/nil_generator.hpp</tt></a>&gt;
+#include &lt;<a href="./../../boost/uuid/string_generator.hpp"><tt>boost/uuid/string_generator.hpp</tt></a>&gt;
+#include &lt;<a href="./../../boost/uuid/name_generator.hpp"><tt>boost/uuid/name_generator.hpp</tt></a>&gt;
+#include &lt;<a href="./../../boost/uuid/random_generator.hpp"><tt>boost/uuid/random_generator.hpp</tt></a>&gt;
+</pre>
+
+<h3><a name="boost/uuid/nil_generator.hpp" href="./../../boost/uuid/nil_generator.hpp">boost/uuid/nil_generator.hpp</a></h3>
+<h4><a name="Synopsis_nil_generator">Synopsis</a></h4>
+<pre>
+namespace boost {
+namespace uuids {
+
+struct nil_generator {
+    typedef uuid result_type;
+
+    uuid operator()() const;
+};
+uuid nil_uuid();
+
+}} //namespace boost::uuids
+</pre>
+
+<h4><a name="Nil Generator">Nil Generator</a></h4>
+<p>The <tt>boost::uuids::nil_generator</tt> class always generates a nil <b>uuid</b>.
+<pre>
+boost::uuids::nil_generator gen;
+boost::uuids::uuid u = gen();
+assert(u.is_nil() == true);
+
+// or for convenience
+boost::uuids::uuid u = boost::uuids::nil_uuid();
+assert(u.is_nil() == true);
+</pre>
+
+<h3><a name="boost/uuid/string_generator.hpp" href="./../../boost/uuid/string_generator.hpp">boost/uuid/string_generator.hpp</a></h3>
+<h4><a name="Synopsis_string_generator">Synopsis</a></h4>
+
+<pre>
+namespace boost {
+namespace uuids {
+
+struct string_generator {
+    typedef uuid result_type;
+
+    template &lt;typename ch, typename char_traits, typename alloc&gt;
+        uuid operator()(std::basic_string&lt;ch, char_traits, alloc&gt; const&amp; s) const;
+};
+
+}} //namespace boost::uuids
+</pre>
+
+<h4><a name="String Generator">String Generator</a></h4>
+<p>The <tt>boost::uuids::string_generator</tt> class generates a <b>uuid</b> from a string.  In addition to the standards-defined string
+format in <A HREF="https://www.ietf.org/rfc/rfc4122.txt">RFC 4122</A> (p. 3), the string generator accepts a few variants.  Valid strings
+match the following PCRE regular expression:
+<pre>
+^({)?([0-9a-fA-F]{8})(?<DASH>-)?([0-9a-fA-F]{4})(?(DASH)-)([0-9a-fA-F]{4})(?(DASH)-)([0-9a-fA-F]{4})(?(DASH)-)([0-9a-fA-F]{12})(?(1)})$
+</pre>
+Or more generally, the following formats are accepted as valid string formats, where <tt>h</tt> is hexadecimal, without case sensitivity, and without any leading or trailing whitespace:
+<pre>
+hhhhhhhh-hhhh-hhhh-hhhh-hhhhhhhhhhhh
+{hhhhhhhh-hhhh-hhhh-hhhh-hhhhhhhhhhhh}
+hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
+{hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh}
+</pre>
+For example:
+<pre>
+boost::uuids::string_generator gen;
+boost::uuids::uuid u1 = gen("{01234567-89ab-cdef-0123-456789abcdef}");
+boost::uuids::uuid u2 = gen(L"01234567-89ab-cdef-0123-456789abcdef");
+boost::uuids::uuid u3 = gen(std::string("0123456789abcdef0123456789abcdef"));
+boost::uuids::uuid u4 = gen(std::wstring(L"01234567-89AB-CDEF-0123-456789ABCDEF"));
+</pre>
+Invalid input will generate a <tt>std::runtime_error</tt> exception.
+
+<h3><a name="boost/uuid/name_generator.hpp" href="./../../boost/uuid/name_generator.hpp">boost/uuid/name_generator.hpp</a></h3>
+<h4><a name="Synopsis_name_generator">Synopsis</a></h4>
+
+<pre>
+namespace boost {
+namespace uuids {
+
+template&lt;class NameHashProvider&gt;
+class basic_name_generator {
+public:
+    typedef uuid result_type;
+
+    explicit basic_name_generator(uuid const&amp; namespace_uuid);
+
+    uuid operator()(const char* name) const;
+    uuid operator()(const wchar_t* name) const;
+    tempate &lt;typename ch, typename char_traits, typename alloc&gt;
+        uuid operator()(std::basic_string&lt;ch, char_traits, alloc&gt; const&amp; name) const;
+    uuid operator()(void const* buffer, std::size_t byte_count) const;
+};
+
+typedef basic_name_generator&lt;detail::md5&gt; name_generator_md5;
+typedef basic_name_generator&lt;detail::sha1&gt; name_generator_sha1;
+typedef name_generator_sha1 name_generator; // deprecated
+typedef name_generator_sha1 name_generator_latest;
+
+}} //namespace boost::uuids
+</pre>
+
+<h4><a name="Name Generator">Name Generator</a></h4>
+<p>
+RFC 4122 specifies that a name-based <b>uuid</b> is derived from content in
+a namespace.  A <b>uuid</b> with identical content in an identical namespace shall
+yield the same <b>uuid</b> as long as the same hasing algorithm is used.
+<h5>Hashing Algorithms</h5>
+RFC 4122 defines two hashing mechanisms for <b>uuid</b> generation:
+<ul>
+<li>MD5</li>
+<li>SHA1</li>
+</ul>
+Since RFC 4122 was written, both of these hash algorithms have been rendered
+insecure.  In anticipation of a new RFC for <b>uuid</b> arriving,
+<tt>name_generator</tt> has been deprecated, and replaced with:
+<ul>
+<li><tt>boost::uuids::name_generator_latest</tt></li>
+<li><tt>boost::uuids::name_generator_md5</tt></li>
+<li><tt>boost::uuids::name_generator_sha1</tt></li>
+</ul>
+<tt>name_generator</tt>, while deprecated, remains a type alias for
+<tt>name_generator_sha1</tt> so the behavior is identical to previous
+releases.  When the successor to SHA1 is chosen,
+it will be implemented under a new name similar to those above.
+If your application does not rely on stable hashing over time, you can
+use <tt>name_generator_latest</tt> to always use the latest hashing
+algorithm available.
+</p>
+<p>Consumers are free to use their own hash provider as long as it satisfies the
+<tt><A href="#Concept:NameHashProvider">NameHashProvider</A></tt> concept.
+<h5>Namespaces</h5>
+There are four well-known namespaces defined in
+<A HREF="https://tools.ietf.org/html/rfc4122#appendix-C">RFC 4122, Appendix C</A> which
+are defined as:
+<pre>
+boost::uuids::ns::dns()     // == {6ba7b810-9dad-11d1-80b4-00c04fd430c8}
+boost::uuids::ns::url()     // == {6ba7b811-9dad-11d1-80b4-00c04fd430c8}
+boost::uuids::ns::oid()     // == {6ba7b812-9dad-11d1-80b4-00c04fd430c8}
+boost::uuids::ns::x500dn()  // == {6ba7b814-9dad-11d1-80b4-00c04fd430c8}
+</pre>
+of course, you are free to use your own namespace if you prefer.  Here is an
+example of name generator usage:
+<pre>
+boost::uuids::name_generator_sha1 gen(boost::uuids::ns::dns());
+boost::uuids::uuid udoc = gen("boost.org");
+std::cout << "boost.org uuid in dns namespace, sha1 version: " << udoc << std::endl;
+</pre>
+produces the output:
+<pre>
+boost.org uuid in dns namespace, sha1 version: 0043f363-bbb4-5369-840a-322df6ec1926
+</pre>
+
+<h3><a name="boost/uuid/random_generator.hpp" href="./../../boost/uuid/random_generator.hpp">boost/uuid/random_generator.hpp</a></h3>
+<h4><a name="Synopsis_random_generator">Synopsis</a></h4>
+
+<pre>
+namespace boost {
+namespace uuids {
+
+template &lt;typename UniformRandomNumberGenerator&gt;
+class basic_random_generator {
+public:
+    typedef uuid result_type;
+
+    basic_random_generator();
+    explicit basic_random_generator(UniformRandomNumberGenerator&amp; gen);
+    explicit basic_random_generator(UniformRandomNumberGenerator* pGen);
+
+    uuid operator()();
+};
+typedef basic_random_generator&lt;mt19937&gt; random_generator;
+
+}} // namespace boost::uuids
+</pre>
+
+<h4><a name="Random Generator">Random Generator</a></h4>
+<p>
+The <tt>boost::uuids::basic_random_generator</tt> class generates a random number
+based uuid from a random number generator (one that conforms to the
+<a href="http://www.boost.org/libs/random/random-concepts.html#uniform-rng">UniformRandomNumberGenerator</a>
+concept).
+<pre>
+//default construct the random number generator and seed it
+boost::uuids::basic_random_generator&lt;boost::mt19937&gt; gen;
+boost::uuids::uuid u = gen();
+
+//for convenience boost::uuids::random_generator
+//is equivalent to boost::uuids::basic_random_generator&lt;boost::mt19937&gt;
+boost::uuids::random_generator gen;
+boost::uuids::uuid u = gen();
+
+//use an existing random number generator
+//pass either a reference or a pointer to the random number generator
+boost::mt19937 ran;
+boost::uuids::basic_random_generator&lt;boost::mt19937&gt; gen(&amp;ran);
+boost::uuids::uuid u = gen();
+</pre>
+
+<h3><a name="boost/uuid/uuid_io.hpp" href="./../../boost/uuid/uuid_io.hpp">boost/uuid/uuid_io.hpp</a></h3>
+<h4><a name="Synopsis_io">Synopsis</a></h4>
+<pre>
+namespace boost {
+namespace uuids {
+
+template &lt;typename ch, typename char_traits&gt;
+    std::basic_ostream&lt;ch, char_traits&gt;&amp; operator&lt;&lt;(std::basic_ostream&lt;ch, char_traits&gt; &amp;os, uuid const&amp; u);
+
+template &lt;typename ch, typename char_traits&gt;
+    std::basic_istream&lt;ch, char_traits&gt;&amp; operator&gt;&gt;(std::basic_istream&lt;ch, char_traits&gt; &amp;is, uuid &amp;u);
+
+std::string to_string(uuid const&amp; u);
+std::wstring to_wstring(uuid const&amp; u);
+
+}} // namespace boost::uuids
+</pre>
+
+<h4><a name="Stream_operators">Stream Operators</a></h4>
+<p>
+The standard input and output stream operators <tt>&lt;&lt;</tt> and <tt>&gt;&gt;</tt>
+are provided by including <a href="../../boost/uuid/uuid_io.hpp"><tt>boost/uuid/uuid_io.hpp</tt></a>.
+The string representation of a <b>uuid</b> is <tt>hhhhhhhh-hhhh-hhhh-hhhh-hhhhhhhhhhhh</tt>
+where <tt>h</tt> is hexadecimal.
+<pre>
+boost::uuids::uuid u1; // initialize uuid
+
+std::stringstream ss;
+ss &lt;&lt; u1;
+
+boost::uuids::uuid u2;
+ss &gt;&gt; u2;
+
+assert(u1, u2);
+</pre>
+
+<p>
+One can also use <a href="http://www.boost.org/libs/conversion/lexical_cast.htm"><tt>boost::lexical_cast</tt></a>.
+<pre>
+boost::uuids::uuid u1; // initialize uuid
+
+std::string s = boost::lexical_cast&lt;std::string&gt;(u);
+boost::uuids::uuid u2 = boost::lexical_cast&lt;boost::uuids::uuid&gt;(s);
+
+assert(u1 == u2);
+</pre>
+
+<h4><a name="to_string">To String</a></h4>
+<p>
+The functions <tt>to_string</tt> and <tt>to_wstring</tt> are provided as a
+convenience to convert a <b>uuid</b> to a string.  They are also likely faster than
+the stream operators or using <a href="http://www.boost.org/libs/conversion/lexical_cast.htm"><tt>boost::lexical_cast</tt></a>.
+<pre>
+boost::uuids::uuid u; // initialize uuid
+
+std::string s1 = to_string(u);
+
+std::wstring s2 = to_wstring(u);
+</pre>
+
+<h3><a name="boost/uuid/uuid_serialize.hpp" href="./../../boost/uuid/uuid_serialize.hpp">boost/uuid/uuid_serialize.hpp</a></h3>
+<h4><a name="Synopsis_serialize">Synopsis</a></h4>
+<pre>
+namespace boost {
+namespace uuids {
+
+BOOST_CLASS_IMPLEMENTATION(boost::uuids::uuid, boost::serialization::primitive_type)
+
+}} // namespace boost::uuids
+</pre>
+
+<h4><a name="Serialization">Serialization</a></h4>
+<p>
+Serialization is accomplished with the <a href="http://www.boost.org/libs/serialization/doc/index.html">
+Boost Serialization</a> library.  A <b>uuid</b> is serialized as a
+<a href="http://www.boost.org/libs/serialization/doc/serialization.html#primitiveoperators">
+primitive type</a>, thus only the <b>uuid</b> value will be saved to/loaded from an archive.
+<p>
+Include <a href="../../boost/uuid/uuid_serialize.hpp"><tt>boost/uuid/uuid_serialize.hpp</tt></a> to enable serialization for <b>uuid</b>s.
+
+<h2><A name="Concepts">Concepts</a></h2>
+This section describes all of the concepts defined by the library.
+<h3><a name="Concept:NameHashProvider">NameHashProvider</a></h3>
+A NameHashProvder type is supplied as a template argument to the <tt>basic_name_generator</tt> class.  It provides
+the hashing function that the name generator uses to generate a <b>uuid</b>.
+<h4>Requirements</h4>
+In this table, <i>G</i> is a type meeting the requirements of NameHashProvider:
+<p><center><table width="85%" summary="Valid expressions">
+<thead>
+<tr bgcolor="lightgray">
+    <th>Expression</th>
+    <th>Semantics, Pre/Post-conditions</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+    <td><tt>typedef G::digest_type</tt></td>
+    <td>A type definition of contiguous raw storage at least 16 bytes in length.</td>
+</tr>
+<tr>
+    <td><tt>void G::process_byte(unsigned char)</tt></td>
+    <td></td>
+</tr>
+<tr>
+    <td><tt>void G::process_bytes(void const*, std::size_t)</tt></td>
+    <td></td>
+</tr>
+<tr>
+    <td><tt>void G::get_digest(typename G::digest_type&amp;)</tt></td>
+    <td>Copies the digest into the supplied parameter.  Called once.</td>
+</tr>
+<tr>
+    <td><tt>unsigned char G::get_version() const</tt></td>
+    <td>Returns the RFC 4122 version for the hashing algorithm (4 bits) in 0x07.</td>
+</tr>
+</tbody>
+</table>
+</center></p>
+<h2><a name="Design notes">Design notes</a></h2>
+<p>
+The document, <a href="http://www.itu.int/ITU-T/studygroups/com17/oid/X.667-E.pdf">
+http://www.itu.int/ITU-T/studygroups/com17/oid/X.667-E.pdf</a>, was used to design
+and implement the <b>boost::uuids::uuid</b> struct.
+
+<p>The <tt>boost::uuids::basic_random_generator</tt> class' default constructor
+seeds the random number generator with a SHA-1 hash of a number of different
+values including <tt>std::time(0)</tt>, <tt>std::clock()</tt>, uninitialized
+data, value return from <tt>new unsigned int</tt>, etc..
+
+<p>Using <a href="http://valgrind.org/">Valgrind</a> produces a number of false
+positives with the default constructor of <tt>boost::uuids::basic_random_generator</tt>.
+One solution is to suppress the errors as described in
+<a href="http://valgrind.org/docs/manual/manual-core.html#manual-core.suppress">Valgrind's documentation</a>.
+Another solution is to use a different constructor of <tt>boost::uuids::basic_random_generator</tt>
+and explicitly pass in a random number generator.
+<pre>
+boost::mt19937 ran;
+ran.seed(time(NULL)); // one should likely seed in a better way
+boost::uuids::basic_random_generator&lt;boost::mt19937&gt; gen(&ran);
+boost::uuids::uuid u = gen();
+</pre>
+
+<p>All functions are re-entrant.  Classes are as thread-safe as an int.  That is an
+instance can not be shared between threads without proper synchronization.
+
+<h2><a name="History and Acknowledgements">History and Acknowledgements</a></h2>
+<p>
+A number of people on the <a href="http://www.boost.org/">boost.org</a>
+mailing list provided useful comments and greatly helped to shape the library.
+
+<p>Revised September 26, 2017</p>
+
+<hr>
+<p><EFBFBD> Copyright Andy Tompkins, 2006</p>
+<p><EFBFBD> Copyright James E. King, III - 2017</p>
+<p> Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html>

libs/uuid/index.html

@@ -0,0 +1,13 @@
+<!-- Copyright (c) 2002-2003 William E. Kempf.
+     Subject to the Boost Software License, Version 1.0. 
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
+-->
+
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=doc/index.html">
+</head>
+<body>
+Automatic redirection failed, please go to <a href="doc/index.html">doc/index.html</a>
+</body>
+</html>

libs/uuid/meta/libraries.json

@@ -0,0 +1,16 @@
+{
+    "key": "uuid",
+    "name": "Uuid",
+    "authors": [
+        "Andy Tompkins"
+    ],
+    "description": "A universally unique identifier.",
+    "category": [
+        "Data",
+        "Domain"
+    ],
+    "maintainers": [
+        "Andy Tompkins <atompkins -at- fastmail.fm>",
+        "Jim King <jking -at - apache.org>"
+    ]
+}

libs/uuid/test/Jamfile.v2

@@ -0,0 +1,104 @@
+# Copyright 2007 Andy Tompkins.
+# Copyright 2017 James E. King, III
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+project libs/uuid/test
+    : requirements
+
+      # boost::random requires this setting for a warning free build:
+      <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+
+    ;
+
+import path ;
+import regex ;
+import testing ;
+
+# this rule enumerates through all the headers and ensures
+# that inclusion of the header by itself is sufficient to
+# compile successfully, proving the header does not depend
+# on any other headers to be included first - adapted from
+# logic in the winapi test bjam script
+rule test_all
+{
+    local all_rules = ;
+    local file ;
+    local headers_path = [ path.make $(BOOST_ROOT)/libs/uuid/include/boost/uuid ] ;
+    for file in [ path.glob-tree $(headers_path) : *.hpp : uuid ]
+    {
+        local rel_file = [ path.relative-to $(headers_path) $(file) ] ;
+        # Note: The test name starts with '~' in order to group these tests in the test report table, preferably at the end.
+        #       All '/' are replaced with '-' because apparently test scripts have a problem with test names containing slashes.
+        local test_name = [ regex.replace $(rel_file) "/" "-" ] ;
+        local decl_test_name = ~hdr-decl-$(test_name) ;
+        # ECHO $(rel_file) ;
+        all_rules += [ compile compile/decl_header.cpp : <define>"BOOST_UUID_TEST_HEADER=$(rel_file)" <dependency>$(file) : $(decl_test_name) ] ;
+    }
+
+    # make sure compile time options work in isolation
+    all_rules += [ compile compile/decl_header.cpp :
+        <define>"BOOST_UUID_TEST_HEADER=uuid.hpp"
+        <define>"BOOST_UUID_NO_TYPE_TRAITS"
+        <dependency>../include/boost/uuid/uuid.hpp :
+            compile_uuid_no_type_traits ] ;
+    all_rules += [ compile compile/decl_header.cpp :
+        <define>"BOOST_UUID_TEST_HEADER=uuid.hpp"
+        <define>"BOOST_UUID_NO_SIMD"
+        <dependency>../include/boost/uuid/uuid.hpp :
+            compile_uuid_no_simd ] ;
+
+    # ECHO All rules: $(all_rules) ;
+    return $(all_rules) ;
+}
+
+test-suite uuid :
+    [ test_all ]
+
+    # test inclucing all .hpp files in 2 translations units
+    # to look for issues when using multiple translation units
+    # eg. missing inline on a global functionstate is not missing
+    [ run test_include1.cpp test_include2.cpp ]
+
+    # main test
+    [ run test_uuid.cpp ]
+    [ run test_uuid_no_simd.cpp ]
+
+    # test uuid_io.hpp
+    [ run test_io.cpp ]
+
+    # test generators
+    [ run test_nil_generator.cpp ]
+    [ run test_name_generator.cpp ]
+    [ run test_string_generator.cpp ]
+    [ run test_random_generator.cpp ../../random/build//boost_random ]
+    # link to boost::random required for the test that uses random_device
+
+    # test tagging an object
+    [ run test_tagging.cpp ]
+
+    # test use cases
+    [ run test_uuid_class.cpp ]
+    [ run test_uuid_in_map.cpp ]
+
+    # test serializing uuids
+    [ run test_serialization.cpp ../../serialization/build//boost_serialization ]
+    # TODO - This test fails to like with boost_wserialization
+    # [ run test_wserialization.cpp
+    #     ../../serialization/build//boost_serialization
+    #     ../../serialization/build//boost_wserialization
+    #     : : : <dependency>../../config/test/all//BOOST_NO_STD_WSTREAMBUF
+    # ]
+
+    # test hash functions
+    [ run test_md5.cpp ]
+    [ run test_sha1.cpp ]
+
+    # test MSVC 12 (VS2013) optimizer bug with SIMD operations.
+    # See https://svn.boost.org/trac/boost/ticket/8509#comment:3
+    # Only happens in Release x64 builds.
+    [ run test_msvc_simd_bug981648_main.cpp
+          test_msvc_simd_bug981648_foo.cpp
+          : : : <variant>release <debug-symbols>on : test_msvc_simd_bug981648 ]
+    ;

libs/uuid/test/compile/decl_header.cpp

@@ -0,0 +1,24 @@
+/*
+ *             Copyright Andrey Semashev 2015.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   decl_header.cpp
+ * \author Andrey Semashev
+ * \date   21.06.2015
+ *
+ * \brief  This file contains a test boilerplate for checking that every
+ *         public header is self-contained and does not have any missing
+ *         #includes.
+ */
+
+#define BOOST_UUID_TEST_INCLUDE_HEADER() <boost/uuid/BOOST_UUID_TEST_HEADER>
+
+#include BOOST_UUID_TEST_INCLUDE_HEADER()
+
+int main(int, char*[])
+{
+    return 0;
+}

libs/uuid/test/compile_uuid.cpp

@@ -0,0 +1,13 @@
+//  (C) Copyright Andy Tompkins 2008. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Purpose to make sure that a translation unit consisting of just the contents
+// of the header file will compile successfully.
+
+#include <boost/uuid/uuid.hpp>

libs/uuid/test/test_generators.cpp

@@ -0,0 +1,137 @@
+//  (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_generators.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/test_tools.hpp>
+
+#include <boost/random.hpp>
+
+template <typename RandomUuidGenerator>
+void check_random_generator(RandomUuidGenerator& uuid_gen)
+{
+    boost::uuids::uuid u1 = uuid_gen();
+    boost::uuids::uuid u2 = uuid_gen();
+
+    BOOST_CHECK_NE(u1, u2);
+
+    // check variant
+    BOOST_CHECK_EQUAL(u1.variant(), boost::uuids::uuid::variant_rfc_4122);
+//    BOOST_CHECK_EQUAL( *(u1.begin()+8) & 0xC0, 0x80);
+    // version
+    BOOST_CHECK_EQUAL( *(u1.begin()+6) & 0xF0, 0x40);
+}
+
+int test_main(int, char*[])
+{
+    using namespace boost::uuids;
+    using boost::test_tools::output_test_stream;
+
+    { // test nil generator
+        uuid u1 = nil_generator()();
+        uuid u2 = {{0}};
+        BOOST_CHECK_EQUAL(u1, u2);
+
+        uuid u3 = nil_uuid();
+        BOOST_CHECK_EQUAL(u3, u2);
+    }
+    
+    { // test string_generator
+        string_generator gen;
+        uuid u = gen("00000000-0000-0000-0000-000000000000");
+        BOOST_CHECK_EQUAL(u, nil_uuid());
+        BOOST_CHECK_EQUAL(u.is_nil(), true);
+
+        const uuid u_increasing = {{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }};
+        const uuid u_decreasing = {{ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }};
+
+        u = gen("0123456789abcdef0123456789ABCDEF");
+        BOOST_CHECK_EQUAL(u, u_increasing);
+        
+        u = gen("{0123456789abcdef0123456789ABCDEF}");
+        BOOST_CHECK_EQUAL(u, u_increasing);
+
+        u = gen("{01234567-89AB-CDEF-0123-456789abcdef}");
+        BOOST_CHECK_EQUAL(u, u_increasing);
+
+        u = gen("01234567-89AB-CDEF-0123-456789abcdef");
+        BOOST_CHECK_EQUAL(u, u_increasing);
+        
+        u = gen(std::string("fedcba98-7654-3210-fedc-ba9876543210"));
+        BOOST_CHECK_EQUAL(u, u_decreasing);
+
+#ifndef BOOST_NO_STD_WSTRING
+        u = gen(L"fedcba98-7654-3210-fedc-ba9876543210");
+        BOOST_CHECK_EQUAL(u, u_decreasing);
+
+        u = gen(std::wstring(L"01234567-89ab-cdef-0123-456789abcdef"));
+        BOOST_CHECK_EQUAL(u, u_increasing);
+#endif //BOOST_NO_STD_WSTRING
+    }
+    
+    { // test name_generator
+        uuid dns_namespace_uuid = {{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}};
+        uuid correct = {{0x21, 0xf7, 0xf8, 0xde, 0x80, 0x51, 0x5b, 0x89, 0x86, 0x80, 0x01, 0x95, 0xef, 0x79, 0x8b, 0x6a}};
+        uuid wcorrect = {{0xb9, 0x50, 0x66, 0x13, 0x2c, 0x04, 0x51, 0x2d, 0xb8, 0xfe, 0xbf, 0x8d, 0x0b, 0xa1, 0xb2, 0x71}};
+
+        name_generator gen(dns_namespace_uuid);
+
+        uuid u = gen("www.widgets.com");
+        BOOST_CHECK_EQUAL(u, correct);
+        BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+        u = gen(L"www.widgets.com");
+        BOOST_CHECK_EQUAL(u, wcorrect);
+        BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+        u = gen(std::string("www.widgets.com"));
+        BOOST_CHECK_EQUAL(u, correct);
+        BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+        u = gen(std::wstring(L"www.widgets.com"));
+        BOOST_CHECK_EQUAL(u, wcorrect);
+        BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+        char name[] = "www.widgets.com";
+        u = gen(name, 15);
+        BOOST_CHECK_EQUAL(u, correct);
+        BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+    }
+
+    { // test random_generator
+        // default random number generator
+        random_generator uuid_gen1;
+        check_random_generator(uuid_gen1);
+        
+        // specific random number generator
+        basic_random_generator<boost::rand48> uuid_gen2;
+        check_random_generator(uuid_gen2);
+        
+        // pass by reference
+        boost::ecuyer1988 ecuyer1988_gen;
+        basic_random_generator<boost::ecuyer1988> uuid_gen3(ecuyer1988_gen);
+        check_random_generator(uuid_gen3);
+        
+        // pass by pointer
+        boost::lagged_fibonacci607 lagged_fibonacci607_gen;
+        basic_random_generator<boost::lagged_fibonacci607> uuid_gen4(&lagged_fibonacci607_gen);
+        check_random_generator(uuid_gen4);
+
+        // random device
+        //basic_random_generator<boost::random_device> uuid_gen5;
+        //check_random_generator(uuid_gen5);
+    }
+    
+    return 0;
+}

libs/uuid/test/test_include1.cpp

@@ -0,0 +1,24 @@
+//  (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_include1.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/uuid_serialize.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/nil_generator.hpp>
+#include <boost/uuid/name_generator.hpp>
+#include <boost/uuid/string_generator.hpp>
+#include <boost/uuid/random_generator.hpp>
+
+int main(int, char*[])
+{
+    return 0;
+}

libs/uuid/test/test_include2.cpp

@@ -0,0 +1,19 @@
+//  (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_include2.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_serialize.hpp>
+#include <boost/uuid/nil_generator.hpp>
+#include <boost/uuid/name_generator.hpp>
+#include <boost/uuid/string_generator.hpp>
+#include <boost/uuid/random_generator.hpp>

libs/uuid/test/test_io.cpp

@@ -0,0 +1,153 @@
+//  (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_io.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/lexical_cast.hpp>
+#include <string>
+#include <sstream>
+#include <iomanip>
+
+using namespace boost::uuids;
+
+void uufail(const std::string& in)
+{
+    uuid out;
+    std::stringstream ss;
+    ss << in;
+    ss >> out;
+    BOOST_TEST_EQ(true, ss.fail());
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+void uufail(const std::wstring& in)
+{
+    uuid out;
+    std::wstringstream ss;
+    ss << in;
+    ss >> out;
+    BOOST_TEST_EQ(true, ss.fail());
+}
+#endif
+
+void uuroundtrip(const uuid& in, const std::string& expect)
+{
+    std::stringstream ss;
+    ss << in;
+    BOOST_TEST_EQ(false, ss.fail());
+    BOOST_TEST_EQ(expect, ss.str());
+
+    uuid out;
+    std::stringstream ss2;
+    ss2 << expect;
+    ss2 >> out;
+    BOOST_TEST_EQ(false, ss2.fail());
+    BOOST_TEST_EQ(in, out);
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+void uuroundtrip(const uuid& in, const std::wstring& expect)
+{
+    std::wstringstream ss;
+    ss << in;
+    BOOST_TEST_EQ(false, ss.fail());
+    BOOST_TEST   (expect == ss.str());
+
+    uuid out;
+    std::wstringstream ss2;
+    ss2 << expect;
+    ss2 >> out;
+    BOOST_TEST_EQ(false, ss2.fail());
+    BOOST_TEST   (in == out);
+}
+#endif
+
+int main(int, char*[])
+{
+    const uuid u1 = {{0}};
+    const uuid u2 = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
+    const uuid u3 = {{0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef,0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef}};
+
+    uuroundtrip(u1, "00000000-0000-0000-0000-000000000000");
+    uuroundtrip(u2, "00010203-0405-0607-0809-0a0b0c0d0e0f");
+    uuroundtrip(u3, "12345678-90ab-cdef-1234-567890abcdef");
+
+    std::stringstream ss5;
+    ss5 << 'a' << std::right << std::setfill('*') << std::setw(40) << u1 << 'a';
+    BOOST_TEST_EQ(ss5.str(), "a****00000000-0000-0000-0000-000000000000a");
+
+    std::stringstream ss6;
+    ss6 << std::left << std::setfill('*') << std::setw(45) << u1;
+    BOOST_TEST_EQ(ss6.str(), "00000000-0000-0000-0000-000000000000*********");
+
+    std::stringstream ss7;
+    ss7 << std::left << std::setfill('*') << std::setw(45) << u2;
+    BOOST_TEST_EQ(ss7.str(), "00010203-0405-0607-0809-0a0b0c0d0e0f*********");
+
+#ifndef BOOST_NO_STD_WSTRING
+    uuroundtrip(u1, L"00000000-0000-0000-0000-000000000000");
+    uuroundtrip(u2, L"00010203-0405-0607-0809-0a0b0c0d0e0f");
+    uuroundtrip(u3, L"12345678-90ab-cdef-1234-567890abcdef");
+#endif
+
+    const char raw[36] = { '0', '1', '2', '3', '4', '5', '6', '7', '-',
+        '8', '9', 'a', 'b', '-',
+        'c', 'd', 'e', 'f', '-',
+        0 , '1', '2', '3', '-',  // 0x00 character is intentional
+        '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+
+    uufail(std::string(raw, 36));
+    uufail("01234567-89ab-cdef-0123456789abcdef");
+    uufail("01234567-89ab-cdef0123-456789abcdef");
+    uufail("01234567-89abcdef-0123-456789abcdef");
+    uufail("0123456789ab-cdef-0123-456789abcdef");
+    uufail("{12345678-90ab-cdef-1234-567890abcdef}");  // stream is not as flexible as string
+    uufail("G1234567-89AB-CDEF-0123-456789abcdef");
+    uufail("01234567-89AB-CDEF-0123-456789abcdeg");
+
+#ifndef BOOST_NO_STD_WSTRING
+    uufail(L"01234567-89ab-cdef-");
+    uufail(L"01234567-89ab-cdef-0123456789abcdef");
+    uufail(L"01234567-89ab-cdef0123-456789abcdef");
+    uufail(L"01234567-89abcdef-0123-456789abcdef");
+    uufail(L"0123456789ab-cdef-0123-456789abcdef");
+    uufail(L"{12345678-90ab-cdef-1234-567890abcdef}");  // stream is not as flexible as string
+    uufail(L"G1234567-89AB-CDEF-0123-456789abcdef");
+    uufail(L"01234567-89AB-CDEF-0123-456789abcdeg");
+#endif
+
+    BOOST_TEST(boost::lexical_cast<std::string>(u1) == std::string("00000000-0000-0000-0000-000000000000"));
+    BOOST_TEST(boost::lexical_cast<uuid>("00000000-0000-0000-0000-000000000000") == u1);
+
+    BOOST_TEST(boost::lexical_cast<std::string>(u3) == std::string("12345678-90ab-cdef-1234-567890abcdef"));
+    BOOST_TEST(boost::lexical_cast<uuid>("12345678-90ab-cdef-1234-567890abcdef") == u3);
+
+#ifndef BOOST_NO_STD_WSTRING
+    BOOST_TEST(boost::lexical_cast<std::wstring>(u1) == std::wstring(L"00000000-0000-0000-0000-000000000000"));
+    BOOST_TEST(boost::lexical_cast<uuid>(L"00000000-0000-0000-0000-000000000000") == u1);
+
+    BOOST_TEST(boost::lexical_cast<std::wstring>(u3) == std::wstring(L"12345678-90ab-cdef-1234-567890abcdef"));
+    BOOST_TEST(boost::lexical_cast<uuid>(L"12345678-90ab-cdef-1234-567890abcdef") == u3);
+#endif
+
+    BOOST_TEST(to_string(u1) == std::string("00000000-0000-0000-0000-000000000000"));
+    BOOST_TEST(to_string(u3) == std::string("12345678-90ab-cdef-1234-567890abcdef"));
+
+#ifndef BOOST_NO_STD_WSTRING
+    BOOST_TEST(to_wstring(u1) == std::wstring(L"00000000-0000-0000-0000-000000000000"));
+    BOOST_TEST(to_wstring(u3) == std::wstring(L"12345678-90ab-cdef-1234-567890abcdef"));
+#endif
+
+    return boost::report_errors();
+}
+

libs/uuid/test/test_md5.cpp

@@ -0,0 +1,47 @@
+//  libs/uuid/test/test_md5.cpp  --------------------------------//
+
+// (C) Copyright 2017 James E. King, III
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/cstdint.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/uuid/detail/md5.hpp>
+
+int main(int, char**)
+{
+    typedef struct
+    {
+        const char * data;
+        boost::uint32_t len;
+        unsigned char expected[16];
+    } Expectation;
+
+    /* http://www.febooti.com/products/filetweak/members/hash-and-crc/test-vectors/ */
+    Expectation expectations[3] = {
+        { "The quick brown fox jumps over the lazy dog", 43,
+          { 0x9e, 0x10, 0x7d, 0x9d, 0x37, 0x2b, 0xb6, 0x82,
+            0x6b, 0xd8, 0x1d, 0x35, 0x42, 0xa4, 0x19, 0xd6 }},
+        { "Test vector from febooti.com", 28,
+          { 0x50, 0x0a, 0xb6, 0x61, 0x3c, 0x6d, 0xb7, 0xfb,
+            0xd3, 0x0c, 0x62, 0xf5, 0xff, 0x57, 0x3d, 0x0f }},
+        { "", 0,
+          { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
+            0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e }}
+    };
+
+    for (boost::uint32_t i = 0; i < 3; ++i) {
+        boost::uuids::detail::md5 hash;
+        hash.process_bytes(expectations[i].data, expectations[i].len);
+        boost::uuids::detail::md5::digest_type result;
+        hash.get_digest(result);
+        BOOST_TEST_EQ(0, memcmp(result, expectations[i].expected,
+            sizeof(boost::uuids::detail::md5::digest_type)));
+        BOOST_TEST_EQ(hash.get_version(), 0x03);
+
+    }
+
+    return boost::report_errors();
+}

libs/uuid/test/test_msvc_simd_bug981648.hpp

@@ -0,0 +1,34 @@
+/*
+* Copyright 2014 Andrey Semashev
+*
+* Distributed under the Boost Software License, Version 1.0.
+* See accompanying file LICENSE_1_0.txt or copy at
+* http://www.boost.org/LICENSE_1_0.txt
+*/
+/*
+* This is a part of the test for a workaround for MSVC 12 (VS2013) optimizer bug
+* which causes incorrect SIMD code generation for operator==. See:
+*
+* https://svn.boost.org/trac/boost/ticket/8509#comment:3
+* https://connect.microsoft.com/VisualStudio/feedbackdetail/view/981648#tabs
+*
+* The header contains common definitions for the two source files.
+*/
+#include <boost/uuid/uuid.hpp>
+using boost::uuids::uuid;
+class headerProperty
+{
+public:
+virtual ~headerProperty() {}
+};
+class my_obj:
+public headerProperty
+{
+public:
+// This char tmp[8] forces the following uuid to be misaligned.
+char tmp[8];
+// This m_uuid is misaligned (not 16-byte aligned) and causes the != operator to crash.
+uuid m_uuid;
+const uuid &get_marker_id() const { return m_uuid; }
+uuid get_id() const { return m_uuid; }
+};

libs/uuid/test/test_msvc_simd_bug981648_foo.cpp

@@ -0,0 +1,32 @@
+/*
+* Copyright 2014 Andrey Semashev
+*
+* Distributed under the Boost Software License, Version 1.0.
+* See accompanying file LICENSE_1_0.txt or copy at
+* http://www.boost.org/LICENSE_1_0.txt
+*/
+/*
+* This is a part of the test for a workaround for MSVC 12 (VS2013) optimizer bug
+* which causes incorrect SIMD code generation for operator==. See:
+*
+* https://svn.boost.org/trac/boost/ticket/8509#comment:3
+* https://connect.microsoft.com/VisualStudio/feedbackdetail/view/981648#tabs
+*
+* The file contains the function that actually causes the crash. Reproduces only
+* in Release x64 builds.
+*/
+#include <cstdio>
+#include "test_msvc_simd_bug981648.hpp"
+void mp_grid_update_marker_parameters(headerProperty* header_prop, my_obj &current_marker)
+{
+headerProperty *old_header_prop = NULL;
+my_obj *p = dynamic_cast<my_obj*>(header_prop);
+/*
+* This != statement crashes with a GP.
+* */
+if (p != NULL && (current_marker.get_id() != p->get_marker_id())) {
+std::printf("works okay, if it reaches this printf: %p\n", reinterpret_cast<void *>(p));
+old_header_prop = header_prop;
+if (old_header_prop == 0) { fprintf(stderr, "ouch"); }
+}
+}

libs/uuid/test/test_msvc_simd_bug981648_main.cpp

@@ -0,0 +1,40 @@
+/*
+* Copyright 2014 Andrey Semashev
+*
+* Distributed under the Boost Software License, Version 1.0.
+* See accompanying file LICENSE_1_0.txt or copy at
+* http://www.boost.org/LICENSE_1_0.txt
+*/
+/*
+* This is a part of the test for a workaround for MSVC 12 (VS2013) optimizer bug
+* which causes incorrect SIMD code generation for operator==. See:
+*
+* https://svn.boost.org/trac/boost/ticket/8509#comment:3
+* https://connect.microsoft.com/VisualStudio/feedbackdetail/view/981648#tabs
+*
+* This file contains the main entry point.
+*/
+#include <cstdio>
+#include "test_msvc_simd_bug981648.hpp"
+extern void mp_grid_update_marker_parameters(headerProperty* header_prop, my_obj &current_marker);
+static my_obj g_my_obj;
+int main(void)
+{
+my_obj *p = &g_my_obj;
+p->m_uuid = uuid();
+uuid one, two;
+one.data[0] = 0; two.data[0] = 1;
+//*****************************************
+// This != statement generates two movdqu statements or pcmpeqd with a memory operand which crashes
+if (one != two) {
+std::printf("The first != operator works okay if it reaches this printf.\n");
+}
+my_obj a;
+a.m_uuid.data[0] = 1;
+std::printf("There should be a another printf coming next.\n");
+//*****************************************
+// The != statement in this function generates a movups and a movdqu statement.
+// It also crashes because the optimizer also creates a pcmpeqd for a non-aligned memory location.
+mp_grid_update_marker_parameters(p, a);
+return 0;
+}

libs/uuid/test/test_name_generator.cpp

@@ -0,0 +1,99 @@
+//  (C) Copyright Andy Tompkins 2010. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_name_generator.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/name_generator.hpp>
+#include <boost/uuid/name_generator_md5.hpp>
+#include <boost/uuid/string_generator.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+int main(int, char*[])
+{
+    using namespace boost::uuids;
+
+    // Verify well-known uuid namespaces
+    BOOST_TEST_EQ(ns::dns(),
+                  string_generator()("6ba7b810-9dad-11d1-80b4-00c04fd430c8"));
+    BOOST_TEST_EQ(ns::url(),
+                  string_generator()("6ba7b811-9dad-11d1-80b4-00c04fd430c8"));
+    BOOST_TEST_EQ(ns::oid(),
+                  string_generator()("6ba7b812-9dad-11d1-80b4-00c04fd430c8"));
+    BOOST_TEST_EQ(ns::x500dn(),
+                  string_generator()("6ba7b814-9dad-11d1-80b4-00c04fd430c8"));
+
+    uuid correct_sha1  = {{0x21, 0xf7, 0xf8, 0xde, 0x80, 0x51, 0x5b, 0x89, 0x86, 0x80, 0x01, 0x95, 0xef, 0x79, 0x8b, 0x6a}};
+    uuid wcorrect_sha1 = {{0xc3, 0x15, 0x27, 0x0b, 0xa4, 0x66, 0x58, 0x72, 0xac, 0xa4, 0x96, 0x26, 0xce, 0xc0, 0xf4, 0xbe}};
+    uuid correct_md5   = {{0xec, 0x5c, 0x20, 0x06, 0x0e, 0x00, 0x3b, 0x25, 0xa0, 0xa8, 0xbc, 0xe8, 0x4e, 0x24, 0xb8, 0x5a}};
+
+    name_generator_sha1 gen(ns::dns());
+
+    uuid u = gen("www.widgets.com");
+    BOOST_TEST_EQ(u, correct_sha1);
+    BOOST_TEST_EQ(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+    BOOST_TEST_EQ(u.version(), boost::uuids::uuid::version_name_based_sha1);
+
+    // RFC 4122 Section 4.3 Bullet 1, same name in same namespace makes the same UUID
+    u = gen(std::string("www.widgets.com"));
+    BOOST_TEST_EQ(u, correct_sha1);
+    BOOST_TEST_EQ(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+    // RFC 4122 Section 4.3 Bullet 2, two names in the same namespace makes a different UUID
+    uuid u2 = gen("www.wonka.com");
+    BOOST_TEST_NE(u, u2);
+    BOOST_TEST_EQ(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+    u = gen(L"www.widgets.com");
+    BOOST_TEST_EQ(u, wcorrect_sha1);
+    BOOST_TEST_EQ(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+#ifndef BOOST_NO_STD_WSTRING
+    u = gen(std::wstring(L"www.widgets.com"));
+    BOOST_TEST_EQ(u, wcorrect_sha1);
+    BOOST_TEST_EQ(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+#endif
+
+    char name[] = "www.widgets.com";
+    u = gen(name, 15);
+    BOOST_TEST_EQ(u, correct_sha1);
+    BOOST_TEST_EQ(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+    // RFC 4122 Section 4.3 Bullet 3, same name in different namespaces makes a different UUID
+    name_generator_sha1 other(ns::url());
+    uuid u3 = other("www.widgets.com");
+    BOOST_TEST_NE(u, u3);
+
+    // used by documentation
+    uuid udoc = gen("boost.org");
+    std::cout << "boost.org uuid in dns namespace: " << udoc << std::endl;
+    // boost.org uuid in dns namespace: 0043f363-bbb4-5369-840a-322df6ec1926
+
+    // deprecated equality check, make sure boost::uuids::name_generator is a sha1 generator
+    name_generator other2(ns::url());
+    uuid u4 = other2("www.widgets.com");
+    BOOST_TEST_EQ(u3, u4);
+
+    // MD5 generator
+    name_generator_md5 mdgen(ns::url());
+    uuid md = mdgen("www.widgets.com");
+    BOOST_TEST_NE(u3, md);
+    BOOST_TEST_EQ(md.variant(), boost::uuids::uuid::variant_rfc_4122);
+    BOOST_TEST_EQ(md.version(), boost::uuids::uuid::version_name_based_md5);
+    BOOST_TEST_EQ(md, correct_md5);
+
+    // latest generator is SHA1 (test will break on change, which is good)
+    name_generator_latest latestgen(ns::dns());
+    uuid latest = latestgen("www.widgets.com");
+    BOOST_TEST_EQ(latest, correct_sha1);
+
+    return boost::report_errors();
+}

libs/uuid/test/test_nil_generator.cpp

@@ -0,0 +1,29 @@
+//  (C) Copyright Andy Tompkins 2010. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_nil_generator.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/nil_generator.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main(int, char*[])
+{
+    using namespace boost::uuids;
+
+    uuid u1 = nil_generator()();
+    uuid u2 = {{0}};
+    BOOST_TEST_EQ(u1, u2);
+
+    uuid u3 = nil_uuid();
+    BOOST_TEST_EQ(u3, u2);
+
+    return boost::report_errors();
+}

libs/uuid/test/test_random_generator.cpp

@@ -0,0 +1,72 @@
+//  (C) Copyright Andy Tompkins 2010. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_random_generator.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/random_generator.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/random.hpp>
+#include <boost/random/random_device.hpp>
+
+template <typename RandomUuidGenerator>
+void check_random_generator(RandomUuidGenerator& uuid_gen)
+{
+    boost::uuids::uuid u1 = uuid_gen();
+    boost::uuids::uuid u2 = uuid_gen();
+
+    BOOST_TEST_NE(u1, u2);
+
+    // check variant
+    BOOST_TEST_EQ(u1.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+    // version
+    BOOST_TEST_EQ(u1.version(), boost::uuids::uuid::version_random_number_based);
+}
+
+int main(int, char*[])
+{
+    using namespace boost::uuids;
+
+    // default random number generator
+    random_generator uuid_gen1;
+    check_random_generator(uuid_gen1);
+    
+    // specific random number generator
+    basic_random_generator<boost::rand48> uuid_gen2;
+    check_random_generator(uuid_gen2);
+    
+    // pass by reference
+    boost::ecuyer1988 ecuyer1988_gen;
+    basic_random_generator<boost::ecuyer1988> uuid_gen3(ecuyer1988_gen);
+    check_random_generator(uuid_gen3);
+
+    // pass by pointer
+    boost::lagged_fibonacci607 lagged_fibonacci607_gen;
+    basic_random_generator<boost::lagged_fibonacci607> uuid_gen4(&lagged_fibonacci607_gen);
+    check_random_generator(uuid_gen4);
+
+    // random device
+    basic_random_generator<boost::random::random_device> uuid_gen5;
+    check_random_generator(uuid_gen5);
+    
+    // there was a bug in basic_random_generator where it did not
+    // produce very random numbers.  This checks for that bug.
+    uuid u = random_generator()();
+    if ( (u.data[4] == u.data[12]) &&
+         (u.data[5] == u.data[9] && u.data[5] == u.data[13]) &&
+         (u.data[7] == u.data[11] && u.data[7] == u.data[15]) &&
+         (u.data[10] == u.data[14]) )
+    {
+        BOOST_ERROR("basic_random_generator is not producing random uuids");
+    }
+
+    return boost::report_errors();
+}

libs/uuid/test/test_serialization.cpp

@@ -0,0 +1,71 @@
+//  (C) Copyright Andy Tompkins 2007. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Purpose to test serializing uuids with narrow archives
+
+#include <boost/detail/lightweight_test.hpp>
+#include <sstream>
+#include <iostream>
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_serialize.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+
+template <class OArchiveType, class IArchiveType, class OStringStreamType, class IStringStreamType>
+void test_archive()
+{
+    using namespace std;
+    using namespace boost::uuids;
+    
+    OStringStreamType o_stream;
+    
+    uuid u1 = {{0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef}};
+
+    uuid u2;
+    
+    // save
+    {
+        OArchiveType oa(o_stream);
+        
+        oa << BOOST_SERIALIZATION_NVP(u1);
+    }
+    
+    //cout << "stream:" << o_stream.str() << "\n\n";
+    
+    // load
+    {
+        IStringStreamType i_stream(o_stream.str());
+        IArchiveType ia(i_stream);
+        
+        ia >> BOOST_SERIALIZATION_NVP(u2);
+    }
+    
+    BOOST_TEST_EQ(u1, u2);
+}
+
+int main( int /* argc */, char* /* argv */[] )
+{
+    using namespace std;
+    using namespace boost::archive;
+    
+    test_archive<text_oarchive, text_iarchive, ostringstream, istringstream>();
+    test_archive<xml_oarchive, xml_iarchive, ostringstream, istringstream>();
+    test_archive<binary_oarchive, binary_iarchive, ostringstream, istringstream>();
+
+    return boost::report_errors();
+}

libs/uuid/test/test_sha1.cpp

@@ -0,0 +1,279 @@
+//  (C) Copyright Andy Tompkins 2007. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_sha1.cpp  -------------------------------//
+
+#include <boost/uuid/detail/sha1.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <algorithm>
+#include <cstring>
+#include <cstddef>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+  using ::strlen;
+  using ::size_t;
+} //namespace std
+#endif
+
+void test_sha1_digest_equal_array(char const * file, int line, char const * function,
+                          const unsigned int (&lhs)[5], const unsigned int (&rhs)[5])
+{
+    for (size_t i=0; i<5; i++) {
+        if ( lhs[i] != rhs[i]) {
+            std::cerr << file << "(" << line << "): sha1 digest [";
+            for (size_t l=0; l<5; l++) {
+                if (l != 0) {
+                    std::cerr << " ";
+                }
+                std::cerr << std::hex << (int)lhs[l];
+            }
+
+            std::cerr << "] not equal [";
+            for (size_t r=0; r<5; r++) {
+                if (r != 0) {
+                    std::cerr << " ";
+                }
+                std::cerr << std::hex << (int)rhs[r];
+            }
+            std::cerr << "] in function '" << function << "'" << std::endl;
+            ++boost::detail::test_errors();
+            return;
+        }
+    }
+}
+
+
+#define BOOST_TEST_SHA1_DIGEST(lhs, rhs) ( test_sha1_digest_equal_array(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION, lhs, rhs) )
+
+void test_sha1(char const*const message, std::size_t length, const unsigned int (&correct_digest)[5])
+{
+    boost::uuids::detail::sha1 sha;
+    sha.process_bytes(message, length);
+
+    unsigned int digest[5];
+    sha.get_digest(digest);
+
+    BOOST_TEST_SHA1_DIGEST(digest, correct_digest);
+}
+
+void test_quick()
+{
+    struct test_case
+    {
+        char const* message;
+        unsigned int digest[5];
+    };
+    test_case cases[] =
+    { { "",
+        { 0xda39a3ee, 0x5e6b4b0d, 0x3255bfef, 0x95601890, 0xafd80709 } }
+    , { "The quick brown fox jumps over the lazy dog",
+        { 0x2fd4e1c6, 0x7a2d28fc, 0xed849ee1, 0xbb76e739, 0x1b93eb12 } }
+    , { "The quick brown fox jumps over the lazy cog",
+        { 0xde9f2c7f, 0xd25e1b3a, 0xfad3e85a, 0x0bd17d9b, 0x100db4b3 } }
+    };
+
+    for (int i=0; i!=sizeof(cases)/sizeof(cases[0]); ++i) {
+        test_case const& tc = cases[i];
+        test_sha1(tc.message, std::strlen(tc.message), tc.digest);
+    }
+}
+
+//SHA Test Vector for Hashing Byte-Oriented Messages
+//http://csrc.nist.gov/cryptval/shs.htm
+//http://csrc.nist.gov/cryptval/shs/shabytetestvectors.zip
+//values from SHA1ShortMsg.txt
+void test_short_messages()
+{
+    struct test_case
+    {
+        char const* message;
+        unsigned int digest[5];
+    };
+    test_case cases[] =
+    { { "",
+         { 0xda39a3ee, 0x5e6b4b0d, 0x3255bfef, 0x95601890, 0xafd80709 } }
+    , { "a8",
+         { 0x99f2aa95, 0xe36f95c2, 0xacb0eaf2, 0x3998f030, 0x638f3f15 } }
+    , { "3000",
+         { 0xf944dcd6, 0x35f9801f, 0x7ac90a40, 0x7fbc4799, 0x64dec024 } }
+    , { "42749e",
+         { 0xa444319e, 0x9b6cc1e8, 0x464c511e, 0xc0969c37, 0xd6bb2619 } }
+    , { "9fc3fe08",
+         { 0x16a0ff84, 0xfcc156fd, 0x5d3ca3a7, 0x44f20a23, 0x2d172253 } }
+    , { "b5c1c6f1af",
+         { 0xfec9deeb, 0xfcdedaf6, 0x6dda525e, 0x1be43597, 0xa73a1f93 } }
+    , { "e47571e5022e",
+         { 0x8ce05118, 0x1f0ed5e9, 0xd0c498f6, 0xbc4caf44, 0x8d20deb5 } }
+    , { "3e1b28839fb758",
+         { 0x67da5383, 0x7d89e03b, 0xf652ef09, 0xc369a341, 0x5937cfd3 } }
+    , { "a81350cbb224cb90",
+         { 0x305e4ff9, 0x888ad855, 0xa78573cd, 0xdf4c5640, 0xcce7e946 } }
+    , { "c243d167923dec3ce1",
+         { 0x5902b77b, 0x3265f023, 0xf9bbc396, 0xba1a93fa, 0x3509bde7 } }
+    , { "50ac18c59d6a37a29bf4",
+         { 0xfcade5f5, 0xd156bf6f, 0x9af97bdf, 0xa9c19bcc, 0xfb4ff6ab } }
+    , { "98e2b611ad3b1cccf634f6",
+         { 0x1d20fbe0, 0x0533c10e, 0x3cbd6b27, 0x088a5de0, 0xc632c4b5 } }
+    , { "73fe9afb68e1e8712e5d4eec",
+         { 0x7e1b7e0f, 0x7a8f3455, 0xa9c03e95, 0x80fd63ae, 0x205a2d93 } }
+    , { "9e701ed7d412a9226a2a130e66",
+         { 0x706f0677, 0x146307b2, 0x0bb0e8d6, 0x311e3299, 0x66884d13 } }
+    , { "6d3ee90413b0a7cbf69e5e6144ca",
+         { 0xa7241a70, 0x3aaf0d53, 0xfe142f86, 0xbf2e8492, 0x51fa8dff } }
+    , { "fae24d56514efcb530fd4802f5e71f",
+         { 0x400f5354, 0x6916d33a, 0xd01a5e6d, 0xf66822df, 0xbdc4e9e6 } }
+    , { "c5a22dd6eda3fe2bdc4ddb3ce6b35fd1",
+         { 0xfac8ab93, 0xc1ae6c16, 0xf0311872, 0xb984f729, 0xdc928ccd } }
+    , { "d98cded2adabf08fda356445c781802d95",
+         { 0xfba6d750, 0xc18da58f, 0x6e2aab10, 0x112b9a5e, 0xf3301b3b } }
+    , { "bcc6d7087a84f00103ccb32e5f5487a751a2",
+         { 0x29d27c2d, 0x44c205c8, 0x107f0351, 0xb05753ac, 0x708226b6 } }
+    , { "36ecacb1055434190dbbc556c48bafcb0feb0d",
+         { 0xb971bfc1, 0xebd6f359, 0xe8d74cb7, 0xecfe7f89, 0x8d0ba845 } }
+    , { "5ff9edb69e8f6bbd498eb4537580b7fba7ad31d0",
+         { 0x96d08c43, 0x0094b9fc, 0xc164ad2f, 0xb6f72d0a, 0x24268f68 } }
+    , { "c95b441d8270822a46a798fae5defcf7b26abace36",
+         { 0xa287ea75, 0x2a593d52, 0x09e28788, 0x1a09c49f, 0xa3f0beb1 } }
+    , { "83104c1d8a55b28f906f1b72cb53f68cbb097b44f860",
+         { 0xa06c7137, 0x79cbd885, 0x19ed4a58, 0x5ac0cb8a, 0x5e9d612b } }
+    , { "755175528d55c39c56493d697b790f099a5ce741f7754b",
+         { 0xbff7d52c, 0x13a36881, 0x32a1d407, 0xb1ab40f5, 0xb5ace298 } }
+    , { "088fc38128bbdb9fd7d65228b3184b3faac6c8715f07272f",
+         { 0xc7566b91, 0xd7b6f56b, 0xdfcaa978, 0x1a7b6841, 0xaacb17e9 } }
+    , { "a4a586eb9245a6c87e3adf1009ac8a49f46c07e14185016895",
+         { 0xffa30c0b, 0x5c550ea4, 0xb1e34f8a, 0x60ec9295, 0xa1e06ac1 } }
+    , { "8e7c555270c006092c2a3189e2a526b873e2e269f0fb28245256",
+         { 0x29e66ed2, 0x3e914351, 0xe872aa76, 0x1df6e4f1, 0xa07f4b81 } }
+    , { "a5f3bfa6bb0ba3b59f6b9cbdef8a558ec565e8aa3121f405e7f2f0",
+         { 0xb28cf5e5, 0xb806a014, 0x91d41f69, 0xbd924876, 0x5c5dc292 } }
+    , { "589054f0d2bd3c2c85b466bfd8ce18e6ec3e0b87d944cd093ba36469",
+         { 0x60224fb7, 0x2c460696, 0x52cd78bc, 0xd08029ef, 0x64da62f3 } }
+    , { "a0abb12083b5bbc78128601bf1cbdbc0fdf4b862b24d899953d8da0ff3",
+         { 0xb72c4a86, 0xf72608f2, 0x4c05f3b9, 0x088ef92f, 0xba431df7 } }
+    , { "82143f4cea6fadbf998e128a8811dc75301cf1db4f079501ea568da68eeb",
+         { 0x73779ad5, 0xd6b71b9b, 0x8328ef72, 0x20ff12eb, 0x167076ac } }
+    , { "9f1231dd6df1ff7bc0b0d4f989d048672683ce35d956d2f57913046267e6f3",
+         { 0xa09671d4, 0x452d7cf5, 0x0015c914, 0xa1e31973, 0xd20cc1a0 } }
+    , { "041c512b5eed791f80d3282f3a28df263bb1df95e1239a7650e5670fc2187919",
+         { 0xe88cdcd2, 0x33d99184, 0xa6fd260b, 0x8fca1b7f, 0x7687aee0 } }
+    , { "17e81f6ae8c2e5579d69dafa6e070e7111461552d314b691e7a3e7a4feb3fae418",
+         { 0x010def22, 0x850deb11, 0x68d525e8, 0xc84c2811, 0x6cb8a269 } }
+    , { "d15976b23a1d712ad28fad04d805f572026b54dd64961fda94d5355a0cc98620cf77",
+         { 0xaeaa40ba, 0x1717ed54, 0x39b1e6ea, 0x901b294b, 0xa500f9ad } }
+    , { "09fce4d434f6bd32a44e04b848ff50ec9f642a8a85b37a264dc73f130f22838443328f",
+         { 0xc6433791, 0x238795e3, 0x4f080a5f, 0x1f1723f0, 0x65463ca0 } }
+    , { "f17af27d776ec82a257d8d46d2b46b639462c56984cc1be9c1222eadb8b26594a25c709d",
+         { 0xe21e22b8, 0x9c1bb944, 0xa32932e6, 0xb2a2f20d, 0x491982c3 } }
+    , { "b13ce635d6f8758143ffb114f2f601cb20b6276951416a2f94fbf4ad081779d79f4f195b22",
+         { 0x575323a9, 0x661f5d28, 0x387964d2, 0xba6ab92c, 0x17d05a8a } }
+    , { "5498793f60916ff1c918dde572cdea76da8629ba4ead6d065de3dfb48de94d234cc1c5002910",
+         { 0xfeb44494, 0xaf72f245, 0xbfe68e86, 0xc4d7986d, 0x57c11db7 } }
+    , { "498a1e0b39fa49582ae688cd715c86fbaf8a81b8b11b4d1594c49c902d197c8ba8a621fd6e3be5",
+         { 0xcff2290b, 0x3648ba28, 0x31b98dde, 0x436a72f9, 0xebf51eee } }
+    , { "3a36ae71521f9af628b3e34dcb0d4513f84c78ee49f10416a98857150b8b15cb5c83afb4b570376e",
+         { 0x9b4efe9d, 0x27b96590, 0x5b0c3dab, 0x67b8d7c9, 0xebacd56c } }
+    , { "dcc76b40ae0ea3ba253e92ac50fcde791662c5b6c948538cffc2d95e9de99cac34dfca38910db2678f",
+         { 0xafedb0ff, 0x156205bc, 0xd831cbdb, 0xda43db8b, 0x0588c113 } }
+    , { "5b5ec6ec4fd3ad9c4906f65c747fd4233c11a1736b6b228b92e90cddabb0c7c2fcf9716d3fad261dff33",
+         { 0x8deb1e85, 0x8f88293a, 0x5e5e4d52, 0x1a34b2a4, 0xefa70fc4 } }
+    , { "df48a37b29b1d6de4e94717d60cdb4293fcf170bba388bddf7a9035a15d433f20fd697c3e4c8b8c5f590ab",
+         { 0x95cbdac0, 0xf74afa69, 0xcebd0e5c, 0x7defbc6f, 0xaf0cbeaf } }
+    , { "1f179b3b82250a65e1b0aee949e218e2f45c7a8dbfd6ba08de05c55acfc226b48c68d7f7057e5675cd96fcfc",
+         { 0xf0307bcb, 0x92842e5a, 0xe0cd4f4f, 0x14f3df7f, 0x877fbef2 } }
+    , { "ee3d72da3a44d971578972a8e6780ce64941267e0f7d0179b214fa97855e1790e888e09fbe3a70412176cb3b54",
+         { 0x7b13bb0d, 0xbf14964b, 0xd63b133a, 0xc85e2210, 0x0542ef55 } }
+    , { "d4d4c7843d312b30f610b3682254c8be96d5f6684503f8fbfbcd15774fc1b084d3741afb8d24aaa8ab9c104f7258",
+         { 0xc314d2b6, 0xcf439be6, 0x78d2a74e, 0x890d96cf, 0xac1c02ed } }
+    , { "32c094944f5936a190a0877fb9178a7bf60ceae36fd530671c5b38c5dbd5e6a6c0d615c2ac8ad04b213cc589541cf6",
+         { 0x4d0be361, 0xe410b47a, 0x9d67d8ce, 0x0bb6a8e0, 0x1c53c078 } }
+    , { "e5d3180c14bf27a5409fa12b104a8fd7e9639609bfde6ee82bbf9648be2546d29688a65e2e3f3da47a45ac14343c9c02",
+         { 0xe5353431, 0xffae097f, 0x675cbf49, 0x8869f6fb, 0xb6e1c9f2 } }
+    , { "e7b6e4b69f724327e41e1188a37f4fe38b1dba19cbf5a7311d6e32f1038e97ab506ee05aebebc1eed09fc0e357109818b9",
+         { 0xb8720a70, 0x68a085c0, 0x18ab1896, 0x1de2765a, 0xa6cd9ac4 } }
+    , { "bc880cb83b8ac68ef2fedc2da95e7677ce2aa18b0e2d8b322701f67af7d5e7a0d96e9e33326ccb7747cfff0852b961bfd475",
+         { 0xb0732181, 0x568543ba, 0x85f2b6da, 0x602b4b06, 0x5d9931aa } }
+    , { "235ea9c2ba7af25400f2e98a47a291b0bccdaad63faa2475721fda5510cc7dad814bce8dabb611790a6abe56030b798b75c944",
+         { 0x9c22674c, 0xf3222c3b, 0xa9216726, 0x94aafee4, 0xce67b96b } }
+    , { "07e3e29fed63104b8410f323b975fd9fba53f636af8c4e68a53fb202ca35dd9ee07cb169ec5186292e44c27e5696a967f5e67709",
+         { 0xd128335f, 0x4cecca90, 0x66cdae08, 0x958ce656, 0xff0b4cfc } }
+    , { "65d2a1dd60a517eb27bfbf530cf6a5458f9d5f4730058bd9814379547f34241822bf67e6335a6d8b5ed06abf8841884c636a25733f",
+         { 0x0b67c57a, 0xc578de88, 0xa2ae055c, 0xaeaec8bb, 0x9b0085a0 } }
+    , { "dcc86b3bd461615bab739d8daafac231c0f462e819ad29f9f14058f3ab5b75941d4241ea2f17ebb8a458831b37a9b16dead4a76a9b0e",
+         { 0xc766f912, 0xa89d4ccd, 0xa88e0cce, 0x6a713ef5, 0xf178b596 } }
+    , { "4627d54f0568dc126b62a8c35fb46a9ac5024400f2995e51635636e1afc4373dbb848eb32df23914230560b82477e9c3572647a7f2bb92",
+         { 0x9aa3925a, 0x9dcb177b, 0x15ccff9b, 0x78e70cf3, 0x44858779 } }
+    , { "ba531affd4381168ef24d8b275a84d9254c7f5cc55fded53aa8024b2c5c5c8aa7146fe1d1b83d62b70467e9a2e2cb67b3361830adbab28d7",
+         { 0x4811fa30, 0x042fc076, 0xacf37c8e, 0x2274d025, 0x307e5943 } }
+    , { "8764dcbcf89dcf4282eb644e3d568bdccb4b13508bfa7bfe0ffc05efd1390be22109969262992d377691eb4f77f3d59ea8466a74abf57b2ef4",
+         { 0x67430184, 0x50c97307, 0x61ee2b13, 0x0df9b91c, 0x1e118150 } }
+    , { "497d9df9ddb554f3d17870b1a31986c1be277bc44feff713544217a9f579623d18b5ffae306c25a45521d2759a72c0459b58957255ab592f3be4",
+         { 0x71ad4a19, 0xd37d92a5, 0xe6ef3694, 0xddbeb5aa, 0x61ada645 } }
+    , { "72c3c2e065aefa8d9f7a65229e818176eef05da83f835107ba90ec2e95472e73e538f783b416c04654ba8909f26a12db6e5c4e376b7615e4a25819",
+         { 0xa7d9dc68, 0xdacefb7d, 0x61161860, 0x48cb355c, 0xc548e11d } }
+    , { "7cc9894454d0055ab5069a33984e2f712bef7e3124960d33559f5f3b81906bb66fe64da13c153ca7f5cabc89667314c32c01036d12ecaf5f9a78de98",
+         { 0x142e429f, 0x0522ba5a, 0xbf5131fa, 0x81df82d3, 0x55b96909 } }
+    , { "74e8404d5a453c5f4d306f2cfa338ca65501c840ddab3fb82117933483afd6913c56aaf8a0a0a6b2a342fc3d9dc7599f4a850dfa15d06c61966d74ea59",
+         { 0xef72db70, 0xdcbcab99, 0x1e963797, 0x6c6faf00, 0xd22caae9 } }
+    , { "46fe5ed326c8fe376fcc92dc9e2714e2240d3253b105adfbb256ff7a19bc40975c604ad7c0071c4fd78a7cb64786e1bece548fa4833c04065fe593f6fb10",
+         { 0xf220a745, 0x7f4588d6, 0x39dc2140, 0x7c942e98, 0x43f8e26b } }
+    , { "836dfa2524d621cf07c3d2908835de859e549d35030433c796b81272fd8bc0348e8ddbc7705a5ad1fdf2155b6bc48884ac0cd376925f069a37849c089c8645",
+         { 0xddd2117b, 0x6e309c23, 0x3ede85f9, 0x62a0c2fc, 0x215e5c69 } }
+    , { "7e3a4c325cb9c52b88387f93d01ae86d42098f5efa7f9457388b5e74b6d28b2438d42d8b64703324d4aa25ab6aad153ae30cd2b2af4d5e5c00a8a2d0220c6116",
+         { 0xa3054427, 0xcdb13f16, 0x4a610b34, 0x8702724c, 0x808a0dcc } }
+    };
+
+    char const xdigits[17] = "0123456789abcdef";
+    char const*const xdigits_end = xdigits+16;
+
+    for (std::size_t i=0; i!=sizeof(cases)/sizeof(cases[0]); ++i) {
+        test_case const& tc = cases[i];
+
+        boost::uuids::detail::sha1 sha;
+        std::size_t message_length = std::strlen(tc.message);
+        BOOST_TEST_EQ(message_length % 2, 0u);
+
+        for (std::size_t b=0; b<message_length; b+=2) {
+            char c = tc.message[b];
+            char const* f = std::find(xdigits, xdigits_end, c);
+            BOOST_TEST_NE(f, xdigits_end);
+
+            unsigned char byte = static_cast<unsigned char>(std::distance(&xdigits[0], f));
+
+            c = tc.message[b+1];
+            f = std::find(xdigits, xdigits_end, c);
+            BOOST_TEST_NE(f, xdigits_end);
+
+            byte <<= 4;
+            byte |= static_cast<unsigned char>(std::distance(&xdigits[0], f));
+
+            sha.process_byte(byte);
+        }
+
+        unsigned int digest[5];
+        sha.get_digest(digest);
+
+        BOOST_TEST_SHA1_DIGEST(digest, tc.digest);
+    }
+}
+
+void test_version()
+{
+    boost::uuids::detail::sha1 sha;
+    BOOST_TEST_EQ(sha.get_version(), 0x05);
+}
+
+int main(int, char*[])
+{
+    test_quick();
+    test_short_messages();
+    test_version();
+
+    return boost::report_errors();
+}

libs/uuid/test/test_string_generator.cpp

@@ -0,0 +1,89 @@
+//  (C) Copyright Andy Tompkins 2010. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_string_generator.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/string_generator.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <stdexcept>
+#include <string>
+
+int main(int, char*[])
+{
+    using namespace boost::uuids;
+    
+    uuid nil_uuid = {{0}};
+    BOOST_TEST_EQ(nil_uuid.is_nil(), true);
+
+    string_generator gen;
+    uuid u = gen("00000000-0000-0000-0000-000000000000");
+    BOOST_TEST_EQ(u, nil_uuid);
+    BOOST_TEST_EQ(u.is_nil(), true);
+
+    const uuid u_increasing = {{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }};
+    const uuid u_decreasing = {{ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }};
+
+    u = gen("0123456789abcdef0123456789ABCDEF");
+    BOOST_TEST_EQ(u, u_increasing);
+    
+    u = gen("{0123456789abcdef0123456789ABCDEF}");
+    BOOST_TEST_EQ(u, u_increasing);
+
+    u = gen("{01234567-89AB-CDEF-0123-456789abcdef}");
+    BOOST_TEST_EQ(u, u_increasing);
+
+    u = gen("01234567-89AB-CDEF-0123-456789abcdef");
+    BOOST_TEST_EQ(u, u_increasing);
+    
+    u = gen(std::string("fedcba98-7654-3210-fedc-ba9876543210"));
+    BOOST_TEST_EQ(u, u_decreasing);
+
+#ifndef BOOST_NO_STD_WSTRING
+    u = gen(L"fedcba98-7654-3210-fedc-ba9876543210");
+    BOOST_TEST_EQ(u, u_decreasing);
+
+    u = gen(std::wstring(L"01234567-89ab-cdef-0123-456789abcdef"));
+    BOOST_TEST_EQ(u, u_increasing);
+
+    u = gen(std::wstring(L"{01234567-89ab-cdef-0123-456789abcdef}"));
+    BOOST_TEST_EQ(u, u_increasing);
+#endif //BOOST_NO_STD_WSTRING
+
+    const char raw[36] = { '0', '1', '2', '3', '4', '5', '6', '7', '-',
+                           '8', '9', 'a', 'b', '-',
+                           'c', 'd', 'e', 'f', '-',
+                            0 , '1', '2', '3', '-',  // 0x00 character is intentional
+                           '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+    BOOST_TEST_THROWS(gen(std::string(raw, 36)), std::runtime_error);
+
+    BOOST_TEST_THROWS(gen("01234567-89ab-cdef-0123456789abcdef"), std::runtime_error);
+    BOOST_TEST_THROWS(gen("01234567-89ab-cdef0123-456789abcdef"), std::runtime_error);
+    BOOST_TEST_THROWS(gen("01234567-89abcdef-0123-456789abcdef"), std::runtime_error);
+    BOOST_TEST_THROWS(gen("0123456789ab-cdef-0123-456789abcdef"), std::runtime_error);
+
+    BOOST_TEST_THROWS(gen("{01234567-89AB-CDEF-0123-456789abcdef)"), std::runtime_error);
+    BOOST_TEST_THROWS(gen("{01234567-89AB-CDEF-0123-456789abcdef"), std::runtime_error);
+    BOOST_TEST_THROWS(gen("01234567-89AB-CDEF-0123-456789abcdef}"), std::runtime_error);
+#ifndef BOOST_NO_STD_WSTRING
+    BOOST_TEST_THROWS(gen(std::wstring(L"{01234567-89AB-CDEF-0123-456789abcdef)")), std::runtime_error);
+    BOOST_TEST_THROWS(gen(std::wstring(L"{01234567-89AB-CDEF-0123-456789abcdef")), std::runtime_error);
+    BOOST_TEST_THROWS(gen(std::wstring(L"01234567-89AB-CDEF-0123-456789abcdef}")), std::runtime_error);
+    BOOST_TEST_THROWS(gen(std::wstring(L"G1234567-89AB-CDEF-0123-456789abcdef}")), std::runtime_error);
+#endif //BOOST_NO_STD_WSTRING
+
+    BOOST_TEST_THROWS(gen("G1234567-89AB-CDEF-0123-456789abcdef"), std::runtime_error);
+    BOOST_TEST_THROWS(gen("Have a great big roast-beef sandwich!"), std::runtime_error);
+
+    BOOST_TEST_THROWS(gen("83f8638b-8dca-4152-zzzz-2ca8b33039b4"), std::runtime_error);
+
+    return boost::report_errors();
+}

libs/uuid/test/test_tagging.cpp

@@ -0,0 +1,80 @@
+//  (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_tagging.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+class object
+{
+public:
+    object()
+        : tag(boost::uuids::random_generator()())
+        , state(0)
+    {}
+
+    explicit object(int state)
+        : tag(boost::uuids::random_generator()())
+        , state(state)
+    {}
+    
+    object(object const& rhs)
+        : tag(rhs.tag)
+        , state(rhs.state)
+    {}
+    
+    bool operator==(object const& rhs) const {
+        return tag == rhs.tag;
+    }
+    bool operator!=(object const& rhs) const {
+      return !(operator==(rhs));
+    }
+    
+    object& operator=(object const& rhs) {
+        tag = rhs.tag;
+        state = rhs.state;
+        return *this;
+    }
+    
+    int get_state() const { return state; }
+    void set_state(int new_state) { state = new_state; }
+    
+private:
+    boost::uuids::uuid tag;
+    
+    int state;
+};
+
+template <typename elem, typename traits>
+std::basic_ostream<elem, traits>& operator<<(std::basic_ostream<elem, traits>& os, object const& o)
+{
+    os << o.get_state();
+    return os;
+}
+
+int main(int, char*[])
+{
+    object o1(1);
+
+    object o2 = o1;
+    BOOST_TEST_EQ(o1, o2);
+
+    o2.set_state(2);
+    BOOST_TEST_EQ(o1, o2);
+    
+    object o3;
+    o3.set_state(3);
+
+    BOOST_TEST_NE(o1, o3);
+    BOOST_TEST_NE(o2, o3);
+    
+    return boost::report_errors();
+}

libs/uuid/test/test_uuid.cpp

@@ -0,0 +1,245 @@
+//  (C) Copyright Andy Tompkins 2007. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_uuid.cpp  -------------------------------//
+
+#include <iostream>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/current_function.hpp>
+
+void test_uuid_equal_array(char const * file, int line, char const * function,
+                           boost::uuids::uuid const& lhs, const unsigned char (&rhs)[16])
+{
+    for (size_t i=0; i<16; i++) {
+        if ( *(lhs.begin()+i) != rhs[i]) {
+            std::cerr << file << "(" << line << "): uuid " << lhs << " not equal " << "{";
+            for (size_t j=0; j<16; j++) {
+                if (j != 0) {
+                    std::cerr << " ";
+                }
+                std::cerr << std::hex << (int)rhs[j];
+            }
+            std::cerr << "} in function '" << function << "'" << std::endl;
+            ++boost::detail::test_errors();
+            return;
+        }
+    }
+}
+
+
+#define BOOST_TEST_UUID(lhs, rhs) ( test_uuid_equal_array(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION, lhs, rhs) )
+
+int main(int, char*[])
+{
+    using namespace boost::uuids;
+
+    // uuid::static_size
+    BOOST_TEST_EQ(uuid::static_size(), 16U);
+
+    { // uuid::operator=()
+        uuid u1 = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
+        uuid u2 = u1;
+        BOOST_TEST_EQ(u2, u1);
+    }
+
+    { // uuid::begin(), end()
+        uuid u = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
+        unsigned char values[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+        BOOST_TEST_UUID(u, values);
+    }
+
+    { // uuid::begin() const, end() const
+        const uuid u = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
+        unsigned char values[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+        BOOST_TEST_UUID(u, values);
+    }
+
+     { // uuid::size()
+        uuid u; // uninitialized
+        BOOST_TEST_EQ(u.size(), 16U);
+    }
+
+    { // uuid::is_nil()
+        uuid u1 = {{0}};
+        BOOST_TEST_EQ(u1.is_nil(), true);
+
+        uuid u2 = {{1,0}};
+        BOOST_TEST_EQ(u2.is_nil(), false);
+    }
+
+    { // uuid::variant()
+        struct Test {
+            unsigned char octet7;
+            boost::uuids::uuid::variant_type variant;
+        };
+        const Test tests[] =
+            { { 0x00, boost::uuids::uuid::variant_ncs }
+            , { 0x10, boost::uuids::uuid::variant_ncs }
+            , { 0x20, boost::uuids::uuid::variant_ncs }
+            , { 0x30, boost::uuids::uuid::variant_ncs }
+            , { 0x40, boost::uuids::uuid::variant_ncs }
+            , { 0x50, boost::uuids::uuid::variant_ncs }
+            , { 0x60, boost::uuids::uuid::variant_ncs }
+            , { 0x70, boost::uuids::uuid::variant_ncs }
+            , { 0x80, boost::uuids::uuid::variant_rfc_4122 }
+            , { 0x90, boost::uuids::uuid::variant_rfc_4122 }
+            , { 0xa0, boost::uuids::uuid::variant_rfc_4122 }
+            , { 0xb0, boost::uuids::uuid::variant_rfc_4122 }
+            , { 0xc0, boost::uuids::uuid::variant_microsoft }
+            , { 0xd0, boost::uuids::uuid::variant_microsoft }
+            , { 0xe0, boost::uuids::uuid::variant_future }
+            , { 0xf0, boost::uuids::uuid::variant_future }
+            };
+        for (size_t i=0; i<sizeof(tests)/sizeof(Test); i++) {
+            uuid u = { {} };
+            u.data[8] = tests[i].octet7; // note that octet7 is array index 8
+
+            BOOST_TEST_EQ(u.variant(), tests[i].variant);
+        }
+    }
+
+     { // uuid::version()
+        struct Test {
+            unsigned char octet9;
+            boost::uuids::uuid::version_type version;
+        };
+        const Test tests[] =
+            { { 0x00, boost::uuids::uuid::version_unknown }
+            , { 0x10, boost::uuids::uuid::version_time_based }
+            , { 0x20, boost::uuids::uuid::version_dce_security }
+            , { 0x30, boost::uuids::uuid::version_name_based_md5 }
+            , { 0x40, boost::uuids::uuid::version_random_number_based }
+            , { 0x50, boost::uuids::uuid::version_name_based_sha1 }
+            , { 0x60, boost::uuids::uuid::version_unknown }
+            , { 0x70, boost::uuids::uuid::version_unknown }
+            , { 0x80, boost::uuids::uuid::version_unknown }
+            , { 0x90, boost::uuids::uuid::version_unknown }
+            , { 0xa0, boost::uuids::uuid::version_unknown }
+            , { 0xb0, boost::uuids::uuid::version_unknown }
+            , { 0xc0, boost::uuids::uuid::version_unknown }
+            , { 0xd0, boost::uuids::uuid::version_unknown }
+            , { 0xe0, boost::uuids::uuid::version_unknown }
+            , { 0xf0, boost::uuids::uuid::version_unknown }
+            };
+        for (size_t i=0; i<sizeof(tests)/sizeof(Test); i++) {
+            uuid u = {{0}};
+            u.data[6] = tests[i].octet9; // note that octet9 is array index 8
+
+            BOOST_TEST_EQ(u.version(), tests[i].version);
+        }
+    }
+
+    { // uuid::swap(), swap()
+        uuid u1 = {{0}};
+        uuid u2 = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
+        u1.swap(u2);
+
+        unsigned char values1[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+        unsigned char values2[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+        BOOST_TEST_UUID(u1, values2);
+        BOOST_TEST_UUID(u2, values1);
+
+        swap(u1, u2);
+        BOOST_TEST_UUID(u1, values1);
+        BOOST_TEST_UUID(u2, values2);
+    }
+
+    { // test comparsion
+        uuid u1 = {{0}};
+        uuid u2 = {{1,0}};
+        uuid u3 = {{255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255}};
+        uuid u4 = {{0,1,0}};
+        uuid u5 = {{0,255,0}};
+
+        BOOST_TEST_EQ(u1, u1);
+
+        BOOST_TEST_NE(u1, u2);
+
+        BOOST_TEST(u1 < u2);
+        BOOST_TEST(u2 < u3);
+        BOOST_TEST(u1 < u4);
+        BOOST_TEST(u1 < u5);
+        BOOST_TEST(u4 < u5);
+        BOOST_TEST(u4 < u2);
+        BOOST_TEST(u5 < u2);
+
+        BOOST_TEST(u1 <= u1);
+        BOOST_TEST(u1 <= u2);
+        BOOST_TEST(u2 <= u3);
+
+        BOOST_TEST(u2 >= u1);
+        BOOST_TEST(u3 >= u1);
+
+        BOOST_TEST(u3 >= u3);
+        BOOST_TEST(u2 >= u1);
+        BOOST_TEST(u3 >= u1);
+    }
+
+    { // ticket 10510
+        // the uuids in the report
+        uuid u6 = {{0x14,0x5c,0xfc,0x95,0x80,0x50,0x45,0x5a,0x83,0x82,0x44,0xca,0x57,0xc1,0x48,0x3b}};
+        uuid u7 = {{0x14,0x5c,0xfc,0x95,0x80,0x50,0x45,0x5a,0x83,0x82,0x44,0xca,0x57,0xc1,0x48,0x3c}};
+
+        // simple uuids to reproduce problem
+        uuid u8 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}};
+        uuid u9 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2}};
+        uuid u10 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254}};
+        uuid u11 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255}};
+
+        // some additional uuids for testing boundary cases
+        uuid u12 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}};
+        uuid u13 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,2}};
+        uuid u14 = {{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}};
+        uuid u15 = {{255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255}};
+
+        BOOST_TEST(u6 < u7);
+        BOOST_TEST(!(u7 < u6));
+
+        BOOST_TEST(u8 < u9);
+        BOOST_TEST(!(u9 < u8));
+        BOOST_TEST(u8 < u10);
+        BOOST_TEST(!(u10 < u8));
+        BOOST_TEST(u8 < u11);
+        BOOST_TEST(!(u11 < u8));
+
+        BOOST_TEST(u9 < u10);
+        BOOST_TEST(!(u10 < u9));
+        BOOST_TEST(u9 < u11);
+        BOOST_TEST(!(u11 < u9));
+
+        BOOST_TEST(u10 < u11);
+        BOOST_TEST(!(u11 < u10));
+
+        BOOST_TEST(u12 < u13);
+        BOOST_TEST(!(u13 < u12));
+        BOOST_TEST(u14 < u15);
+        BOOST_TEST(!(u15 < u14));
+    }
+
+    { // test hash
+        uuid u1 = {{0}};
+        uuid u2 = {{1,0}};
+        uuid u3 = {{255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255}};
+
+        boost::hash<uuid> uuid_hasher;
+
+        BOOST_TEST_NE(uuid_hasher(u1), uuid_hasher(u2));
+        BOOST_TEST_NE(uuid_hasher(u1), uuid_hasher(u3));
+        BOOST_TEST_NE(uuid_hasher(u2), uuid_hasher(u3));
+    }
+
+    { // test is_pod
+        BOOST_TEST_EQ(boost::is_pod<uuid>::value, true);
+    }
+
+    return boost::report_errors();
+}

libs/uuid/test/test_uuid_class.cpp

@@ -0,0 +1,42 @@
+//  (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_uuid_class.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <boost/detail/lightweight_test.hpp>
+
+class uuid_class : public boost::uuids::uuid
+{
+public:
+    uuid_class()
+        : boost::uuids::uuid(boost::uuids::random_generator()())
+    {}
+    
+    explicit uuid_class(boost::uuids::uuid const& u)
+        : boost::uuids::uuid(u)
+    {}
+};
+
+int main(int, char*[])
+{
+    uuid_class u1;
+    uuid_class u2;
+    BOOST_TEST_NE(u1, u2);
+    BOOST_TEST_EQ(u1.is_nil(), false);
+    BOOST_TEST_EQ(u2.is_nil(), false);
+
+    u2 = u1;
+    BOOST_TEST_EQ(u1, u2);
+
+    return boost::report_errors();
+}

libs/uuid/test/test_uuid_in_map.cpp

@@ -0,0 +1,36 @@
+//  (C) Copyright Andy Tompkins 2011. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// libs/uuid/test/test_uuid_in_map.cpp  -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <map>
+
+#include <boost/detail/lightweight_test.hpp>
+
+int main(int, char*[])
+{
+    boost::uuids::random_generator gen;
+
+    boost::uuids::uuid u1 = gen();
+    boost::uuids::uuid u2 = gen();
+    boost::uuids::uuid u3 = gen();
+
+    std::map<boost::uuids::uuid, int> uuid_map;
+    uuid_map[u1] = 1;
+    uuid_map[u2] = 2;
+    uuid_map[u3] = 3;
+
+    BOOST_TEST_EQ(1, uuid_map[u1]);
+    BOOST_TEST_EQ(2, uuid_map[u2]);
+    BOOST_TEST_EQ(3, uuid_map[u3]);
+
+    return boost::report_errors();
+}

libs/uuid/test/test_uuid_no_simd.cpp

@@ -0,0 +1,153 @@
+//  (C) Copyright Andy Tompkins 2007. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  libs/uuid/test/test_uuid_no_simd.cpp  -------------------------------//
+
+// This test is a subset of libs/uuid/test/test_uuid.cpp, compiled without any
+// SIMD optimizations. The test specifically verifies generic implementations
+// of the routines.
+
+#define BOOST_UUID_NO_SIMD
+
+#include <iostream>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/current_function.hpp>
+
+void test_uuid_equal_array(char const * file, int line, char const * function,
+                           boost::uuids::uuid const& lhs, const unsigned char (&rhs)[16])
+{
+    for (size_t i=0; i<16; i++) {
+        if ( *(lhs.begin()+i) != rhs[i]) {
+            std::cerr << file << "(" << line << "): uuid " << lhs << " not equal " << "{";
+            for (size_t j=0; j<16; j++) {
+                if (j != 0) {
+                    std::cerr << " ";
+                }
+                std::cerr << std::hex << (int)rhs[j];
+            }
+            std::cerr << "} in function '" << function << "'" << std::endl;
+            ++boost::detail::test_errors();
+            return;
+        }
+    }
+}
+
+
+#define BOOST_TEST_UUID(lhs, rhs) ( test_uuid_equal_array(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION, lhs, rhs) )
+
+
+int main(int, char*[])
+{
+    using namespace boost::uuids;
+
+    { // uuid::operator=()
+        uuid u1 = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
+        uuid u2 = u1;
+        BOOST_TEST_EQ(u2, u1);
+    }
+
+    { // uuid::is_nil()
+        uuid u1 = {{0}};
+        BOOST_TEST_EQ(u1.is_nil(), true);
+
+        uuid u2 = {{1,0}};
+        BOOST_TEST_EQ(u2.is_nil(), false);
+    }
+
+    { // uuid::swap(), swap()
+        uuid u1 = {{0}};
+        uuid u2 = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
+        u1.swap(u2);
+
+        unsigned char values1[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+        unsigned char values2[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+        BOOST_TEST_UUID(u1, values2);
+        BOOST_TEST_UUID(u2, values1);
+
+        swap(u1, u2);
+        BOOST_TEST_UUID(u1, values1);
+        BOOST_TEST_UUID(u2, values2);
+    }
+
+    { // test comparsion
+        uuid u1 = {{0}};
+        uuid u2 = {{1,0}};
+        uuid u3 = {{255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255}};
+        uuid u4 = {{0,1,0}};
+        uuid u5 = {{0,255,0}};
+
+        BOOST_TEST_EQ(u1, u1);
+
+        BOOST_TEST_NE(u1, u2);
+
+        BOOST_TEST(u1 < u2);
+        BOOST_TEST(u2 < u3);
+        BOOST_TEST(u1 < u4);
+        BOOST_TEST(u1 < u5);
+        BOOST_TEST(u4 < u5);
+        BOOST_TEST(u4 < u2);
+        BOOST_TEST(u5 < u2);
+
+        BOOST_TEST(u1 <= u1);
+        BOOST_TEST(u1 <= u2);
+        BOOST_TEST(u2 <= u3);
+
+        BOOST_TEST(u2 >= u1);
+        BOOST_TEST(u3 >= u1);
+
+        BOOST_TEST(u3 >= u3);
+        BOOST_TEST(u2 >= u1);
+        BOOST_TEST(u3 >= u1);
+    }
+
+    { // ticket 10510
+        // the uuids in the report
+        uuid u6 = {{0x14,0x5c,0xfc,0x95,0x80,0x50,0x45,0x5a,0x83,0x82,0x44,0xca,0x57,0xc1,0x48,0x3b}};
+        uuid u7 = {{0x14,0x5c,0xfc,0x95,0x80,0x50,0x45,0x5a,0x83,0x82,0x44,0xca,0x57,0xc1,0x48,0x3c}};
+
+        // simple uuids to reproduce problem
+        uuid u8 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}};
+        uuid u9 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2}};
+        uuid u10 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254}};
+        uuid u11 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255}};
+
+        // some additional uuids for testing boundary cases
+        uuid u12 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}};
+        uuid u13 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,2}};
+        uuid u14 = {{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}};
+        uuid u15 = {{255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255}};
+
+        BOOST_TEST(u6 < u7);
+        BOOST_TEST(!(u7 < u6));
+
+        BOOST_TEST(u8 < u9);
+        BOOST_TEST(!(u9 < u8));
+        BOOST_TEST(u8 < u10);
+        BOOST_TEST(!(u10 < u8));
+        BOOST_TEST(u8 < u11);
+        BOOST_TEST(!(u11 < u8));
+
+        BOOST_TEST(u9 < u10);
+        BOOST_TEST(!(u10 < u9));
+        BOOST_TEST(u9 < u11);
+        BOOST_TEST(!(u11 < u9));
+
+        BOOST_TEST(u10 < u11);
+        BOOST_TEST(!(u11 < u10));
+
+        BOOST_TEST(u12 < u13);
+        BOOST_TEST(!(u13 < u12));
+        BOOST_TEST(u14 < u15);
+        BOOST_TEST(!(u15 < u14));
+    }
+
+    return boost::report_errors();
+}

libs/uuid/test/test_wserialization.cpp

@@ -0,0 +1,71 @@
+//  (C) Copyright Andy Tompkins 2008. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Purpose to test serializing uuids with wide stream archives
+
+#include <boost/detail/lightweight_test.hpp>
+#include <sstream>
+#include <iostream>
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_serialize.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <boost/archive/text_woarchive.hpp>
+#include <boost/archive/text_wiarchive.hpp>
+
+#include <boost/archive/xml_woarchive.hpp>
+#include <boost/archive/xml_wiarchive.hpp>
+
+#include <boost/archive/binary_woarchive.hpp>
+#include <boost/archive/binary_wiarchive.hpp>
+
+template <class OArchiveType, class IArchiveType, class OStringStreamType, class IStringStreamType>
+void test_archive()
+{
+    using namespace std;
+    using namespace boost::uuids;
+    
+    OStringStreamType o_stream;
+    
+    uuid u1 = {{0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef}};
+
+    uuid u2;
+    
+    // save
+    {
+        OArchiveType oa(o_stream);
+        
+        oa << BOOST_SERIALIZATION_NVP(u1);
+    }
+    
+    //wcout << "stream:" << o_stream.str() << "\n\n";
+    
+    // load
+    {
+        IStringStreamType i_stream(o_stream.str());
+        IArchiveType ia(i_stream);
+        
+        ia >> BOOST_SERIALIZATION_NVP(u2);
+    }
+    
+    BOOST_TEST_EQ(u1, u2);
+}
+
+int test_main( int /* argc */, char* /* argv */[] )
+{
+    using namespace std;
+    using namespace boost::archive;
+    
+    test_archive<text_woarchive, text_wiarchive, wostringstream, wistringstream>();
+    test_archive<xml_woarchive, xml_wiarchive, wostringstream, wistringstream>();
+    test_archive<binary_woarchive, binary_wiarchive, wostringstream, wistringstream>();
+
+    return boost::report_errors();
+}