def "string backed text resource"() {
        when:
        run("stringText")

        then:
        result.assertTasksExecuted(":stringText")
        file("output.txt").text == "my config"

        when:
        run("stringText")

        then:
        result.assertTasksSkipped(":stringText")
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)

    archiveFileName = "config.zip"
    from generateConfigFile.get()
}

configurations {
    sharedConfig
}

dependencies {
    sharedConfig generateConfigZip.outputs.files
}

task stringText(type: MyTask) {
    config = resources.text.fromString("my config")
    output = project.file("output.txt")
}

task fileText(type: MyTask) {
    config = resources.text.fromFile("config.txt")

#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSet.h"
#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/tfr/ir/tfr_ops.h"

namespace mlir {
namespace TFR {
namespace {

// TODO(b/174692018): Use the official allowlist of the unregistered attrs.
const llvm::StringSet<>& GetAllowedAttributes() {
  static auto* const ops = new llvm::StringSet<>({"device", "_tpu_replicate"});
  return *ops;

            llvm::cl::list_init<std::string>(noinline_functions),
            llvm::cl::ZeroOrMore};
  }

  // Gets a set of function names from `noinline_functions_`.
  StringSet<> GetNoinlineFunctionsSet() {
    StringSet<> noinline_functions;
    noinline_functions.insert(noinline_functions_.begin(),
                              noinline_functions_.end());
    return noinline_functions;
  }

namespace {

// Returns the ops that should use node name if shared_name is empty.
const llvm::StringSet<>& GetOpsUsingNodeName() {
  static auto* const ops =
      new llvm::StringSet<>({"VariableV2", "Variable", "BatchFunction"});
  return *ops;
}

// Returns the set of ops that we want to generate shared_names for them if
// empty.
const llvm::StringSet<>& GetSharedNameGenerationCompatibleOps() {
  return GetOpsUsingNodeName();
}

	}()
	globalMinioPort = "9000"

	tempGlobalDomainIPs := globalDomainIPs
	defer func() {
		globalDomainIPs = tempGlobalDomainIPs
	}()

	ipv4TestCases := []struct {
		endPoints      set.StringSet
		expectedResult set.StringSet
	}{
		{set.NewStringSet(), set.NewStringSet()},
		{set.CreateStringSet("localhost"), set.NewStringSet()},
		{set.CreateStringSet("localhost", "10.0.0.1"), set.CreateStringSet("10.0.0.1:9000")},

	"github.com/minio/minio-go/v7/pkg/set"
)

// TestGetMissingSiteNames
func TestGetMissingSiteNames(t *testing.T) {
	testCases := []struct {
		currSites []madmin.PeerInfo
		oldDepIDs set.StringSet
		newDepIDs set.StringSet
		expNames  []string
	}{
		// Test1: missing some sites in replicated setup
		{
			[]madmin.PeerInfo{
				{Endpoint: "minio1:9000", Name: "minio1", DeploymentID: "dep1"},

LogicalResult ValidateAttrs(Operation* src, const StringSet<>& registered);

// Copies all the allowed attributes in 'src' to 'dst'. The copy failed if the
// 'dst' has the attribute. Return a failure if there are any attributes are not
// allowed and also unregistered.
LogicalResult CopyAllowedUnregisteredAttrs(Operation* src, CallOp dst,
                                           const StringSet<>& registered);

#include "tensorflow/cc/experimental/libtf/impl/string.h"

#include "tensorflow/core/platform/test.h"

namespace tf {
namespace libtf {
namespace impl {

TEST(StringTest, TestBasicInterning) {
  String s1("foo");
  String s2("foo");
  EXPECT_EQ(&s1.str(), &s2.str());
}

}  // namespace impl
}  // namespace libtf

#include <memory>
#include <optional>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>

#include "absl/status/status.h"
#include "absl/types/span.h"
#include "llvm/ADT/StringSet.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/IR/BuiltinAttributes.h"  // from @llvm-project
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project