verify(delegate, times(1)).close();
    }

    @Test
    @DisplayName("remove() delegates to underlying iterator")
    void removeDelegates() {
        // Arrange: no elements - no parent setup needed since no URLs are created
        when(delegate.hasNext()).thenReturn(false);
        NetServerFileEntryAdapterIterator itr = new NetServerFileEntryAdapterIterator(parent, delegate, null);

        // Act

    // you should remove the 'final' if you need to override this
    /**
     * Hook method called before action execution.
     * This method refreshes the user information if a user is logged in
     * and delegates to the view helper's action hook.
     *
     * @param runtime the action runtime context
     * @return the action response, or null to continue with normal processing
     */
    @Override

 *
 * @author Kevin Damm
 * @author Kyle Maddison
 */
final class LittleEndianByteArray {

  /**
   * The instance that actually does the work; delegates to VarHandle, Unsafe, or a Java-8
   * compatible pure-Java fallback.
   */
  private static final LittleEndianBytes byteArray = makeGetter();

  /**

  override fun getLocalPrincipal(): Principal = delegate!!.localPrincipal

  override fun getCipherSuite(): String = delegate!!.cipherSuite

  override fun getProtocol(): String = delegate!!.protocol

  override fun getPeerHost(): String = delegate!!.peerHost

  override fun getPeerPort(): Int = delegate!!.peerPort

  override fun getPacketBufferSize(): Int = delegate!!.packetBufferSize

 * under the License.
 */
package org.apache.maven.repository.legacy.resolver.conflict;

import javax.inject.Named;
import javax.inject.Singleton;

/**
 * The default conflict resolver that delegates to the nearest strategy.
 *
 * @see NearestConflictResolver
 * @deprecated As of 3.0, use a specific implementation instead, e.g. {@link NearestConflictResolver}
 */
@Deprecated
@Named
@Singleton

import javax.net.ssl.SSLSocketFactory

/**
 * A [SSLSocketFactory] that delegates calls. Sockets can be configured after creation by
 * overriding [.configureSocket].
 */
open class DelegatingSSLSocketFactory(
  private val delegate: SSLSocketFactory,
) : SSLSocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): SSLSocket {
    val sslSocket = delegate.createSocket() as SSLSocket
    return configureSocket(sslSocket)
  }

/**
 * A [ServerSocketFactory] that delegates calls. Sockets can be configured after creation by
 * overriding [.configureServerSocket].
 */
open class DelegatingServerSocketFactory(
  private val delegate: ServerSocketFactory,
) : ServerSocketFactory() {
  @Throws(IOException::class)
  override fun createServerSocket(): ServerSocket {
    val serverSocket = delegate.createServerSocket()

/**
 * An SSLSocketFactory that delegates calls. Sockets created by the delegate are wrapped with ones
 * that will not accept the [TLS_FALLBACK_SCSV] cipher, thus bypassing server-side fallback
 * checks on platforms that support it. Unfortunately this wrapping will disable any
 * reflection-based calls to SSLSocket from Platform.
 */
class FallbackTestClientSocketFactory(
  delegate: SSLSocketFactory,

    void emptyIterator() {
        when(delegate.hasNext()).thenReturn(false);

        TestIterator iterator = new TestIterator(null);

        assertFalse(iterator.hasNext());
        assertNull(iterator.next());
    }

    @Test
    @DisplayName("Close delegates to underlying iterator")
    void closeDelegation() throws CIFSException {
        when(delegate.hasNext()).thenReturn(false);

 * the License.
 */
package com.google.common.collect;

import java.util.Collection;
import org.jspecify.annotations.Nullable;

/** Never actually created; instead delegates to JdkBackedImmutableMultiset. */
final class RegularImmutableMultiset<E> extends ImmutableMultiset<E> {
  static final ImmutableMultiset<Object> EMPTY =
      JdkBackedImmutableMultiset.create(ImmutableList.of());