public E next() {
      if (occurrencesLeft == 0) {
        currentEntry = entryIterator.next();
        occurrencesLeft = currentEntry.getValue().get();
      }
      occurrencesLeft--;
      canRemove = true;
      /*
       * requireNonNull is safe because occurrencesLeft starts at 0, forcing us to initialize
       * currentEntry above. After that, we never clear it.
       */

					v = mime.BEncoding.Encode("UTF-8", v)
				} else {
					v = mime.QEncoding.Encode("UTF-8", v)
				}
			}
			w.Header()[strings.ToLower(k)] = []string{v}
			isSet = true
			break
		}

		if !isSet {
			w.Header().Set(k, v)
		}
	}

	var start, rangeLen int64
	totalObjectSize, err := objInfo.GetActualSize()
	if err != nil {
		return err
	}

	return "minio_" + s
}

// isDescendantOf returns true if it is a descendant of (or the same as)
// `ancestor`.
//
// For example:
//
//	 	/a, /a/b, /a/b/c are all descendants of /a.
//		/abc or /abd/a are not descendants of /ab.
func (cp collectorPath) isDescendantOf(arg string) bool {
	descendant := string(cp)
	if descendant == arg {
		return true
	}
	if len(arg) >= len(descendant) {
		return false
	}

                break;
            default:
                throw new IllegalArgumentException("Unknown source [" + source + "]");
        }
        fetchContext = new FetchSourceContext(
            true,
            Strings.splitStringByCommaToArray(includes),
            Strings.splitStringByCommaToArray(excludes)
        );
        includesSet = Set.of(fetchContext.includes());

    @Test
    @DisplayName("Should handle retry policy correctly")
    void testRetryPolicy() {
        // Given
        SmbOperationException.RetryPolicy policy = new SmbOperationException.RetryPolicy(3, 1000, 10000, 2.0, true);

        exception = new SmbOperationException(SmbOperationException.ErrorCode.CONNECTION_TIMEOUT, "Timeout occurred", null, policy, null);

        // When/Then - Should retry for attempts 1 and 2

      .build()
  }

  internal fun lookupDecompressor(encoding: String): DecompressionAlgorithm? =
    algorithms.find {
      it.encoding.equals(encoding, ignoreCase = true)
    }

  /**
   * A decompression algorithm such as Gzip. Must provide the Accept-Encoding value and decompress a Source.
   */
  interface DecompressionAlgorithm {
    val encoding: String

      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    call1.execute().use { response -> response.body.string() }

    listener.shouldClose = true
    // Large headers are a likely reason the servers would cut off the connection before it completes sending
    // request headers.
    // 431 "Request Header Fields Too Large"
    val largeHeaders =
      Headers

  }

  @Override
  public void forEach(Consumer<? super K> action) {
    checkNotNull(action);
    map.forEach((k, v) -> action.accept(k));
  }

  @Override
  boolean isPartialView() {
    return true;
  }

  // redeclare to help optimizers with b/310253115
  @SuppressWarnings("RedundantOverride")
  @Override
  @J2ktIncompatible
  @GwtIncompatible
    Object writeReplace() {
    return super.writeReplace();

    return ordering.<@NonNull S>nullsLast();
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof NullsFirstOrdering) {
      NullsFirstOrdering<?> that = (NullsFirstOrdering<?>) object;
      return this.ordering.equals(that.ordering);
    }
    return false;
  }

        assertContains(message, "manyReason");
    }

    private void assertContains(final String s, final String contained) {
        assertThat(s, s.indexOf(contained) > -1, is(true));
    }