delegate.add(checkNotNull(first));
    do {
      delegate.add(checkNotNull(elements.next()));
    } while (elements.hasNext());

    return unsafeDelegate(delegate);
  }

  // Factory methods that skips the null checks on elements, only used when
  // the elements are known to be non-null.
  static <E> ImmutableSet<E> unsafeDelegate(Set<E> delegate) {
    switch (delegate.size()) {
      case 0:
        return of();

				// Determine if os.NotExist error is because of
				// baseDir's parent being present, retry it once such
				// that the MkdirAll is retried once for the parent
				// of dirPath.
				// Because it is worth a retry to skip a different
				// baseDir which is slightly higher up the depth.
				nbaseDir := path.Dir(baseDir)
				if baseDir != "" && nbaseDir != "" && nbaseDir != SlashSeparator {
					baseDir = nbaseDir
				}
				continue

//	        SignedHeaders=signedHeaders, Signature=signature
func parseSignV4(v4Auth string, region string, stype serviceType) (sv signValues, aec APIErrorCode) {
	// credElement is fetched first to skip replacing the space in access key.
	credElement := strings.TrimPrefix(strings.Split(strings.TrimSpace(v4Auth), ",")[0], signV4Algorithm)
	// Replace all spaced strings, some clients can send spaced

                try {
                  startUp();
                  notifyStarted();
                  // If stopAsync() is called while starting we may be in the STOPPING state in
                  // which case we should skip right down to shutdown.
                  if (isRunning()) {
                    try {
                      AbstractExecutionThreadService.this.run();
                    } catch (Throwable t) {

        ']'.code,
        '{'.code,
        '}'.code,
        '|'.code,
        '^'.code,
        '\''.code,
        ';'.code,
        '='.code,
        '@'.code,
      ).override(
        Encoding.SKIP,
        ':'.code,
        '/'.code,
        '\\'.code,
        '?'.code,
        '#'.code,
      ).test(UrlComponentEncodingTester.Component.USER)
  }

  @Test
  fun passwordCharacters() {

			for _, sts := range stsKeys {
				accessKeys.STSKeys = append(accessKeys.STSKeys, madmin.ServiceAccountInfo{
					AccessKey:  sts.AccessKey,
					Expiration: &sts.Expiration,
				})
			}
			// if only STS keys, skip if user has no STS keys
			if !listServiceAccounts && len(stsKeys) == 0 {
				continue
			}
		}

		if listServiceAccounts {
			serviceAccounts, err := globalIAMSys.ListServiceAccounts(ctx, internalDN)

            Arrays.fill(buffer, (byte) 0xFF);

            lock.encode(buffer, 0);

            // Reserved field bytes are not modified by the encode method
            // The implementation just skips these bytes without writing zeros
            assertEquals(-1, SMBUtil.readInt4(buffer, 20));
        }
    }

    @Nested
    @DisplayName("Flag Constants Tests")
    class FlagConstantsTests {

  val mappingsBuffer = StringBuilder()
  val sectionIndexBuffer = Buffer()

  var previousMappedRanges: List<MappedRange>? = null

  for ((section, sectionMappedRanges) in sections) {
    // Skip sequential ranges when they are equal.
    if (sectionMappedRanges == previousMappedRanges) continue
    previousMappedRanges = sectionMappedRanges

    val sectionOffset = rangesBuffer.size.toInt() / 4

var errDoneForNow = errors.New("done for now")

// errSkipFile returned by the fn() for readDirFn() when it needs
// to proceed to next entry.
var errSkipFile = errors.New("skip this file")

var errIgnoreFileContrib = errors.New("ignore this file's contribution toward data-usage")

// errXLBackend XL drive mode requires fresh deployment.

	for {
		select {
		case <-GlobalContext.Done():
			return
		case u, ok := <-m.opCh:
			if !ok {
				return
			}

			// We might land at .metacache, .trash, .multipart
			// no need to heal them skip, only when bucket
			// is '.minio.sys'
			if u.Bucket == minioMetaBucket {
				// No MRF needed for temporary objects
				if wildcard.Match("buckets/*/.metacache/*", u.Object) {
					continue
				}