Comparable<?> endpoint() {
      throw new IllegalStateException("range unbounded on this side");
    }

    @Override
    boolean isLessThan(Comparable<?> value) {
      return true;
    }

    @Override
    BoundType typeAsLowerBound() {
      throw new IllegalStateException();
    }

    @Override
    BoundType typeAsUpperBound() {

   * k)), as opposed to e.g. {@code Stream.sorted(comparator).limit(k)}, which currently takes O(n
   * log n) time and O(n) space.
   *
   * @throws IllegalArgumentException if {@code k < 0}
   * @since 22.0
   */
  public static <T extends @Nullable Object> Collector<T, ?, List<T>> least(
      int k, Comparator<? super T> comparator) {
    checkNonnegative(k, "k");

        assertEquals(112, size);
    }

    @Test
    @DisplayName("Should calculate size correctly with contexts")
    void testSizeWithContexts() throws Exception {
        // Given
        when(mockConfig.getMaximumVersion()).thenReturn(DialectVersion.SMB311);
        when(mockConfig.isEncryptionEnabled()).thenReturn(true);

   * Returns the {@code short} value that is equal to {@code value}, if possible.
   *
   * @param value any value in the range of the {@code short} type
   * @return the {@code short} value that equals {@code value}
   * @throws IllegalArgumentException if {@code value} is greater than {@link Short#MAX_VALUE} or
   *     less than {@link Short#MIN_VALUE}
   */
  public static short checkedCast(long value) {
    short result = (short) value;

     * @param artifactCoordinates t
     * @return the version range resolution result
     * @throws VersionResolverException if an errors occurs
     */
    @Nonnull
    default VersionRangeResolverResult resolve(
            @Nonnull Session session, @Nonnull ArtifactCoordinates artifactCoordinates)
            throws VersionResolverException {
        return resolve(VersionRangeResolverRequest.build(session, artifactCoordinates));

  }

  override fun getValueNames(): Array<String> = delegate!!.valueNames

  @Throws(SSLPeerUnverifiedException::class)
  override fun getPeerCertificates(): Array<Certificate>? = delegate!!.peerCertificates

  override fun getLocalCertificates(): Array<Certificate>? = delegate!!.localCertificates

  @Suppress("removal", "OVERRIDE_DEPRECATION")
  @Throws(SSLPeerUnverifiedException::class)

     * @param userToolchainsSource The {@link Source} pointing to the user toolchains, must not be {@code null}
     * @throws ToolchainsBuilderException if the project cannot be created
     * @throws IllegalArgumentException if an argument is {@code null} or invalid
     * @see #build(ToolchainsBuilderRequest)
     */
    @Nonnull
    default ToolchainsBuilderResult build(

    assertThat(Reflection.getPackageName(Map.Entry.class)).isEqualTo("java.util");
  }

  public void testNewProxy() throws Exception {
    Runnable runnable = Reflection.newProxy(Runnable.class, X_RETURNER);
    assertThat(runnable.toString()).isEqualTo("x");
  }

  public void testNewProxyCantWorkOnAClass() throws Exception {
    assertThrows(
        IllegalArgumentException.class, () -> Reflection.newProxy(Object.class, X_RETURNER));

  <T> T getFinalValue(ClosingFuture<T> closingFuture) throws ExecutionException {
    return getUninterruptibly(closingFuture.finishToFuture());
  }

  @Override
  void assertFinallyFailsWithException(ClosingFuture<?> closingFuture) {
    assertThatFutureFailsWithException(closingFuture.finishToFuture());
  }

  @Override
  void assertBecomesCanceled(ClosingFuture<?> closingFuture) throws ExecutionException {

import org.junit.Test;

/**
 * @author koichik
 *
 */
public class ConstructorDescTest {

    /**
     * @throws Exception
     */
    @SuppressWarnings("rawtypes")
    @Test
    public void testDefaultConstructor() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final ConstructorDesc ctor = beanDesc.getConstructorDesc();