return
		}
		img, typ, err := image.Decode(bytes.NewReader(b))
		if err != nil || typ != "jpeg" {
			return
		}
		for q := 1; q <= 100; q++ {
			var w bytes.Buffer
			err := Encode(&w, img, &Options{Quality: q})
			if err != nil {
				t.Errorf("failed to encode valid image: %s", err)
				continue
			}
			img1, err := Decode(&w)
			if err != nil {
				t.Errorf("failed to decode roundtripped image: %s", err)
				continue

type metadataValidatingDecoder struct {
	decoder runtime.Decoder
}

func (m *metadataValidatingDecoder) Decode(data []byte, defaults *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
	obj, gvk, err := m.decoder.Decode(data, defaults, into)

	// if we already errored, return

	_ = 0
}

func _() {
	for {
		goto L
	}
L:

	MoreCode()
}

func _() {
	for {
		goto L
	}
L:	// A comment on the same line as the label, followed by a single empty line.
	// Known bug: There may be more than one empty line before MoreCode()
	//            (see go/printer/nodes.go, func linebreak).

	MoreCode()
}

func _() {
	for {
		goto L
	}
L:

		reader:   r,
		decoder:  d,
		buf:      make([]byte, 1024),
		maxBytes: 16 * 1024 * 1024,
	}
}

var ErrObjectTooLarge = fmt.Errorf("object to decode was longer than maximum allowed size")

// Decode reads the next object from the stream and decodes it.
func (d *decoder) Decode(defaults *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
	base := 0
	for {

	}
	return append(a, replacementChar)
}

// Decode returns the Unicode code point sequence represented
// by the UTF-16 encoding s.
func Decode(s []uint16) []rune {
	// Preallocate capacity to hold up to 64 runes.
	// Decode inlines, so the allocation can live on the stack.
	buf := make([]rune, 0, 64)
	return decode(s, buf)
}

// decode appends to buf the Unicode code point sequence represented

			e := &Encoder{CompressionLevel: l}
			err = e.Encode(&w, img)
			if err != nil {
				t.Errorf("failed to encode valid image: %s", err)
				continue
			}
			img1, err := Decode(&w)
			if err != nil {
				t.Errorf("failed to decode roundtripped image: %s", err)
				continue
			}
			got := img1.Bounds()
			want := img.Bounds()
			if !got.Eq(want) {

	{"testdata/video-005.gray.png", "testdata/video-005.gray.png", 0},
}

func decode(filename string) (image.Image, string, error) {
	f, err := os.Open(filename)
	if err != nil {
		return nil, "", err
	}
	defer f.Close()
	return image.Decode(bufio.NewReader(f))
}

func decodeConfig(filename string) (image.Config, string, error) {
	f, err := os.Open(filename)
	if err != nil {

package tls

import (
	"encoding/pem"
	"fmt"
	"runtime"
	"testing"
	"time"
)

func TestCertCache(t *testing.T) {
	cc := certCache{}
	p, _ := pem.Decode([]byte(rsaCertPEM))
	if p == nil {
		t.Fatal("Failed to decode certificate")
	}

	certA, err := cc.newCert(p.Bytes)
	if err != nil {
		t.Fatalf("newCert failed: %s", err)
	}
	certB, err := cc.newCert(p.Bytes)
	if err != nil {

        when:
        def payload = FileLockPacketPayload.decode([1, 0, 0, 0, 0, 0, 0, 0, 42, 1] as byte[], 9)

        then:
        payload.lockId == 42
        payload.type == UNKNOWN
    }

    def "decodes payloads with type #type"() {
        when:
        def payload = FileLockPacketPayload.decode([1, 0, 0, 0, 0, 0, 0, 0, 42, type.ordinal()] as byte[], 10)

        then:

	Lines []int
	Infos []lineInfo
}

type serializedFileSet struct {
	Base  int
	Files []serializedFile
}

// Read calls decode to deserialize a file set into s; s must not be nil.
func (s *FileSet) Read(decode func(any) error) error {
	var ss serializedFileSet
	if err := decode(&ss); err != nil {
		return err
	}

	s.mutex.Lock()
	s.base = ss.Base
	files := make([]*File, len(ss.Files))