if keyID == "" && len(kmsKey) != 0 {
		logger.CriticalIf(context.Background(), errors.New("The key ID must not be empty if a KMS data key is present"))
	}
	if keyID != "" && len(kmsKey) == 0 {
		logger.CriticalIf(context.Background(), errors.New("The KMS data key must not be empty if a key ID is present"))
	}

	if metadata == nil {
		metadata = make(map[string]string, 5)
	}

	// Validate all test cases.
	for i, testCase := range testCases {
		// Initialize a new xlStorage layer.
		_, err := newLocalXLStorage(testCase.name)
		if err != testCase.err {
			t.Fatalf("TestXLStorage %d failed wanted: %s, got: %s", i+1, err, testCase.err)
		}
	}
}

// TestXLStorageMakeVol - TestXLStorage validate the logic for creation of new xlStorage volume.
// Asserts the failures too against the expected failures.

  - [Known Issues](#known-issues)
  - [Before Upgrading](#before-upgrading)
      - [New Deprecations](#new-deprecations)
      - [Removed Deprecations](#removed-deprecations)
      - [Graduated to Stable/GA](#graduated-to-stablega)
      - [Graduated to Beta](#graduated-to-beta)
    - [New alpha features](#new-alpha-features)
  - [Other Notable Changes](#other-notable-changes-10)

                .build();
    }

    @Nonnull
    static ModelBuilderRequestBuilder builder() {
        return new ModelBuilderRequestBuilder();
    }

    @Nonnull
    static ModelBuilderRequestBuilder builder(ModelBuilderRequest request) {
        return new ModelBuilderRequestBuilder(request);
    }

    @NotThreadSafe
    class ModelBuilderRequestBuilder {
        Session session;

```go
// hashes the key returning an integer.
func sipHashMod(key string, cardinality int, id [16]byte) int {
        if cardinality <= 0 {
                return -1
        }
        sip := siphash.New(id[:])
        sip.Write([]byte(key))
        return int(sip.Sum64() % uint64(cardinality))
}
```

        if (!jobHelper.isAvailable(id)) {
            logger.info("Job is unavailable, unregistering: id={}", id);
            jobHelper.unregister(scheduledJob);
            return;
        }

        final JobLog jobLog = new JobLog(scheduledJob);
        final String jobLogId = (String) runtime.getParameterMap().get(Constants.JOB_LOG_ID);
        if (jobLogId != null) {
            jobLog.setId(jobLogId);
        }

    public int load() {
        final Map<String, Map<String, String[]>> relatedQueryMap = new HashMap<>();
        getAvailableRelatedQueryList().stream().forEach(entity -> {
            final String key = getHostKey(entity);
            Map<String, String[]> map = relatedQueryMap.get(key);
            if (map == null) {
                map = new HashMap<>();
                relatedQueryMap.put(key, map);
            }

            return builder.getOutputStream();
        } catch (final IOException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to print the output.", e);
            }
            return new ByteArrayOutputStream();
        }
    }

    /**
     * Creates an OutputStream from a ToXContent object with the specified media type.
     *
     * @param xContent the content object to convert

import java.util.HashSet;
import java.util.Set;

public class LinkRenderer {
    private final Document document;
    private final DslDocModel model;
    private final Set<String> primitiveTypes = new HashSet<String>();
    private final String groovyVersion;
    private final String javaVersion;

    public LinkRenderer(Document document, DslDocModel model, String groovyVersion, String javaVersion) {

        if: matrix.openid == 'http://127.0.0.1:5556/dex'
        run: |
          make test-site-replication-oidc
  iam-import-with-missing-entities:
    name: Test IAM import in new cluster with missing entities
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: ${{ matrix.go-version }}