Create ParsePath API fuzz

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 <cmath>
 #include <signal.h>
 #include <stdlib.h>
 
 // TODO(kjlubick): Remove once http://crrev.com/1671193002 lands
 __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', fuzz the API with this name.");
 
 DEFINE_string2(type, t, "api", "How to interpret --bytes, either 'image_scale', 'image_mode', 'skp', or 'api'.");
@@ skipping 77 matching lines @@
 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]);
     }
 }
 
 int fuzz_img(SkData* bytes, uint8_t scale, uint8_t mode) {
     // We can scale 1x, 2x, 4x, 8x, 16x
     scale = scale % 5;
-    float fscale = pow(2.0f, scale);
-    SkDebugf("Scaling factor: %d\n", fscale);
+    float fscale = (float)pow(2.0f, scale);
+    SkDebugf("Scaling factor: %f\n", fscale);
 
     // We have 4 different modes of decoding, just like DM.
     mode = mode % 4;
     SkDebugf("Mode: %d\n", mode);
 
     // This is mostly copied from DMSrcSink's CodecSrc::draw method.
     SkDebugf("Decoding\n");
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(bytes));
     if (nullptr == codec.get()) {
         SkDebugf("[terminated] Couldn't create codec.\n");
@@ skipping 257 matching lines @@
         this->signalBoring();
     }
 
     T val;
     memcpy(&val, fBytes->bytes() + fNextByte, sizeof(T));
     fNextByte += sizeof(T);
     return val;
 }
 
 uint8_t  Fuzz::nextB() { return this->nextT<uint8_t >(); }
+bool  Fuzz::nextBool() { return nextB()&1; }
 uint32_t Fuzz::nextU() { return this->nextT<uint32_t>(); }
 float    Fuzz::nextF() { return this->nextT<float   >(); }
 
+
+uint32_t Fuzz::nextRangeU(uint32_t min, uint32_t max) {
+    if (min > max) {
+        SkDebugf("Check mins and maxes (%d, %d)\n", min, max);
+        this->signalBoring();
+    }
+    uint32_t range = max - min + 1;
+    if (0 == range) {
+        return this->nextU();
+    } else {
+        return min + this->nextU() % range;
+    }
+}
+float Fuzz::nextRangeF(float min, float max) {
+    if (min > max) {
+        SkDebugf("Check mins and maxes (%f, %f)\n", min, max);
+        this->signalBoring();
+    }
+    float f = std::abs(this->nextF());
+    if (!std::isnormal(f) && f != 0.0) {
+        this->signalBoring();
+    }
+    return min + fmod(f, (max - min + 1));
+}