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[]

	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')
}

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

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