.add(BigInteger.valueOf(Integer.MAX_VALUE).add(bigI))
          .add(BigInteger.valueOf(Integer.MIN_VALUE).add(bigI))
          .add(BigInteger.ONE.shiftLeft(63).add(bigI))
          .add(BigInteger.ONE.shiftLeft(64).add(bigI));
    }
    TEST_LONGS = testLongsBuilder.build();
    TEST_BIG_INTEGERS = testBigIntegersBuilder.build();
  }

  public void testAsUnsignedAndLongValueAreInverses() {

@REM ----------------------------------------------------------------------------
@REM Licensed to the Apache Software Foundation (ASF) under one
@REM or more contributor license agreements.  See the NOTICE file
@REM distributed with this work for additional information
@REM regarding copyright ownership.  The ASF licenses this file
@REM to you under the Apache License, Version 2.0 (the
@REM "License"); you may not use this file except in compliance

        try (final ResponseData responseData = smbClient.doGet(baseUrl + "none")) {
            assertEquals(0, responseData.getStatus());
            assertEquals(404, responseData.getHttpStatusCode());
            assertEquals(0, responseData.getContentLength());
            assertNull(responseData.getResponseBody());
            assertEquals(baseUrl + "none", responseData.getUrl());
        }

        try {

  static void checkCast(Class<?> clazz, Object obj) {}

  static <T> T[] clone(T[] array) {
    return (T[]) Arrays.copyOfRange(array, 0, array.length);
  }

  // TODO: Consolidate different copies in one single place.
  static String format(String template, Object... args) {
    // start substituting the arguments into the '%s' placeholders
    StringBuilder builder = new StringBuilder(template.length() + 16 * args.length);

import java.util.concurrent.Callable;
import org.jspecify.annotations.Nullable;

/**
 * A listening executor service which forwards all its method calls to another listening executor
 * service. Subclasses should override one or more methods to modify the behavior of the backing
 * executor service as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

       * that behavior is undefined when the backing map is modified through another API. (It even
       * permits us to throw IllegalStateException. Maybe we should have done that, but we probably
       * shouldn't change now for fear of breaking people.)
       */
      return (lastKnownIndex == -1) ? unsafeNull() : value(lastKnownIndex);
    }

    @Override

    }
  }

  /**
   * Ensures that all interface methods of {@code forwarderClass} are forwarded to the {@link
   * ForwardingObject#delegate}. {@code forwarderClass} is assumed to only implement one interface.
   */
  static <T extends ForwardingObject> void testForwardingObject(Class<T> forwarderClass) {
    List<Class<?>> interfaces = new ArrayList<>(Arrays.asList(forwarderClass.getInterfaces()));

  /**
   * Indicates that the constructor or factory method of a map, usually an immutable map, throws an
   * {@link IllegalArgumentException} when presented with duplicate keys instead of discarding all
   * but one.
   */
  REJECTS_DUPLICATES_AT_CREATION,

  GENERAL_PURPOSE(SUPPORTS_PUT, SUPPORTS_REMOVE);

  private final Set<Feature<? super Map>> implied;

  MapFeature(Feature<? super Map>... implied) {

 *
 * <p>This class manages a collection of {@link SmbAuthentication} objects, each associated
 * with a specific path prefix. When a path is provided, it iterates through the stored
 * authentications to find the one whose path prefix matches the beginning of the given path.
 * This allows for different SMB shares to use different authentication credentials.</p>
 *
 */
public class SmbAuthenticationHolder {

@NullMarked
public abstract class TestStringMapGenerator implements TestMapGenerator<String, String> {

  @Override
  public SampleElements<Entry<String, String>> samples() {
    return new SampleElements<>(
        mapEntry("one", "January"),
        mapEntry("two", "February"),
        mapEntry("three", "March"),
        mapEntry("four", "April"),
        mapEntry("five", "May"));
  }

  @Override