Fix fuzzing condition to loop neighbors

Author: chusitoo

flatbush.h

@@ -69,7 +69,7 @@ class span {
 namespace flatbush {
 
 constexpr auto gMaxHilbert = std::numeric_limits<uint16_t>::max();
-constexpr auto gMaxDistance = std::numeric_limits<double>::max();
+constexpr auto gMaxDistance = 1.34078e+154;  // std::sqrt(std::numeric_limits<double>::max())
 constexpr auto gMaxResults = std::numeric_limits<size_t>::max();
 constexpr auto gInvalidArrayType = std::numeric_limits<uint8_t>::max();
 constexpr uint16_t gMinNodeSize = 2;
@@ -416,6 +416,7 @@ class Flatbush {
 
   inline bool canDoNeighbors(const Point<ArrayType>& iPoint,
                              size_t iMaxResults,
+                             double iMaxDistance,
                              double iMaxDistSquared) const {
 #if defined(_WIN32) || defined(_WIN64)
     // On Windows, isnan throws on anything that is not float, double or long double
@@ -429,8 +430,8 @@ class Flatbush {
     const auto wDistY = axisDistance(iPoint.mY, mBounds.mMinY, mBounds.mMaxY);
     const auto wDistance = wDistX * wDistX + wDistY * wDistY;
 
-    return !wIsNanPoint && iMaxResults != 0UL && !std::isnan(iMaxDistSquared) &&
-           iMaxDistSquared >= 0.0 && wDistance < iMaxDistSquared;
+    return !wIsNanPoint && iMaxResults != 0UL && iMaxDistance > 0.0 && !std::isnan(wDistance) &&
+           std::isnormal(iMaxDistSquared) && wDistance <= iMaxDistSquared;
   }
 
   Flatbush(uint32_t iNumItems, uint16_t iNodeSize) noexcept;
@@ -758,7 +759,7 @@ std::vector<size_t> Flatbush<ArrayType>::neighbors(const Point<ArrayType>& iPoin
                                                    double iMaxDistance,
                                                    const FilterCb& iFilterFn) const noexcept {
   const auto wMaxDistSquared = iMaxDistance * iMaxDistance;
-  const auto wCanLoop = canDoNeighbors(iPoint, iMaxResults, wMaxDistSquared);
+  const auto wCanLoop = canDoNeighbors(iPoint, iMaxResults, iMaxDistance, wMaxDistSquared);
   const auto wNumItems = numItems();
   const auto wNodeSize = nodeSize();
   auto wNodeIndex = mBoxes.size() - 1UL;

fuzz_neighbors.cpp

@@ -35,22 +35,22 @@ flatbush::Flatbush<double> createIndex() {
   return wIndex;
 }
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *iData, size_t iSize) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* iData, size_t iSize) {
   static auto sIndex = createIndex();
 
   if (iSize == 32) {
-    const auto wX = *flatbush::detail::bit_cast<const double *>(&iData[0]);
-    const auto wY = *flatbush::detail::bit_cast<const double *>(&iData[8]);
-    const flatbush::Point<double> wPoint{wX, wY};
-
-    const auto wMaxResults = *flatbush::detail::bit_cast<const size_t *>(&iData[16]);
-    const auto wMaxDistance = *flatbush::detail::bit_cast<const double *>(&iData[24]);
-
-    auto wResult = sIndex.neighbors(wPoint, wMaxResults, wMaxDistance);
+    const auto wX = *flatbush::detail::bit_cast<const double*>(&iData[0]);
+    const auto wY = *flatbush::detail::bit_cast<const double*>(&iData[8]);
+    const auto wMaxResults = *flatbush::detail::bit_cast<const size_t*>(&iData[16]);
+    const auto wMaxDistance = *flatbush::detail::bit_cast<const double*>(&iData[24]);
+    const auto wMaxDistSquared = wMaxDistance * wMaxDistance;
 
+    const flatbush::Point<double> wPoint{wX, wY};
+    const auto wResult = sIndex.neighbors(wPoint, wMaxResults, wMaxDistance);
     const auto wDistance = std::pow(wX - 42, 2.0) + std::pow(wY, 2.0);
 
-    if (wMaxResults > 0 && wMaxDistance >= 0 && wDistance <= std::pow(wMaxDistance, 2.0)) {
+    if (wMaxResults > 0 && wMaxDistance >= 0 && std::isnormal(wMaxDistSquared) &&
+        wDistance <= wMaxDistSquared) {
       assert(wResult.size() == 1);
     } else {
       assert(wResult.size() == 0);

test.cpp

@@ -534,9 +534,8 @@ void quickSortImbalancedDataset() {
   std::cout << "quicksort should work with an imbalanced dataset" << std::endl;
 
   static const auto linspace =
-      [](double wStart, double wStop, uint32_t wNum, bool wEndpoint = true) {
-        const auto wDiv = wEndpoint ? (wNum - 1) : wNum;
-        const auto wStep = (wStop - wStart) / wDiv;
+      [](double wStart, double wStop, uint32_t wNum) {
+        const auto wStep = (wStop - wStart) / (wNum - 1);
         std::vector<double> wItems(wNum);
         for (uint32_t wIndex = 0; wIndex < wNum; ++wIndex) {
           wItems.at(wIndex) = wStart + wStep * static_cast<double>(wIndex);