Enhance build configuration and improve macro definitions

sunxfancy · sunxfancy · commit d660dcea414c · 2025-12-09T01:40:53.000-08:00
- Updated Makefile to include CMAKE_EXPORT_COMPILE_COMMANDS and CXX_FLAGS for better build support.
- Modified benchmark, fuzz test, and unit test macros to suppress warnings and improve usability.
- Adjusted Printer class to handle enum printing with magic_enum when enabled.
- Refined IRObject structure for better memory handling and added checks in serialization functions.
- Updated test cases for improved accuracy and consistency in logging and assertions.
diff --git a/.clangd b/.clangd
@@ -0,0 +1,2 @@
+CompileFlags:
+  CompilationDatabase: ./build/linux
diff --git a/Makefile b/Makefile
@@ -6,7 +6,9 @@ build/linux/Makefile: Makefile
 	mkdir -p build/linux
 	cmake -B build/linux -S . -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_STANDARD=11 \
 		-DBUILD_EXAMPLES=ON -DBUILD_TEST=ON -DUSE_MOLD=ON -DDISABLE_CUDA_BUILD=OFF -DENABLE_FUZZING=ON \
-		-DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang
+		-DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang \
+		-DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
+		-DCMAKE_CXX_FLAGS=-L/home/utils/llvm-20.1.8/lib/clang/20/lib/linux
 
 linux: build/linux/Makefile
 	cmake --build build/linux -j `nproc`
diff --git a/include/zeroerr/benchmark.h b/include/zeroerr/benchmark.h
@@ -20,8 +20,10 @@ ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH
         {name, __FILE__, __LINE__, function, {__VA_ARGS__}}, zeroerr::TestType::bench); \
     static void function(ZEROERR_UNUSED(zeroerr::TestContext* _ZEROERR_TEST_CONTEXT))
 
-#define BENCHMARK(name, ...) \
-    ZEROERR_CREATE_BENCHMARK_FUNC(ZEROERR_NAMEGEN(_zeroerr_benchmark), name, __VA_ARGS__)
+#define BENCHMARK(...) \
+    ZEROERR_SUPPRESS_VARIADIC_MACRO \
+    ZEROERR_CREATE_BENCHMARK_FUNC(ZEROERR_NAMEGEN(_zeroerr_benchmark), __VA_ARGS__) \
+    ZEROERR_SUPPRESS_VARIADIC_MACRO_POP \
 
 
 namespace zeroerr {
diff --git a/include/zeroerr/domains/arbitrary.h b/include/zeroerr/domains/arbitrary.h
@@ -70,7 +70,7 @@ class Arbitrary<T, 2, is_unsigned_int<T>> : public DomainConvertable<T> {
 
     CorpusType GetRandomCorpus(Rng& rng) const override { return static_cast<T>(rng.bounded(100)); }
 
-    void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {
+    void Mutate(Rng& rng, CorpusType& v, bool) const override {
         v = static_cast<T>(rng.bounded(100));
     }
 };
@@ -88,7 +88,7 @@ class Arbitrary<T, 2, is_signed_int<T>> : public DomainConvertable<T> {
 
     CorpusType GetRandomCorpus(Rng& rng) const override { return static_cast<T>(rng.bounded(100)); }
 
-    void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {
+    void Mutate(Rng& rng, CorpusType& v, bool) const override {
         v = static_cast<T>(rng.bounded(100));
         v -= 50;
     }
@@ -106,7 +106,7 @@ class Arbitrary<T, 2, is_float_point<T>> : public DomainConvertable<T> {
         return static_cast<T>(rng.bounded(1000));
     }
 
-    void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {
+    void Mutate(Rng& rng, CorpusType& v, bool) const override {
         v = static_cast<T>(rng.bounded(1000));
     }
 };
diff --git a/include/zeroerr/domains/in_range.h b/include/zeroerr/domains/in_range.h
@@ -41,7 +41,7 @@ class InRange : public DomainConvertable<T> {
         return v;
     }
 
-    void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {
+    void Mutate(Rng& rng, CorpusType& v, bool) const override {
         CorpusType offsize = max - min + 1;
         v                  = rng.bounded(offsize);
         v                  = min + v;
diff --git a/include/zeroerr/fuzztest.h b/include/zeroerr/fuzztest.h
@@ -26,8 +26,10 @@ ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH
         {name, __FILE__, __LINE__, function, {__VA_ARGS__}}, zeroerr::TestType::fuzz_test); \
     static void function(ZEROERR_UNUSED(zeroerr::TestContext* _ZEROERR_TEST_CONTEXT))
 
-#define FUZZ_TEST_CASE(name, ...) \
-    ZEROERR_CREATE_FUZZ_TEST_FUNC(ZEROERR_NAMEGEN(_zeroerr_testcase), name, __VA_ARGS__)
+#define FUZZ_TEST_CASE(...) \
+    ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH \
+    ZEROERR_CREATE_FUZZ_TEST_FUNC(ZEROERR_NAMEGEN(_zeroerr_testcase), __VA_ARGS__) \
+    ZEROERR_SUPPRESS_COMMON_WARNINGS_POP
 
 #define FUZZ_FUNC(func) zeroerr::FuzzFunction(func, _ZEROERR_TEST_CONTEXT)
 
diff --git a/include/zeroerr/internal/config.h b/include/zeroerr/internal/config.h
@@ -83,6 +83,7 @@
 #define ZEROERR_TRIGGER_PARENTHESIS_(...) ,
 
 #define ZEROERR_ISEMPTY(...)                                                                     \
+    ZEROERR_SUPPRESS_VARIADIC_MACRO                                                              \
     _ZEROERR_ISEMPTY(/* test if there is just one argument, eventually an empty                  \
                 one */                                                                           \
                      ZEROERR_HAS_COMMA(__VA_ARGS__), /* test if ZEROERR_TRIGGER_PARENTHESIS_     \
@@ -93,7 +94,8 @@
                      ZEROERR_HAS_COMMA(__VA_ARGS__(                                              \
                          /*empty*/)), /* test if placing it between ZEROERR_TRIGGER_PARENTHESIS_ \
                                          and the parenthesis adds a comma */                     \
-                     ZEROERR_HAS_COMMA(ZEROERR_TRIGGER_PARENTHESIS_ __VA_ARGS__(/*empty*/)))
+                     ZEROERR_HAS_COMMA(ZEROERR_TRIGGER_PARENTHESIS_ __VA_ARGS__(/*empty*/)))     \
+    ZEROERR_SUPPRESS_VARIADIC_MACRO_POP
 
 #define ZEROERR_PASTE5(_0, _1, _2, _3, _4) _0##_1##_2##_3##_4
 #define _ZEROERR_ISEMPTY(_0, _1, _2, _3) \
@@ -227,6 +229,7 @@
     ZEROERR_CLANG_SUPPRESS_WARNING("-Wmissing-prototypes")                                         \
     ZEROERR_CLANG_SUPPRESS_WARNING("-Wc++98-compat")                                               \
     ZEROERR_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic")                                      \
+    ZEROERR_CLANG_SUPPRESS_WARNING("-Wvariadic-macro-arguments-omitted")                           \
                                                                                                    \
     ZEROERR_GCC_SUPPRESS_WARNING_PUSH                                                              \
     ZEROERR_GCC_SUPPRESS_WARNING("-Wunknown-pragmas")                                              \
@@ -295,8 +298,9 @@
 
 #define ZEROERR_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END ZEROERR_MSVC_SUPPRESS_WARNING_POP
 
-#define ZEROERR_SUPPRESS_VARIADIC_MACRO \
-    ZEROERR_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wgnu-zero-variadic-macro-arguments")
+#define ZEROERR_SUPPRESS_VARIADIC_MACRO                                             \
+    ZEROERR_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wgnu-zero-variadic-macro-arguments") \
+    ZEROERR_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wvariadic-macro-arguments-omitted")
 
 #define ZEROERR_SUPPRESS_VARIADIC_MACRO_POP ZEROERR_CLANG_SUPPRESS_WARNING_POP
 
diff --git a/include/zeroerr/internal/serialization.h b/include/zeroerr/internal/serialization.h
@@ -41,7 +41,7 @@ namespace zeroerr {
  */
 
 struct IRObject {
-    IRObject() { std::memset(this, 0, sizeof(IRObject)); }
+    IRObject() { memset(this, 0, sizeof(IRObject)); }
     ~IRObject() {}
     IRObject(const IRObject& other) { *this = other; }
     IRObject(IRObject&& other) { *this = std::move(other); }
@@ -55,7 +55,7 @@ struct IRObject {
         return *this;
     }
 
-    enum Type { Undefined, Int, Float, String, ShortString, Object };
+    enum Type { Undefined = 0, Int, Float, String, ShortString, Object };
 
     union {
         int64_t   i;
@@ -65,7 +65,7 @@ struct IRObject {
         IRObject* o;  // first must be the number of elements
     };
     char     others[7];
-    unsigned type;
+    unsigned char type;
 
     template <typename T>
     typename std::enable_if<std::is_integral<T>::value, T>::type GetScalar() {
@@ -128,7 +128,10 @@ struct IRObject {
         int64_t   size;
         IRObject* children;
     };
-    Childrens GetChildren() { return {o->i, o + 1}; }
+    Childrens GetChildren() { 
+        if (type != Type::Object) return {0, nullptr};
+        return {o->i, o + 1};
+    }
 
     void SetChildren(IRObject* children) {
         o    = children - 1;
diff --git a/include/zeroerr/internal/typetraits.h b/include/zeroerr/internal/typetraits.h
@@ -262,9 +262,10 @@ void visit2_at(std::tuple<Ts...>& tup1, const std::tuple<T2s...>& tup2, size_t i
     typename std::enable_if<x, void>::type
 #define ZEROERR_IS_INT        std::is_integral<T>::value
 #define ZEROERR_IS_FLOAT      std::is_floating_point<T>::value
+#define ZEROERR_IS_ENUM       std::is_enum<T>::value
 #define ZEROERR_IS_CONTAINER  detail::is_container<T>::value
 #define ZEROERR_IS_STRING     detail::is_string<T>::value
-#define ZEROERR_IS_POINTER    std::is_pointer<T>::value
+#define ZEROERR_IS_POINTER    (std::is_pointer<T>::value || std::is_same<T, std::nullptr_t>::value)
 #define ZEROERR_IS_CHAR       std::is_same<T, char>::value
 #define ZEROERR_IS_WCHAR      std::is_same<T, wchar_t>::value
 #define ZEROERR_IS_CLASS      std::is_class<T>::value
diff --git a/include/zeroerr/print.h b/include/zeroerr/print.h
@@ -114,6 +114,13 @@ struct Printer {
         return demangle(typeid(t).name());
     }
 
+#if defined(ZEROERR_ENABLE_MAGIC_ENUM) && (ZEROERR_CXX_STANDARD >= 17)
+    ZEROERR_ENABLE_IF(ZEROERR_IS_ENUM)
+    print(T value, unsigned level, const char* lb, rank<0>) { os << tab(level) << magic_enum::enum_name(value) << lb; }
+#else
+    ZEROERR_ENABLE_IF(ZEROERR_IS_ENUM)
+    print(T value, unsigned level, const char* lb, rank<0>) { os << tab(level) << value << lb; }
+#endif
 
     ZEROERR_ENABLE_IF(ZEROERR_IS_INT || ZEROERR_IS_FLOAT)
     print(T value, unsigned level, const char* lb, rank<0>) { os << tab(level) << value << lb; }
@@ -123,7 +130,7 @@ struct Printer {
         if (value == nullptr)
             os << tab(level) << "nullptr" << lb;
         else
-            os << tab(level) << "<" << type(value) << " at " << value << ">" << lb;
+            os << tab(level) << "<" << type(value) << " at " << static_cast<const void*>(value) << ">" << lb;
     }
 
 
diff --git a/include/zeroerr/unittest.h b/include/zeroerr/unittest.h
@@ -15,13 +15,20 @@ ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH
         {name, __FILE__, __LINE__, function, {__VA_ARGS__}});        \
     static void function(ZEROERR_UNUSED(zeroerr::TestContext* _ZEROERR_TEST_CONTEXT))
 
-#define TEST_CASE(name, ...) \
-    ZEROERR_CREATE_TEST_FUNC(ZEROERR_NAMEGEN(_zeroerr_testcase), name, __VA_ARGS__)
+#define TEST_CASE(...) \
+    ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH \
+    ZEROERR_CREATE_TEST_FUNC(ZEROERR_NAMEGEN(_zeroerr_testcase), __VA_ARGS__) \
+    ZEROERR_SUPPRESS_COMMON_WARNINGS_POP
 
-#define SUB_CASE(name, ...)                                                          \
+#define ZEROERR_CREATE_SUB_CASE(name, ...)                                                  \
     zeroerr::SubCase(name, __FILE__, __LINE__, _ZEROERR_TEST_CONTEXT, {__VA_ARGS__}) \
         << [=](ZEROERR_UNUSED(zeroerr::TestContext * _ZEROERR_TEST_CONTEXT)) mutable
 
+#define SUB_CASE(...) \
+    ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH \
+    ZEROERR_CREATE_SUB_CASE(__VA_ARGS__) \
+    ZEROERR_SUPPRESS_COMMON_WARNINGS_POP
+
 #define ZEROERR_CREATE_TEST_CLASS(fixture, classname, funcname, name, ...)                   \
     class classname : public fixture {                                                       \
     public:                                                                                  \
@@ -35,9 +42,9 @@ ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH
         {name, __FILE__, __LINE__, ZEROERR_CAT(call_, funcname), {__VA_ARGS__}});            \
     inline void classname::funcname(ZEROERR_UNUSED(zeroerr::TestContext* _ZEROERR_TEST_CONTEXT))
 
-#define TEST_CASE_FIXTURE(fixture, name, ...)                           \
+#define TEST_CASE_FIXTURE(fixture, ...)                           \
     ZEROERR_CREATE_TEST_CLASS(fixture, ZEROERR_NAMEGEN(_zeroerr_class), \
-                              ZEROERR_NAMEGEN(_zeroerr_test_method), name, __VA_ARGS__)
+                              ZEROERR_NAMEGEN(_zeroerr_test_method), __VA_ARGS__)
 
 
 #define ZEROERR_HAVE_SAME_OUTPUT _ZEROERR_TEST_CONTEXT->save_output();
@@ -357,8 +364,8 @@ class Decorator {
     // Called on each assertion, return true can skip the assertion
     virtual bool onAssertion() { return false; }
 
-    // Called when the test finished, return true means the test containing errors
-    virtual bool onFinish(const TestCase&, const TestContext&) { return false; }
+    // Called when the test finished, return true means the test containing changes
+    virtual bool onFinish(const TestCase&, TestContext&) { return false; }
 };
 
 Decorator* skip(bool isSkip = true);
diff --git a/src/log.cpp b/src/log.cpp
@@ -178,8 +178,8 @@ LogIterator::LogIterator(LogStream& stream, std::string message, std::string fun
                          int line)
     : p(stream.first),
       q(stream.first->begin()),
-      message_filter(message),
       function_name_filter(function_name),
+      message_filter(message),
       line_filter(line) {
     while (!check_filter() && p) next();
 }
diff --git a/src/serialization.cpp b/src/serialization.cpp
@@ -98,9 +98,11 @@ static void to_string(IRObject obj, std::stringstream& ss) {
 
 static IRObject from_string(std::stringstream& ss, std::string& token) {
     IRObject obj;
+    if (token.empty()) return obj;
     if (token == "{") {
         std::vector<IRObject> children;
         while (ss >> token) {
+            if (token.empty()) return obj;
             if (token == "}") break;
             IRObject child = from_string(ss, token);
             if (child.type == IRObject::Type::Undefined)
diff --git a/src/unittest.cpp b/src/unittest.cpp
@@ -243,11 +243,14 @@ static bool runOnExecution(const TestCase& tc) {
     return false;
 }
 
-static bool runOnFinish(const TestCase& tc, const TestContext& ctx) {
+static bool runOnFinish(const TestCase& tc, TestContext& ctx) {
+    bool contain_changes = false;
     for (auto& decorator : tc.decorators) {
-        if (decorator->onFinish(tc, ctx)) return true;
+        if (decorator->onFinish(tc, ctx)) {
+            contain_changes = true;
+        }
     }
-    return false;
+    return contain_changes;
 }
 
 int UnitTest::run() {
@@ -291,11 +294,10 @@ int UnitTest::run() {
         }
         int type = sum.add(context);
         if (runOnFinish(tc, context)) {
-            if (type != 2) {
-                sum.failed += 1;
-                type = 2;
-            }
-        }
+            if (context.passed > 0) type = 0;
+            if (context.warning > 0) type = 1;
+            if (context.failed > 0) type = 2;
+        } 
         reporter->testCaseEnd(tc, new_buf, context, type);
         context.reset();
         new_buf.str("");
@@ -375,12 +377,13 @@ class ConsoleReporter : public IReporter {
 
     virtual void testCaseStart(const TestCase& tc, std::stringbuf&) override {
         std::cerr << "TEST CASE " << Dim << "[" << getFileName(tc.file) << ":" << tc.line << "] "
-                  << Reset << FgCyan << tc.name << Reset << std::endl;
+                  << Reset << FgCyan << tc.name << Reset;
     }
 
     virtual void testCaseEnd(const TestCase&, std::stringbuf& sb, const TestContext&,
                              int type) override {
-        if (!(ut.silent && type == 0)) std::cerr << insertIndentation(sb.str()) << std::endl;
+        if (!(ut.silent && type == 0)) std::cerr << "  " << (type == 0 ? "✅" : type == 1 ? "⚠️" : "❌")
+        << std::endl << insertIndentation(sb.str()) << std::endl;
     }
 
     virtual void subCaseStart(const TestCase& tc, std::stringbuf&) override {
@@ -838,7 +841,7 @@ class TimeoutDecorator : public Decorator {
     TimeoutDecorator() : timeout(0) {}
     TimeoutDecorator(float timeout) : timeout(timeout) {}
 
-    bool onFinish(const TestCase& tc, const TestContext& ctx) override {
+    bool onFinish(const TestCase&, TestContext& ctx) override {
         if (ctx.duration > std::chrono::duration<double>(timeout)) {
             std::cerr << FgRed <<  "Timeout: " << Reset << ctx.duration.count() << "s > " << timeout << "s" << std::endl;
             return true;
@@ -860,6 +863,21 @@ class FailureDecorator : public Decorator {
     enum FailureType { may_fail, should_fail };
     FailureDecorator(FailureType type) : type(type) {}
 
+    bool onFinish(const TestCase& tc, TestContext& ctx) override {
+        if (type == FailureType::may_fail) {
+            ctx.failed += ctx.passed;
+            ctx.passed = 0;
+            return true;
+        }
+        if (type == FailureType::should_fail) {
+            int failed = ctx.failed;
+            ctx.failed = ctx.passed;
+            ctx.passed = failed;
+            return true;
+        }
+        return false;
+    }
+
 private:
     FailureType type;
 };
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -49,6 +49,7 @@ set(test_files
     ${CMAKE_CURRENT_SOURCE_DIR}/print_test.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/table_test.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/unit_test.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/serialization_test.cpp
 )
 
 if (ENABLE_FUZZING)
@@ -72,6 +73,11 @@ if (ENABLE_FUZZING)
         OUTPUT_VARIABLE LIB_FUZZER_PATH
         OUTPUT_STRIP_TRAILING_WHITESPACE
     )
+    if (NOT LIB_FUZZER_PATH)
+        message(FATAL_ERROR "libfuzzer not found")
+    else()
+        message(STATUS "libfuzzer path: ${LIB_FUZZER_PATH}")
+    endif()
 
     set_target_properties(unittest PROPERTIES COMPILE_DEFINITIONS ZEROERR_ENABLE_FUZZING)
     target_compile_options(unittest PRIVATE -fsanitize=fuzzer-no-link)
diff --git a/test/log_test.cpp b/test/log_test.cpp
@@ -16,8 +16,7 @@ using namespace zeroerr;
 TEST_CASE("log_test") {
     LOG("Hello {i}", 1);
     WARN("Test Warning {print}", "print data");
-
-    ERR_IF(1 == 1, "1 == 1");
+    WARN_IF(1 == 1, "1 == 1");
 
     for (int i = 0; i < 10; ++i) {
         LOG_EVERY_(3, "log every 3 times: {i}", i);
@@ -50,7 +49,7 @@ TEST_CASE("lazy evaluation") {
         sum += i;
         INFO("i =", i);
         INFO("i+1 =", i + 1);
-        REQUIRE(0 <= sum < 50);
+        CHECK(0 <= sum < 50);
     }
 }
 #ifdef ZEROERR_ENABLE_SPEED_TEST
@@ -176,7 +175,7 @@ TEST_CASE("iterate log stream") {
 
     auto& stream = zeroerr::LogStream::getDefault();
     for (auto p = stream.begin(); p != stream.end(); ++p) {
-        if (p->info->function == std::string("function") && p->info->line == 122) {
+        if (p->info->function == std::string("function") && p->info->line == 172) {
             std::cerr << "p.get<int>(\"i\") = " << p.get<int>("i") << std::endl;
             CHECK(p.get<int>("i") == 1);
         }
diff --git a/test/serialization_test.cpp b/test/serialization_test.cpp
diff --git a/test/unit_test.cpp b/test/unit_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+CompileFlags:`
	`2`	`+ CompilationDatabase: ./build/linux`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ class Arbitrary<T, 2, is_unsigned_int<T>> : public DomainConvertable<T> {`
`70`	`70`
`71`	`71`	`CorpusType GetRandomCorpus(Rng& rng) const override { return static_cast<T>(rng.bounded(100)); }`
`72`	`72`
`73`		`- void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {`
	`73`	`+ void Mutate(Rng& rng, CorpusType& v, bool) const override {`
`74`	`74`	`v = static_cast<T>(rng.bounded(100));`
`75`	`75`	`}`
`76`	`76`	`};`
`@@ -88,7 +88,7 @@ class Arbitrary<T, 2, is_signed_int<T>> : public DomainConvertable<T> {`
`88`	`88`
`89`	`89`	`CorpusType GetRandomCorpus(Rng& rng) const override { return static_cast<T>(rng.bounded(100)); }`
`90`	`90`
`91`		`- void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {`
	`91`	`+ void Mutate(Rng& rng, CorpusType& v, bool) const override {`
`92`	`92`	`v = static_cast<T>(rng.bounded(100));`
`93`	`93`	`v -= 50;`
`94`	`94`	`}`
`@@ -106,7 +106,7 @@ class Arbitrary<T, 2, is_float_point<T>> : public DomainConvertable<T> {`
`106`	`106`	`return static_cast<T>(rng.bounded(1000));`
`107`	`107`	`}`
`108`	`108`
`109`		`- void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {`
	`109`	`+ void Mutate(Rng& rng, CorpusType& v, bool) const override {`
`110`	`110`	`v = static_cast<T>(rng.bounded(1000));`
`111`	`111`	`}`
`112`	`112`	`};`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ class InRange : public DomainConvertable<T> {`
`41`	`41`	`return v;`
`42`	`42`	`}`
`43`	`43`
`44`		`- void Mutate(Rng& rng, CorpusType& v, bool only_shrink) const override {`
	`44`	`+ void Mutate(Rng& rng, CorpusType& v, bool) const override {`
`45`	`45`	`CorpusType offsize = max - min + 1;`
`46`	`46`	`v = rng.bounded(offsize);`
`47`	`47`	`v = min + v;`