// if either host or share name is different, return s
		{`\\host\share\foo`, ``, `\\host\share\foo`},
		{`\\host\share\foo`, `\foo`, `\\host\share\foo`},
		{`\\host\share\foo`, `\\host\other\`, `\\host\share\foo`},
		{`\\host\share\foo`, `\\other\share\`, `\\host\share\foo`},
		{`\\host\share\foo`, `\\host\`, `\\host\share\foo`},
		{`\\host\share\foo`, `\share\`, `\\host\share\foo`},

		// only volume names are case-insensitive

// Returns a tensor of zeros with the same shape and type as x.
Status ZerosLike(AbstractContext* ctx, AbstractTensorHandle* const x,
                 AbstractTensorHandle** y, const char* name = nullptr,
                 const char* raw_device_name = nullptr);

// Returns the shape of a tensor.
Status Shape(AbstractContext* ctx, AbstractTensorHandle* const input,

func.func @unique_vars() {
  %0 = "tf.VarHandleOp"() {container = "", shape = "tfshape$", shared_name = "x"} : () -> tensor<!tf_type.resource<tensor<f32>>>
  %1 = "tf.VarHandleOp"() {container = "", shape = "tfshape$", shared_name = "y"} : () -> tensor<!tf_type.resource<tensor<i32>>>
  func.return
}

// CHECK-LABEL: func @duplicate_vars
// CHECK-SAME: (%arg0: tensor<!tf_type.resource<tensor<f32>>> {tf.resource_name = "x"})
// CHECK-NOT: "tf.VarHandleOp"

// determine the shape of the result of `tf.Max`.
// CHECK-DAG: %[[CST:.*]] = "tf.Const"
// CHECK-SAME: dense<0>
// CHECK-DAG: %[[CST_0:.*]] = "tf.Const"
// CHECK-SAME: dense<0>
// CHECK-DAG: %[[CST_1:.*]] = "tf.Const"
// CHECK-SAME: dense<1>
// CHECK-DAG: %[[CST_2:.*]] = "tf.Const"
// CHECK-SAME: dense<1>

// -----

// CHECK-LABEL: @early_stop_at_shape_op

# CHECK-SAME:  ([[VAL_0:%.*]]: tensor<1x8x8x2xi32>) -> (tensor<1x8x8x2xi32>, tensor<i32>, tensor<10xi32>)
# CHECK-SAME:  control_outputs = ""
# CHECK-SAME:  inputs = "unranked"
# CHECK-SAME:  outputs = "unranked,static,static_10"
# CHECK-DAG:         [[VAL_2:%.*]] = arith.constant dense<0> : tensor<10xi32>
# CHECK-DAG:         [[VAL_1:%.*]] = arith.constant dense<0> : tensor<i32>

    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
library {
}
versions {
}

# CHECK-LABEL: func @main
# CHECK-SAME:  (%[[ARG_0:[a-z0-9]+]]: tensor<f32>) -> tensor<*xf32>
# CHECK-SAME:  control_outputs = ""
# CHECK-SAME:  inputs = "input"
# CHECK-SAME:  outputs = "output_node"
# CHECK:         %[[GRAPH:[0-9]+]] = tf_executor.graph

      CHECK-NEXT:   %[[shape:.*]] = tfr.get_shape %x -> !shape.shape

      CHECK-NEXT:   %[[shape_1:.*]] = tfr.get_shape %x -> !shape.shape
      CHECK-NEXT:   %[[len:.*]] = shape.rank %[[shape_1]] : !shape.shape -> !shape.size
      CHECK-NEXT:   %[[index:.*]] = shape.size_to_index %[[len]] : !shape.size
      CHECK-NEXT:   %[[begin:.*]] = arith.constant 0 : index

// Test case: Basic converting.

func.func @f() {
  // CHECK: "tf.VarHandleOp"
  // CHECK: "tf.ReadVariableOp"
  %val0 = "tf.VariableV2"() {_class = ["loc:@v"], container = "", device = "", shape = #tf_type.shape<96>, shared_name = ""} : () -> tensor<96x!tf_type.f32ref>
  %val1 = "tf.Identity"(%val0) : (tensor<96x!tf_type.f32ref>) -> tensor<96xf32>
  func.return
}

// -----

    # output shape: [-1, 14, 14, 32]
    max_pool1 = gen_mnist_ops.new_max_pool(conv1, 2, 2, 2, 2, 'SAME')

    # output shape: [-1, 14, 14, 64]
    conv2 = gen_mnist_ops.new_conv2d(max_pool1, self.weights['f2'],
                                     self.biases['b2'], 1, 1, 1, 1, 'SAME',
                                     'RELU')

    # output shape: [-1, 7, 7, 64]

# it is being invoked.
# CHECK: module
# CHECK-SAME: tf.versions
# CHECK-SAME: bad_consumers
# CHECK-SAME: min_consumer
# CHECK-SAME: producer

# CHECK:      func {{@[a-zA-Z_0-9]+}}(
# CHECK-SAME:   [[ARG:%.*]]: tensor<*xf32> {tf_saved_model.index_path = ["x"]}

# CHECK: [[shape:%.*]] = "tf.Shape"([[ARG]])
# CHECK-NEXT: [[batch_size:%.*]] = "tf.StridedSlice"([[shape]],
# CHECK-NEXT: [[result:%.*]] = "tf.Pack"([[batch_size]],