t.Fatal(err)
	}
	if n != len(wire1) || !bytes.Equal(wire1, wire2[:n]) {
		t.Fatalf("unexpected wire:\n%s", hex.Dump(wire2[:n]))
	}

	wire1 = append([]byte{0x6b, 0x38, 0x73, 0x00}, wire1...)

	obj1WithKind := obj1.DeepCopyObject()
	obj1WithKind.GetObjectKind().SetGroupVersionKind(schema.GroupVersionKind{Group: "", Version: "v1", Kind: "Carp"})
	testCases := []struct {
		obj   runtime.Object
		data  []byte

import org.gradle.api.Project;

/**
 * Adds an "example" extension to project and wires dependencies from the extension to a Configuration.
 */
public class ExamplePlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        ExampleExtension example = project.getExtensions().create("example", ExampleExtension.class);
// tag::wire-dependencies[]

recommend using the "official" serialization stack in `k8s.io/apimachinery`.
Directly serializing these types to proto will not result in data that matches
the wire format or is compatible with other kubernetes ecosystem tools. The
reason is that the wire format includes a magic prefix and an envelope proto.
Please see:
https://kubernetes.io/docs/reference/using-api/api-concepts/#protobuf-encoding

	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)

import okhttp3.internal.http2.Header
import okio.ByteString

/**
 * Representation of an individual case (set of headers and wire format). There are many cases for a
 * single story.  This class is used reflectively with Moshi to parse stories.
 */
data class Case(
  val seqno: Int = 0,
  val wire: ByteString? = null,
  val headers: List<Map<String, String>>,
) : Cloneable {
  val headersList: List<Header>
    get() {

	return &chunkedWriter{w}
}

// Writing to chunkedWriter translates to writing in HTTP chunked Transfer
// Encoding wire format to the underlying Wire chunkedWriter.
type chunkedWriter struct {
	Wire io.Writer
}

// Write the contents of data as one chunk to Wire.
// NOTE: Note that the corresponding chunk-writing procedure in Conn.Write has
// a bug since it does not check for success of [io.WriteString]

        }.findAll {
            !it.contains('.')
        }.unique().sort()
    }

    @Unroll("tasks inputs and outputs are wired correctly A: #aEnabled, B: #bEnabled")
    def "tasks inputs and outputs are wired correctly"() {
        when:
        container.a.required = aEnabled
        container.b.required = bEnabled

        then:
        outputFiles*.name == fileNames

    @TaskAction fun action() { println(inputValue.get()) }
}

// tag::system-properties-task-inputs[]
tasks.register<PrintValue>("printProperty") {
    // Using the Gradle API, provides a lazy Provider<String> wired to a task input
    inputValue = providers.systemProperty("system")
}

    @TaskAction void action() { println(inputValue.get()) }
}

// tag::execution[]
tasks.register('printValue', PrintValue) {
    // Using the Gradle API, provides a lazy Provider<String> wired to a task input
    inputValue = providers.environmentVariable('ENVIRONMENTAL')
}

    @TaskAction void action() { println(inputValue.get()) }
}

// tag::system-properties-task-inputs[]
tasks.register('printProperty', PrintValue) {
    // Using the Gradle API, provides a lazy Provider<String> wired to a task input
    inputValue = providers.systemProperty('system')
}