Make parallel unit testing work on windows

tests/PathOpsCubicIntersectionTestData.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "PathOpsCubicIntersectionTestData.h"
 #include <limits>
 
 static const double D = FLT_EPSILON / 2;
@@ skipping 79 matching lines @@
         {{{1, 6.5}, {12.5, 1},   {-4, 1},   {.5, 6}}}
     }, {
         {{{315.748, 312.84}, {312.644, 318.134}, {305.836, 319.909}, {300.542, 316.804}}},
         {{{317.122, 309.05}, {316.112, 315.102}, {310.385, 319.19},  {304.332, 318.179}}}
     }, {
         {{{1046.604051, 172.937967},  {1046.604051, 178.9763059}, {1041.76745,  183.9279165}, {1035.703842, 184.0432409}}},
         {{{1046.452235, 174.7640504}, {1045.544872, 180.1973817}, {1040.837966, 184.0469882}, {1035.505925, 184.0469882}}}
     }, {
         {{{125.79356, 199.57382}, {51.16556, 128.93575}, {87.494,  16.67848}, {167.29361, 16.67848}}},
         {{{167.29361, 55.81876}, {100.36128, 55.81876}, {68.64099, 145.4755}, {125.7942, 199.57309}}}
+    }, {
+        {{{104.11546583642826, 370.21352558595504}, {122.96968232592344, 404.54489231839295},
+          {169.90881005384728, 425.00067000000007}, {221.33045999999999, 425.00067000000001}}},
+        {{{116.32365976159625, 381.71048540582598}, {103.86096590870899, 381.71048540581626},
+          {91.394188003200725, 377.17917781762833}, {82.622283093355179, 368.11683661930334}}}
     }
 };
 
 const size_t tests_count = sizeof(tests) / sizeof(tests[0]);
 
-SkDCubic hexTests[][2] = {
-    {
-        // placeholder for hex converted below
-        {{{0, 0}, {0, 0}, {0, 0}, {0, 0}}}, {{{0, 0}, {0, 0}, {0, 0}, {0, 0}}}
-    }
-};
-
-const size_t hexTests_count = sizeof(hexTests) / sizeof(hexTests[0]);
-
-static const uint64_t testx[2][8] = {
-    {
-        0xf0d0d1ca63075a40LLU, 0x9408ce996a237740LLU, 0x6d5675460fbe5e40LLU, 0x6ef501e1b7487940LLU,
-        0x9a71d2f8143d6540LLU, 0x6bc18bbe02907a40LLU, 0x5b94d92093aa6b40LLU, 0x6ac18bbe02907a40LLU
-    },
-    {
-        0x92c56ed7b6145d40LLU, 0xede4f1255edb7740LLU, 0x1138c1101af75940LLU, 0x42e4f1255edb7740LLU,
-        0x408e51603ad95640LLU, 0x1e2e8fe9dd927740LLU, 0x1cb4777cd3a75440LLU, 0x212e1390de017740LLU
-    }
-};
-
-void convert_testx() {
-    const uint64_t* inPtr = testx[0];
-    double* outPtr = &hexTests[sizeof(tests) / sizeof(tests[0]) - 1][0][0].fX;
-    for (unsigned index = 0; index < sizeof(testx) / sizeof(testx[0][0]); ++index) {
-        uint64_t input = *inPtr++;
-        unsigned char* output = (unsigned char*) outPtr++;
-        for (unsigned byte = 0; byte < sizeof(input); ++byte) {
-            output[byte] = input >> (7 - byte) * 8;
-        }
-    }
-}
-
 const SkDCubic lines[] = {
     {{{0, 0}, {0, 0}, {0, 0}, {1, 0}}},  // 0: horizontal
     {{{1, 0}, {0, 0}, {0, 0}, {0, 0}}},
     {{{1, 0}, {2, 0}, {3, 0}, {4, 0}}},
     {{{0, 0}, {0, 0}, {0, 0}, {0, 1}}},  // 5: vertical
     {{{0, 1}, {0, 0}, {0, 0}, {0, 0}}},
     {{{0, 1}, {0, 2}, {0, 3}, {0, 4}}},
     {{{0, 0}, {0, 0}, {0, 0}, {1, 1}}},  // 10: 3 coincident
     {{{1, 1}, {0, 0}, {0, 0}, {0, 0}}},
     {{{0, 0}, {0, 0}, {1, 1}, {2, 2}}},  // 14: 2 coincident
@@ skipping 144 matching lines @@
     {{{1, 1}, {4, 4}, {3, 3}, {2+M, 2}}},  // INVESTIGATE: why the epsilon is smaller
     {{{2, 2}, {1, 1}, {3+N, 3}, {4, 4}}},
     {{{2, 2}, {1+N, 1}, {4, 4}, {3, 3}}},
     {{{2, 2+N}, {3, 3}, {1, 1}, {4, 4}}},
     {{{2+M, 2}, {3, 3}, {4, 4}, {1, 1}}},  // INVESTIGATE: why the epsilon is smaller
     {{{2, 2}, {4+N, 4}, {1, 1}, {3, 3}}},
     {{{2, 2}, {4, 4}, {3, 3}, {1, 1+N}}},
 };
 
 const size_t negEpsilonLines_count = sizeof(negEpsilonLines) / sizeof(negEpsilonLines[0]);