go-fuzz VS go-json

It does instrumented fuzzing. The older https://github.com/dvyukov/go-fuzz would rewrite your sources to inject the instrumentation and pass the rewritten sources to the compiler, but it didn't really work with Go modules. This is something that probably makes sense to integrate with the compiler toolchain, same as `go test`'s coverage testing.

And another Go-Fuzz

Anyone seen good articles on converting go-fuzz tests to native fuzzing? Specifics on the new corpus format and a converter from go-fuzz would be really useful.

It’s great to hear that the fuzzer is built on go-fuzz so hopefully the conversion process won’t be too bad: https://github.com/dvyukov/go-fuzz/issues/329

> it shows the limitations of the language that you can't just build this inside the language.

Not sure why you'd make that assumption. https://github.com/dvyukov/go-fuzz

Rather than explore the specific issues my tests found, I started playing with running https://github.com/dvyukov/go-fuzz against go-json which seems to have fairly quickly found some issues. I've opened https://github.com/goccy/go-json/issues/174 to start the conversation about how you want to proceed here.

You can check the go-fuzz's trophies here.

Maybe you can add support for using a fuzzer like https://github.com/dvyukov/go-fuzz or https://github.com/google/gofuzz

I recently stumbled upon go-fuzz (that is also linked in the proposal). I'm amazed how fuzzing has made the go toolchain stronger and integrated this technique into some of our CI/CD pipelines for continuous testing. Having native fuzzy testing support (not just in go) would be great.

Go tests and benchmarks are so easy to write and run: just add TestFoo and BenchmarkFoo functions to a bar_test.go file, and "go test" does the rest. It's currently doable, but it requires a 3rd party library (go-fuzz) and a bit of fluffing around. This will make fuzz testing an equally first-class citizen with standard Go tooling (just add FuzzFoo), and as such we'll probably see a lot more people testing with fuzzing.

I used go-fuzz in GoAWK and it found several bugs (see https://benhoyt.com/writings/goawk/#fuzz-testing), and almost everyone who's done fuzz testing has similar reports. Certainly go-fuzz has found many, many bugs in Go itself: https://github.com/dvyukov/go-fuzz#trophies

For what it's worth, I wrote an article for LWN about the upcoming support for built-in fuzzing in Go: https://lwn.net/Articles/829242/ (of course, if you want full details, read the full proposal).

go stdlib json encoding/decoding is incredibly slow, not sure for how much longer because there are drop in replacements now that I think are just as strict and feature parity.

3rd party JSON libraries could help if you were comparing JSON. https://github.com/goccy/go-json

However, I understand the code that is generated is super optimized. For example, rather than use a router, it does a static code generated router. Rather than use goccy/go-json, it does manual marshalling.

Minimal dependencies: julienschmidt/httprouter and goccy/go-json

I suggested using https://github.com/goccy/go-json at my work, since its a drop in replacement for the standard lib, but there are people who apprehensive. In my opinion the performance gains are significant to justify adoption. But I'd like your input.

go-json for encoding/decoding

I develop a super fast JSON library ( https://github.com/goccy/go-json ) for Go .

Rather than explore the specific issues my tests found, I started playing with running https://github.com/dvyukov/go-fuzz against go-json which seems to have fairly quickly found some issues. I've opened https://github.com/goccy/go-json/issues/174 to start the conversation about how you want to proceed here.

The "How it works" section as well as the "Unique speed-up technique" just below it are fantastic.