Added tests for generateRandom.

3 files changed, 90 insertions, 44 deletions

diff --git a/cpp/include/IceUtil/Random.h b/cpp/include/IceUtil/Random.h
index d92ffe4d1b4..64c010ba2c5 100644
--- a/cpp/include/IceUtil/Random.h
+++ b/cpp/include/IceUtil/Random.h
@@ -35,7 +35,7 @@ private:
 };
 
 ICE_UTIL_API void generateRandom(char*, int);
-ICE_UTIL_API int random(int);
+ICE_UTIL_API int random(int = 0);
 
 }
 
diff --git a/cpp/src/IceUtil/Random.cpp b/cpp/src/IceUtil/Random.cpp
index e7cd4c18a31..501e6582cd8 100644
--- a/cpp/src/IceUtil/Random.cpp
+++ b/cpp/src/IceUtil/Random.cpp
@@ -197,5 +197,5 @@ IceUtil::random(int limit)
 {
     int r;
     generateRandom(reinterpret_cast<char*>(&r), sizeof(int));
-    return r % limit;
+    return limit == 0 ? r : r % limit;
 }
diff --git a/cpp/test/IceUtil/uuid/Client.cpp b/cpp/test/IceUtil/uuid/Client.cpp
index 5515b44a542..969bb8f4f2c 100644
--- a/cpp/test/IceUtil/uuid/Client.cpp
+++ b/cpp/test/IceUtil/uuid/Client.cpp
@@ -8,6 +8,7 @@
 // **********************************************************************
 
 #include <IceUtil/UUID.h>
+#include <IceUtil/Random.h>
 #include <IceUtil/Time.h>
 #include <IceUtil/Thread.h>
 #include <IceUtil/StaticMutex.h>
@@ -26,29 +27,29 @@ inline void usage(const char* myName)
     cerr << "Usage: " << myName << " [number of UUIDs to generate] [number of threads]" << endl;
 }
 
-class InsertThread : public Thread
+template<typename T, typename GenerateFunc> class InsertThread : public Thread
 {
 public:
-
     
-    InsertThread(int threadId, set<string>& uuidSet, long howMany, bool verbose)
-	: _threadId(threadId), _uuidSet(uuidSet), _howMany(howMany), _verbose(verbose)
+    typedef set<T> ItemSet;
+    
+    InsertThread(int threadId, ItemSet& itemSet, GenerateFunc func, long howMany, bool verbose)
+	: _threadId(threadId), _itemSet(itemSet), _func(func), _howMany(howMany), _verbose(verbose)
     {
     }
 
-
     void run()
     {
 	for(long i = 0; i < _howMany; i++)
 	{
-	    string uuid = generateUUID();
+	    T item = _func();
 
 	    StaticMutex::Lock lock(staticMutex);
-	    pair<set<string>::iterator, bool> ok = _uuidSet.insert(uuid);
+	    pair<typename ItemSet::iterator, bool> ok = _itemSet.insert(item);
 	    if(!ok.second)
 	    {
 		cerr << "******* iteration " << i << endl;
-		cerr << "******* Duplicate UUID: " << *ok.first << endl;
+		cerr << "******* Duplicate item: " << *ok.first << endl;
 	    }
 
 	    test(ok.second);
@@ -62,50 +63,53 @@ public:
 
 
 private:
+
     int _threadId;
-    set<string>& _uuidSet;
+    ItemSet& _itemSet;
+    GenerateFunc _func;
     long _howMany;
     bool _verbose;
 };
 
-int main(int argc, char* argv[])
+struct GenerateUUID
 {
-    long howMany = 300000;
-    int threadCount = 3;
-    bool verbose = false;
-
-    if(argc > 3)
+    string
+    operator()()
     {
-	usage(argv[0]);
-	return EXIT_FAILURE;
+	return generateUUID();
     }
-    else if(argc == 3)
+};
+
+struct GenerateRandomString
+{
+    string
+    operator()()
     {
-	howMany = atol(argv[1]);
-	if (howMany == 0)
-	{
-	    usage(argv[0]);
-	    return EXIT_FAILURE;
-	}
-	threadCount = atoi(argv[2]);
-	if(threadCount <= 0)
+	string s;
+	s.resize(20);
+	char buf[20];
+	IceUtil::generateRandom(buf, sizeof(buf));
+	for(unsigned int i = 0; i < sizeof(buf); ++i)
 	{
-	    usage(argv[0]);
-	    return EXIT_FAILURE;
+	    s[i] = 33 + buf[i] % (127-33); // We use ASCII 33-126 (from ! to ~, w/o space).
 	}
-	verbose = true;
+	return s;
     }
-    else if(argc == 2)
+};
+
+struct GenerateRandomInt
+{
+    int
+    operator()()
     {
-	howMany = atol(argv[1]);
-	if (howMany == 0)
-	{
-	    usage(argv[0]);
-	    return EXIT_FAILURE;
-	}
+	return IceUtil::random();
     }
-    
-    cout << "Generating " << howMany << " UUIDs using " << threadCount << " thread";
+};
+
+template<typename T, typename GenerateFunc> void
+runTest(int threadCount, GenerateFunc func, long howMany, bool verbose, string name)
+{
+    cout << "Generating " << howMany << " " << name << "s using " << threadCount << " thread";
     if(threadCount > 1)
     {
 	cout << "s";
@@ -121,14 +125,14 @@ int main(int argc, char* argv[])
 	cout << flush;
     }
 
-    set<string> uuidSet;
+    set<T> itemSet;
     
     vector<ThreadControl> threads;
 
     Time start = Time::now();
     for(int i = 0; i < threadCount; i++)
     {
-	ThreadPtr t = new InsertThread(i, uuidSet, howMany / threadCount, verbose); 
+	ThreadPtr t = new InsertThread<T, GenerateFunc>(i, itemSet, func, howMany / threadCount, verbose); 
 	threads.push_back(t->start());
     }
     for(vector<ThreadControl>::iterator p = threads.begin(); p != threads.end(); ++p)
@@ -141,11 +145,53 @@ int main(int argc, char* argv[])
 
     if(verbose)
     {
-        cout << "Each UUID took an average of "  
+        cout << "Each " << name << " took an average of "  
 	     << (double) ((finish - start).toMicroSeconds()) / howMany 
-	     << " micro seconds to generate and insert into a set<string>." 
+	     << " micro seconds to generate and insert into a set." 
 	     << endl;
     }
+}
+
+int main(int argc, char* argv[])
+{
+    long howMany = 300000;
+    int threadCount = 3;
+    bool verbose = false;
+
+    if(argc > 3)
+    {
+	usage(argv[0]);
+	return EXIT_FAILURE;
+    }
+    else if(argc == 3)
+    {
+	howMany = atol(argv[1]);
+	if (howMany == 0)
+	{
+	    usage(argv[0]);
+	    return EXIT_FAILURE;
+	}
+	threadCount = atoi(argv[2]);
+	if(threadCount <= 0)
+	{
+	    usage(argv[0]);
+	    return EXIT_FAILURE;
+	}
+	verbose = true;
+    }
+    else if(argc == 2)
+    {
+	howMany = atol(argv[1]);
+	if (howMany == 0)
+	{
+	    usage(argv[0]);
+	    return EXIT_FAILURE;
+	}
+    }
 
+    runTest<string, GenerateUUID>(threadCount, GenerateUUID(), howMany, verbose, "UUID");
+    runTest<string, GenerateRandomString>(threadCount, GenerateRandomString(), howMany, verbose, "string");
+//    runTest<int, GenerateRandomInt>(threadCount, GenerateRandomInt(), howMany, verbose, "integer");
+    
     return EXIT_SUCCESS;
 }