Add another random generation style.

This time for a more limited range of values so that equal values turn
up more often.  This is a bit shoddy, but seems like the best way to
improve the existing tests without too much effort.

test/helpers/fwd.hpp

@@ -10,11 +10,17 @@
 
 namespace test
 {
-    int generate(int const*);
-    char generate(char const*);
-    signed char generate(signed char const*);
-    std::string generate(std::string*);
-    float generate(float const*);
+    typedef enum {
+        default_generator,
+        generate_collisions,
+        limited_range
+    } random_generator;
+
+    int generate(int const*, random_generator);
+    char generate(char const*, random_generator);
+    signed char generate(signed char const*, random_generator);
+    std::string generate(std::string const*, random_generator);
+    float generate(float const*, random_generator);
 
     struct base_type {} base;
     struct derived_type : base_type {} derived;

test/helpers/generators.hpp

@@ -27,25 +27,32 @@ namespace test
         }
     };
 
-    inline int generate(int const*)
-    {
+    std::size_t random_value(std::size_t max) {
         using namespace std;
-        return rand();
+        return static_cast<std::size_t>(rand()) % max;
     }
 
-    inline char generate(char const*)
+    inline int generate(int const*, random_generator g)
+    {
+        using namespace std;
+        int value = rand();
+        if (g == limited_range) { value = value % 100; }
+        return value;
+    }
+
+    inline char generate(char const*, random_generator)
     {
         using namespace std;
         return static_cast<char>((rand() >> 1) % (128-32) + 32);
     }
 
-    inline signed char generate(signed char const*)
+    inline signed char generate(signed char const*, random_generator)
     {
         using namespace std;
         return static_cast<signed char>(rand());
     }
 
-    inline std::string generate(std::string const*)
+    inline std::string generate(std::string const*, random_generator g)
     {
         using namespace std;
 
@@ -53,17 +60,30 @@ namespace test
 
         std::string result;
 
-        int length = rand() % 10;
-        for(int i = 0; i < length; ++i)
-            result += generate(char_ptr);
+        if (g == limited_range) {
+            std::size_t length = test::random_value(2) + 2;
+
+            char const* strings[] = { "'vZh(3~ms", "%m", "_Y%U", "N'Y", "4,J_J" };
+            for (std::size_t i = 0; i < length; ++i) {
+                result += strings[random_value(sizeof(strings) / sizeof(strings[0]))];
+            }
+        }
+        else {
+            std::size_t length = test::random_value(10) + 1;
+            for (std::size_t i = 0; i < length; ++i) {
+                result += generate(char_ptr, g);
+            }
+        }
 
         return result;
     }
 
-    float generate(float const*)
+    float generate(float const*, random_generator g)
     {
         using namespace std;
-        return (float) rand() / (float) RAND_MAX;
+        int x = 0;
+        int value = generate(&x, g);
+        return (float) value / (float) RAND_MAX;
     }
 }
 

test/helpers/random_values.hpp

@@ -14,11 +14,6 @@
 
 namespace test
 {
-    typedef enum {
-        default_generator,
-        generate_collisions
-    } random_generator;
-
     template <class X>
     struct unordered_generator_set
     {
@@ -32,16 +27,15 @@ namespace test
         template <class T>
         void fill(T& x, std::size_t len) {
             value_type* value_ptr = 0;
-            int* int_ptr = 0;
             len += x.size();
 
             for (std::size_t i = 0; i < len; ++i) {
-                value_type value = generate(value_ptr);
+                value_type value = generate(value_ptr, type_);
 
-                int count = type_ == generate_collisions ?
-                    1 + (generate(int_ptr) % 5) : 1;
+                std::size_t count = type_ == generate_collisions ?
+                    random_value(5) + 1 : 1;
 
-                for(int j = 0; j < count; ++j) {
+                for(std::size_t j = 0; j < count; ++j) {
                     x.push_back(value);
                 }
             }
@@ -63,17 +57,16 @@ namespace test
         void fill(T& x, std::size_t len) {
             key_type* key_ptr = 0;
             mapped_type* mapped_ptr = 0;
-            int* int_ptr = 0;
 
             for (std::size_t i = 0; i < len; ++i) {
-                key_type key = generate(key_ptr);
+                key_type key = generate(key_ptr, type_);
 
-                int count = type_ == generate_collisions ?
-                    1 + (generate(int_ptr) % 5) : 1;
+                std::size_t count = type_ == generate_collisions ?
+                    random_value(5) + 1 : 1;
 
-                for(int j = 0; j < count; ++j) {
+                for(std::size_t j = 0; j < count; ++j) {
                     x.push_back(std::pair<key_type const, mapped_type>(
-                        key, generate(mapped_ptr)));
+                        key, generate(mapped_ptr, type_)));
                 }
             }
         }