update fuzztest

CMakeLists.txt

@@ -108,6 +108,7 @@ if(MANIFOLD_FUZZ)
   set(FUZZTEST_FUZZING_MODE ON)
   # address sanitizer required
   add_compile_options(-fsanitize=address)
+  add_link_options(-fsanitize=address)
 endif()
 
 if(TRACY_ENABLE)

cmake/manifoldDeps.cmake

@@ -224,7 +224,7 @@ if(MANIFOLD_FUZZ)
   FetchContent_Declare(
     fuzztest
     GIT_REPOSITORY https://github.com/google/fuzztest.git
-    GIT_TAG 2606e04a43e5a7730e437a849604a61f1cb0ff28
+    GIT_TAG 7b107216fa6cd62659234366aee493d6f8832d46
     GIT_PROGRESS TRUE
   )
   FetchContent_MakeAvailable(fuzztest)

test/CMakeLists.txt

@@ -69,4 +69,9 @@ if(MANIFOLD_FUZZ)
   target_link_libraries(polygon_fuzz PUBLIC manifold)
   link_fuzztest(polygon_fuzz)
   gtest_discover_tests(polygon_fuzz)
+
+  add_executable(manifold_fuzz manifold_fuzz.cpp)
+  target_link_libraries(manifold_fuzz PUBLIC manifold)
+  link_fuzztest(manifold_fuzz)
+  gtest_discover_tests(manifold_fuzz)
 endif()

test/boolean_test.cpp

@@ -421,3 +421,15 @@ TEST(Boolean, Precision2) {
   cube2 = cube2.Translate(vec3(scale * kPrecision));
   EXPECT_FALSE((cube ^ cube2).IsEmpty());
 }
+
+TEST(Boolean, SimpleCubeRegression) {
+  ManifoldParams().intermediateChecks = true;
+  ManifoldParams().processOverlaps = false;
+  Manifold result =
+      Manifold::Cube().Rotate(-0.10000000000000001, 0.10000000000000001, -1.) +
+      Manifold::Cube() -
+      Manifold::Cube().Rotate(-0.10000000000000001, -0.10000000000066571, -1.);
+  EXPECT_EQ(result.Status(), Manifold::Error::NoError);
+  ManifoldParams().intermediateChecks = false;
+  ManifoldParams().processOverlaps = true;
+}

test/manifold_fuzz.cpp

@@ -0,0 +1,99 @@
+// Copyright 2024 The Manifold Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <atomic>
+#include <future>
+
+#include "fuzztest/fuzztest.h"
+#include "gtest/gtest.h"
+#include "manifold/manifold.h"
+
+using namespace fuzztest;
+using namespace manifold;
+
+enum class TransformType { Translate, Rotate, Scale };
+struct Transform {
+  TransformType ty;
+  std::array<double, 3> vector;
+};
+struct CubeOp {
+  std::vector<Transform> transforms;
+  bool isUnion;
+};
+
+// larger numbers may cause precision issues, prefer to test them later
+auto GoodNumbers = OneOf(InRange(0.1, 10.0), InRange(-10.0, -0.1));
+auto Vec3Domain = ArrayOf<3>(GoodNumbers);
+auto TransformDomain = StructOf<Transform>(
+    ElementOf({TransformType::Translate, TransformType::Rotate,
+               TransformType::Scale}),
+    Vec3Domain);
+auto CsgDomain =
+    VectorOf(StructOf<CubeOp>(VectorOf(TransformDomain).WithMaxSize(20),
+                              ElementOf({false, true})))
+        .WithMaxSize(100);
+
+void SimpleCube(const std::vector<CubeOp> &inputs) {
+  ManifoldParams().intermediateChecks = true;
+  ManifoldParams().processOverlaps = false;
+  Manifold result;
+  for (const auto &input : inputs) {
+    auto cube = Manifold::Cube();
+    for (const auto &transform : input.transforms) {
+      printf("transform: %d\n", static_cast<int>(transform.ty));
+      switch (transform.ty) {
+        case TransformType::Translate:
+          cube = cube.Translate({std::get<0>(transform.vector),
+                                 std::get<1>(transform.vector),
+                                 std::get<2>(transform.vector)});
+          break;
+        case TransformType::Rotate:
+          cube = cube.Rotate(std::get<0>(transform.vector),
+                             std::get<1>(transform.vector),
+                             std::get<2>(transform.vector));
+          break;
+        case TransformType::Scale:
+          cube = cube.Scale({std::get<0>(transform.vector),
+                             std::get<1>(transform.vector),
+                             std::get<2>(transform.vector)});
+          break;
+      }
+    }
+
+    printf("isUnion: %d\n", input.isUnion);
+    std::atomic<pid_t> tid;
+    std::atomic<bool> faulted(true);
+    auto asyncFuture = std::async(
+        std::launch::async, [&result, &faulted, &tid, &cube, &input]() {
+          tid.store(gettid());
+          if (input.isUnion) {
+            result += cube;
+          } else {
+            result -= cube;
+          }
+          EXPECT_EQ(result.Status(), Manifold::Error::NoError);
+          faulted.store(false);
+        });
+    if (asyncFuture.wait_for(std::chrono::milliseconds(10000)) ==
+        std::future_status::timeout) {
+      printf("timeout after %dms...\n", 10000);
+      pthread_cancel(tid.load());
+    }
+
+    EXPECT_FALSE(faulted.load());
+    if (faulted.load()) break;
+  }
+}
+
+FUZZ_TEST(ManifoldFuzz, SimpleCube).WithDomains(CsgDomain);

test/polygon_fuzz.cpp

@@ -18,6 +18,7 @@
 
 #include "fuzztest/fuzztest.h"
 #include "gtest/gtest.h"
+#include "manifold/optional_assert.h"
 #include "manifold/polygon.h"
 
 using namespace fuzztest;
@@ -43,7 +44,7 @@ void TriangulationNoCrash(
         try {
           manifold::Triangulate(polys, precision);
           faulted.store(false);
-        } catch (manifold::geometryErr e) {
+        } catch (geometryErr e) {
           // geometryErr is fine
           faulted.store(false);
         } catch (...) {