pax_global_header00006660000000000000000000000064140036026700014510gustar00rootroot0000000000000052 comment=e66437191f77fea48ac6ee86bd92d8bcc13285e6 golang-github-google-gofuzz-1.2.0/000077500000000000000000000000001400360267000170335ustar00rootroot00000000000000golang-github-google-gofuzz-1.2.0/.travis.yml000066400000000000000000000001321400360267000211400ustar00rootroot00000000000000language: go go: - 1.11.x - 1.12.x - 1.13.x - master script: - go test -cover golang-github-google-gofuzz-1.2.0/CONTRIBUTING.md000066400000000000000000000061501400360267000212660ustar00rootroot00000000000000# How to contribute # We'd love to accept your patches and contributions to this project. There are just a few small guidelines you need to follow. ## Contributor License Agreement ## Contributions to any Google project must be accompanied by a Contributor License Agreement. This is not a copyright **assignment**, it simply gives Google permission to use and redistribute your contributions as part of the project. * If you are an individual writing original source code and you're sure you own the intellectual property, then you'll need to sign an [individual CLA][]. * If you work for a company that wants to allow you to contribute your work, then you'll need to sign a [corporate CLA][]. You generally only need to submit a CLA once, so if you've already submitted one (even if it was for a different project), you probably don't need to do it again. [individual CLA]: https://developers.google.com/open-source/cla/individual [corporate CLA]: https://developers.google.com/open-source/cla/corporate ## Submitting a patch ## 1. It's generally best to start by opening a new issue describing the bug or feature you're intending to fix. Even if you think it's relatively minor, it's helpful to know what people are working on. Mention in the initial issue that you are planning to work on that bug or feature so that it can be assigned to you. 1. Follow the normal process of [forking][] the project, and setup a new branch to work in. It's important that each group of changes be done in separate branches in order to ensure that a pull request only includes the commits related to that bug or feature. 1. Go makes it very simple to ensure properly formatted code, so always run `go fmt` on your code before committing it. You should also run [golint][] over your code. As noted in the [golint readme][], it's not strictly necessary that your code be completely "lint-free", but this will help you find common style issues. 1. Any significant changes should almost always be accompanied by tests. The project already has good test coverage, so look at some of the existing tests if you're unsure how to go about it. [gocov][] and [gocov-html][] are invaluable tools for seeing which parts of your code aren't being exercised by your tests. 1. Do your best to have [well-formed commit messages][] for each change. This provides consistency throughout the project, and ensures that commit messages are able to be formatted properly by various git tools. 1. Finally, push the commits to your fork and submit a [pull request][]. [forking]: https://help.github.com/articles/fork-a-repo [golint]: https://github.com/golang/lint [golint readme]: https://github.com/golang/lint/blob/master/README [gocov]: https://github.com/axw/gocov [gocov-html]: https://github.com/matm/gocov-html [well-formed commit messages]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html [squash]: http://git-scm.com/book/en/Git-Tools-Rewriting-History#Squashing-Commits [pull request]: https://help.github.com/articles/creating-a-pull-request golang-github-google-gofuzz-1.2.0/LICENSE000066400000000000000000000261361400360267000200500ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. golang-github-google-gofuzz-1.2.0/README.md000066400000000000000000000044311400360267000203140ustar00rootroot00000000000000gofuzz ====== 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! golang-github-google-gofuzz-1.2.0/bytesource/000077500000000000000000000000001400360267000212175ustar00rootroot00000000000000golang-github-google-gofuzz-1.2.0/bytesource/bytesource.go000066400000000000000000000046451400360267000237430ustar00rootroot00000000000000/* Copyright 2014 Google Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ // Package bytesource provides a rand.Source64 that is determined by a slice of bytes. package bytesource import ( "bytes" "encoding/binary" "io" "math/rand" ) // ByteSource implements rand.Source64 determined by a slice of bytes. The random numbers are // generated from each 8 bytes in the slice, until the last bytes are consumed, from which a // fallback pseudo random source is created in case more random numbers are required. // It also exposes a `bytes.Reader` API, which lets callers consume the bytes directly. type ByteSource struct { *bytes.Reader fallback rand.Source } // New returns a new ByteSource from a given slice of bytes. func New(input []byte) *ByteSource { s := &ByteSource{ Reader: bytes.NewReader(input), fallback: rand.NewSource(0), } if len(input) > 0 { s.fallback = rand.NewSource(int64(s.consumeUint64())) } return s } func (s *ByteSource) Uint64() uint64 { // Return from input if it was not exhausted. if s.Len() > 0 { return s.consumeUint64() } // Input was exhausted, return random number from fallback (in this case fallback should not be // nil). Try first having a Uint64 output (Should work in current rand implementation), // otherwise return a conversion of Int63. if s64, ok := s.fallback.(rand.Source64); ok { return s64.Uint64() } return uint64(s.fallback.Int63()) } func (s *ByteSource) Int63() int64 { return int64(s.Uint64() >> 1) } func (s *ByteSource) Seed(seed int64) { s.fallback = rand.NewSource(seed) s.Reader = bytes.NewReader(nil) } // consumeUint64 reads 8 bytes from the input and convert them to a uint64. It assumes that the the // bytes reader is not empty. func (s *ByteSource) consumeUint64() uint64 { var bytes [8]byte _, err := s.Read(bytes[:]) if err != nil && err != io.EOF { panic("failed reading source") // Should not happen. } return binary.BigEndian.Uint64(bytes[:]) } golang-github-google-gofuzz-1.2.0/bytesource/bytesource_test.go000066400000000000000000000056521400360267000250010ustar00rootroot00000000000000/* Copyright 2014 Google Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package bytesource import ( "math/rand" "testing" ) func TestByteSource(t *testing.T) { t.Parallel() randFromSource := func(s ...byte) *rand.Rand { return rand.New(New(s)) } randFromSeed := func(seed int64) *rand.Rand { var s1 ByteSource s1.Seed(seed) return rand.New(&s1) } t.Run("Inputs with identical 8 byte prefix", func(t *testing.T) { rand1 := randFromSource(1, 2, 3, 4, 5, 6, 7, 8, 9) rand2 := randFromSource(1, 2, 3, 4, 5, 6, 7, 8, 9) if rand1.Int() != rand2.Int() { t.Errorf("Inputs with identical 9 byte prefix result in different 1st output.") } if rand1.Int() != rand2.Int() { t.Errorf("Inputs with identical 9 byte prefix result in different 2nd output.") } }) t.Run("Inputs with different 8 byte prefix", func(t *testing.T) { rand2 := randFromSource(1, 2, 3, 4, 5, 6, 7, 1, 9) rand1 := randFromSource(1, 2, 3, 4, 5, 6, 7, 8, 9) if rand1.Int() != rand2.Int() { t.Errorf("Inputs with identical 9th byte prefix result in different 1st output.") } if rand1.Int() == rand2.Int() { t.Errorf("Inputs with different 8 bytes prefix result in identical 2nd output.") } }) t.Run("Multiple invocation", func(t *testing.T) { // First random from input byte, second from random source. r := randFromSource(1, 2, 3, 4, 6, 7, 8, 9) if r.Int() == r.Int() { t.Errorf("Two random numbers are identical.") } // First and second numbers from random source. r = randFromSource(1) if r.Int() == r.Int() { t.Errorf("Two random numbers are identical.") } }) t.Run("Seed", func(t *testing.T) { if randFromSeed(42).Int() != randFromSeed(42).Int() { t.Error("Two random numbers from the same seed differ.") } if randFromSeed(42).Int() == randFromSeed(43).Int() { t.Error("Two random numbers from different seeds are identical.") } }) } func TestByteSourceValues(t *testing.T) { t.Parallel() // Data in chunks of 8 bytes. data := []byte{ 99, 12, 23, 12, 65, 34, 12, 12, 99, 12, 23, 12, 25, 34, 15, 13, 99, 12, 23, 42, 25, 34, 11, 14, 99, 12, 54, 12, 25, 34, 99, 11, } r := rand.New(New(data)) got := []int{r.Int(), r.Int(), r.Int(), r.Int(), r.Int()} want := []int{ 3568552425102051206, 3568552489526560135, 3568569467532292485, 7616166771204380295, 5210010188159375967, } for i := range got { if want[i] != got[i] { t.Errorf("want[%d] = %d, got: %d", i, want[i], got[i]) } } } golang-github-google-gofuzz-1.2.0/doc.go000066400000000000000000000012341400360267000201270ustar00rootroot00000000000000/* Copyright 2014 Google Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ // Package fuzz is a library for populating go objects with random values. package fuzz golang-github-google-gofuzz-1.2.0/example_test.go000066400000000000000000000131431400360267000220560ustar00rootroot00000000000000/* Copyright 2014 Google Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package fuzz_test import ( "encoding/json" "fmt" "math/rand" "strings" "github.com/google/gofuzz" ) func ExampleSimple() { type MyType struct { A string B string C int D struct { E float64 } } f := fuzz.New() object := MyType{} uniqueObjects := map[MyType]int{} for i := 0; i < 1000; i++ { f.Fuzz(&object) uniqueObjects[object]++ } fmt.Printf("Got %v unique objects.\n", len(uniqueObjects)) // Output: // Got 1000 unique objects. } func ExampleCustom() { type MyType struct { A int B string } counter := 0 f := fuzz.New().Funcs( func(i *int, c fuzz.Continue) { *i = counter counter++ }, ) object := MyType{} uniqueObjects := map[MyType]int{} for i := 0; i < 100; i++ { f.Fuzz(&object) if object.A != i { fmt.Printf("Unexpected value: %#v\n", object) } uniqueObjects[object]++ } fmt.Printf("Got %v unique objects.\n", len(uniqueObjects)) // Output: // Got 100 unique objects. } func ExampleComplex() { type OtherType struct { A string B string } type MyType struct { Pointer *OtherType Map map[string]OtherType PointerMap *map[string]OtherType Slice []OtherType SlicePointer []*OtherType PointerSlicePointer *[]*OtherType } f := fuzz.New().RandSource(rand.NewSource(0)).NilChance(0).NumElements(1, 1).Funcs( func(o *OtherType, c fuzz.Continue) { o.A = "Foo" o.B = "Bar" }, func(op **OtherType, c fuzz.Continue) { *op = &OtherType{"A", "B"} }, func(m map[string]OtherType, c fuzz.Continue) { m["Works Because"] = OtherType{ "Fuzzer", "Preallocated", } }, ) object := MyType{} f.Fuzz(&object) bytes, err := json.MarshalIndent(&object, "", " ") if err != nil { fmt.Printf("error: %v\n", err) } fmt.Printf("%s\n", string(bytes)) // Output: // { // "Pointer": { // "A": "A", // "B": "B" // }, // "Map": { // "Works Because": { // "A": "Fuzzer", // "B": "Preallocated" // } // }, // "PointerMap": { // "Works Because": { // "A": "Fuzzer", // "B": "Preallocated" // } // }, // "Slice": [ // { // "A": "Foo", // "B": "Bar" // } // ], // "SlicePointer": [ // { // "A": "A", // "B": "B" // } // ], // "PointerSlicePointer": [ // { // "A": "A", // "B": "B" // } // ] // } } func ExampleMap() { f := fuzz.New().NilChance(0).NumElements(1, 1) var myMap map[struct{ A, B, C int }]string f.Fuzz(&myMap) fmt.Printf("myMap has %v element(s).\n", len(myMap)) // Output: // myMap has 1 element(s). } func ExampleSingle() { f := fuzz.New() var i int f.Fuzz(&i) // Technically, we'd expect this to fail one out of 2 billion attempts... fmt.Printf("(i == 0) == %v", i == 0) // Output: // (i == 0) == false } func ExampleEnum() { 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) { // Note c's embedded Rand allows for direct use. // We could also use c.RandBool() here. switch c.Intn(2) { case 0: e.Type = A c.Fuzz(&e.AInfo) case 1: e.Type = B c.Fuzz(&e.BInfo) } }, ) for i := 0; i < 100; i++ { var myObject MyInfo f.Fuzz(&myObject) switch myObject.Type { case A: if myObject.AInfo == nil { fmt.Println("AInfo should have been set!") } if myObject.BInfo != nil { fmt.Println("BInfo should NOT have been set!") } case B: if myObject.BInfo == nil { fmt.Println("BInfo should have been set!") } if myObject.AInfo != nil { fmt.Println("AInfo should NOT have been set!") } default: fmt.Println("Invalid enum value!") } } // Output: } func ExampleCustomString() { a2z := "abcdefghijklmnopqrstuvwxyz" a2z0to9 := "abcdefghijklmnopqrstuvwxyz0123456789" // example for generating custom string within one unicode range. var A string unicodeRange := fuzz.UnicodeRange{'a', 'z'} f := fuzz.New().Funcs(unicodeRange.CustomStringFuzzFunc()) f.Fuzz(&A) for i := range A { if !strings.ContainsRune(a2z, rune(A[i])) { fmt.Printf("A[%d]: %v is not in range of a-z.\n", i, A[i]) } } fmt.Println("Got a string, each character is selected from a-z.") // example for generating custom string within multiple unicode range. var B string unicodeRanges := fuzz.UnicodeRanges{ {'a', 'z'}, {'0', '9'}, // You can also use 0x0030 as 0, 0x0039 as 9. } ff := fuzz.New().Funcs(unicodeRanges.CustomStringFuzzFunc()) ff.Fuzz(&B) for i := range B { if !strings.ContainsRune(a2z0to9, rune(B[i])) { fmt.Printf("A[%d]: %v is not in range list [ a-z, 0-9 ].\n", i, string(B[i])) } } fmt.Println("Got a string, each character is selected from a-z, 0-9.") // Output: // Got a string, each character is selected from a-z. // Got a string, each character is selected from a-z, 0-9. } golang-github-google-gofuzz-1.2.0/fuzz.go000066400000000000000000000426121400360267000203650ustar00rootroot00000000000000/* Copyright 2014 Google Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package fuzz import ( "fmt" "math/rand" "reflect" "regexp" "time" "github.com/google/gofuzz/bytesource" "strings" ) // fuzzFuncMap is a map from a type to a fuzzFunc that handles that type. type fuzzFuncMap map[reflect.Type]reflect.Value // Fuzzer knows how to fill any object with random fields. type Fuzzer struct { fuzzFuncs fuzzFuncMap defaultFuzzFuncs fuzzFuncMap r *rand.Rand nilChance float64 minElements int maxElements int maxDepth int skipFieldPatterns []*regexp.Regexp } // New returns a new Fuzzer. Customize your Fuzzer further by calling Funcs, // RandSource, NilChance, or NumElements in any order. func New() *Fuzzer { return NewWithSeed(time.Now().UnixNano()) } func NewWithSeed(seed int64) *Fuzzer { f := &Fuzzer{ defaultFuzzFuncs: fuzzFuncMap{ reflect.TypeOf(&time.Time{}): reflect.ValueOf(fuzzTime), }, fuzzFuncs: fuzzFuncMap{}, r: rand.New(rand.NewSource(seed)), nilChance: .2, minElements: 1, maxElements: 10, maxDepth: 100, } return f } // NewFromGoFuzz is a helper function that enables using gofuzz (this // project) with go-fuzz (https://github.com/dvyukov/go-fuzz) for continuous // fuzzing. Essentially, it enables translating the fuzzing bytes from // go-fuzz to any Go object using this library. // // This implementation promises a constant translation from a given slice of // bytes to the fuzzed objects. This promise will remain over future // versions of Go and of this library. // // Note: the returned Fuzzer should not be shared between multiple goroutines, // as its deterministic output will no longer be available. // // Example: use go-fuzz to test the function `MyFunc(int)` in the package // `mypackage`. Add the file: "mypacakge_fuzz.go" with the content: // // // +build gofuzz // package mypacakge // import fuzz "github.com/google/gofuzz" // func Fuzz(data []byte) int { // var i int // fuzz.NewFromGoFuzz(data).Fuzz(&i) // MyFunc(i) // return 0 // } func NewFromGoFuzz(data []byte) *Fuzzer { return New().RandSource(bytesource.New(data)) } // Funcs adds each entry in fuzzFuncs as a custom fuzzing function. // // Each entry in fuzzFuncs must be a function taking two parameters. // The first parameter must be a pointer or map. It is the variable that // function will fill with random data. The second parameter must be a // fuzz.Continue, which will provide a source of randomness and a way // to automatically continue fuzzing smaller pieces of the first parameter. // // These functions are called sensibly, e.g., if you wanted custom string // fuzzing, the function `func(s *string, c fuzz.Continue)` would get // called and passed the address of strings. Maps and pointers will always // be made/new'd for you, ignoring the NilChange option. For slices, it // doesn't make much sense to pre-create them--Fuzzer doesn't know how // long you want your slice--so take a pointer to a slice, and make it // yourself. (If you don't want your map/pointer type pre-made, take a // pointer to it, and make it yourself.) See the examples for a range of // custom functions. func (f *Fuzzer) Funcs(fuzzFuncs ...interface{}) *Fuzzer { for i := range fuzzFuncs { v := reflect.ValueOf(fuzzFuncs[i]) if v.Kind() != reflect.Func { panic("Need only funcs!") } t := v.Type() if t.NumIn() != 2 || t.NumOut() != 0 { panic("Need 2 in and 0 out params!") } argT := t.In(0) switch argT.Kind() { case reflect.Ptr, reflect.Map: default: panic("fuzzFunc must take pointer or map type") } if t.In(1) != reflect.TypeOf(Continue{}) { panic("fuzzFunc's second parameter must be type fuzz.Continue") } f.fuzzFuncs[argT] = v } return f } // RandSource causes f to get values from the given source of randomness. // Use if you want deterministic fuzzing. func (f *Fuzzer) RandSource(s rand.Source) *Fuzzer { f.r = rand.New(s) return f } // NilChance sets the probability of creating a nil pointer, map, or slice to // 'p'. 'p' should be between 0 (no nils) and 1 (all nils), inclusive. func (f *Fuzzer) NilChance(p float64) *Fuzzer { if p < 0 || p > 1 { panic("p should be between 0 and 1, inclusive.") } f.nilChance = p return f } // NumElements sets the minimum and maximum number of elements that will be // added to a non-nil map or slice. func (f *Fuzzer) NumElements(atLeast, atMost int) *Fuzzer { if atLeast > atMost { panic("atLeast must be <= atMost") } if atLeast < 0 { panic("atLeast must be >= 0") } f.minElements = atLeast f.maxElements = atMost return f } func (f *Fuzzer) genElementCount() int { if f.minElements == f.maxElements { return f.minElements } return f.minElements + f.r.Intn(f.maxElements-f.minElements+1) } func (f *Fuzzer) genShouldFill() bool { return f.r.Float64() >= f.nilChance } // MaxDepth sets the maximum number of recursive fuzz calls that will be made // before stopping. This includes struct members, pointers, and map and slice // elements. func (f *Fuzzer) MaxDepth(d int) *Fuzzer { f.maxDepth = d return f } // Skip fields which match the supplied pattern. Call this multiple times if needed // This is useful to skip XXX_ fields generated by protobuf func (f *Fuzzer) SkipFieldsWithPattern(pattern *regexp.Regexp) *Fuzzer { f.skipFieldPatterns = append(f.skipFieldPatterns, pattern) return f } // Fuzz recursively fills all of obj's fields with something random. First // this tries to find a custom fuzz function (see Funcs). If there is no // custom function this tests whether the object implements fuzz.Interface and, // if so, calls Fuzz on it to fuzz itself. If that fails, this will see if // there is a default fuzz function provided by this package. If all of that // fails, this will generate random values for all primitive fields and then // recurse for all non-primitives. // // This is safe for cyclic or tree-like structs, up to a limit. Use the // MaxDepth method to adjust how deep you need it to recurse. // // obj must be a pointer. Only exported (public) fields can be set (thanks, // golang :/ ) Intended for tests, so will panic on bad input or unimplemented // fields. func (f *Fuzzer) Fuzz(obj interface{}) { v := reflect.ValueOf(obj) if v.Kind() != reflect.Ptr { panic("needed ptr!") } v = v.Elem() f.fuzzWithContext(v, 0) } // FuzzNoCustom is just like Fuzz, except that any custom fuzz function for // obj's type will not be called and obj will not be tested for fuzz.Interface // conformance. This applies only to obj and not other instances of obj's // type. // Not safe for cyclic or tree-like structs! // obj must be a pointer. Only exported (public) fields can be set (thanks, golang :/ ) // Intended for tests, so will panic on bad input or unimplemented fields. func (f *Fuzzer) FuzzNoCustom(obj interface{}) { v := reflect.ValueOf(obj) if v.Kind() != reflect.Ptr { panic("needed ptr!") } v = v.Elem() f.fuzzWithContext(v, flagNoCustomFuzz) } const ( // Do not try to find a custom fuzz function. Does not apply recursively. flagNoCustomFuzz uint64 = 1 << iota ) func (f *Fuzzer) fuzzWithContext(v reflect.Value, flags uint64) { fc := &fuzzerContext{fuzzer: f} fc.doFuzz(v, flags) } // fuzzerContext carries context about a single fuzzing run, which lets Fuzzer // be thread-safe. type fuzzerContext struct { fuzzer *Fuzzer curDepth int } func (fc *fuzzerContext) doFuzz(v reflect.Value, flags uint64) { if fc.curDepth >= fc.fuzzer.maxDepth { return } fc.curDepth++ defer func() { fc.curDepth-- }() if !v.CanSet() { return } if flags&flagNoCustomFuzz == 0 { // Check for both pointer and non-pointer custom functions. if v.CanAddr() && fc.tryCustom(v.Addr()) { return } if fc.tryCustom(v) { return } } if fn, ok := fillFuncMap[v.Kind()]; ok { fn(v, fc.fuzzer.r) return } switch v.Kind() { case reflect.Map: if fc.fuzzer.genShouldFill() { v.Set(reflect.MakeMap(v.Type())) n := fc.fuzzer.genElementCount() for i := 0; i < n; i++ { key := reflect.New(v.Type().Key()).Elem() fc.doFuzz(key, 0) val := reflect.New(v.Type().Elem()).Elem() fc.doFuzz(val, 0) v.SetMapIndex(key, val) } return } v.Set(reflect.Zero(v.Type())) case reflect.Ptr: if fc.fuzzer.genShouldFill() { v.Set(reflect.New(v.Type().Elem())) fc.doFuzz(v.Elem(), 0) return } v.Set(reflect.Zero(v.Type())) case reflect.Slice: if fc.fuzzer.genShouldFill() { n := fc.fuzzer.genElementCount() v.Set(reflect.MakeSlice(v.Type(), n, n)) for i := 0; i < n; i++ { fc.doFuzz(v.Index(i), 0) } return } v.Set(reflect.Zero(v.Type())) case reflect.Array: if fc.fuzzer.genShouldFill() { n := v.Len() for i := 0; i < n; i++ { fc.doFuzz(v.Index(i), 0) } return } v.Set(reflect.Zero(v.Type())) case reflect.Struct: for i := 0; i < v.NumField(); i++ { skipField := false fieldName := v.Type().Field(i).Name for _, pattern := range fc.fuzzer.skipFieldPatterns { if pattern.MatchString(fieldName) { skipField = true break } } if !skipField { fc.doFuzz(v.Field(i), 0) } } case reflect.Chan: fallthrough case reflect.Func: fallthrough case reflect.Interface: fallthrough default: panic(fmt.Sprintf("Can't handle %#v", v.Interface())) } } // tryCustom searches for custom handlers, and returns true iff it finds a match // and successfully randomizes v. func (fc *fuzzerContext) tryCustom(v reflect.Value) bool { // First: see if we have a fuzz function for it. doCustom, ok := fc.fuzzer.fuzzFuncs[v.Type()] if !ok { // Second: see if it can fuzz itself. if v.CanInterface() { intf := v.Interface() if fuzzable, ok := intf.(Interface); ok { fuzzable.Fuzz(Continue{fc: fc, Rand: fc.fuzzer.r}) return true } } // Finally: see if there is a default fuzz function. doCustom, ok = fc.fuzzer.defaultFuzzFuncs[v.Type()] if !ok { return false } } switch v.Kind() { case reflect.Ptr: if v.IsNil() { if !v.CanSet() { return false } v.Set(reflect.New(v.Type().Elem())) } case reflect.Map: if v.IsNil() { if !v.CanSet() { return false } v.Set(reflect.MakeMap(v.Type())) } default: return false } doCustom.Call([]reflect.Value{v, reflect.ValueOf(Continue{ fc: fc, Rand: fc.fuzzer.r, })}) return true } // Interface represents an object that knows how to fuzz itself. Any time we // find a type that implements this interface we will delegate the act of // fuzzing itself. type Interface interface { Fuzz(c Continue) } // Continue can be passed to custom fuzzing functions to allow them to use // the correct source of randomness and to continue fuzzing their members. type Continue struct { fc *fuzzerContext // For convenience, Continue implements rand.Rand via embedding. // Use this for generating any randomness if you want your fuzzing // to be repeatable for a given seed. *rand.Rand } // Fuzz continues fuzzing obj. obj must be a pointer. func (c Continue) Fuzz(obj interface{}) { v := reflect.ValueOf(obj) if v.Kind() != reflect.Ptr { panic("needed ptr!") } v = v.Elem() c.fc.doFuzz(v, 0) } // FuzzNoCustom continues fuzzing obj, except that any custom fuzz function for // obj's type will not be called and obj will not be tested for fuzz.Interface // conformance. This applies only to obj and not other instances of obj's // type. func (c Continue) FuzzNoCustom(obj interface{}) { v := reflect.ValueOf(obj) if v.Kind() != reflect.Ptr { panic("needed ptr!") } v = v.Elem() c.fc.doFuzz(v, flagNoCustomFuzz) } // RandString makes a random string up to 20 characters long. The returned string // may include a variety of (valid) UTF-8 encodings. func (c Continue) RandString() string { return randString(c.Rand) } // RandUint64 makes random 64 bit numbers. // Weirdly, rand doesn't have a function that gives you 64 random bits. func (c Continue) RandUint64() uint64 { return randUint64(c.Rand) } // RandBool returns true or false randomly. func (c Continue) RandBool() bool { return randBool(c.Rand) } func fuzzInt(v reflect.Value, r *rand.Rand) { v.SetInt(int64(randUint64(r))) } func fuzzUint(v reflect.Value, r *rand.Rand) { v.SetUint(randUint64(r)) } func fuzzTime(t *time.Time, c Continue) { var sec, nsec int64 // Allow for about 1000 years of random time values, which keeps things // like JSON parsing reasonably happy. sec = c.Rand.Int63n(1000 * 365 * 24 * 60 * 60) c.Fuzz(&nsec) *t = time.Unix(sec, nsec) } var fillFuncMap = map[reflect.Kind]func(reflect.Value, *rand.Rand){ reflect.Bool: func(v reflect.Value, r *rand.Rand) { v.SetBool(randBool(r)) }, reflect.Int: fuzzInt, reflect.Int8: fuzzInt, reflect.Int16: fuzzInt, reflect.Int32: fuzzInt, reflect.Int64: fuzzInt, reflect.Uint: fuzzUint, reflect.Uint8: fuzzUint, reflect.Uint16: fuzzUint, reflect.Uint32: fuzzUint, reflect.Uint64: fuzzUint, reflect.Uintptr: fuzzUint, reflect.Float32: func(v reflect.Value, r *rand.Rand) { v.SetFloat(float64(r.Float32())) }, reflect.Float64: func(v reflect.Value, r *rand.Rand) { v.SetFloat(r.Float64()) }, reflect.Complex64: func(v reflect.Value, r *rand.Rand) { v.SetComplex(complex128(complex(r.Float32(), r.Float32()))) }, reflect.Complex128: func(v reflect.Value, r *rand.Rand) { v.SetComplex(complex(r.Float64(), r.Float64())) }, reflect.String: func(v reflect.Value, r *rand.Rand) { v.SetString(randString(r)) }, reflect.UnsafePointer: func(v reflect.Value, r *rand.Rand) { panic("unimplemented") }, } // randBool returns true or false randomly. func randBool(r *rand.Rand) bool { return r.Int31()&(1<<30) == 0 } type int63nPicker interface { Int63n(int64) int64 } // UnicodeRange describes a sequential range of unicode characters. // Last must be numerically greater than First. type UnicodeRange struct { First, Last rune } // UnicodeRanges describes an arbitrary number of sequential ranges of unicode characters. // To be useful, each range must have at least one character (First <= Last) and // there must be at least one range. type UnicodeRanges []UnicodeRange // choose returns a random unicode character from the given range, using the // given randomness source. func (ur UnicodeRange) choose(r int63nPicker) rune { count := int64(ur.Last - ur.First + 1) return ur.First + rune(r.Int63n(count)) } // CustomStringFuzzFunc constructs a FuzzFunc which produces random strings. // Each character is selected from the range ur. If there are no characters // in the range (cr.Last < cr.First), this will panic. func (ur UnicodeRange) CustomStringFuzzFunc() func(s *string, c Continue) { ur.check() return func(s *string, c Continue) { *s = ur.randString(c.Rand) } } // check is a function that used to check whether the first of ur(UnicodeRange) // is greater than the last one. func (ur UnicodeRange) check() { if ur.Last < ur.First { panic("The last encoding must be greater than the first one.") } } // randString of UnicodeRange makes a random string up to 20 characters long. // Each character is selected form ur(UnicodeRange). func (ur UnicodeRange) randString(r *rand.Rand) string { n := r.Intn(20) sb := strings.Builder{} sb.Grow(n) for i := 0; i < n; i++ { sb.WriteRune(ur.choose(r)) } return sb.String() } // defaultUnicodeRanges sets a default unicode range when user do not set // CustomStringFuzzFunc() but wants fuzz string. var defaultUnicodeRanges = UnicodeRanges{ {' ', '~'}, // ASCII characters {'\u00a0', '\u02af'}, // Multi-byte encoded characters {'\u4e00', '\u9fff'}, // Common CJK (even longer encodings) } // CustomStringFuzzFunc constructs a FuzzFunc which produces random strings. // Each character is selected from one of the ranges of ur(UnicodeRanges). // Each range has an equal probability of being chosen. If there are no ranges, // or a selected range has no characters (.Last < .First), this will panic. // Do not modify any of the ranges in ur after calling this function. func (ur UnicodeRanges) CustomStringFuzzFunc() func(s *string, c Continue) { // Check unicode ranges slice is empty. if len(ur) == 0 { panic("UnicodeRanges is empty.") } // if not empty, each range should be checked. for i := range ur { ur[i].check() } return func(s *string, c Continue) { *s = ur.randString(c.Rand) } } // randString of UnicodeRanges makes a random string up to 20 characters long. // Each character is selected form one of the ranges of ur(UnicodeRanges), // and each range has an equal probability of being chosen. func (ur UnicodeRanges) randString(r *rand.Rand) string { n := r.Intn(20) sb := strings.Builder{} sb.Grow(n) for i := 0; i < n; i++ { sb.WriteRune(ur[r.Intn(len(ur))].choose(r)) } return sb.String() } // randString makes a random string up to 20 characters long. The returned string // may include a variety of (valid) UTF-8 encodings. func randString(r *rand.Rand) string { return defaultUnicodeRanges.randString(r) } // randUint64 makes random 64 bit numbers. // Weirdly, rand doesn't have a function that gives you 64 random bits. func randUint64(r *rand.Rand) uint64 { return uint64(r.Uint32())<<32 | uint64(r.Uint32()) } golang-github-google-gofuzz-1.2.0/fuzz_test.go000066400000000000000000000314401400360267000214210ustar00rootroot00000000000000/* Copyright 2014 Google Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package fuzz import ( "math/rand" "reflect" "regexp" "strings" "testing" "time" ) func TestFuzz_basic(t *testing.T) { obj := &struct { I int I8 int8 I16 int16 I32 int32 I64 int64 U uint U8 uint8 U16 uint16 U32 uint32 U64 uint64 Uptr uintptr S string B bool T time.Time C64 complex64 C128 complex128 }{} failed := map[string]int{} for i := 0; i < 10; i++ { New().Fuzz(obj) if n, v := "i", obj.I; v == 0 { failed[n] = failed[n] + 1 } if n, v := "i8", obj.I8; v == 0 { failed[n] = failed[n] + 1 } if n, v := "i16", obj.I16; v == 0 { failed[n] = failed[n] + 1 } if n, v := "i32", obj.I32; v == 0 { failed[n] = failed[n] + 1 } if n, v := "i64", obj.I64; v == 0 { failed[n] = failed[n] + 1 } if n, v := "u", obj.U; v == 0 { failed[n] = failed[n] + 1 } if n, v := "u8", obj.U8; v == 0 { failed[n] = failed[n] + 1 } if n, v := "u16", obj.U16; v == 0 { failed[n] = failed[n] + 1 } if n, v := "u32", obj.U32; v == 0 { failed[n] = failed[n] + 1 } if n, v := "u64", obj.U64; v == 0 { failed[n] = failed[n] + 1 } if n, v := "uptr", obj.Uptr; v == 0 { failed[n] = failed[n] + 1 } if n, v := "s", obj.S; v == "" { failed[n] = failed[n] + 1 } if n, v := "b", obj.B; v == false { failed[n] = failed[n] + 1 } if n, v := "t", obj.T; v.IsZero() { failed[n] = failed[n] + 1 } if n, v := "c64", obj.C64; v == 0 { failed[n] = failed[n] + 1 } if n, v := "c128", obj.C128; v == 0 { failed[n] = failed[n] + 1 } } checkFailed(t, failed) } func checkFailed(t *testing.T, failed map[string]int) { for k, v := range failed { if v > 8 { t.Errorf("%v seems to not be getting set, was zero value %v times", k, v) } } } func TestFuzz_structptr(t *testing.T) { obj := &struct { A *struct { S string } }{} f := New().NilChance(.5) failed := map[string]int{} for i := 0; i < 10; i++ { f.Fuzz(obj) if n, v := "a not nil", obj.A; v == nil { failed[n] = failed[n] + 1 } if n, v := "a nil", obj.A; v != nil { failed[n] = failed[n] + 1 } if n, v := "as", obj.A; v == nil || v.S == "" { failed[n] = failed[n] + 1 } } checkFailed(t, failed) } // tryFuzz tries fuzzing up to 20 times. Fail if check() never passes, report the highest // stage it ever got to. func tryFuzz(t *testing.T, f *Fuzzer, obj interface{}, check func() (stage int, passed bool)) { maxStage := 0 for i := 0; i < 20; i++ { f.Fuzz(obj) stage, passed := check() if stage > maxStage { maxStage = stage } if passed { return } } t.Errorf("Only ever got to stage %v", maxStage) } func TestFuzz_structmap(t *testing.T) { obj := &struct { A map[struct { S string }]struct { S2 string } B map[string]string }{} tryFuzz(t, New(), obj, func() (int, bool) { if obj.A == nil { return 1, false } if len(obj.A) == 0 { return 2, false } for k, v := range obj.A { if k.S == "" { return 3, false } if v.S2 == "" { return 4, false } } if obj.B == nil { return 5, false } if len(obj.B) == 0 { return 6, false } for k, v := range obj.B { if k == "" { return 7, false } if v == "" { return 8, false } } return 9, true }) } func TestFuzz_structslice(t *testing.T) { obj := &struct { A []struct { S string } B []string }{} tryFuzz(t, New(), obj, func() (int, bool) { if obj.A == nil { return 1, false } if len(obj.A) == 0 { return 2, false } for _, v := range obj.A { if v.S == "" { return 3, false } } if obj.B == nil { return 4, false } if len(obj.B) == 0 { return 5, false } for _, v := range obj.B { if v == "" { return 6, false } } return 7, true }) } func TestFuzz_structarray(t *testing.T) { obj := &struct { A [3]struct { S string } B [2]int }{} tryFuzz(t, New(), obj, func() (int, bool) { for _, v := range obj.A { if v.S == "" { return 1, false } } for _, v := range obj.B { if v == 0 { return 2, false } } return 3, true }) } func TestFuzz_custom(t *testing.T) { obj := &struct { A string B *string C map[string]string D *map[string]string }{} testPhrase := "gotcalled" testMap := map[string]string{"C": "D"} f := New().Funcs( func(s *string, c Continue) { *s = testPhrase }, func(m map[string]string, c Continue) { m["C"] = "D" }, ) tryFuzz(t, f, obj, func() (int, bool) { if obj.A != testPhrase { return 1, false } if obj.B == nil { return 2, false } if *obj.B != testPhrase { return 3, false } if e, a := testMap, obj.C; !reflect.DeepEqual(e, a) { return 4, false } if obj.D == nil { return 5, false } if e, a := testMap, *obj.D; !reflect.DeepEqual(e, a) { return 6, false } return 7, true }) } type SelfFuzzer string // Implement fuzz.Interface. func (sf *SelfFuzzer) Fuzz(c Continue) { *sf = selfFuzzerTestPhrase } const selfFuzzerTestPhrase = "was fuzzed" func TestFuzz_interface(t *testing.T) { f := New() var obj1 SelfFuzzer tryFuzz(t, f, &obj1, func() (int, bool) { if obj1 != selfFuzzerTestPhrase { return 1, false } return 1, true }) var obj2 map[int]SelfFuzzer tryFuzz(t, f, &obj2, func() (int, bool) { for _, v := range obj2 { if v != selfFuzzerTestPhrase { return 1, false } } return 1, true }) } func TestFuzz_interfaceAndFunc(t *testing.T) { const privateTestPhrase = "private phrase" f := New().Funcs( // This should take precedence over SelfFuzzer.Fuzz(). func(s *SelfFuzzer, c Continue) { *s = privateTestPhrase }, ) var obj1 SelfFuzzer tryFuzz(t, f, &obj1, func() (int, bool) { if obj1 != privateTestPhrase { return 1, false } return 1, true }) var obj2 map[int]SelfFuzzer tryFuzz(t, f, &obj2, func() (int, bool) { for _, v := range obj2 { if v != privateTestPhrase { return 1, false } } return 1, true }) } func TestFuzz_noCustom(t *testing.T) { type Inner struct { Str string } type Outer struct { Str string In Inner } testPhrase := "gotcalled" f := New().Funcs( func(outer *Outer, c Continue) { outer.Str = testPhrase c.Fuzz(&outer.In) }, func(inner *Inner, c Continue) { inner.Str = testPhrase }, ) c := Continue{fc: &fuzzerContext{fuzzer: f}, Rand: f.r} // Fuzzer.Fuzz() obj1 := Outer{} f.Fuzz(&obj1) if obj1.Str != testPhrase { t.Errorf("expected Outer custom function to have been called") } if obj1.In.Str != testPhrase { t.Errorf("expected Inner custom function to have been called") } // Continue.Fuzz() obj2 := Outer{} c.Fuzz(&obj2) if obj2.Str != testPhrase { t.Errorf("expected Outer custom function to have been called") } if obj2.In.Str != testPhrase { t.Errorf("expected Inner custom function to have been called") } // Fuzzer.FuzzNoCustom() obj3 := Outer{} f.FuzzNoCustom(&obj3) if obj3.Str == testPhrase { t.Errorf("expected Outer custom function to not have been called") } if obj3.In.Str != testPhrase { t.Errorf("expected Inner custom function to have been called") } // Continue.FuzzNoCustom() obj4 := Outer{} c.FuzzNoCustom(&obj4) if obj4.Str == testPhrase { t.Errorf("expected Outer custom function to not have been called") } if obj4.In.Str != testPhrase { t.Errorf("expected Inner custom function to have been called") } } func TestFuzz_NumElements(t *testing.T) { f := New().NilChance(0).NumElements(0, 1) obj := &struct { A []int }{} tryFuzz(t, f, obj, func() (int, bool) { if obj.A == nil { return 1, false } return 2, len(obj.A) == 0 }) tryFuzz(t, f, obj, func() (int, bool) { if obj.A == nil { return 3, false } return 4, len(obj.A) == 1 }) } func TestFuzz_Maxdepth(t *testing.T) { type S struct { S *S } f := New().NilChance(0) f.MaxDepth(1) for i := 0; i < 100; i++ { obj := S{} f.Fuzz(&obj) if obj.S != nil { t.Errorf("Expected nil") } } f.MaxDepth(3) // field, ptr for i := 0; i < 100; i++ { obj := S{} f.Fuzz(&obj) if obj.S == nil { t.Errorf("Expected obj.S not nil") } else if obj.S.S != nil { t.Errorf("Expected obj.S.S nil") } } f.MaxDepth(5) // field, ptr, field, ptr for i := 0; i < 100; i++ { obj := S{} f.Fuzz(&obj) if obj.S == nil { t.Errorf("Expected obj.S not nil") } else if obj.S.S == nil { t.Errorf("Expected obj.S.S not nil") } else if obj.S.S.S != nil { t.Errorf("Expected obj.S.S.S nil") } } } func TestFuzz_SkipPattern(t *testing.T) { obj := &struct { S1 string S2 string XXX_S string S_XXX string In struct { Str string XXX_S1 string S2_XXX string } }{} f := New().NilChance(0).SkipFieldsWithPattern(regexp.MustCompile(`^XXX_`)) f.Fuzz(obj) tryFuzz(t, f, obj, func() (int, bool) { if obj.XXX_S != "" { return 1, false } if obj.S_XXX == "" { return 2, false } if obj.In.XXX_S1 != "" { return 3, false } if obj.In.S2_XXX == "" { return 4, false } return 5, true }) } func TestFuzz_NilChanceZero(t *testing.T) { // This data source for random will result in the following four values // being sampled (the first, 0, being the most interesting case): // 0; 0.8727288671879787; 0.5547307616625858; 0.021885026049502695 data := []byte("H0000000\x00") f := NewFromGoFuzz(data).NilChance(0) var fancyStruct struct { A, B, C, D *string } f.Fuzz(&fancyStruct) // None of the pointers should be nil, as NilChance is 0 if fancyStruct.A == nil { t.Error("First value in struct was nil") } if fancyStruct.B == nil { t.Error("Second value in struct was nil") } if fancyStruct.C == nil { t.Error("Third value in struct was nil") } if fancyStruct.D == nil { t.Error("Fourth value in struct was nil") } } type int63mode int const ( modeRandom int63mode = iota modeFirst modeLast ) type customInt63 struct { mode int63mode } func (c customInt63) Int63n(n int64) int64 { switch c.mode { case modeFirst: return 0 case modeLast: return n - 1 default: return rand.Int63n(n) } } func Test_charRange_choose(t *testing.T) { lowercaseLetters := UnicodeRange{'a', 'z'} t.Run("Picks first", func(t *testing.T) { r := customInt63{mode: modeFirst} letter := lowercaseLetters.choose(r) if letter != 'a' { t.Errorf("Expected a, got %v", letter) } }) t.Run("Picks last", func(t *testing.T) { r := customInt63{mode: modeLast} letter := lowercaseLetters.choose(r) if letter != 'z' { t.Errorf("Expected z, got %v", letter) } }) } func Test_UnicodeRange_CustomStringFuzzFunc(t *testing.T) { a2z := "abcdefghijklmnopqrstuvwxyz" unicodeRange := UnicodeRange{'a', 'z'} f := New().Funcs(unicodeRange.CustomStringFuzzFunc()) var myString string f.Fuzz(&myString) t.Run("Picks a-z string", func(t *testing.T) { for i := range myString { if !strings.ContainsRune(a2z, rune(myString[i])) { t.Errorf("Expected a-z, got %v", string(myString[i])) } } }) } func Test_UnicodeRange_Check(t *testing.T) { unicodeRange := UnicodeRange{'a', 'z'} unicodeRange.check() } func Test_UnicodeRanges_CustomStringFuzzFunc(t *testing.T) { a2z0to9 := "abcdefghijklmnopqrstuvwxyz0123456789" unicodeRanges := UnicodeRanges{ {'a', 'z'}, {'0', '9'}, } f := New().Funcs(unicodeRanges.CustomStringFuzzFunc()) var myString string f.Fuzz(&myString) t.Run("Picks a-z0-9 string", func(t *testing.T) { for i := range myString { if !strings.ContainsRune(a2z0to9, rune(myString[i])) { t.Errorf("Expected a-z0-9, got %v", string(myString[i])) } } }) } func TestNewFromGoFuzz(t *testing.T) { t.Parallel() input := []byte{1, 2, 3} var got int NewFromGoFuzz(input).Fuzz(&got) if want := 5563767293437588600; want != got { t.Errorf("Fuzz(%q) = %d, want: %d", input, got, want) } } func BenchmarkRandBool(b *testing.B) { rs := rand.New(rand.NewSource(123)) for i := 0; i < b.N; i++ { randBool(rs) } } func BenchmarkRandString(b *testing.B) { rs := rand.New(rand.NewSource(123)) for i := 0; i < b.N; i++ { randString(rs) } } func BenchmarkUnicodeRangeRandString(b *testing.B) { unicodeRange := UnicodeRange{'a', 'z'} rs := rand.New(rand.NewSource(123)) for i := 0; i < b.N; i++ { unicodeRange.randString(rs) } } func BenchmarkUnicodeRangesRandString(b *testing.B) { unicodeRanges := UnicodeRanges{ {'a', 'z'}, {'0', '9'}, } rs := rand.New(rand.NewSource(123)) for i := 0; i < b.N; i++ { unicodeRanges.randString(rs) } } golang-github-google-gofuzz-1.2.0/go.mod000066400000000000000000000000511400360267000201350ustar00rootroot00000000000000module github.com/google/gofuzz go 1.12