cleaning-up tests

Author: Alami-Amine

src/credentials/tests/FuzzChipCertPW.cpp

@@ -6,6 +6,8 @@
 
 #include "credentials/CHIPCert.h"
 
+namespace {
+
 using namespace chip;
 using namespace chip::Credentials;
 
@@ -47,11 +49,6 @@ void ChipCertFuzzer(const std::vector<std::uint8_t> & bytes)
         (void) ExtractSubjectDNFromChipCert(span, subjectDN);
     }
 
-    {
-        ChipCertificateData certData;
-        (void) DecodeChipCert(span, certData);
-    }
-
     {
         uint8_t outCertBuf[kMaxDERCertLength];
         MutableByteSpan outCert(outCertBuf);
@@ -61,13 +58,12 @@ void ChipCertFuzzer(const std::vector<std::uint8_t> & bytes)
     {
         // TODO: #34352 To Move this to a Fixture once Errors related to FuzzTest Fixtures are resolved
         ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR);
-        ByteSpan span(bytes.data(), bytes.size());
         ValidateChipRCAC(span);
         chip::Platform::MemoryShutdown();
     }
 }
 
-FUZZ_TEST(ChipCert, ChipCertFuzzer).WithDomains(Arbitrary<std::vector<std::uint8_t>>());
+FUZZ_TEST(FuzzChipCert, ChipCertFuzzer).WithDomains(Arbitrary<std::vector<std::uint8_t>>());
 
 // The Property function for DecodeChipCertFuzzer, The FUZZ_TEST Macro will call this function.
 void DecodeChipCertFuzzer(const std::vector<std::uint8_t> & bytes, BitFlags<CertDecodeFlags> aDecodeFlag)
@@ -88,12 +84,12 @@ void DecodeChipCertFuzzer(const std::vector<std::uint8_t> & bytes, BitFlags<Cert
 // https://github.com/google/fuzztest/blob/main/doc/domains-reference.md#elementof-domains-element-of
 auto AnyCertDecodeFlag()
 {
-
     constexpr BitFlags<CertDecodeFlags> NullDecodeFlag;
     constexpr BitFlags<CertDecodeFlags> GenTBSHashFlag(CertDecodeFlags::kGenerateTBSHash);
     constexpr BitFlags<CertDecodeFlags> TrustAnchorFlag(CertDecodeFlags::kIsTrustAnchor);
 
     return ElementOf<CertDecodeFlags>({ NullDecodeFlag, GenTBSHashFlag, TrustAnchorFlag });
 }
 
-FUZZ_TEST(ChipCert, DecodeChipCertFuzzer).WithDomains(Arbitrary<std::vector<std::uint8_t>>(), AnyCertDecodeFlag());
+FUZZ_TEST(FuzzChipCert, DecodeChipCertFuzzer).WithDomains(Arbitrary<std::vector<std::uint8_t>>(), AnyCertDecodeFlag());
+} // namespace

src/lib/core/tests/FuzzTlvReaderPW.cpp

@@ -8,6 +8,8 @@
 #include "lib/core/TLV.h"
 #include "lib/core/TLVUtilities.h"
 
+namespace {
+
 using chip::TLV::TLVReader;
 
 using namespace fuzztest;
@@ -20,11 +22,14 @@ static CHIP_ERROR FuzzIterator(const TLVReader & aReader, size_t aDepth, void *
     return CHIP_NO_ERROR;
 }
 
-void FuzzTlvRead(const std::vector<std::uint8_t> & bytes)
+// The Property Function
+void FuzzTlvReader(const std::vector<std::uint8_t> & bytes)
 {
     TLVReader reader;
     reader.Init(bytes.data(), bytes.size());
     chip::TLV::Utilities::Iterate(reader, FuzzIterator, nullptr);
 }
+// Fuzz tests are instantiated with the FUZZ_TEST macro
+FUZZ_TEST(TLVReader, FuzzTlvReader).WithDomains(Arbitrary<std::vector<std::uint8_t>>());
 
-FUZZ_TEST(ChipCert, FuzzTlvRead).WithDomains(Arbitrary<std::vector<std::uint8_t>>());
+} // namespace

src/lib/dnssd/minimal_mdns/tests/FuzzPacketParsingPW.cpp

@@ -7,11 +7,11 @@
 #include <lib/dnssd/minimal_mdns/Parser.h>
 #include <lib/dnssd/minimal_mdns/RecordData.h>
 
+namespace {
+
 using namespace fuzztest;
 using namespace std;
 
-namespace {
-
 using namespace chip;
 using namespace mdns::Minimal;
 
@@ -57,8 +57,6 @@ class FuzzDelegate : public ParserDelegate
     mdns::Minimal::BytesRange mPacketRange;
 };
 
-} // namespace
-
 void PacketParserFuzz(const std::vector<std::uint8_t> & bytes)
 {
     BytesRange packet(bytes.data(), bytes.data() + bytes.size());
@@ -67,6 +65,8 @@ void PacketParserFuzz(const std::vector<std::uint8_t> & bytes)
     mdns::Minimal::ParsePacket(packet, &delegate);
 }
 
+FUZZ_TEST(MinimalmDNS, PacketParserFuzz).WithDomains(Arbitrary<vector<uint8_t>>());
+
 class TxtRecordAccumulator : public TxtRecordDelegate
 {
 public:
@@ -89,7 +89,8 @@ class TxtRecordAccumulator : public TxtRecordDelegate
     }
 };
 
-void TxtResponderFuzz2(const std::vector<std::uint8_t> & aRecord)
+// The Property Function
+void TxtResponderFuzz(const std::vector<std::uint8_t> & aRecord)
 {
 
     bool equal_sign_present = false;
@@ -126,5 +127,6 @@ void TxtResponderFuzz2(const std::vector<std::uint8_t> & aRecord)
     }
 }
 
-FUZZ_TEST(MinimalmDNS, TxtResponderFuzz2).WithDomains(Arbitrary<vector<uint8_t>>().WithMaxSize(254));
-FUZZ_TEST(MinimalmDNS, PacketParserFuzz).WithDomains(Arbitrary<vector<uint8_t>>());
+FUZZ_TEST(MinimalmDNS, TxtResponderFuzz).WithDomains(Arbitrary<vector<uint8_t>>().WithMaxSize(254));
+
+} // namespace

src/lib/format/tests/FuzzPayloadDecoderPW.cpp

@@ -59,7 +59,9 @@ void RunDecodeFuzz(const std::vector<std::uint8_t> & bytes, chip::Protocols::Id
     }
 }
 
-// This allows us to create a FuzzTest "Input Domain" to fuzz test with all the combinations of protocols.
+// This function allows us to fuzz using one of four protocols; by using FuzzTests's `ElementOf` API, we define an
+// input domain by explicitly enumerating the set of values in it More Info:
+// https://github.com/google/fuzztest/blob/main/doc/domains-reference.md#elementof-domains-element-of
 auto AnyProtocolID()
 {
     return ElementOf({ chip::Protocols::SecureChannel::Id, chip::Protocols::InteractionModel::Id, chip::Protocols::BDX::Id,

src/setup_payload/tests/FuzzBase38PW.cpp

@@ -9,6 +9,8 @@
 #include <setup_payload/Base38Decode.h>
 #include <setup_payload/Base38Encode.h>
 
+namespace {
+
 using namespace fuzztest;
 using namespace chip;
 
@@ -23,6 +25,9 @@ void Base38DecodeFuzz(const std::vector<uint8_t> & bytes)
     chip::base38Decode(base38EncodedString, decodedData);
 }
 
+// The invocation of the FuzzTest
+FUZZ_TEST(Base38Decoder, Base38DecodeFuzz).WithDomains(Arbitrary<std::vector<uint8_t>>());
+
 /* The property function for a base38 roundtrip Fuzzer.
  * It starts by encoding the fuzzing value passed
  * into Base38. The encoded value will then be decoded.
@@ -55,6 +60,10 @@ void Base38RoundTripFuzz(const std::vector<uint8_t> & bytes)
     ASSERT_EQ(decodedData, bytes);
 }
 
+// Max size of the vector is defined as 306 since that will give an outputSizeNeeded of 511 which is less than the required
+// kMaxOutputSize
+FUZZ_TEST(Base38Decoder, Base38RoundTripFuzz).WithDomains(Arbitrary<std::vector<uint8_t>>().WithMaxSize(306));
+
 void FuzzQRCodeSetupPayloadParser(const std::string & s)
 {
     chip::Platform::MemoryInit();
@@ -63,11 +72,6 @@ void FuzzQRCodeSetupPayloadParser(const std::string & s)
     QRCodeSetupPayloadParser(s).populatePayload(payload);
 }
 
-// The invocation of the FuzzTest
-FUZZ_TEST(Base38Decoder, Base38DecodeFuzz).WithDomains(Arbitrary<std::vector<uint8_t>>());
-
-// Max size of the vector is defined as 306 since that will give an outputSizeNeeded of 511 which is less than the required
-// kMaxOutputSize
-FUZZ_TEST(Base38Decoder, Base38RoundTripFuzz).WithDomains(Arbitrary<std::vector<uint8_t>>().WithMaxSize(306));
-
 FUZZ_TEST(Base38Decoder, FuzzQRCodeSetupPayloadParser).WithDomains(Arbitrary<std::string>());
+
+} // namespace