errContains: `unexpected status: 503, fetching bundle: {"error": "system down"}`,
		},
		{
			name:        "Bundle contains no certificate",
			in:          input1,
			extraCerts:  serverCerts,
			statusCode:  http.StatusOK,
			body:        invalidSpiffeX509Bundle,
			errContains: "expected 1 certificate in x509-svid entry 0; got 0",
		},
		{
			name:        "Bundle cannot be decoded",
			in:          input1,

                module('org.gradle.test:lib:1.0')
                module('org.gradle.test:lib2:1.0')
            }
        }
    }

    void "overriding the version of a bundle overrides the version of all dependencies of the bundle"() {
        tomlFile << """[libraries]
lib = {group = "org.gradle.test", name="lib", version.require="1.0"}
lib2.module = "org.gradle.test:lib2"
lib2.version = "1.0"

[bundles]

	expectTbCount(t, tb, 2, 3*time.Second, "server1(running) trustAnchor not updated in bundle")

	// Test3: Stop server1
	server1.Close()
	// Check server1's valid trustAnchor is no longer in the trustbundle within poll frequency window
	expectTbCount(t, tb, 1, 6*time.Second, "server1(stopped) trustAnchor not removed from bundle")

	// Test4: Update with server1, server2 and mesh pem ca

  });

  std::string result;
  std::optional<tensorflow::Session *> session = std::nullopt;
  if (bundle) session = bundle->GetSession();
  auto status = tensorflow::ConvertTFExecutorToTFLOrFlatbuffer(
      module.value().get(), output_mlir, toco_flags, pass_config, tags,
      /*saved_model_dir=*/"", bundle.get(), &result, serialize_stablehlo_ops);
  if (!status.ok()) {
    llvm::errs() << status.message() << '\n';

    bool show_debug_info, TF_Status* status) {
  // Load the saved model into a SavedModelV2Bundle.

  tensorflow::SavedModelV2Bundle bundle;
  auto load_status =
      tensorflow::SavedModelV2Bundle::Load(saved_model_path, &bundle);
  if (!load_status.ok()) {
    tsl::Set_TF_Status_from_Status(status, load_status);
    return "// error";
  }

  if (!found) {
    return tensorflow::errors::Aborted("Export type is not supported.");
  }

  auto bundle = std::make_unique<tensorflow::SavedModelBundle>();
  bundle = nullptr;

  TF_ASSIGN_OR_RETURN(
      auto module,
      ImportSavedModelOrMLIR(input_model, &context, &source_mgr, &bundle));
  if (verbose) {
    TF_RETURN_IF_ERROR(ExportModule(*module,

Input properties can be overridden by specifying the same property name.

.Make the bundle task cacheable
====
include::sample[dir="snippets/buildCache/cacheable-bundle/kotlin",files="build.gradle.kts[tags=bundle-task]"]
include::sample[dir="snippets/buildCache/cacheable-bundle/groovy",files="build.gradle[tags=bundle-task]"]
====

[[sec:build_cache_configure]]
== Configure the Build Cache

    }

    String versionCatalog(String group, String name) {
        return "libs.$group.$name"
    }

    String versionCatalogBundle(String bundle) {
        return "libs.bundles.$bundle"
    }

    String testFixtures(String expression) {
        return "testFixtures($expression)"
    }

    String platform(String expression) {
        return "platform($expression)"

var scope = log.RegisterScope("validationController", "validation webhook controller")

type Options struct {
	// Istio system namespace where istiod resides.
	WatchedNamespace string

	// File path to the x509 certificate bundle used by the webhook server
	// and patched into the webhook config.
	CABundleWatcher *keycertbundle.Watcher

	// Revision for control plane performing patching on the validating webhook.
	Revision string

  auto bundle = std::make_unique<tensorflow::SavedModelBundle>();
  TF_ASSIGN_OR_RETURN(
      auto module,
      ImportSavedModel(
          model_flags.saved_model_dir(), model_flags.saved_model_version(),
          tags, absl::MakeSpan(custom_opdefs), exported_names, specs,
          !toco_flags.enable_tflite_resource_variables(), &context, &bundle));

  if (!model_flags.input_arrays().empty() ||