Change old PRG to be SkLCGRandom; change new one to SkRandom

tests/MathTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Test.h"
 #include "SkFloatBits.h"
 #include "SkFloatingPoint.h"
 #include "SkMathPriv.h"
 #include "SkPoint.h"
 #include "SkRandom.h"
 #include "SkColorPriv.h"
 
 static void test_clz(skiatest::Reporter* reporter) {
     REPORTER_ASSERT(reporter, 32 == SkCLZ(0));
     REPORTER_ASSERT(reporter, 31 == SkCLZ(1));
     REPORTER_ASSERT(reporter, 1 == SkCLZ(1 << 30));
     REPORTER_ASSERT(reporter, 0 == SkCLZ(~0U));
 
-    SkMWCRandom rand;
+    SkRandom rand;
     for (int i = 0; i < 1000; ++i) {
         uint32_t mask = rand.nextU();
         // need to get some zeros for testing, but in some obscure way so the
         // compiler won't "see" that, and work-around calling the functions.
         mask >>= (mask & 31);
         int intri = SkCLZ(mask);
         int porta = SkCLZ_portable(mask);
         REPORTER_ASSERT(reporter, intri == porta);
     }
 }
@@ skipping 42 matching lines @@
 
     for (int a = 0; a <= 32767; ++a) {
         for (int b = 0; b <= 32767; ++b) {
             unsigned prod0 = SkMul16ShiftRound(a, b, 8);
             unsigned prod1 = SkMulDiv255Round(a, b);
             SkASSERT(prod0 == prod1);
         }
     }
 #endif
 
-    SkMWCRandom rand;
+    SkRandom rand;
     for (int i = 0; i < 10000; ++i) {
         unsigned a = rand.nextU() & 0x7FFF;
         unsigned b = rand.nextU() & 0x7FFF;
 
         unsigned prod0 = SkMul16ShiftRound(a, b, 8);
         unsigned prod1 = SkMulDiv255Round(a, b);
 
         REPORTER_ASSERT(reporter, prod0 == prod1);
     }
 }
@@ skipping 116 matching lines @@
                          const SkPoint& p, SkScalar targetLen) {
     float x = SkScalarToFloat(p.fX);
     float y = SkScalarToFloat(p.fY);
     float len = sk_float_sqrt(x*x + y*y);
 
     len /= SkScalarToFloat(targetLen);
 
     REPORTER_ASSERT(reporter, len > 0.999f && len < 1.001f);
 }
 
-static float nextFloat(SkMWCRandom& rand) {
+static float nextFloat(SkRandom& rand) {
     SkFloatIntUnion data;
     data.fSignBitInt = rand.nextU();
     return data.fFloat;
 }
 
 /*  returns true if a == b as resulting from (int)x. Since it is undefined
  what to do if the float exceeds 2^32-1, we check for that explicitly.
  */
 static bool equal_float_native_skia(float x, uint32_t ni, uint32_t si) {
     if (!(x == x)) {    // NAN
@@ skipping 53 matching lines @@
 
 static void test_int2float(skiatest::Reporter* reporter, int ival) {
     float x0 = (float)ival;
     float x1 = SkIntToFloatCast(ival);
     float x2 = SkIntToFloatCast_NoOverflowCheck(ival);
     REPORTER_ASSERT(reporter, x0 == x1);
     REPORTER_ASSERT(reporter, x0 == x2);
 }
 
 static void unittest_fastfloat(skiatest::Reporter* reporter) {
-    SkMWCRandom rand;
+    SkRandom rand;
     size_t i;
 
     static const float gFloats[] = {
         0.f, 1.f, 0.5f, 0.499999f, 0.5000001f, 1.f/3,
         0.000000001f, 1000000000.f,     // doesn't overflow
         0.0000000001f, 10000000000.f    // does overflow
     };
     for (i = 0; i < SK_ARRAY_COUNT(gFloats); i++) {
         test_float_conversions(reporter, gFloats[i]);
         test_float_conversions(reporter, -gFloats[i]);
@@ skipping 100 matching lines @@
     };
     for (size_t i = 0; i < SK_ARRAY_COUNT(gTriples); i += 3) {
         REPORTER_ASSERT(reporter,
                         SkCopySign32(gTriples[i], gTriples[i+1]) == gTriples[i+2]);
         float x = (float)gTriples[i];
         float y = (float)gTriples[i+1];
         float expected = (float)gTriples[i+2];
         REPORTER_ASSERT(reporter, sk_float_copysign(x, y) == expected);
     }
 
-    SkMWCRandom rand;
+    SkRandom rand;
     for (int j = 0; j < 1000; j++) {
         int ix = rand.nextS();
         REPORTER_ASSERT(reporter, SkCopySign32(ix, ix) == ix);
         REPORTER_ASSERT(reporter, SkCopySign32(ix, -ix) == -ix);
         REPORTER_ASSERT(reporter, SkCopySign32(-ix, ix) == ix);
         REPORTER_ASSERT(reporter, SkCopySign32(-ix, -ix) == -ix);
 
         SkScalar sx = rand.nextSScalar1();
         REPORTER_ASSERT(reporter, SkScalarCopySign(sx, sx) == sx);
         REPORTER_ASSERT(reporter, SkScalarCopySign(sx, -sx) == -sx);
         REPORTER_ASSERT(reporter, SkScalarCopySign(-sx, sx) == sx);
         REPORTER_ASSERT(reporter, SkScalarCopySign(-sx, -sx) == -sx);
     }
 }
 
 static void TestMath(skiatest::Reporter* reporter) {
     int         i;
     int32_t     x;
-    SkMWCRandom    rand;
+    SkRandom    rand;
 
     // these should assert
 #if 0
     SkToS8(128);
     SkToS8(-129);
     SkToU8(256);
     SkToU8(-5);
 
     SkToS16(32768);
     SkToS16(-32769);
@@ skipping 237 matching lines @@
     }
     for (size_t i = 0; i < SK_ARRAY_COUNT(g32); ++i) {
         REPORTER_ASSERT(reporter, g32[i].fYang == SkEndianSwap32(g32[i].fYin));
     }
     for (size_t i = 0; i < SK_ARRAY_COUNT(g64); ++i) {
         REPORTER_ASSERT(reporter, g64[i].fYang == SkEndianSwap64(g64[i].fYin));
     }
 }
 
 DEFINE_TESTCLASS("Endian", EndianTestClass, TestEndian)