* of the same type exist in the container, the one with the highest
     * priority value will be selected for injection.
     * <p>
     * There are no predefined minimum or maximum values, but it's recommended
     * to use values that allow for future adjustments (e.g., using values
     * like 100, 200, 300 rather than consecutive numbers).
     *
     * @return the priority value for ordering

  /**
   * Returns a range, closed on both ends, whose endpoints are the minimum and maximum values
   * contained in this set. This is equivalent to {@code range(CLOSED, CLOSED)}.
   *
   * @throws NoSuchElementException if this set is empty
   */
  public abstract Range<C> range();

  /**
   * Returns the minimal range with the given boundary types for which all values in this set are

  static final int HASH_TABLE_BITS_MASK = (1 << HASH_TABLE_BITS_MAX_BITS) - 1;

  /** Maximum size of a compact hash-based collection (2^30 - 1 because 0 is UNSET). */
  static final int MAX_SIZE = Ints.MAX_POWER_OF_TWO - 1;

  /** Default size of a compact hash-based collection. */
  static final int DEFAULT_SIZE = 3;

  /**
   * Minimum size of the hash table of a compact hash-based collection. Because small hash tables

        ),
    ] = None,
    min_length: Annotated[
        Optional[int],
        Doc(
            """
            Minimum length for strings.
            """
        ),
    ] = None,
    max_length: Annotated[
        Optional[int],
        Doc(
            """
            Maximum length for strings.
            """
        ),
    ] = None,
    pattern: Annotated[
        Optional[str],

        .withRefreshes(ImmutableSet.of(DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)));
  }

  private static void warmUp(LoadingCache<Object, Object> cache, int minimum, int maximum) {
    for (int i = minimum; i < maximum; i++) {
      cache.getUnchecked(i);
    }
  }

  private Entry<Object, Object> entryOf(Object key, Object value) {
    return Maps.immutableEntry(key, value);
  }

        .withRefreshes(ImmutableSet.of(DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)));
  }

  private static void warmUp(LoadingCache<Object, Object> cache, int minimum, int maximum) {
    for (int i = minimum; i < maximum; i++) {
      cache.getUnchecked(i);
    }
  }

  private Entry<Object, Object> entryOf(Object key, Object value) {
    return Maps.immutableEntry(key, value);
  }

 */
class AddressPolicy(
  /**
   * How many concurrent calls should be possible to make at any time.
   * The pool will routinely try to pre-emptively open connections to satisfy this minimum.
   * Connections will still be closed if they idle beyond the keep-alive but will be replaced.
   */
  @JvmField val minimumConcurrentCalls: Int = 0,
  /** How long to wait to retry pre-emptive connection attempts that fail. */

        when:
        UpdateKotlinVersions.selectVersionsFrom(minimumSupported, allVersions)

        then:
        def ex = thrown(IllegalArgumentException)
        ex.message == "Minimum supported '1.9.10' was not found in available versions: [2.0.0, 2.0.0-RC1, 2.0.0-Beta1]"
    }

        }
    }

    @Test
    @DisplayName("Test decode with minimum buffer size")
    void testDecodeWithMinimumBuffer() throws SMBProtocolDecodingException {
        // Create buffer with exact size needed
        byte[] buffer = new byte[8];
        long value = 42L;
        SMBUtil.writeInt8(value, buffer, 0);

        // Decode with minimum length
        int bytesRead = fileInfo.decode(buffer, 0, 8);

    }

    /**
     * Gets the minimum port number for active mode FTP.
     *
     * @return The minimum port number
     */
    public int getActiveMinPort() {
        return activeMinPort;
    }

    /**
     * Sets the minimum port number for active mode FTP.
     *
     * @param activeMinPort The minimum port number
     */