f.Add(make([]byte, 100))
	f.Fuzz(func(t *testing.T, b []byte) {
		if len(b) < 50 {
			// Make sure that b is large enough that it can be minimized
			return
		}
		// Given the randomness of the mutations, this should allow the
		// minimizer to trim down the value a bit.
		for _, n := range b {
			if n != 0 {
				if len(b) == 50 {
					t.Log("got the minimum size!")
				}

[!fuzz-instrumented] skip

# Test that when an interesting value is discovered (one that expands coverage),
# the fuzzing engine minimizes it before writing it to the cache.
#
# The program below starts with a seed value of length 100, but more coverage
# will be found for any value other than the seed. We should end with a value
# in the cache of length 1 (the minimizer currently does not produce empty
# strings). check_cache.go confirms that.
#

Katie Hockman <******@****.***> 1638375916 -0500

		if good, err := checkFile(name, expected); err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(1)
		} else if good {
			os.Exit(0)
		}
	}
	fmt.Fprintln(os.Stderr, "input over minimized")
	os.Exit(1)

// license that can be found in the LICENSE file.

// Check that we don't crash due to "lost track of variable in
// liveness" errors against unused variables.

package p

import "strings"

// Minimized test case from github.com/mvdan/sh/syntax.
func F() {
	var _ = []string{
		strings.Repeat("\n\n\t\t        \n", 10) +
			"# " + strings.Repeat("foo bar ", 10) + "\n" +
			strings.Repeat("longlit_", 10) + "\n",
	}

// license that can be found in the LICENSE file.

package net

import (
	"internal/poll"
	"io"
)

var pollSplice = poll.Splice

// spliceFrom transfers data from r to c using the splice system call to minimize
// copies from and to userspace. c must be a TCP connection.
// Currently, spliceFrom is only enabled if r is a TCP or a stream-oriented Unix connection.
//
// If spliceFrom returns handled == false, it has performed no work.

plugins {
    `java-library`
    id("com.github.johnrengelman.shadow")
}

shadow {
    applicationDistribution.from("src/dist")
}

tasks.shadowJar {
    minimize()

package runtime

func XTestSPWrite(t TestingT) {
	// Test that we can traceback from the stack check prologue of a function
	// that writes to SP. See #62326.

	// Start a goroutine to minimize the initial stack and ensure we grow the stack.
	done := make(chan bool)
	go func() {
		testSPWrite() // Defined in assembly
		done <- true
	}()
	<-done

python infra/helper.py build_image istio
python infra/helper.py build_fuzzers istio ~/go/src/istio.io/istio
```

Reproduce failure:

```bash
python infra/helper.py reproduce istio FuzzX ~/Downloads/clusterfuzz-testcase-minimized-FuzzX-1234
```

Run:

```bash
python infra/helper.py run_fuzzer istio FuzzValidateMeshConfig

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test faketime support. This is its own test program because we have
// to build it with custom build tags and hence want to minimize
// dependencies.

package main

import (
	"os"
	"time"
)

func main() {
	println("line 1")
	// Stream switch, increments time
	os.Stdout.WriteString("line 2\n")