_ = string(si) // ERROR "cannot convert.* string|invalid type conversion"
	_ = []byte(si) // ERROR "cannot convert.*\[\]byte|invalid type conversion"
	_ = []rune(si) // ERROR "cannot convert.*\[\]rune|invalid type conversion"
	_ = []int64(si)
	_ = Tstring(si) // ERROR "cannot convert.*Tstring|invalid type conversion"
	_ = Tbyte(si)   // ERROR "cannot convert.*Tbyte|invalid type conversion"

  int vectorSize = 3;
  Tensor tags(DT_STRING, {vectorSize});
  Tensor values(DT_DOUBLE, {vectorSize});
  tags.vec<tstring>()(0) = "tag1";
  tags.vec<tstring>()(1) = "tag2";
  tags.vec<tstring>()(2) = "tag3";
  values.vec<double>()(0) = 1.0;
  values.vec<double>()(1) = -0.73;
  values.vec<double>()(2) = 10000.0;
  TestScalarSummaryOp(&tags, &values, R"(
                      value { tag: 'tag1' simple_value: 1.0 }

      /*dims=*/nullptr, /*num_dims=*/0,
      /*len=*/sizeof(tensorflow::tstring), status.get()));

  if (TF_GetCode(status.get()) != TF_OK) {
    TF_OpKernelContext_Failure(ctx, status.get());
    return;
  }
  tensorflow::tstring* output_tstring = reinterpret_cast<tensorflow::tstring*>(
      TF_TensorData(summary_tensor.get()));
  CHECK(SerializeToTString(s, output_tstring));
}

      /*dims=*/nullptr, /*num_dims=*/0,
      /*len=*/sizeof(tensorflow::tstring), status.get()));
  if (TF_GetCode(status.get()) != TF_OK) {
    TF_OpKernelContext_Failure(ctx, status.get());
    return;
  }
  tensorflow::tstring* output_tstring = reinterpret_cast<tensorflow::tstring*>(
      TF_TensorData(summary_tensor.get()));
  CHECK(SerializeToTString(s, output_tstring));
}

                        sizeof(tensorflow::tstring), params.status);
  if (TF_GetCode(params.status) != TF_OK) {
    TF_DeleteTensor(summary_tensor);
    TF_OpKernelContext_Failure(ctx, params.status);
    return;
  }
  tensorflow::tstring* output_tstring =
      reinterpret_cast<tensorflow::tstring*>(TF_TensorData(summary_tensor));
  CHECK(SerializeToTString(s, output_tstring));

			types.IsSimple[et] = true
		}
	}

	types.IsSimple[types.TBOOL] = true

	okforadd[types.TSTRING] = true

	okforbool[types.TBOOL] = true

	okforcap[types.TARRAY] = true
	okforcap[types.TCHAN] = true
	okforcap[types.TSLICE] = true

	ir.OKForConst[types.TBOOL] = true
	ir.OKForConst[types.TSTRING] = true

	okforlen[types.TARRAY] = true
	okforlen[types.TCHAN] = true
	okforlen[types.TMAP] = true

  EXPECT_EQ(TF_GetCode(status), TF_OK) << TF_Message(status);

  EXPECT_EQ(TF_NumDims(result), 0);
  tensorflow::tstring* output_value =
      static_cast<tensorflow::tstring*>(TF_TensorData(result));
  std::string file_contents(*output_value);
  EXPECT_NE(file_contents.find("TEST ASSET FILE CONTENTS"), std::string::npos);

  TF_DeleteTensor(result);
  TFE_DeleteTensorHandle(read_file_fn_outputs[0]);
  TFE_DeleteOp(read_file_op);

// explicit conversion of constants
var x1 = string(1)
var x2 string = string(1)
var x3 = int(1.5)     // ERROR "convert|truncate"
var x4 int = int(1.5) // ERROR "convert|truncate"
var x5 = "a" + string(1)
var x6 = int(1e100)      // ERROR "overflow|cannot convert"
var x7 = float32(1e1000) // ERROR "overflow|cannot convert"

// unsafe.Pointer can only convert to/from uintptr

        test::AsTensor<tstring>({"foo.txt"}, TensorShape({})), path_outputs[0]);
  }

  void CheckSavedModelBundle(const string& export_dir,
                             const SavedModelBundleLite& bundle) {
    ValidateAssets(export_dir, bundle);
    // Retrieve the regression signature from the bundle.
    const auto& signature_def = bundle.GetSignatures().at("regress_x_to_y");

  if (tensor.get() == nullptr) {
    return errors::Internal(
        "Failed to create vector string tensor for checkpoint restore");
  }
  // Use placement new to construct the string, since we don't have
  // access to Tensor::flat. This is conceptually equivalent to:
  // tensor.flat<tstring>()(0) = s
  new (tensor->Data()) tstring(s);

  out->reset(ctx->CreateLocalHandle(tensor.get()));
  return Status();
}