mirror of
https://github.com/TwiN/gatus.git
synced 2024-12-05 22:30:51 +01:00
83a5813daf
+ Update dependencies
90 lines
2.3 KiB
Markdown
90 lines
2.3 KiB
Markdown
gofuzz
|
|
======
|
|
|
|
gofuzz is a library for populating go objects with random values.
|
|
|
|
[![GoDoc](https://godoc.org/github.com/google/gofuzz?status.svg)](https://godoc.org/github.com/google/gofuzz)
|
|
[![Travis](https://travis-ci.org/google/gofuzz.svg?branch=master)](https://travis-ci.org/google/gofuzz)
|
|
|
|
This is useful for testing:
|
|
|
|
* Do your project's objects really serialize/unserialize correctly in all cases?
|
|
* Is there an incorrectly formatted object that will cause your project to panic?
|
|
|
|
Import with ```import "github.com/google/gofuzz"```
|
|
|
|
You can use it on single variables:
|
|
```go
|
|
f := fuzz.New()
|
|
var myInt int
|
|
f.Fuzz(&myInt) // myInt gets a random value.
|
|
```
|
|
|
|
You can use it on maps:
|
|
```go
|
|
f := fuzz.New().NilChance(0).NumElements(1, 1)
|
|
var myMap map[ComplexKeyType]string
|
|
f.Fuzz(&myMap) // myMap will have exactly one element.
|
|
```
|
|
|
|
Customize the chance of getting a nil pointer:
|
|
```go
|
|
f := fuzz.New().NilChance(.5)
|
|
var fancyStruct struct {
|
|
A, B, C, D *string
|
|
}
|
|
f.Fuzz(&fancyStruct) // About half the pointers should be set.
|
|
```
|
|
|
|
You can even customize the randomization completely if needed:
|
|
```go
|
|
type MyEnum string
|
|
const (
|
|
A MyEnum = "A"
|
|
B MyEnum = "B"
|
|
)
|
|
type MyInfo struct {
|
|
Type MyEnum
|
|
AInfo *string
|
|
BInfo *string
|
|
}
|
|
|
|
f := fuzz.New().NilChance(0).Funcs(
|
|
func(e *MyInfo, c fuzz.Continue) {
|
|
switch c.Intn(2) {
|
|
case 0:
|
|
e.Type = A
|
|
c.Fuzz(&e.AInfo)
|
|
case 1:
|
|
e.Type = B
|
|
c.Fuzz(&e.BInfo)
|
|
}
|
|
},
|
|
)
|
|
|
|
var myObject MyInfo
|
|
f.Fuzz(&myObject) // Type will correspond to whether A or B info is set.
|
|
```
|
|
|
|
See more examples in ```example_test.go```.
|
|
|
|
You can use this library for easier [go-fuzz](https://github.com/dvyukov/go-fuzz)ing.
|
|
go-fuzz provides the user a byte-slice, which should be converted to different inputs
|
|
for the tested function. This library can help convert the byte slice. Consider for
|
|
example a fuzz test for a the function `mypackage.MyFunc` that takes an int arguments:
|
|
```go
|
|
// +build gofuzz
|
|
package mypackage
|
|
|
|
import fuzz "github.com/google/gofuzz"
|
|
|
|
func Fuzz(data []byte) int {
|
|
var i int
|
|
fuzz.NewFromGoFuzz(data).Fuzz(&i)
|
|
MyFunc(i)
|
|
return 0
|
|
}
|
|
```
|
|
|
|
Happy testing!
|