Option.empty(),
                Option.empty(),
                getExtra()
        );

        Inputs inputs = incremental.inputs(compileOptions, compilers, setup, previousResult);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(inputs.toString());
        }
        if (spec.getScalaCompileOptions().isForce()) {
            // TODO This should use Deleter

    inputs.property('acceptedViolations', acceptedViolations.toAcceptedChangesMap())
    inputs.property("baseline.version", compatibilityBaselineVersion)
    inputs.property("currentVersion", baseVersion)
    def apiSourceFolders = configurations.currentSources.incoming.artifactView { lenient(true) }.files
    inputs.files("apiSourceFolders", apiSourceFolders)
    inputs.files(currentClasspath)

LogicalResult FoldOperation(OpBuilder& builder, Operation* op,
                            SmallVector<Value>& results) {
  SmallVector<ElementsAttr> inputs;
  for (auto operand : op->getOperands()) {
    auto preceding_const_op = operand.getDefiningOp<TF::ConstOp>();
    if (preceding_const_op) {
      inputs.push_back(preceding_const_op.getValue());
      continue;
    }

    Operation* preceding_op = operand.getDefiningOp();

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

name: Latest Changes

on:
  pull_request_target:
    branches:
      - master
    types:
      - closed
  workflow_dispatch:
    inputs:
      number:
        description: PR number
        required: true
      debug_enabled:
        description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
        required: false
        default: 'false'

jobs:
  latest-changes:

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

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

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