ASSERT_EQ(alloc_count, 0);
  void* ptr_value = new Cool();
  {
    TaggedValue capsule =
        TaggedValue::Capsule(static_cast<void*>(ptr_value),
                             [](void* x) { delete static_cast<Cool*>(x); });
    ASSERT_EQ(alloc_count, 1);
    ASSERT_EQ(capsule.capsule(), ptr_value);
    test_moved = std::move(capsule);
    ASSERT_EQ(capsule.type(), TaggedValue::NONE);  // NOLINT
    test_copy = test_moved;

// CHECK: %[[CAST_1:.*]] = "tf.Cast"(%[[CLIPBYVALUE_0]]) <{Truncate = false}> : (tensor<1x100x100x1xi32>) -> tensor<1x100x100x1xf32>

// CHECK: %[[CLIPBYVALUE_1:.*]] = "tf.ClipByValue"
// CHECK-SAME: (tensor<1x98x98x1xi32>, tensor<i32>, tensor<i32>) -> tensor<1x98x98x1xi32>
// CHECK: %[[CAST_3:.*]] = "tf.Cast"(%[[CLIPBYVALUE_1]]) <{Truncate = false}> : (tensor<1x98x98x1xi32>) -> tensor<1x98x98x1xf32>

	config := &KubeletClientConfig{
		// Invalid certificate and key path
		TLSClientConfig: KubeletTLSConfig{
			CertFile: "../../client/testdata/mycertinvalid.cer",
			KeyFile:  "../../client/testdata/mycertinvalid.key",
			CAFile:   "../../client/testdata/myCA.cer",
		},
	}

	rt, err := MakeTransport(config)
	if err == nil {
		t.Errorf("Expected an error")
	}
	if rt != nil {

        num_elements, "\n", "Data size: ", data.size(), "\n"));
  }
  auto maybe_capsule = Get<internal::Capsule>(String("ctx"));
  if (!maybe_capsule.status().ok()) {
    return maybe_capsule.status();
  }
  auto capsule = maybe_capsule.value();
  auto ctx = capsule.cast<tensorflow::ImmediateExecutionContext*>();
  tensorflow::AbstractTensorPtr t(

nation, conceived in Liberty, and dedicated to the proposition that all men are created equal. Now we are engaged in a great Civil War, testing whether that nation, or any nation so conceived and so dedicated, can long endure. We are met on a great battle-field of that war. We have come to dedicate a portion of that field, as a final resting place for those who here gave their lives that that nation might live. It is altogether fitting and proper that we should do this. But, in a larger sense, we can...

			Key:   parts[0],
			Value: strings.Trim(parts[1], " "),
		})
	}

	if clientCert != "" && clientKey != "" {
		request.CertFile = clientCert
		request.KeyFile = clientKey
	}
	if caFile != "" {
		request.CaCertFile = caFile
	}
	return request, nil
}

func main() {
	if err := rootCmd.Execute(); err != nil {
		os.Exit(-1)
	}

	credFetcherTypeEnv, credIdentityProvider string,
) (*security.Options, error) {
	jwtPath := constants.ThirdPartyJwtPath
	switch jwtPolicy {
	case jwt.PolicyThirdParty:
		log.Info("JWT policy is third-party-jwt")
		jwtPath = constants.ThirdPartyJwtPath
	case jwt.PolicyFirstParty:
		log.Warnf("Using deprecated JWT policy 'first-party-jwt'; treating as 'third-party-jwt'")
		jwtPath = constants.ThirdPartyJwtPath
	default:

                break
            case "exclude module":
                return "module('${anonymize(value)}')"
            case "exclude module id":
                def (group, name) = value.split(':')
                return "moduleId('${anonymize(group)}', '${anonymize(name)}')"
            case "module names":
                return "moduleSet(${value.collect { "'${anonymize(it)}'" }.join(', ')})"
            case "module ids":

TaggedValue MakeContext(T runtime) {
  AbstractContext* ctx_raw = nullptr;
  Status s = BuildImmediateExecutionContext(runtime, &ctx_raw);
  // ASSERT_EQ(tensorflow::errors::OK, s.code()) << s.message();
  return TaggedValue::Capsule(static_cast<void*>(ctx_raw), [](void* p) {
    tensorflow::internal::AbstractContextDeleter()(
        static_cast<AbstractContext*>(p));
  });
}
}  // namespace

TEST_P(UnifiedCAPI, HoldTensors) {

	}

	if cfg.SkipTLSVerify {
		// User explicitly opted into insecure.
		cluster.InsecureSkipTLSVerify = true
	} else {
		caFile := model.GetOrDefault(cfg.KubeCAFile, cfg.K8sServiceAccountPath+"/ca.crt")
		caContents, err := os.ReadFile(caFile)
		if err != nil {
			return kubeconfig{}, err
		}
		cluster.CertificateAuthorityData = caContents
	}