fuzz: list API fuzzing options if -t api and -n matches nothing.

fuzz/fuzz.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Fuzz.h"
 #include "SkCanvas.h"
 #include "SkCodec.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkForceLinking.h"
 #include "SkImage.h"
 #include "SkImageEncoder.h"
 #include "SkMallocPixelRef.h"
 #include "SkPicture.h"
 #include "SkStream.h"
 
 #include <signal.h>
 #include <stdlib.h>
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 DEFINE_string2(bytes, b, "", "A path to a file.  This can be the fuzz bytes or a binary to parse.");
-DEFINE_string2(name, n, "", "If --type is 'api', run the DEF_FUZZ API fuzz with this name.");
+DEFINE_string2(name, n, "", "If --type is 'api', fuzz the API with this name.");
 
 DEFINE_string2(type, t, "api", "How to interpret --bytes, either 'image', 'skp', or 'api'.");
 DEFINE_string2(dump, d, "", "If not empty, dump 'image' or 'skp' types as a PNG with this name.");
 
 static int printUsage(const char* name) {
-    SkDebugf("Usage: %s -t <type> -b <path/to/file> [-n api_fuzz_name]\n", name);
+    SkDebugf("Usage: %s -t <type> -b <path/to/file> [-n api-to-fuzz]\n", name);
     return 1;
 }
 
 static int fuzz_api(SkData*);
 static int fuzz_img(SkData*);
 static int fuzz_skp(SkData*);
 
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
 
     const char* path = FLAGS_bytes.isEmpty() ? argv[0] : FLAGS_bytes[0];
     SkAutoTUnref<SkData> bytes(SkData::NewFromFileName(path));
     if (!bytes) {
         SkDebugf("Could not read %s\n", path);
         return 2;
     }
 
-    switch (FLAGS_type[0][0]) {
-        case 'a': return fuzz_api(bytes);
-        case 'i': return fuzz_img(bytes);
-        case 's': return fuzz_skp(bytes);
+    if (!FLAGS_type.isEmpty()) {
+        switch (FLAGS_type[0][0]) {
+            case 'a': return fuzz_api(bytes);
+            case 'i': return fuzz_img(bytes);
+            case 's': return fuzz_skp(bytes);
+        }
     }
     return printUsage(argv[0]);
 }
 
 int fuzz_api(SkData* bytes) {
+    const char* name = FLAGS_name.isEmpty() ? "" : FLAGS_name[0];
+
     for (auto r = SkTRegistry<Fuzzable>::Head(); r; r = r->next()) {
         auto fuzzable = r->factory();
-        if (0 == strcmp(FLAGS_name[0], fuzzable.name)) {
+        if (0 == strcmp(name, fuzzable.name)) {
             SkDebugf("Fuzzing %s...\n", fuzzable.name);
             Fuzz fuzz(bytes);
             fuzzable.fn(&fuzz);
             return 0;
         }
     }
-    SkDebugf("API fuzz %s not found\n", FLAGS_name[0]);
+
+    SkDebugf("When using --type api, please choose an API to fuzz with --name/-n:\n");
+    for (auto r = SkTRegistry<Fuzzable>::Head(); r; r = r->next()) {
+        auto fuzzable = r->factory();
+        SkDebugf("\t%s\n", fuzzable.name);
+    }
     return 1;
 }
 
 static void dump_png(SkBitmap bitmap) {
     if (!FLAGS_dump.isEmpty()) {
         SkImageEncoder::EncodeFile(FLAGS_dump[0], bitmap, SkImageEncoder::kPNG_Type, 100);
         SkDebugf("Dumped to %s\n", FLAGS_dump[0]);
     }
 }
 
@@ skipping 84 matching lines @@
     T val;
     memcpy(&val, fBytes->bytes() + fNextByte, sizeof(T));
     fNextByte += sizeof(T);
     return val;
 }
 
 uint8_t  Fuzz::nextB() { return this->nextT<uint8_t >(); }
 uint32_t Fuzz::nextU() { return this->nextT<uint32_t>(); }
 float    Fuzz::nextF() { return this->nextT<float   >(); }