func.func @tail_single_outside_compiled_op() {
    // CHECK:      %[[CLUSTER_OUT:.*]] = "tf_device.cluster"
    // CHECK-NEXT:   %[[A_OUT:.*]] = "tf.A"
    // CHECK-NEXT:   "tf.NoOp"
    // CHECK-NEXT:   tf_device.return %[[A_OUT]]
    // CHECK-NEXT: {
    // CHECK-DAG:  num_cores_per_replica = 1
    // CHECK-DAG:  step_marker_location = ""
    // CHECK-DAG:  topology = ""

func.func @multiple_func_body_ops() {
  tf_executor.graph {
    tf_executor.island {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    tf_executor.fetch
  }
  tf_executor.graph {
    tf_executor.island {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return
}

// -----

      <artifactId>org.eclipse.sisu.plexus</artifactId>
    </dependency>
    <dependency>
      <groupId>org.eclipse.sisu</groupId>
      <artifactId>org.eclipse.sisu.inject</artifactId>
      <classifier>no_asm</classifier>
    </dependency>
    <dependency>
      <groupId>com.google.inject</groupId>
      <artifactId>guice</artifactId>
      <classifier>classes</classifier>
    </dependency>
    <dependency>

        value {
          b: true
        }
      }
    }
    node {
      name: "init"
      op: "NoOp"
      input: "^a/Assign"
      input: "^b/Assign"
      input: "^c/Assign"
    }
    node {
      name: "group_deps"
      op: "NoOp"
      input: "^Assign"
    }
    node {
      name: "save/Const"
      op: "Const"
      attr {

        }

        return result;
    }

    public void add(RepositorySystemSession session, LocalArtifactRegistration request) {
        // noop
    }

    public void add(RepositorySystemSession session, LocalMetadataRegistration request) {
        // noop
    }

    static class ArtifactMetadataAdapter implements ArtifactMetadata {

        private final Metadata metadata;

        } else {
            // We don't know the type of element in the provider, so we assume it's the type of the collection
            DefaultListProperty<T> defaultListProperty = new DefaultListProperty<T>(PropertyHost.NO_OP, Cast.uncheckedCast(getType()));
            defaultListProperty.convention(provider);
            providerInternal = defaultListProperty;
        }
        store.addPendingCollection(providerInternal);
    }

        !copy.get().is(originalValue)
    }

    def "creates isolated map property"() {
        def originalMap = [a: 1, b: 2]
        def original = new DefaultMapProperty(PropertyHost.NO_OP, String, Number)
        original.set(originalMap)

        given:
        1 * managedFactoryRegistry.lookup(_) >> new ManagedFactories.MapPropertyManagedFactory(TestUtil.propertyFactory())

        expect:

        getOutputFilesProducedByWork() >> ImmutableSortedMap.of()
    }
    def validationContext = new DefaultWorkValidationContext(WorkValidationContext.TypeOriginInspector.NO_OP)
    def executionContext = Mock(TaskExecutionContext)
    def scriptSource = Mock(ScriptSource)
    def standardOutputCapture = Mock(StandardOutputCapture)

GOPATH ?= $(shell cd ${ISTIO_GO}/../../..; pwd)
export GOPATH

# If GOPATH is made up of several paths, use the first one for our targets in this Makefile
GO_TOP := $(shell echo ${GOPATH} | cut -d ':' -f1)
export GO_TOP

GO ?= go

GOARCH_LOCAL := $(TARGET_ARCH)
GOOS_LOCAL := $(TARGET_OS)

#-----------------------------------------------------------------------------
# Output control

    ],
)

pytype_strict_library(
    name = "quantize_model_test_base",
    testonly = 1,
    srcs = ["integration_test/quantize_model_test_base.py"],
    tags = ["no_pip"],
    deps = [
        ":representative_dataset",
        "//tensorflow:tensorflow_py",
        "//tensorflow/core:protos_all_py",
        "//tensorflow/python/client:session",