*(*ptr)->tensor() = value;
                                (*ptr)->is_initialized = true;
                                return absl::OkStatus();
                              }));
  mutex_lock ml(*variable->mu());
  OP_REQUIRES(
      context,
      !variable->is_initialized || variable->tensor()->dtype() == dtype_,
      errors::InvalidArgument(

  auto* var_ptr = GetVariableFromSession(var_handle_op, device_name, mgr);
  if (!var_ptr) return false;
  auto* tensor = var_ptr->tensor();
  bool is_initialized = tensor && tensor->IsInitialized();
  var_ptr->Unref();
  return is_initialized;
}

LogicalResult MarkInitializedVariablesInFunction(func::FuncOp function,
                                                 tensorflow::Session* session) {

#include "tensorflow/core/public/session.h"

namespace mlir {
namespace tf_saved_model {
// Marks all variables in 'function' whether they are initialized
// in 'session' or not by setting an attribute named 'is_initialized'
// on each variable op with value true/false based on variable is initialized
// in the session or not.
// If 'session' is NULL the function is no-op.

  // CHECK: "tf.VarHandleOp"
  // CHECK-SAME: shared_name = "var1"
  // CHECK-SAME: _is_initialized = true
  // CHECK: "tf.VarHandleOp"
  // CHECK-SAME: shared_name = "var2"
  // CHECK-SAME: _is_initialized = true
  // CHECK: "tf.VarHandleOp"
  // CHECK-SAME: shared_name = "var3"
  // CHECK-SAME: _is_initialized = false

  // INVALID-NOT: _is_initialized

  }

  // One resource, one read. _is_initialized is true, should be promoted.
  // CHECK-LABEL: func @read(%arg0: tensor<f32> {tf.resource_name = "x"}) -> tensor<f32>
  func.func @read() -> tensor<f32> {
    // CHECK-NOT: "tf.VarHandleOp"
    // CHECK-NOT: "tf.ReadVariableOp"
    // CHECK: return %arg0
    %1 = "tf.VarHandleOp"() {container = "", shared_name = "x", _is_initialized = true} : () -> tensor<!tf_type.resource<tensor<f32>>>

        )

        val result = runtimeInstanceFromResult(schema, resolution, kotlinFunctionAsConfigureLambda, RuntimeCustomAccessors.none, ::TopLevel)

        assertTrue { result.configuredLazy.isInitialized() }
    }

    @Test
    fun `configuring function with no block for Kotlin default param leads to object access`() {
        val resolution = schema.resolve(
            """
            configuring()

        private
        fun checkForFailure() {
            failure.getAndSet(null)?.let { throw it }
        }
    }

    override fun close() {
        executorService.apply {
            if (isInitialized()) {
                value.shutdown()
            }
        }
    }

        .cache(cache)
        .cookieJar(JavaNetCookieJar(cookieManager))
        .build()
  }

  @AfterEach
  fun tearDown() {
    ResponseCache.setDefault(null)
    if (this::cache.isInitialized) {
      cache.delete()
    }
  }

  @Test
  fun corruptedCipher() {
    val response =
      testCorruptingCache {
        corruptMetadata {
          // mess with cipher suite

        val resolution = schema.resolve("configureCustomInstance { }")
        assertTrue(runtimeInstanceFromResult(schema, resolution, configureLambdas, runtimeCustomAccessors, ::MyReceiver).myHiddenInstance.isInitialized())
    }


    @Test
    fun `accesses receiver from runtime lambda argument mapping to JVM`() {
        val resolution = schema.resolve(
            """
            configureLambdaArgument {

  xla::Shape old_shape = xla::TypeToShape(t);
  XLA_Shape old_shape_c = {};
  XLA_Shape new_shape_c = {};
  TfTpu_ExecutorApiFn *executor = stream_executor::tpu::ExecutorApiFn();
  if (!stream_executor::tpu::IsInitialized(executor)) {
    return failure();
  }
  ApiConverter::ToC(old_shape, &old_shape_c);
  executor->TpuTransferManager_GetInfeedLayoutFn(&old_shape_c, &new_shape_c);
  xla::Shape new_shape = ApiConverter::FromC(&new_shape_c);