[!fuzz] skip
[!cgo] skip
[short] skip
env GOCACHE=$WORK/cache

# Test that fuzzing works with cgo (issue 65169)

go test -fuzz=. -fuzztime=1x
stdout ok
! stdout FAIL

-- go.mod --
module example.com/p

go 1.20
-- c.go --
package p

import "C"
-- c_test.go --
package p

import "testing"

func Fuzz(f *testing.F) {
	f.Add(0)
	f.Fuzz(func(t *testing.T, x int) {})

// See the License for the specific language governing permissions and
// limitations under the License.

// nolint: revive
package fuzz

import (
	"bytes"
	"errors"

	fuzz "github.com/AdaLogics/go-fuzz-headers"

	"istio.io/istio/istioctl/pkg/writer/compare"
)

func createIstiodDumps(f *fuzz.ConsumeFuzzer) (map[string][]byte, error) {
	m := make(map[string][]byte)
	maxNoEntries := 50
	qty, err := f.GetInt()

// 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 (
	"errors"

	fuzz "github.com/AdaLogics/go-fuzz-headers"

	"istio.io/istio/pilot/pkg/model"
	"istio.io/istio/pilot/pkg/serviceregistry/memory"
	"istio.io/istio/pkg/config/host"
	"istio.io/istio/pkg/config/mesh"

// See the License for the specific language governing permissions and
// limitations under the License.

package fuzz

import (
	"bytes"

	fuzz "github.com/AdaLogics/go-fuzz-headers"

	"istio.io/istio/pkg/config/mesh"
	"istio.io/istio/pkg/kube/inject"
)

func FuzzIntoResourceFile(data []byte) int {
	f := fuzz.NewConsumer(data)
	var sidecarTemplate map[string]string
	err := f.FuzzMap(&sidecarTemplate)
	if err != nil {

import "testing"

func FuzzFoo(f *testing.F) {
    f.Add("this is fine")
    f.Fuzz(func(t *testing.T, s string) {
        if s == "fails" {
            t.Error("error here")
        }
    })
}
-- testdata/fuzz/FuzzFoo/thisfails --
go test fuzz v1
string("fails")
-- testdata/fuzz/FuzzFoo/thispasses --
go test fuzz v1

[short] skip
[!fuzz] skip
env GOCACHE=$WORK/cache

# If the I/O error occurs before F.Fuzz is called, the coordinator should
# stop the worker and say that.
! go test -fuzz=FuzzClosePipeBefore -parallel=1
stdout '\s*fuzzing process terminated without fuzzing:'
! stdout 'communicating with fuzzing process'
! exists testdata

# If the I/O error occurs after F.Fuzz is called (unlikely), just exit.

! go test -run=FuzzMutate -fuzz=FuzzMutate
exists testdata/fuzz/FuzzMutate

# Testdata should now contain a corpus entry which will fail FuzzMutate.
# Run the test without fuzzing, setting -parallel to different values to make
# sure it fails, and doesn't hang.
! go test -run=FuzzMutate -parallel=1
! go test -run=FuzzMutate -parallel=2
! go test -run=FuzzMutate -parallel=4

-- go.mod --
module fuzz_parallel

go 1.17

// limitations under the License.

package inject

import (
	"testing"

	fuzz "github.com/AdaLogics/go-fuzz-headers"
)

func FuzzRunTemplate(f *testing.F) {
	f.Fuzz(func(t *testing.T, data []byte, v string) {
		ff := fuzz.NewConsumer(data)

		// create injection parameters
		IP := InjectionParameters{}
		err := ff.GenerateStruct(&IP)
		if err != nil {

				}
			} else {
				types := []runtime.Object{&example.Pod{}}
				t := types[c.Rand.Intn(len(types))]
				c.Fuzz(t)
				*j = t
			}
		},
		func(r *runtime.RawExtension, c fuzz.Continue) {
			// Pick an arbitrary type and fuzz it
			types := []runtime.Object{&example.Pod{}}
			obj := types[c.Rand.Intn(len(types))]
			c.Fuzz(obj)

			// Convert the object to raw bytes

			} else {
				types := []runtime.Object{&testapigroup.Carp{}}
				t := types[c.Rand.Intn(len(types))]
				c.Fuzz(t)
				*j = t
			}
		},
		func(r *runtime.RawExtension, c fuzz.Continue) {
			// Pick an arbitrary type and fuzz it
			types := []runtime.Object{&testapigroup.Carp{}}
			obj := types[c.Rand.Intn(len(types))]
			c.Fuzz(obj)

			// Convert the object to raw bytes