Merge #20828: fuzz: Introduce CallOneOf helper to replace switch-case

fa75d40ef8 fuzz: Introduce CallOneOf helper to replace switch-case (MarcoFalke)

Pull request description:

  The current `switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, nn)) { case 0: ... case 1: ... case nn: ...` has several problems:

  * It makes it hard to review newly added targets, because it requires manual counting of cases
  * It makes it hard to update a target, because updating all case labels is trivial, but tedious to review and causes merge conflicts
  * ~~Updating the target raises the question whether the case labels should be preserved to not invalidate the existing fuzz inputs format. Fuzz input format might already change implicitly on every commit, so this isn't something worthwhile to pursue.~~ Edit: This pull doesn't fix this problem.

  Fix all issues by adding a new `CallOneOf` helper

ACKs for top commit:
  ajtowns:
    ACK fa75d40ef8 - code review only
  jnewbery:
    utACK fa75d40ef8

Tree-SHA512: 2daa602b240b86c8e85a024e008f03a57ba60349377eed771f4d21a97a9dba9b66e93fff16ff1992018d4330be7a1a276944c3dfdf698748ce135626c380e563

src/test/fuzz/addrman.cpp

@@ -45,36 +45,31 @@ FUZZ_TARGET_INIT(addrman, initialize_addrman)
         }
     }
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 11)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 addr_man.Clear();
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 addr_man.ResolveCollisions();
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 (void)addr_man.SelectTriedCollision();
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 (void)addr_man.Select(fuzzed_data_provider.ConsumeBool());
-            break;
+            },
-        }
+            [&] {
-        case 4: {
                 (void)addr_man.GetAddr(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
-            break;
+            },
-        }
+            [&] {
-        case 5: {
                 const std::optional<CAddress> opt_address = ConsumeDeserializable<CAddress>(fuzzed_data_provider);
                 const std::optional<CNetAddr> opt_net_addr = ConsumeDeserializable<CNetAddr>(fuzzed_data_provider);
                 if (opt_address && opt_net_addr) {
                     addr_man.Add(*opt_address, *opt_net_addr, fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 100000000));
                 }
-            break;
+            },
-        }
+            [&] {
-        case 6: {
                 std::vector<CAddress> addresses;
                 while (fuzzed_data_provider.ConsumeBool()) {
                     const std::optional<CAddress> opt_address = ConsumeDeserializable<CAddress>(fuzzed_data_provider);
@@ -87,41 +82,34 @@ FUZZ_TARGET_INIT(addrman, initialize_addrman)
                 if (opt_net_addr) {
                     addr_man.Add(addresses, *opt_net_addr, fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 100000000));
                 }
-            break;
+            },
-        }
+            [&] {
-        case 7: {
                 const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider);
                 if (opt_service) {
                     addr_man.Good(*opt_service, fuzzed_data_provider.ConsumeBool(), ConsumeTime(fuzzed_data_provider));
                 }
-            break;
+            },
-        }
+            [&] {
-        case 8: {
                 const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider);
                 if (opt_service) {
                     addr_man.Attempt(*opt_service, fuzzed_data_provider.ConsumeBool(), ConsumeTime(fuzzed_data_provider));
                 }
-            break;
+            },
-        }
+            [&] {
-        case 9: {
                 const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider);
                 if (opt_service) {
                     addr_man.Connected(*opt_service, ConsumeTime(fuzzed_data_provider));
                 }
-            break;
+            },
-        }
+            [&] {
-        case 10: {
                 const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider);
                 if (opt_service) {
                     addr_man.SetServices(*opt_service, ServiceFlags{fuzzed_data_provider.ConsumeIntegral<uint64_t>()});
                 }
-            break;
+            },
-        }
+            [&] {
-        case 11: {
                 (void)addr_man.Check();
-            break;
+            });
-        }
-        }
     }
     (void)addr_man.size();
     CDataStream data_stream(SER_NETWORK, PROTOCOL_VERSION);

src/test/fuzz/autofile.cpp

@@ -21,43 +21,37 @@ FUZZ_TARGET(autofile)
     FuzzedAutoFileProvider fuzzed_auto_file_provider = ConsumeAutoFile(fuzzed_data_provider);
     CAutoFile auto_file = fuzzed_auto_file_provider.open();
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 5)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 std::array<uint8_t, 4096> arr{};
                 try {
                     auto_file.read((char*)arr.data(), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
                 } catch (const std::ios_base::failure&) {
                 }
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 const std::array<uint8_t, 4096> arr{};
                 try {
                     auto_file.write((const char*)arr.data(), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
                 } catch (const std::ios_base::failure&) {
                 }
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 try {
                     auto_file.ignore(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
                 } catch (const std::ios_base::failure&) {
                 }
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 auto_file.fclose();
-            break;
+            },
-        }
+            [&] {
-        case 4: {
                 ReadFromStream(fuzzed_data_provider, auto_file);
-            break;
+            },
-        }
+            [&] {
-        case 5: {
                 WriteToStream(fuzzed_data_provider, auto_file);
-            break;
+            });
-        }
-        }
     }
     (void)auto_file.Get();
     (void)auto_file.GetType();

src/test/fuzz/banman.cpp

@@ -38,51 +38,43 @@ FUZZ_TARGET_INIT(banman, initialize_banman)
     {
         BanMan ban_man{banlist_file, nullptr, ConsumeBanTimeOffset(fuzzed_data_provider)};
         while (fuzzed_data_provider.ConsumeBool()) {
-            switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 11)) {
+            CallOneOf(
-            case 0: {
+                fuzzed_data_provider,
+                [&] {
                     ban_man.Ban(ConsumeNetAddr(fuzzed_data_provider),
                                 ConsumeBanTimeOffset(fuzzed_data_provider), fuzzed_data_provider.ConsumeBool());
-                break;
+                },
-            }
+                [&] {
-            case 1: {
                     ban_man.Ban(ConsumeSubNet(fuzzed_data_provider),
                                 ConsumeBanTimeOffset(fuzzed_data_provider), fuzzed_data_provider.ConsumeBool());
-                break;
+                },
-            }
+                [&] {
-            case 2: {
                     ban_man.ClearBanned();
-                break;
+                },
-            }
+                [] {},
-            case 4: {
+                [&] {
                     ban_man.IsBanned(ConsumeNetAddr(fuzzed_data_provider));
-                break;
+                },
-            }
+                [&] {
-            case 5: {
                     ban_man.IsBanned(ConsumeSubNet(fuzzed_data_provider));
-                break;
+                },
-            }
+                [&] {
-            case 6: {
                     ban_man.Unban(ConsumeNetAddr(fuzzed_data_provider));
-                break;
+                },
-            }
+                [&] {
-            case 7: {
                     ban_man.Unban(ConsumeSubNet(fuzzed_data_provider));
-                break;
+                },
-            }
+                [&] {
-            case 8: {
                     banmap_t banmap;
                     ban_man.GetBanned(banmap);
-                break;
+                },
-            }
+                [&] {
-            case 9: {
                     ban_man.DumpBanlist();
-                break;
+                },
-            }
+                [] {},
-            case 11: {
+                [&] {
                     ban_man.Discourage(ConsumeNetAddr(fuzzed_data_provider));
-                break;
+                });
-            }
-            }
         }
     }
     fs::remove(banlist_file);

src/test/fuzz/bloom_filter.cpp

@@ -25,47 +25,43 @@ FUZZ_TARGET(bloom_filter)
         fuzzed_data_provider.ConsumeIntegral<unsigned int>(),
         static_cast<unsigned char>(fuzzed_data_provider.PickValueInArray({BLOOM_UPDATE_NONE, BLOOM_UPDATE_ALL, BLOOM_UPDATE_P2PUBKEY_ONLY, BLOOM_UPDATE_MASK}))};
     while (fuzzed_data_provider.remaining_bytes() > 0) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 3)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 const std::vector<unsigned char> b = ConsumeRandomLengthByteVector(fuzzed_data_provider);
                 (void)bloom_filter.contains(b);
                 bloom_filter.insert(b);
                 const bool present = bloom_filter.contains(b);
                 assert(present);
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 const std::optional<COutPoint> out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
                 if (!out_point) {
-                break;
+                    return;
                 }
                 (void)bloom_filter.contains(*out_point);
                 bloom_filter.insert(*out_point);
                 const bool present = bloom_filter.contains(*out_point);
                 assert(present);
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 const std::optional<uint256> u256 = ConsumeDeserializable<uint256>(fuzzed_data_provider);
                 if (!u256) {
-                break;
+                    return;
                 }
                 (void)bloom_filter.contains(*u256);
                 bloom_filter.insert(*u256);
                 const bool present = bloom_filter.contains(*u256);
                 assert(present);
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 const std::optional<CMutableTransaction> mut_tx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
                 if (!mut_tx) {
-                break;
+                    return;
                 }
                 const CTransaction tx{*mut_tx};
                 (void)bloom_filter.IsRelevantAndUpdate(tx);
-            break;
+            });
-        }
-        }
         (void)bloom_filter.IsWithinSizeConstraints();
     }
 }

src/test/fuzz/buffered_file.cpp

@@ -31,41 +31,36 @@ FUZZ_TARGET(buffered_file)
     if (opt_buffered_file && fuzzed_file != nullptr) {
         bool setpos_fail = false;
         while (fuzzed_data_provider.ConsumeBool()) {
-            switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 4)) {
+            CallOneOf(
-            case 0: {
+                fuzzed_data_provider,
+                [&] {
                     std::array<uint8_t, 4096> arr{};
                     try {
                         opt_buffered_file->read((char*)arr.data(), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
                     } catch (const std::ios_base::failure&) {
                     }
-                break;
+                },
-            }
+                [&] {
-            case 1: {
                     opt_buffered_file->SetLimit(fuzzed_data_provider.ConsumeIntegralInRange<uint64_t>(0, 4096));
-                break;
+                },
-            }
+                [&] {
-            case 2: {
                     if (!opt_buffered_file->SetPos(fuzzed_data_provider.ConsumeIntegralInRange<uint64_t>(0, 4096))) {
                         setpos_fail = true;
                     }
-                break;
+                },
-            }
+                [&] {
-            case 3: {
                     if (setpos_fail) {
                         // Calling FindByte(...) after a failed SetPos(...) call may result in an infinite loop.
-                    break;
+                        return;
                     }
                     try {
                         opt_buffered_file->FindByte(fuzzed_data_provider.ConsumeIntegral<char>());
                     } catch (const std::ios_base::failure&) {
                     }
-                break;
+                },
-            }
+                [&] {
-            case 4: {
                     ReadFromStream(fuzzed_data_provider, *opt_buffered_file);
-                break;
+                });
-            }
-            }
         }
         opt_buffered_file->GetPos();
         opt_buffered_file->GetType();

src/test/fuzz/coins_view.cpp

@@ -50,10 +50,11 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
     Coin random_coin;
     CMutableTransaction random_mutable_transaction;
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 9)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 if (random_coin.IsSpent()) {
-                break;
+                    return;
                 }
                 Coin coin = random_coin;
                 bool expected_code_path = false;
@@ -68,57 +69,48 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
                     }
                 }
                 assert(expected_code_path);
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 (void)coins_view_cache.Flush();
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 coins_view_cache.SetBestBlock(ConsumeUInt256(fuzzed_data_provider));
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 Coin move_to;
                 (void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to : nullptr);
-            break;
+            },
-        }
+            [&] {
-        case 4: {
                 coins_view_cache.Uncache(random_out_point);
-            break;
+            },
-        }
+            [&] {
-        case 5: {
                 if (fuzzed_data_provider.ConsumeBool()) {
                     backend_coins_view = CCoinsView{};
                 }
                 coins_view_cache.SetBackend(backend_coins_view);
-            break;
+            },
-        }
+            [&] {
-        case 6: {
                 const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
                 if (!opt_out_point) {
-                break;
+                    return;
                 }
                 random_out_point = *opt_out_point;
-            break;
+            },
-        }
+            [&] {
-        case 7: {
                 const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
                 if (!opt_coin) {
-                break;
+                    return;
                 }
                 random_coin = *opt_coin;
-            break;
+            },
-        }
+            [&] {
-        case 8: {
                 const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
                 if (!opt_mutable_transaction) {
-                break;
+                    return;
                 }
                 random_mutable_transaction = *opt_mutable_transaction;
-            break;
+            },
-        }
+            [&] {
-        case 9: {
                 CCoinsMap coins_map;
                 while (fuzzed_data_provider.ConsumeBool()) {
                     CCoinsCacheEntry coins_cache_entry;
@@ -128,7 +120,7 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
                     } else {
                         const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
                         if (!opt_coin) {
-                        break;
+                            return;
                         }
                         coins_cache_entry.coin = *opt_coin;
                     }
@@ -144,9 +136,7 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
                     }
                 }
                 assert(expected_code_path);
-            break;
+            });
-        }
-        }
     }
 
     {
@@ -199,8 +189,9 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
     }
 
     if (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 6)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 const CTransaction transaction{random_mutable_transaction};
                 bool is_spent = false;
                 for (const CTxOut& tx_out : transaction.vout) {
@@ -211,7 +202,7 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
                 if (is_spent) {
                     // Avoid:
                     // coins.cpp:69: void CCoinsViewCache::AddCoin(const COutPoint &, Coin &&, bool): Assertion `!coin.IsSpent()' failed.
-                break;
+                    return;
                 }
                 bool expected_code_path = false;
                 const int height = fuzzed_data_provider.ConsumeIntegral<int>();
@@ -226,56 +217,51 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
                     }
                 }
                 assert(expected_code_path);
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 (void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache, false);
                 (void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache, true);
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 TxValidationState state;
                 CAmount tx_fee_out;
                 const CTransaction transaction{random_mutable_transaction};
                 if (ContainsSpentInput(transaction, coins_view_cache)) {
                     // Avoid:
                     // consensus/tx_verify.cpp:171: bool Consensus::CheckTxInputs(const CTransaction &, TxValidationState &, const CCoinsViewCache &, int, CAmount &): Assertion `!coin.IsSpent()' failed.
-                break;
+                    return;
                 }
                 try {
                     (void)Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out);
                     assert(MoneyRange(tx_fee_out));
                 } catch (const std::runtime_error&) {
                 }
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 const CTransaction transaction{random_mutable_transaction};
                 if (ContainsSpentInput(transaction, coins_view_cache)) {
                     // Avoid:
                     // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
-                break;
+                    return;
                 }
                 (void)GetP2SHSigOpCount(transaction, coins_view_cache);
-            break;
+            },
-        }
+            [&] {
-        case 4: {
                 const CTransaction transaction{random_mutable_transaction};
                 if (ContainsSpentInput(transaction, coins_view_cache)) {
                     // Avoid:
                     // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
-                break;
+                    return;
                 }
                 const int flags = fuzzed_data_provider.ConsumeIntegral<int>();
                 if (!transaction.vin.empty() && (flags & SCRIPT_VERIFY_WITNESS) != 0 && (flags & SCRIPT_VERIFY_P2SH) == 0) {
                     // Avoid:
                     // script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness *, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
-                break;
+                    return;
                 }
                 (void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
-            break;
+            },
-        }
+            [&] {
-        case 5: {
                 CCoinsStats stats;
                 bool expected_code_path = false;
                 try {
@@ -284,12 +270,9 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
                     expected_code_path = true;
                 }
                 assert(expected_code_path);
-            break;
+            },
-        }
+            [&] {
-        case 6: {
                 (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
-            break;
+            });
-        }
-        }
     }
 }

src/test/fuzz/connman.cpp

@@ -32,108 +32,104 @@ FUZZ_TARGET_INIT(connman, initialize_connman)
     CSubNet random_subnet;
     std::string random_string;
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 27)) {
+        CallOneOf(
-        case 0:
+            fuzzed_data_provider,
+            [&] {
                 random_address = ConsumeAddress(fuzzed_data_provider);
-            break;
+            },
-        case 1:
+            [&] {
                 random_netaddr = ConsumeNetAddr(fuzzed_data_provider);
-            break;
+            },
-        case 2:
+            [&] {
                 random_service = ConsumeService(fuzzed_data_provider);
-            break;
+            },
-        case 3:
+            [&] {
                 random_subnet = ConsumeSubNet(fuzzed_data_provider);
-            break;
+            },
-        case 4:
+            [&] {
                 random_string = fuzzed_data_provider.ConsumeRandomLengthString(64);
-            break;
+            },
-        case 5: {
+            [&] {
                 std::vector<CAddress> addresses;
                 while (fuzzed_data_provider.ConsumeBool()) {
                     addresses.push_back(ConsumeAddress(fuzzed_data_provider));
                 }
                 // Limit nTimePenalty to int32_t to avoid signed integer overflow
                 (void)connman.AddNewAddresses(addresses, ConsumeAddress(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<int32_t>());
-            break;
+            },
-        }
+            [&] {
-        case 6:
                 connman.AddNode(random_string);
-            break;
+            },
-        case 7:
+            [&] {
                 connman.CheckIncomingNonce(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
-            break;
+            },
-        case 8:
+            [&] {
                 connman.DisconnectNode(fuzzed_data_provider.ConsumeIntegral<NodeId>());
-            break;
+            },
-        case 9:
+            [&] {
                 connman.DisconnectNode(random_netaddr);
-            break;
+            },
-        case 10:
+            [&] {
                 connman.DisconnectNode(random_string);
-            break;
+            },
-        case 11:
+            [&] {
                 connman.DisconnectNode(random_subnet);
-            break;
+            },
-        case 12:
+            [&] {
                 connman.ForEachNode([](auto) {});
-            break;
+            },
-        case 13:
+            [&] {
                 connman.ForEachNodeThen([](auto) {}, []() {});
-            break;
+            },
-        case 14:
+            [&] {
                 (void)connman.ForNode(fuzzed_data_provider.ConsumeIntegral<NodeId>(), [&](auto) { return fuzzed_data_provider.ConsumeBool(); });
-            break;
+            },
-        case 15:
+            [&] {
                 (void)connman.GetAddresses(fuzzed_data_provider.ConsumeIntegral<size_t>(), fuzzed_data_provider.ConsumeIntegral<size_t>());
-            break;
+            },
-        case 16: {
+            [&] {
                 (void)connman.GetAddresses(random_node, fuzzed_data_provider.ConsumeIntegral<size_t>(), fuzzed_data_provider.ConsumeIntegral<size_t>());
-            break;
+            },
-        }
+            [&] {
-        case 17:
                 (void)connman.GetDeterministicRandomizer(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
-            break;
+            },
-        case 18:
+            [&] {
                 (void)connman.GetNodeCount(fuzzed_data_provider.PickValueInArray({CConnman::CONNECTIONS_NONE, CConnman::CONNECTIONS_IN, CConnman::CONNECTIONS_OUT, CConnman::CONNECTIONS_ALL}));
-            break;
+            },
-        case 19:
+            [&] {
                 connman.MarkAddressGood(random_address);
-            break;
+            },
-        case 20:
+            [&] {
                 (void)connman.OutboundTargetReached(fuzzed_data_provider.ConsumeBool());
-            break;
+            },
-        case 21:
+            [&] {
                 // Limit now to int32_t to avoid signed integer overflow
                 (void)connman.PoissonNextSendInbound(fuzzed_data_provider.ConsumeIntegral<int32_t>(), fuzzed_data_provider.ConsumeIntegral<int>());
-            break;
+            },
-        case 22: {
+            [&] {
                 CSerializedNetMsg serialized_net_msg;
                 serialized_net_msg.m_type = fuzzed_data_provider.ConsumeRandomLengthString(CMessageHeader::COMMAND_SIZE);
                 serialized_net_msg.data = ConsumeRandomLengthByteVector(fuzzed_data_provider);
                 connman.PushMessage(&random_node, std::move(serialized_net_msg));
-            break;
+            },
-        }
+            [&] {
-        case 23:
                 connman.RemoveAddedNode(random_string);
-            break;
+            },
-        case 24: {
+            [&] {
                 const std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider);
                 if (SanityCheckASMap(asmap)) {
                     connman.SetAsmap(asmap);
                 }
-            break;
+            },
-        }
+            [&] {
-        case 25:
                 connman.SetNetworkActive(fuzzed_data_provider.ConsumeBool());
-            break;
+            },
-        case 26:
+            [&] {
                 connman.SetServices(random_service, ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS));
-            break;
+            },
-        case 27:
+            [&] {
                 connman.SetTryNewOutboundPeer(fuzzed_data_provider.ConsumeBool());
-            break;
+            });
-        }
     }
     (void)connman.GetAddedNodeInfo();
     (void)connman.GetExtraFullOutboundCount();

src/test/fuzz/crypto.cpp

@@ -39,8 +39,9 @@ FUZZ_TARGET(crypto)
     MuHash3072 muhash;
 
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 2)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 if (fuzzed_data_provider.ConsumeBool()) {
                     data = ConsumeRandomLengthByteVector(fuzzed_data_provider);
                     if (data.empty()) {
@@ -68,9 +69,8 @@ FUZZ_TARGET(crypto)
                 } else {
                     muhash /= MuHash3072(data);
                 }
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 (void)hash160.Reset();
                 (void)hash256.Reset();
                 (void)ripemd160.Reset();
@@ -79,69 +79,55 @@ FUZZ_TARGET(crypto)
                 (void)sha3.Reset();
                 (void)sha512.Reset();
                 muhash = MuHash3072();
-            break;
+            },
-        }
+            [&] {
-        case 2: {
+                CallOneOf(
-            switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 10)) {
+                    fuzzed_data_provider,
-            case 0: {
+                    [&] {
                         data.resize(CHash160::OUTPUT_SIZE);
                         hash160.Finalize(data);
-                break;
+                    },
-            }
+                    [&] {
-            case 1: {
                         data.resize(CHash256::OUTPUT_SIZE);
                         hash256.Finalize(data);
-                break;
+                    },
-            }
+                    [&] {
-            case 2: {
                         data.resize(CHMAC_SHA256::OUTPUT_SIZE);
                         hmac_sha256.Finalize(data.data());
-                break;
+                    },
-            }
+                    [&] {
-            case 3: {
                         data.resize(CHMAC_SHA512::OUTPUT_SIZE);
                         hmac_sha512.Finalize(data.data());
-                break;
+                    },
-            }
+                    [&] {
-            case 4: {
                         data.resize(CRIPEMD160::OUTPUT_SIZE);
                         ripemd160.Finalize(data.data());
-                break;
+                    },
-            }
+                    [&] {
-            case 5: {
                         data.resize(CSHA1::OUTPUT_SIZE);
                         sha1.Finalize(data.data());
-                break;
+                    },
-            }
+                    [&] {
-            case 6: {
                         data.resize(CSHA256::OUTPUT_SIZE);
                         sha256.Finalize(data.data());
-                break;
+                    },
-            }
+                    [&] {
-            case 7: {
                         data.resize(CSHA512::OUTPUT_SIZE);
                         sha512.Finalize(data.data());
-                break;
+                    },
-            }
+                    [&] {
-            case 8: {
                         data.resize(1);
                         data[0] = sip_hasher.Finalize() % 256;
-                break;
+                    },
-            }
+                    [&] {
-            case 9: {
                         data.resize(SHA3_256::OUTPUT_SIZE);
                         sha3.Finalize(data);
-                break;
+                    },
-            }
+                    [&] {
-            case 10: {
                         uint256 out;
                         muhash.Finalize(out);
-                break;
+                    });
-            }
+            });
-            }
-            break;
-        }
-        }
     }
     if (fuzzed_data_provider.ConsumeBool()) {
         uint64_t state[25];

src/test/fuzz/crypto_chacha20.cpp

@@ -20,31 +20,26 @@ FUZZ_TARGET(crypto_chacha20)
         chacha20 = ChaCha20{key.data(), key.size()};
     }
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 4)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 const std::vector<unsigned char> key = ConsumeFixedLengthByteVector(fuzzed_data_provider, fuzzed_data_provider.ConsumeIntegralInRange<size_t>(16, 32));
                 chacha20.SetKey(key.data(), key.size());
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 chacha20.SetIV(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 chacha20.Seek(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 std::vector<uint8_t> output(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
                 chacha20.Keystream(output.data(), output.size());
-            break;
+            },
-        }
+            [&] {
-        case 4: {
                 std::vector<uint8_t> output(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
                 const std::vector<uint8_t> input = ConsumeFixedLengthByteVector(fuzzed_data_provider, output.size());
                 chacha20.Crypt(input.data(), output.data(), input.size());
-            break;
+            });
-        }
-        }
     }
 }

src/test/fuzz/crypto_chacha20_poly1305_aead.cpp

@@ -29,44 +29,37 @@ FUZZ_TARGET(crypto_chacha20_poly1305_aead)
     std::vector<uint8_t> out(buffer_size + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0);
     bool is_encrypt = fuzzed_data_provider.ConsumeBool();
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 6)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 buffer_size = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(64, 4096);
                 in = std::vector<uint8_t>(buffer_size + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0);
                 out = std::vector<uint8_t>(buffer_size + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0);
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 (void)aead.Crypt(seqnr_payload, seqnr_aad, aad_pos, out.data(), out.size(), in.data(), buffer_size, is_encrypt);
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 uint32_t len = 0;
                 const bool ok = aead.GetLength(&len, seqnr_aad, aad_pos, in.data());
                 assert(ok);
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 seqnr_payload += 1;
                 aad_pos += CHACHA20_POLY1305_AEAD_AAD_LEN;
                 if (aad_pos + CHACHA20_POLY1305_AEAD_AAD_LEN > CHACHA20_ROUND_OUTPUT) {
                     aad_pos = 0;
                     seqnr_aad += 1;
                 }
-            break;
+            },
-        }
+            [&] {
-        case 4: {
                 seqnr_payload = fuzzed_data_provider.ConsumeIntegral<int>();
-            break;
+            },
-        }
+            [&] {
-        case 5: {
                 seqnr_aad = fuzzed_data_provider.ConsumeIntegral<int>();
-            break;
+            },
-        }
+            [&] {
-        case 6: {
                 is_encrypt = fuzzed_data_provider.ConsumeBool();
-            break;
+            });
-        }
-        }
     }
 }

src/test/fuzz/merkleblock.cpp

@@ -17,15 +17,15 @@ FUZZ_TARGET(merkleblock)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     CPartialMerkleTree partial_merkle_tree;
-    switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 1)) {
+    CallOneOf(
-    case 0: {
+        fuzzed_data_provider,
+        [&] {
             const std::optional<CPartialMerkleTree> opt_partial_merkle_tree = ConsumeDeserializable<CPartialMerkleTree>(fuzzed_data_provider);
             if (opt_partial_merkle_tree) {
                 partial_merkle_tree = *opt_partial_merkle_tree;
             }
-        break;
+        },
-    }
+        [&] {
-    case 1: {
             CMerkleBlock merkle_block;
             const std::optional<CBlock> opt_block = ConsumeDeserializable<CBlock>(fuzzed_data_provider);
             CBloomFilter bloom_filter;
@@ -41,9 +41,7 @@ FUZZ_TARGET(merkleblock)
                 }
             }
             partial_merkle_tree = merkle_block.txn;
-        break;
+        });
-    }
-    }
     (void)partial_merkle_tree.GetNumTransactions();
     std::vector<uint256> matches;
     std::vector<unsigned int> indices;

src/test/fuzz/net.cpp

@@ -32,85 +32,74 @@ FUZZ_TARGET_INIT(net, initialize_net)
     CNode node{ConsumeNode(fuzzed_data_provider)};
     node.SetCommonVersion(fuzzed_data_provider.ConsumeIntegral<int>());
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 10)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 node.CloseSocketDisconnect();
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 node.MaybeSetAddrName(fuzzed_data_provider.ConsumeRandomLengthString(32));
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 const std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider);
                 if (!SanityCheckASMap(asmap)) {
-                break;
+                    return;
                 }
                 CNodeStats stats;
                 node.copyStats(stats, asmap);
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 const CNode* add_ref_node = node.AddRef();
                 assert(add_ref_node == &node);
-            break;
+            },
-        }
+            [&] {
-        case 4: {
                 if (node.GetRefCount() > 0) {
                     node.Release();
                 }
-            break;
+            },
-        }
+            [&] {
-        case 5: {
                 if (node.m_addr_known == nullptr) {
-                break;
+                    return;
                 }
                 const std::optional<CAddress> addr_opt = ConsumeDeserializable<CAddress>(fuzzed_data_provider);
                 if (!addr_opt) {
-                break;
+                    return;
                 }
                 node.AddAddressKnown(*addr_opt);
-            break;
+            },
-        }
+            [&] {
-        case 6: {
                 if (node.m_addr_known == nullptr) {
-                break;
+                    return;
                 }
                 const std::optional<CAddress> addr_opt = ConsumeDeserializable<CAddress>(fuzzed_data_provider);
                 if (!addr_opt) {
-                break;
+                    return;
                 }
                 FastRandomContext fast_random_context{ConsumeUInt256(fuzzed_data_provider)};
                 node.PushAddress(*addr_opt, fast_random_context);
-            break;
+            },
-        }
+            [&] {
-        case 7: {
                 const std::optional<CInv> inv_opt = ConsumeDeserializable<CInv>(fuzzed_data_provider);
                 if (!inv_opt) {
-                break;
+                    return;
                 }
                 node.AddKnownTx(inv_opt->hash);
-            break;
+            },
-        }
+            [&] {
-        case 8: {
                 node.PushTxInventory(ConsumeUInt256(fuzzed_data_provider));
-            break;
+            },
-        }
+            [&] {
-        case 9: {
                 const std::optional<CService> service_opt = ConsumeDeserializable<CService>(fuzzed_data_provider);
                 if (!service_opt) {
-                break;
+                    return;
                 }
                 node.SetAddrLocal(*service_opt);
-            break;
+            },
-        }
+            [&] {
-        case 10: {
                 const std::vector<uint8_t> b = ConsumeRandomLengthByteVector(fuzzed_data_provider);
                 bool complete;
                 node.ReceiveMsgBytes(b, complete);
-            break;
+            });
-        }
-        }
     }
 
     (void)node.GetAddrLocal();

src/test/fuzz/policy_estimator.cpp

@@ -24,20 +24,20 @@ FUZZ_TARGET_INIT(policy_estimator, initialize_policy_estimator)
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     CBlockPolicyEstimator block_policy_estimator;
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 3)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 const std::optional<CMutableTransaction> mtx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
                 if (!mtx) {
-                break;
+                    return;
                 }
                 const CTransaction tx{*mtx};
                 block_policy_estimator.processTransaction(ConsumeTxMemPoolEntry(fuzzed_data_provider, tx), fuzzed_data_provider.ConsumeBool());
                 if (fuzzed_data_provider.ConsumeBool()) {
                     (void)block_policy_estimator.removeTx(tx.GetHash(), /* inBlock */ fuzzed_data_provider.ConsumeBool());
                 }
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 std::vector<CTxMemPoolEntry> mempool_entries;
                 while (fuzzed_data_provider.ConsumeBool()) {
                     const std::optional<CMutableTransaction> mtx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
@@ -53,17 +53,13 @@ FUZZ_TARGET_INIT(policy_estimator, initialize_policy_estimator)
                     ptrs.push_back(&mempool_entry);
                 }
                 block_policy_estimator.processBlock(fuzzed_data_provider.ConsumeIntegral<unsigned int>(), ptrs);
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 (void)block_policy_estimator.removeTx(ConsumeUInt256(fuzzed_data_provider), /* inBlock */ fuzzed_data_provider.ConsumeBool());
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 block_policy_estimator.FlushUnconfirmed();
-            break;
+            });
-        }
-        }
         (void)block_policy_estimator.estimateFee(fuzzed_data_provider.ConsumeIntegral<int>());
         EstimationResult result;
         (void)block_policy_estimator.estimateRawFee(fuzzed_data_provider.ConsumeIntegral<int>(), fuzzed_data_provider.ConsumeFloatingPoint<double>(), fuzzed_data_provider.PickValueInArray(ALL_FEE_ESTIMATE_HORIZONS), fuzzed_data_provider.ConsumeBool() ? &result : nullptr);

src/test/fuzz/rolling_bloom_filter.cpp

@@ -22,29 +22,27 @@ FUZZ_TARGET(rolling_bloom_filter)
         fuzzed_data_provider.ConsumeIntegralInRange<unsigned int>(1, 1000),
         0.999 / fuzzed_data_provider.ConsumeIntegralInRange<unsigned int>(1, std::numeric_limits<unsigned int>::max())};
     while (fuzzed_data_provider.remaining_bytes() > 0) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 2)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 const std::vector<unsigned char> b = ConsumeRandomLengthByteVector(fuzzed_data_provider);
                 (void)rolling_bloom_filter.contains(b);
                 rolling_bloom_filter.insert(b);
                 const bool present = rolling_bloom_filter.contains(b);
                 assert(present);
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 const std::optional<uint256> u256 = ConsumeDeserializable<uint256>(fuzzed_data_provider);
                 if (!u256) {
-                break;
+                    return;
                 }
                 (void)rolling_bloom_filter.contains(*u256);
                 rolling_bloom_filter.insert(*u256);
                 const bool present = rolling_bloom_filter.contains(*u256);
                 assert(present);
-            break;
+            },
-        }
+            [&] {
-        case 2:
                 rolling_bloom_filter.reset();
-            break;
+            });
-        }
     }
 }

src/test/fuzz/script_ops.cpp

@@ -16,33 +16,32 @@ FUZZ_TARGET(script_ops)
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     CScript script = ConsumeScript(fuzzed_data_provider);
     while (fuzzed_data_provider.remaining_bytes() > 0) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 7)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 CScript s = ConsumeScript(fuzzed_data_provider);
                 script = std::move(s);
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 const CScript& s = ConsumeScript(fuzzed_data_provider);
                 script = s;
-            break;
+            },
-        }
+            [&] {
-        case 2:
                 script << fuzzed_data_provider.ConsumeIntegral<int64_t>();
-            break;
+            },
-        case 3:
+            [&] {
                 script << ConsumeOpcodeType(fuzzed_data_provider);
-            break;
+            },
-        case 4:
+            [&] {
                 script << ConsumeScriptNum(fuzzed_data_provider);
-            break;
+            },
-        case 5:
+            [&] {
                 script << ConsumeRandomLengthByteVector(fuzzed_data_provider);
-            break;
+            },
-        case 6:
+            [&] {
                 script.clear();
-            break;
+            },
-        case 7: {
+            [&] {
                 (void)script.GetSigOpCount(false);
                 (void)script.GetSigOpCount(true);
                 (void)script.GetSigOpCount(script);
@@ -64,8 +63,6 @@ FUZZ_TARGET(script_ops)
                     std::vector<uint8_t> program;
                     (void)script.IsWitnessProgram(version, program);
                 }
-            break;
+            });
-        }
-        }
     }
 }

src/test/fuzz/scriptnum_ops.cpp

@@ -29,8 +29,9 @@ FUZZ_TARGET(scriptnum_ops)
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     CScriptNum script_num = ConsumeScriptNum(fuzzed_data_provider);
     while (fuzzed_data_provider.remaining_bytes() > 0) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 11)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 const int64_t i = fuzzed_data_provider.ConsumeIntegral<int64_t>();
                 assert((script_num == i) != (script_num != i));
                 assert((script_num <= i) != (script_num > i));
@@ -45,9 +46,8 @@ FUZZ_TARGET(scriptnum_ops)
                 if (IsValidSubtraction(script_num, CScriptNum{i})) {
                     assert((script_num - i) + i == script_num);
                 }
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
                 assert((script_num == random_script_num) != (script_num != random_script_num));
                 assert((script_num <= random_script_num) != (script_num > random_script_num));
@@ -62,72 +62,66 @@ FUZZ_TARGET(scriptnum_ops)
                 if (IsValidSubtraction(script_num, random_script_num)) {
                     assert((script_num - random_script_num) + random_script_num == script_num);
                 }
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
                 if (!IsValidAddition(script_num, random_script_num)) {
                     // Avoid assertion failure:
                     // ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed.
-                break;
+                    return;
                 }
                 script_num += random_script_num;
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
                 if (!IsValidSubtraction(script_num, random_script_num)) {
                     // Avoid assertion failure:
                     // ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed.
-                break;
+                    return;
                 }
                 script_num -= random_script_num;
-            break;
+            },
-        }
+            [&] {
-        case 4:
                 script_num = script_num & fuzzed_data_provider.ConsumeIntegral<int64_t>();
-            break;
+            },
-        case 5:
+            [&] {
                 script_num = script_num & ConsumeScriptNum(fuzzed_data_provider);
-            break;
+            },
-        case 6:
+            [&] {
                 script_num &= ConsumeScriptNum(fuzzed_data_provider);
-            break;
+            },
-        case 7:
+            [&] {
                 if (script_num == CScriptNum{std::numeric_limits<int64_t>::min()}) {
                     // Avoid assertion failure:
                     // ./script/script.h:279: CScriptNum CScriptNum::operator-() const: Assertion `m_value != std::numeric_limits<int64_t>::min()' failed.
-                break;
+                    return;
                 }
                 script_num = -script_num;
-            break;
+            },
-        case 8:
+            [&] {
                 script_num = fuzzed_data_provider.ConsumeIntegral<int64_t>();
-            break;
+            },
-        case 9: {
+            [&] {
                 const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>();
                 if (!IsValidAddition(script_num, CScriptNum{random_integer})) {
                     // Avoid assertion failure:
                     // ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed.
-                break;
+                    return;
                 }
                 script_num += random_integer;
-            break;
+            },
-        }
+            [&] {
-        case 10: {
                 const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>();
                 if (!IsValidSubtraction(script_num, CScriptNum{random_integer})) {
                     // Avoid assertion failure:
                     // ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed.
-                break;
+                    return;
                 }
                 script_num -= random_integer;
-            break;
+            },
-        }
+            [&] {
-        case 11:
                 script_num &= fuzzed_data_provider.ConsumeIntegral<int64_t>();
-            break;
+            });
-        }
         (void)script_num.getint();
         (void)script_num.getvch();
     }

src/test/fuzz/strprintf.cpp

@@ -4,6 +4,7 @@
 
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
+#include <test/fuzz/util.h>
 #include <tinyformat.h>
 #include <util/strencodings.h>
 #include <util/translation.h>
@@ -109,32 +110,32 @@ FUZZ_TARGET(str_printf)
     }
 
     try {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 5)) {
+        CallOneOf(
-        case 0:
+            fuzzed_data_provider,
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32));
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeRandomLengthString(32));
-            break;
+            },
-        case 1:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32).c_str());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeRandomLengthString(32).c_str());
-            break;
+            },
-        case 2:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<signed char>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<signed char>());
-            break;
+            },
-        case 3:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<unsigned char>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<unsigned char>());
-            break;
+            },
-        case 4:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<char>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<char>());
-            break;
+            },
-        case 5:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeBool());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeBool());
-            break;
+            });
-        }
     } catch (const tinyformat::format_error&) {
     }
 
@@ -155,40 +156,40 @@ FUZZ_TARGET(str_printf)
     }
 
     try {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 7)) {
+        CallOneOf(
-        case 0:
+            fuzzed_data_provider,
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeFloatingPoint<float>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeFloatingPoint<float>());
-            break;
+            },
-        case 1:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeFloatingPoint<double>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeFloatingPoint<double>());
-            break;
+            },
-        case 2:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<int16_t>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<int16_t>());
-            break;
+            },
-        case 3:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<uint16_t>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<uint16_t>());
-            break;
+            },
-        case 4:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<int32_t>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<int32_t>());
-            break;
+            },
-        case 5:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<uint32_t>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<uint32_t>());
-            break;
+            },
-        case 6:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<int64_t>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<int64_t>());
-            break;
+            },
-        case 7:
+            [&] {
                 (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<uint64_t>());
                 (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<uint64_t>());
-            break;
+            });
-        }
     } catch (const tinyformat::format_error&) {
     }
 }

src/test/fuzz/system.cpp

@@ -32,35 +32,31 @@ FUZZ_TARGET(system)
     }
 
     while (fuzzed_data_provider.ConsumeBool()) {
-        switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 7)) {
+        CallOneOf(
-        case 0: {
+            fuzzed_data_provider,
+            [&] {
                 args_manager.SelectConfigNetwork(fuzzed_data_provider.ConsumeRandomLengthString(16));
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 args_manager.SoftSetArg(fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeRandomLengthString(16));
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 args_manager.ForceSetArg(fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeRandomLengthString(16));
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 args_manager.SoftSetBoolArg(fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeBool());
-            break;
+            },
-        }
+            [&] {
-        case 4: {
                 const OptionsCategory options_category = fuzzed_data_provider.PickValueInArray<OptionsCategory>({OptionsCategory::OPTIONS, OptionsCategory::CONNECTION, OptionsCategory::WALLET, OptionsCategory::WALLET_DEBUG_TEST, OptionsCategory::ZMQ, OptionsCategory::DEBUG_TEST, OptionsCategory::CHAINPARAMS, OptionsCategory::NODE_RELAY, OptionsCategory::BLOCK_CREATION, OptionsCategory::RPC, OptionsCategory::GUI, OptionsCategory::COMMANDS, OptionsCategory::REGISTER_COMMANDS, OptionsCategory::HIDDEN});
                 // Avoid hitting:
                 // util/system.cpp:425: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed.
                 const std::string argument_name = GetArgumentName(fuzzed_data_provider.ConsumeRandomLengthString(16));
                 if (args_manager.GetArgFlags(argument_name) != nullopt) {
-                break;
+                    return;
                 }
                 args_manager.AddArg(argument_name, fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeIntegral<unsigned int>(), options_category);
-            break;
+            },
-        }
+            [&] {
-        case 5: {
                 // Avoid hitting:
                 // util/system.cpp:425: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed.
                 const std::vector<std::string> names = ConsumeRandomLengthStringVector(fuzzed_data_provider);
@@ -76,13 +72,11 @@ FUZZ_TARGET(system)
                     hidden_arguments.push_back(hidden_argument);
                 }
                 args_manager.AddHiddenArgs(hidden_arguments);
-            break;
+            },
-        }
+            [&] {
-        case 6: {
                 args_manager.ClearArgs();
-            break;
+            },
-        }
+            [&] {
-        case 7: {
                 const std::vector<std::string> random_arguments = ConsumeRandomLengthStringVector(fuzzed_data_provider);
                 std::vector<const char*> argv;
                 argv.reserve(random_arguments.size());
@@ -94,9 +88,7 @@ FUZZ_TARGET(system)
                     (void)args_manager.ParseParameters(argv.size(), argv.data(), error);
                 } catch (const std::logic_error&) {
                 }
-            break;
+            });
-        }
-        }
     }
 
     const std::string s1 = fuzzed_data_provider.ConsumeRandomLengthString(16);

src/test/fuzz/util.h

@@ -36,6 +36,17 @@
 #include <string>
 #include <vector>
 
+template <typename... Callables>
+void CallOneOf(FuzzedDataProvider& fuzzed_data_provider, Callables... callables)
+{
+    constexpr size_t call_size{sizeof...(callables)};
+    static_assert(call_size >= 1);
+    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
+
+    size_t i{0};
+    return ((i++ == call_index ? callables() : void()), ...);
+}
+
 [[nodiscard]] inline std::vector<uint8_t> ConsumeRandomLengthByteVector(FuzzedDataProvider& fuzzed_data_provider, const size_t max_length = 4096) noexcept
 {
     const std::string s = fuzzed_data_provider.ConsumeRandomLengthString(max_length);
@@ -165,37 +176,31 @@ template <typename WeakEnumType, size_t size>
 [[nodiscard]] inline CTxDestination ConsumeTxDestination(FuzzedDataProvider& fuzzed_data_provider) noexcept
 {
     CTxDestination tx_destination;
-    switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 5)) {
+    CallOneOf(
-    case 0: {
+        fuzzed_data_provider,
+        [&] {
             tx_destination = CNoDestination{};
-        break;
+        },
-    }
+        [&] {
-    case 1: {
             tx_destination = PKHash{ConsumeUInt160(fuzzed_data_provider)};
-        break;
+        },
-    }
+        [&] {
-    case 2: {
             tx_destination = ScriptHash{ConsumeUInt160(fuzzed_data_provider)};
-        break;
+        },
-    }
+        [&] {
-    case 3: {
             tx_destination = WitnessV0ScriptHash{ConsumeUInt256(fuzzed_data_provider)};
-        break;
+        },
-    }
+        [&] {
-    case 4: {
             tx_destination = WitnessV0KeyHash{ConsumeUInt160(fuzzed_data_provider)};
-        break;
+        },
-    }
+        [&] {
-    case 5: {
             WitnessUnknown witness_unknown{};
             witness_unknown.version = fuzzed_data_provider.ConsumeIntegral<int>();
             const std::vector<uint8_t> witness_unknown_program_1 = fuzzed_data_provider.ConsumeBytes<uint8_t>(40);
             witness_unknown.length = witness_unknown_program_1.size();
             std::copy(witness_unknown_program_1.begin(), witness_unknown_program_1.end(), witness_unknown.program);
             tx_destination = witness_unknown;
-        break;
+        });
-    }
-    }
     return tx_destination;
 }
 
@@ -354,32 +359,26 @@ public:
             return nullptr;
         }
         std::string mode;
-        switch (m_fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 5)) {
+        CallOneOf(
-        case 0: {
+            m_fuzzed_data_provider,
+            [&] {
                 mode = "r";
-            break;
+            },
-        }
+            [&] {
-        case 1: {
                 mode = "r+";
-            break;
+            },
-        }
+            [&] {
-        case 2: {
                 mode = "w";
-            break;
+            },
-        }
+            [&] {
-        case 3: {
                 mode = "w+";
-            break;
+            },
-        }
+            [&] {
-        case 4: {
                 mode = "a";
-            break;
+            },
-        }
+            [&] {
-        case 5: {
                 mode = "a+";
-            break;
+            });
-        }
-        }
 #ifdef _GNU_SOURCE
         const cookie_io_functions_t io_hooks = {
             FuzzedFileProvider::read,
@@ -477,66 +476,64 @@ public:
     return {fuzzed_data_provider};
 }
 
-#define WRITE_TO_STREAM_CASE(id, type, consume) \
+#define WRITE_TO_STREAM_CASE(type, consume) \
-    case id: {                                  \
+    [&] {                                   \
         type o = consume;                   \
         stream << o;                        \
-        break;                                  \
     }
 template <typename Stream>
 void WriteToStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept
 {
     while (fuzzed_data_provider.ConsumeBool()) {
         try {
-            switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 13)) {
+            CallOneOf(
-                WRITE_TO_STREAM_CASE(0, bool, fuzzed_data_provider.ConsumeBool())
+                fuzzed_data_provider,
-                WRITE_TO_STREAM_CASE(1, char, fuzzed_data_provider.ConsumeIntegral<char>())
+                WRITE_TO_STREAM_CASE(bool, fuzzed_data_provider.ConsumeBool()),
-                WRITE_TO_STREAM_CASE(2, int8_t, fuzzed_data_provider.ConsumeIntegral<int8_t>())
+                WRITE_TO_STREAM_CASE(char, fuzzed_data_provider.ConsumeIntegral<char>()),
-                WRITE_TO_STREAM_CASE(3, uint8_t, fuzzed_data_provider.ConsumeIntegral<uint8_t>())
+                WRITE_TO_STREAM_CASE(int8_t, fuzzed_data_provider.ConsumeIntegral<int8_t>()),
-                WRITE_TO_STREAM_CASE(4, int16_t, fuzzed_data_provider.ConsumeIntegral<int16_t>())
+                WRITE_TO_STREAM_CASE(uint8_t, fuzzed_data_provider.ConsumeIntegral<uint8_t>()),
-                WRITE_TO_STREAM_CASE(5, uint16_t, fuzzed_data_provider.ConsumeIntegral<uint16_t>())
+                WRITE_TO_STREAM_CASE(int16_t, fuzzed_data_provider.ConsumeIntegral<int16_t>()),
-                WRITE_TO_STREAM_CASE(6, int32_t, fuzzed_data_provider.ConsumeIntegral<int32_t>())
+                WRITE_TO_STREAM_CASE(uint16_t, fuzzed_data_provider.ConsumeIntegral<uint16_t>()),
-                WRITE_TO_STREAM_CASE(7, uint32_t, fuzzed_data_provider.ConsumeIntegral<uint32_t>())
+                WRITE_TO_STREAM_CASE(int32_t, fuzzed_data_provider.ConsumeIntegral<int32_t>()),
-                WRITE_TO_STREAM_CASE(8, int64_t, fuzzed_data_provider.ConsumeIntegral<int64_t>())
+                WRITE_TO_STREAM_CASE(uint32_t, fuzzed_data_provider.ConsumeIntegral<uint32_t>()),
-                WRITE_TO_STREAM_CASE(9, uint64_t, fuzzed_data_provider.ConsumeIntegral<uint64_t>())
+                WRITE_TO_STREAM_CASE(int64_t, fuzzed_data_provider.ConsumeIntegral<int64_t>()),
-                WRITE_TO_STREAM_CASE(10, float, fuzzed_data_provider.ConsumeFloatingPoint<float>())
+                WRITE_TO_STREAM_CASE(uint64_t, fuzzed_data_provider.ConsumeIntegral<uint64_t>()),
-                WRITE_TO_STREAM_CASE(11, double, fuzzed_data_provider.ConsumeFloatingPoint<double>())
+                WRITE_TO_STREAM_CASE(float, fuzzed_data_provider.ConsumeFloatingPoint<float>()),
-                WRITE_TO_STREAM_CASE(12, std::string, fuzzed_data_provider.ConsumeRandomLengthString(32))
+                WRITE_TO_STREAM_CASE(double, fuzzed_data_provider.ConsumeFloatingPoint<double>()),
-                WRITE_TO_STREAM_CASE(13, std::vector<char>, ConsumeRandomLengthIntegralVector<char>(fuzzed_data_provider))
+                WRITE_TO_STREAM_CASE(std::string, fuzzed_data_provider.ConsumeRandomLengthString(32)),
-            }
+                WRITE_TO_STREAM_CASE(std::vector<char>, ConsumeRandomLengthIntegralVector<char>(fuzzed_data_provider)));
         } catch (const std::ios_base::failure&) {
             break;
         }
     }
 }
 
-#define READ_FROM_STREAM_CASE(id, type) \
+#define READ_FROM_STREAM_CASE(type) \
-    case id: {                          \
+    [&] {                           \
         type o;                     \
         stream >> o;                \
-        break;                          \
     }
 template <typename Stream>
 void ReadFromStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept
 {
     while (fuzzed_data_provider.ConsumeBool()) {
         try {
-            switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 13)) {
+            CallOneOf(
-                READ_FROM_STREAM_CASE(0, bool)
+                fuzzed_data_provider,
-                READ_FROM_STREAM_CASE(1, char)
+                READ_FROM_STREAM_CASE(bool),
-                READ_FROM_STREAM_CASE(2, int8_t)
+                READ_FROM_STREAM_CASE(char),
-                READ_FROM_STREAM_CASE(3, uint8_t)
+                READ_FROM_STREAM_CASE(int8_t),
-                READ_FROM_STREAM_CASE(4, int16_t)
+                READ_FROM_STREAM_CASE(uint8_t),
-                READ_FROM_STREAM_CASE(5, uint16_t)
+                READ_FROM_STREAM_CASE(int16_t),
-                READ_FROM_STREAM_CASE(6, int32_t)
+                READ_FROM_STREAM_CASE(uint16_t),
-                READ_FROM_STREAM_CASE(7, uint32_t)
+                READ_FROM_STREAM_CASE(int32_t),
-                READ_FROM_STREAM_CASE(8, int64_t)
+                READ_FROM_STREAM_CASE(uint32_t),
-                READ_FROM_STREAM_CASE(9, uint64_t)
+                READ_FROM_STREAM_CASE(int64_t),
-                READ_FROM_STREAM_CASE(10, float)
+                READ_FROM_STREAM_CASE(uint64_t),
-                READ_FROM_STREAM_CASE(11, double)
+                READ_FROM_STREAM_CASE(float),
-                READ_FROM_STREAM_CASE(12, std::string)
+                READ_FROM_STREAM_CASE(double),
-                READ_FROM_STREAM_CASE(13, std::vector<char>)
+                READ_FROM_STREAM_CASE(std::string),
-            }
+                READ_FROM_STREAM_CASE(std::vector<char>));
         } catch (const std::ios_base::failure&) {
             break;
         }