Add some tests for the unordered associative containers.

[SVN r2954]

test/helpers/generators.hpp

@@ -0,0 +1,88 @@
+
+//  Copyright Daniel James 2005-2006. 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)
+
+// A crude wrapper round Boost.Random to make life easier.
+
+#if !defined(BOOST_UNORDERED_TEST_HELPERS_GENERATORS_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_GENERATORS_HEADER
+
+#include <string>
+#include <utility>
+
+#include <boost/random/inversive_congruential.hpp>
+#include <boost/random/uniform_int.hpp>
+#include <boost/random/lagged_fibonacci.hpp>
+#include <boost/random/uniform_real.hpp>
+#include <boost/random/variate_generator.hpp>
+
+#include "./fwd.hpp"
+
+namespace test
+{
+    typedef boost::hellekalek1995 integer_generator_type;
+    typedef boost::lagged_fibonacci607 real_generator_type;
+
+    template <class T>
+    struct generator
+    {
+        typedef T value_type;
+        value_type operator()()
+        {
+            return generate((T const*) 0);
+        }
+    };
+
+    inline int generate(int const*)
+    {
+        static boost::variate_generator<integer_generator_type, boost::uniform_int<> >
+            vg((integer_generator_type()), boost::uniform_int<>(0, 1000));
+        return vg();
+    }
+
+    inline char generate(char const*)
+    {
+        static boost::variate_generator<integer_generator_type, boost::uniform_int<char> >
+            vg((integer_generator_type()), boost::uniform_int<char>(32, 128));
+        return vg();
+    }
+
+    inline std::string generate(std::string const*)
+    {
+        using namespace std;
+
+        static test::generator<char> char_gen;
+
+        std::string result;
+
+        int length = rand() % 10;
+        for(int i = 0; i < length; ++i)
+            result += char_gen();
+
+        //std::generate_n(
+        //        std::back_inserter(result),
+        //        rand() % 10,
+        //        char_gen);
+
+        return result;
+    }
+
+    float generate(float const*)
+    {
+        static boost::variate_generator<real_generator_type, boost::uniform_real<float> >
+            vg((real_generator_type()), boost::uniform_real<float>());
+        return vg();
+    }
+
+    template <class T1, class T2> std::pair<T1, T2> generate(
+            std::pair<T1, T2>  const*)
+    {
+        static generator<T1> g1;
+        static generator<T2> g2;
+
+        return std::pair<T1, T2>(g1(), g2());
+    }
+}
+
+#endif