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

package mesh

import "testing"

func FuzzValidateMeshConfig(f *testing.F) {
	f.Fuzz(func(t *testing.T, data string) {
		_, _ = ApplyMeshConfigDefaults(data)
	})

	"k8s.io/apimachinery/pkg/util/diff"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"

	"github.com/google/go-cmp/cmp"
	fuzz "github.com/google/gofuzz"
	flag "github.com/spf13/pflag"
	"sigs.k8s.io/yaml"
)

var fuzzIters = flag.Int("fuzz-iters", 50, "How many fuzzing iterations to do.")

type testMetaFactory struct{}

func (testMetaFactory) Interpret(data []byte) (*schema.GroupVersionKind, error) {

	disallowedPrefixes := []string{
		"foo/bar",
		"k8s.io/foo/bar/vendor/k8s.io/baz/buz",
		"bar/foo/baz",
	}

	testCases := []struct {
		name            string
		pkgPath         string
		shouldBeAllowed bool
	}{
		{
			name:            "package path beginning with forbidden prefix is rejected",
			pkgPath:         "foo/bar/baz/buz",
			shouldBeAllowed: false,
		},
		{

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

// If you update this constraint, also update internal/platform.FuzzSupported.
//
//go:build !darwin && !freebsd && !linux && !windows

package fuzz

import (
	"os"
	"os/exec"
)

type sharedMemSys struct{}

func sharedMemMapFile(f *os.File, size int, removeOnClose bool) (*sharedMem, error) {
	panic("not implemented")
}

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

package authenticate

import (
	"testing"
)

func FuzzBuildSecurityCaller(f *testing.F) {
	f.Fuzz(func(t *testing.T, s string) {
		_, _ = buildSecurityCaller(s)
	})

// 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 (
	"istio.io/istio/security/pkg/util"
)

func FuzzJwtUtil(data []byte) int {
	_, _ = util.GetExp(string(data))
	_, _ = util.GetAud(string(data))
	_, _ = util.ExtractJwtAud(string(data))
	return 1

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

package chiron

import (
	"os"
	"testing"
)

func FuzzReadCACert(f *testing.F) {
	f.Fuzz(func(t *testing.T, caCert []byte) {
		// create ca file
		caFile, err := os.Create("caFile")
		if err != nil {
			return
		}
		defer func() {
			caFile.Close()
			os.Remove("caFile")
		}()

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !libfuzzer

package fuzz

import _ "unsafe" // for go:linkname

//go:linkname libfuzzerTraceCmp1 runtime.libfuzzerTraceCmp1
//go:linkname libfuzzerTraceCmp2 runtime.libfuzzerTraceCmp2
//go:linkname libfuzzerTraceCmp4 runtime.libfuzzerTraceCmp4

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fuzz

import (
	"fmt"
	"os"
	"os/exec"
	"syscall"
	"unsafe"
)

type sharedMemSys struct {
	mapObj syscall.Handle
}

func sharedMemMapFile(f *os.File, size int, removeOnClose bool) (mem *sharedMem, err error) {
	defer func() {
		if err != nil {

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

package fuzzer

import (
	"math/rand"
	"time"

	fuzz "github.com/google/gofuzz"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
	"k8s.io/kubelet/config/v1beta1"
	"k8s.io/kubernetes/pkg/cluster/ports"