SpecType   string
	StatusType string
}

type inputs struct {
	Entries  []colEntry
	Packages []packageImport
}

func buildInputs() (inputs, error) {
	b, err := os.ReadFile(filepath.Join(env.IstioSrc, "pkg/config/schema/metadata.yaml"))
	if err != nil {
		fmt.Printf("unable to read input file: %v", err)
		return inputs{}, err
	}

	// Parse the file.
	m, err := ast.Parse(string(b))

// CHECK-NEXT:          },
// CHECK-NEXT:          has_rank: true
// CHECK-NEXT:        } ],
// CHECK-NEXT:        inputs: [ 0 ],
// CHECK-NEXT:        outputs: [ 2 ],
// CHECK-NEXT:        operators: [ {
// CHECK-NEXT:          inputs: [ 0 ],
// CHECK-NEXT:          outputs: [ 1 ]
// CHECK-NEXT:        }, {
// CHECK-NEXT:          inputs: [ 1 ],
// CHECK-NEXT:          outputs: [ 2 ]
// CHECK-NEXT:        } ],
// CHECK-NEXT:        name: "main"

            32,
            32,
            16
          ],
          "quantization": {
          }
        }
      ],
      "inputs": [
        0,
        1
      ],
      "outputs": [
        3
      ],
      "operators": [
        {
          "inputs": [
            0,
            1,
            -1
          ],
          "outputs": [
            3
          ],

    }
}

// tag::bundle-task[]
tasks.register<NpmTask>("bundle") {
    args = listOf("run", "bundle")

    outputs.cacheIf { true }

    inputs.dir(file("scripts"))
        .withPropertyName("scripts")
        .withPathSensitivity(PathSensitivity.RELATIVE)

    inputs.files("package.json", "package-lock.json")
        .withPropertyName("configFiles")
        .withPathSensitivity(PathSensitivity.RELATIVE)

                }
            }
        }

        then:
        def binaries = realizeBinaries()
        binaries.size() == 2
        binaries.bin1.inputs == [binaries.bin1.sources.src1, binaries.bin1.sources.src2] as Set
        binaries.bin2.inputs == [binaries.bin2.sources.src1] as Set
    }

    def "copies binary tasks into task container"() {
        when:
        dsl {

tasks.register("showTestClasspath") {
    val testCompileClasspath: FileCollection = configurations.testCompileClasspath.get()
    val testRuntimeClasspath: FileCollection = configurations.testRuntimeClasspath.get()
    inputs.files(testCompileClasspath)
    inputs.files(testRuntimeClasspath)
    doLast {
        println(testCompileClasspath.files.map(File::getName))
        println(testRuntimeClasspath.files.map(File::getName))
    }

/**
 * An instantiator which is responsible for allowing the capture of implicit
 * inputs provided by injected services. For this to be possible, a capturing
 * instantiator "session" must be created before the instance is created. This
 * must be done by calling the {@link #capturing(ImplicitInputRecorder)} method
 * which provides a registrar which will record implicit inputs.
 *
 * Not all services have to be capturing. Only services implementing the

// end::system-properties[]

abstract class PrintValue extends DefaultTask {
    @Input abstract Property<String> getInputValue()
    @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')
}

	"istio.io/istio/pkg/workloadapi"
)

func TestServiceEntryServices(t *testing.T) {
	cases := []struct {
		name   string
		inputs []any
		se     *networkingclient.ServiceEntry
		result []*workloadapi.Service
	}{
		{
			name:   "DNS service entry with address",
			inputs: []any{},
			se: &networkingclient.ServiceEntry{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "name",
					Namespace: "ns",
				},

// RUN: flatbuffer_translate -mlir-to-tflite-flatbuffer %s -o - | flatbuffer_to_string - | FileCheck %s

module {
func.func @add(%arg0: tensor<3x2xf32>) -> tensor<3x2xf32> attributes {tf.entry_function = {inputs = "serving_default_x", outputs = "outputs"}} {
  %0 = "tfl.pseudo_const" () {value = dense<[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]> : tensor<3x2xf32>} : () -> tensor<3x2xf32>