[compiler-rt] FDP: add ConsumeRandomLengthString() version without arguments.

[Dor1s]

PTAL, this is a small change requested/suggested by Mitch. I have another one ready (which is a large refactoring) that would come after.

[hctim]

compiler-rt/include/fuzzer/FuzzedDataProvider.h

115

Why not just:

std::string ConsumeRandomLengthString(size_t max_length = remaining_bytes_) {?

[Dor1s]

compiler-rt/include/fuzzer/FuzzedDataProvider.h

115

I don't think a non-const value can be used for the default argument

[Dor1s]

fix tidy error

[hctim]

LGTM w/ one comment

compiler-rt/include/fuzzer/FuzzedDataProvider.h

115

Maybe I'm being silly, but this shouldn't be an issue, no? https://godbolt.org/z/46E8ht

[Dor1s]

make the linter happy #2

[Dor1s]

compiler-rt/include/fuzzer/FuzzedDataProvider.h

115

hm, looks like it's not necessarily should be const, but anyhow it can't be a "non-static data member"

In file included from <...>/llvm-project/compiler-rt/lib/fuzzer/tests/FuzzedDataProviderUnittest.cpp:9:
<...>/llvm-build/lib/clang/11.0.0/include/fuzzer/FuzzedDataProvider.h:115:61: error: invalid use of non-static data member 'remaining_bytes_'
  std::string ConsumeRandomLengthString(size_t max_length = remaining_bytes_) {
                                                            ^~~~~~~~~~~~~~~~
1 error generated.

same in gcc: https://godbolt.org/z/DdVHv4

[hctim]

compiler-rt/include/fuzzer/FuzzedDataProvider.h

115

TIL - LGTM.

[metzman]

LGTM

[Dor1s]

rebase

compiler-rt/include/fuzzer/FuzzedDataProvider.h

template <typename T> T ConsumeIntegralInRange(T min, T max) {
 
     return static_cast<T>(min + result);
   }
 
   // Returns a std::string of length from 0 to |max_length|. When it runs out of
   // input data, returns what remains of the input. Designed to be more stable
   // with respect to a fuzzer inserting characters than just picking a random
   // length and then consuming that many bytes with |ConsumeBytes|.
   std::string ConsumeRandomLengthString(size_t max_length) {
     // Reads bytes from the start of |data_ptr_|. Maps "\\" to "\", and maps "\"
     // followed by anything else to the end of the string. As a result of this
     // logic, a fuzzer can insert characters into the string, and the string
     // will be lengthened to include those new characters, resulting in a more
     // stable fuzzer than picking the length of a string independently from
     // picking its contents.
     std::string result;
 
for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
       }
       result += next;
     }
 
     result.shrink_to_fit();
     return result;
   }
 
+  // Returns a std::string of length from 0 to |remaining_bytes_|.
+  std::string ConsumeRandomLengthString() {
+    return ConsumeRandomLengthString(remaining_bytes_);
+  }
+
   // Returns a std::vector containing all remaining bytes of the input data.
   template <typename T> std::vector<T> ConsumeRemainingBytes() {
     return ConsumeBytes<T>(remaining_bytes_);
   }
 
   // Returns a std::string containing all remaining bytes of the input data.
   // Prefer using |ConsumeRemainingBytes| unless you actually need a std::string
   // object.

compiler-rt/lib/fuzzer/tests/FuzzedDataProviderUnittest.cpp

EXPECT_EQ(std::string(
                 "\xB3\xFD\xE3\x05\xA4\x03\x37\x49\x50\x4B\xBC\x39\xA2\x09\x6C"
                 "\x2F\xAF\xD1\xB5\x47\xBF\x92\xBD\x79\xE5\xC5\x6E\x51\xA4\xED"
                 "\xE9\xBD\x40\x4A\xFC\x25\x7A\x27\xC8\x92\xF7\x30\xDE\x40\x66"
                 "\x66\xE8\x5F\x65\x39\x7E\x9E\x80\x2B\x01\x71\x2A\xFF\xD3\x0A"
                 "\xAC\x6E\x49\x32\x79\x10\x6A\x6F\x97\x96\x70\x7E\x50\x65\xC9"
                 "\x1D\xBD\x4E\x17\x04\x1E\xBA\x26\xAC\x1F\xE3\x37\x1C\x15\x43"
                 "\x60\x41\x2A\x7C\xCA\x70\xCE\xAB\x20\x24\xF8\xD9\x1F\x14\x7C"),
             DataProv.ConsumeRandomLengthString(31337));
-  EXPECT_EQ(std::string(Data + 141, Data + 141 + 5),
+  size_t Offset = 141;
+  EXPECT_EQ(std::string(Data + Offset, Data + Offset + 5),
             DataProv.ConsumeRandomLengthString(5));
-  EXPECT_EQ(std::string(Data + 141 + 5, Data + 141 + 5 + 2),
+  Offset += 5;
+  EXPECT_EQ(std::string(Data + Offset, Data + Offset + 2),
             DataProv.ConsumeRandomLengthString(2));
+  Offset += 2;
+
+  // Call the overloaded method without arguments (uses max length available).
+  EXPECT_EQ(std::string(Data + Offset, Data + Offset + 664),
+            DataProv.ConsumeRandomLengthString());
+  Offset += 664 + 2; // +2 because of '\' character followed by any other byte.
+
+  EXPECT_EQ(std::string(Data + Offset, Data + Offset + 92),
+            DataProv.ConsumeRandomLengthString());
+  Offset += 92 + 2;
 
   // Exhaust the buffer.
   auto String = DataProv.ConsumeBytesAsString(31337);
-  EXPECT_EQ(size_t(876), String.length());
+  EXPECT_EQ(size_t(116), String.length());
   EXPECT_EQ(std::string(), DataProv.ConsumeRandomLengthString(1));
 }
 
 TEST(FuzzedDataProvider, ConsumeRemainingBytes) {
   {
     FuzzedDataProvider DataProv(Data, sizeof(Data));
     EXPECT_EQ(std::vector<uint8_t>(Data, Data + sizeof(Data)),
               DataProv.ConsumeRemainingBytes<uint8_t>());