{
          "shape": [1, 4],
          "name": "input",
          "quantization": {
          }
        },
        {
          "shape": [2, 2],
          "name": "output",
          "quantization": {
          }
        }
      ],
      "inputs": [0],
      "outputs": [1],
      "operators": [
        {
          "inputs": [ 0 ],
          "outputs": [ 1 ],

// 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"

	"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",
				},

            16
          ],
          "name": "output",
          "quantization": {
          }
        }
      ],
      "inputs": [
        0,
        1
      ],
      "outputs": [
        2
      ],
      "operators": [
        {
          "inputs": [
            0,
            1
          ],
          "outputs": [
            2
          ],

  // Tensors: Vector of tensors that back the TensorValue inputs
  // Inputs: Vector of inputs that are backed by tensors.
  mlir::LogicalResult PrepareKernelInputs(
      const llvm::SmallDenseSet<int>& required_consts,
      std::vector<tensorflow::XlaExpression>& expressions,
      std::vector<tensorflow::Tensor>& tensors,
      std::vector<tensorflow::TensorValue>& inputs);

}

Status FakeSession::Run(
    const std::vector<std::pair<std::string, Tensor>>& inputs,
    const std::vector<std::string>& output_names,
    const std::vector<std::string>& target_nodes,
    std::vector<Tensor>* outputs) {
  tensorflow::RunMetadata run_metadata;
  return Run(tensorflow::RunOptions(), inputs, output_names, target_nodes,
             outputs, &run_metadata);
}

Status FakeSession::Run(

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

        InputFingerprinter.Result inputs = work.getInputFingerprinter().fingerprintInputProperties(
            ImmutableSortedMap.of(),
            ImmutableSortedMap.of(),
            ImmutableSortedMap.of(),
            ImmutableSortedMap.of(),
            work::visitIdentityInputs
        );

        ImmutableSortedMap<String, ValueSnapshot> identityInputProperties = inputs.getValueSnapshots();

import java.io.File


/**
 * Defines specific configuration inputs that should not be included in the configuration cache fingerprint.
 */
@ServiceScope(Scope.BuildTree::class)
interface IgnoredConfigurationInputs {
    /**
     * Checks if the [file] should be excluded from the configuration inputs fingerprint if it participates
     * in file system checks, such as [File.exists], [File.isFile] etc.
     */

                            binary.builtBy(task);
                        }
                    });

            List<ModelView<?>> inputsWithBinary = new ArrayList<ModelView<?>>(inputs.size());
            inputsWithBinary.addAll(inputs.subList(1, inputs.size()));
            inputsWithBinary.add(InstanceModelView.of(getSubject().getPath(), getSubject().getType(), binary));

            invoke(invoker, inputsWithBinary, cast, binary, binary);