Improve reproducibility of test runs.

test/cctest/test-types.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <list>
 
 #include "cctest.h"
 #include "types.h"
+#include "utils/random-number-generator.h"
 
 using namespace v8::internal;
 
 template<class Type, class TypeHandle, class Region>
 class Types {
  public:
   Types(Region* region, Isolate* isolate) :
       Representation(Type::Representation(region)),
       Semantic(Type::Semantic(region)),
       None(Type::None(region)),
@@ skipping 63 matching lines @@
       types.push_back(Fuzz());
     }
 
     objects.push_back(smi);
     objects.push_back(signed32);
     objects.push_back(object1);
     objects.push_back(object2);
     objects.push_back(array);
   }
 
+  RandomNumberGenerator rng;
+
   TypeHandle Representation;
   TypeHandle Semantic;
   TypeHandle None;
   TypeHandle Any;
   TypeHandle Boolean;
   TypeHandle Null;
   TypeHandle Undefined;
   TypeHandle Number;
   TypeHandle SignedSmall;
   TypeHandle Signed32;
@@ skipping 48 matching lines @@
   TypeHandle Intersect(TypeHandle t1, TypeHandle t2) {
     return Type::Intersect(t1, t2, region_);
   }
 
   template<class Type2, class TypeHandle2>
   TypeHandle Convert(TypeHandle2 t) {
     return Type::template Convert<Type2>(t, region_);
   }
 
   TypeHandle Fuzz(int depth = 5) {
-    switch (rand() % (depth == 0 ? 3 : 20)) {
+    switch (rng.NextInt(depth == 0 ? 3 : 20)) {
       case 0: {  // bitset
         int n = 0
         #define COUNT_BITSET_TYPES(type, value) + 1
         BITSET_TYPE_LIST(COUNT_BITSET_TYPES)
         #undef COUNT_BITSET_TYPES
         ;
-        int i = rand() % n;
+        int i = rng.NextInt(n);
         #define PICK_BITSET_TYPE(type, value) \
           if (i-- == 0) return Type::type(region_);
         BITSET_TYPE_LIST(PICK_BITSET_TYPE)
         #undef PICK_BITSET_TYPE
         UNREACHABLE();
       }
       case 1:  // class
-        switch (rand() % 2) {
+        switch (rng.NextInt(2)) {
           case 0: return ObjectClass;
           case 1: return ArrayClass;
         }
         UNREACHABLE();
       case 2:  // constant
-        switch (rand() % 6) {
+        switch (rng.NextInt(6)) {
           case 0: return SmiConstant;
           case 1: return Signed32Constant;
           case 2: return ObjectConstant1;
           case 3: return ObjectConstant2;
           case 4: return ArrayConstant1;
           case 5: return ArrayConstant2;
         }
         UNREACHABLE();
       default: {  // union
-        int n = rand() % 10;
+        int n = rng.NextInt(10);
         TypeHandle type = None;
         for (int i = 0; i < n; ++i) {
           type = Type::Union(type, Fuzz(depth - 1), region_);
         }
         return type;
       }
     }
     UNREACHABLE();
   }
 
@@ skipping 872 matching lines @@
   ZoneTests().Intersect();
   HeapTests().Intersect();
 }
 
 
 TEST(Convert) {
   CcTest::InitializeVM();
   ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
   HeapTests().Convert<Type, Type*, Zone, ZoneRep>();
 }