webrtc-streamer 0.8.13 → 0.8.14

package/cxxopts/test/fuzz.cpp

@@ -0,0 +1,107 @@
+#include <cassert>
+#include <cxxopts.hpp>
+#include <fuzzer/FuzzedDataProvider.h>
+
+constexpr int kMaxOptions = 1024;
+constexpr int kMaxArgSize = 1024;
+
+enum class ParseableTypes
+{
+  kInt,
+  kString,
+  kVectorString,
+  kFloat,
+  kDouble,
+
+  // Marker for fuzzer.
+  kMaxValue,
+};
+
+template <typename T>
+void
+add_fuzzed_option(cxxopts::Options* options, FuzzedDataProvider* provider)
+{
+  assert(options);
+  assert(provider);
+
+  options->add_options()(provider->ConsumeRandomLengthString(kMaxArgSize),
+                         provider->ConsumeRandomLengthString(kMaxArgSize),
+                         cxxopts::value<T>());
+}
+
+extern "C" int
+LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+  try
+  {
+    FuzzedDataProvider provider(data, size);
+
+    // Randomly generate a usage string.
+    cxxopts::Options options(provider.ConsumeRandomLengthString(kMaxArgSize),
+                             provider.ConsumeRandomLengthString(kMaxArgSize));
+
+    // Randomly generate a set of flags configurations.
+    for (int i = 0; i < provider.ConsumeIntegralInRange<int>(0, kMaxOptions);
+         i++)
+    {
+      switch (provider.ConsumeEnum<ParseableTypes>())
+      {
+      case ParseableTypes::kInt:
+        add_fuzzed_option<int>(&options, &provider);
+        break;
+      case ParseableTypes::kString:
+        add_fuzzed_option<std::string>(&options, &provider);
+        break;
+      case ParseableTypes::kVectorString:
+        add_fuzzed_option<std::vector<std::string>>(&options, &provider);
+        break;
+      case ParseableTypes::kFloat:
+        add_fuzzed_option<float>(&options, &provider);
+        break;
+      case ParseableTypes::kDouble:
+        add_fuzzed_option<double>(&options, &provider);
+        break;
+      default:
+        break;
+      }
+    }
+    // Sometimes allow unrecognised options.
+    if (provider.ConsumeBool())
+    {
+      options.allow_unrecognised_options();
+    }
+    // Sometimes allow trailing positional arguments.
+    if (provider.ConsumeBool())
+    {
+      std::string positional_option_name =
+        provider.ConsumeRandomLengthString(kMaxArgSize);
+      options.add_options()(positional_option_name,
+                            provider.ConsumeRandomLengthString(kMaxArgSize),
+                            cxxopts::value<std::vector<std::string>>());
+      options.parse_positional({positional_option_name});
+    }
+
+    // Build command line input.
+    const int argc = provider.ConsumeIntegralInRange<int>(1, kMaxOptions);
+
+    std::vector<std::string> command_line_container;
+    command_line_container.reserve(argc);
+
+    std::vector<const char*> argv;
+    argv.reserve(argc);
+
+    for (int i = 0; i < argc; i++)
+    {
+      command_line_container.push_back(
+        provider.ConsumeRandomLengthString(kMaxArgSize));
+      argv.push_back(command_line_container[i].c_str());
+    }
+
+    // Parse command line;
+    auto result = options.parse(argc, argv.data());
+  } catch (...)
+  {
+  }
+
+  return 0;
+}

package/cxxopts/test/link_a.cpp

@@ -0,0 +1,6 @@
+#include "cxxopts.hpp"
+
+int main(int, char**)
+{
+  return 0;
+}

package/cxxopts/test/link_b.cpp

@@ -0,0 +1 @@
+#include <cxxopts.hpp>

package/cxxopts/test/main.cpp

@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"