return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

    public void addField(final String key, final Object value) {
        fields.put(key, value);
    }

    public String getLogMessage() {
        return getUrl();
    }

    public LocalDateTime getRequestedAt() {
        return getCreatedAt();
    }

//
// `filterByLabels` is a map of label names to list of allowed label values to
// filter by. Note that this filtering happens before any renaming of labels.
//
// `renameLabels` is a map of label names to rename. The keys are the original
// label names and the values are the new label names.
//
// `bucketFilter` is a list of bucket values to filter. If this is non-empty,
// only metrics for the given buckets are added.
//

			cfg := config.New()
			cfg[config.LambdaWebhookSubSys] = map[string]config.KVS{
				functionID: {
					{Key: "endpoint", Value: lambdaServer.URL},
					{Key: "enable", Value: config.EnableOn},
				},
			}
			cfg[config.APISubSys] = map[string]config.KVS{
				"api": {
					{Key: "gzip", Value: config.EnableOff},
				},
			}

			var err error

        return groupId + ":" + artifactId;
    }

    public static String key(Artifact artifact) {
        return key(artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion());
    }

    public static String key(String groupId, String artifactId, String version) {
        notBlank(groupId, "groupId can neither be null, empty nor blank");

	"github.com/minio/minio/internal/config"
	"github.com/minio/pkg/v3/env"
)

// DefaultKVS default configuration values for ILM subsystem
var DefaultKVS = config.KVS{
	config.KV{
		Key:   transitionWorkers,
		Value: "100",
	},
	config.KV{
		Key:   expirationWorkers,
		Value: "100",
	},
}

// Config represents the different configuration values for ILM subsystem
type Config struct {
	TransitionWorkers int

            if (setting.containsKey(idKey)) {
                requestBody.put(idKey, setting.get(idKey));
            }
            for (String key : keySet) {
                if (!requestBody.containsKey(key)) {
                    requestBody.put(key, setting.get(key));
                }
            }

            checkPutMethod(requestBody, getItemEndpointSuffix()).then().body("response.status", equalTo(0));

        dfs.insert(path, dr);

        assertNotNull(dfs.referrals);
        assertFalse(dfs.referrals.map.isEmpty());
        String key = "\\server\\share\\folder";
        assertTrue(dfs.referrals.map.containsKey(key.toLowerCase()));
    }

    @Test
    void testInsert_WithTrailingSlash() {
        String path = "\\server\\share\\folder\\";
        DfsReferral dr = new DfsReferral();

    private static class KeyNotFoundException extends Exception {
        private static final long serialVersionUID = 1L;

        private KeyNotFoundException(final String key) {
            super(key);
        }
    }

    @Override
    protected ObjectiveProperties newObjectiveProperties(final String resourcePath, final PropertyFilter propertyFilter) {

    public static final int DIRECTORY_LEASE_FLAG_NOTIFICATIONS = 0x00000002;
    
    public DirectoryLeaseContext(Smb2LeaseKey key, int leaseState, DirectoryCacheScope scope) {
        super();
        setLeaseKey(key);
        setLeaseState(leaseState);
        this.cacheScope = scope;
        this.maxCacheAge = 30000;  // 30 seconds default
        this.notificationEnabled = true;
    }

    DelayingIdentityLoader(CountDownLatch delayLatch) {
      this.delayLatch = delayLatch;
    }

    @CanIgnoreReturnValue // Sure, why not?
    @Override
    public T apply(T key) {
      awaitUninterruptibly(delayLatch);
      return key;
    }
  }

  /*
   * TODO(cpovirk): eliminate duplication between these tests and those in LegacyMapMakerTests and
   * anywhere else
   */