"next() should still return last element after peeking", "C", peekingIterator.next());

    assertThrows(NoSuchElementException.class, () -> peekingIterator.peek());
    assertThrows(NoSuchElementException.class, () -> peekingIterator.peek());
    assertThrows(NoSuchElementException.class, () -> peekingIterator.next());
  }

  public void testCantRemoveAfterPeek() {
    List<String> list = Lists.newArrayList("A", "B", "C");

  @Synchronized fun writeSuccessCount(): Int = writeSuccessCount

  @Throws(IOException::class)
  fun size(): Long = cache.size()

  /** Max size of the cache (in bytes). */
  fun maxSize(): Long = cache.maxSize

  @Throws(IOException::class)
  override fun flush() {
    cache.flush()
  }

  @Throws(IOException::class)
  override fun close() {
    cache.close()
  }

  @get:JvmName("directory")

import jcifs.SmbSession;

/**
 * Tests for SmbTreeHandleInternal interface using Mockito to verify
 * interactions and observable behavior of collaborators.
 */
@ExtendWith(MockitoExtension.class)
public class SmbTreeHandleInternalTest {

    @Mock
    private SmbTreeHandleInternal handle;

    @Test
    @DisplayName("release(): verifies it is invoked exactly once")
    void release_invokedOnce() throws Exception {

        container.singleton("mimeTypeHelper", MimeTypeHelperImpl.class)
                .singleton("tikaExtractor", TikaExtractor.class)
                .singleton("zipExtractor", ZipExtractor.class)
                .<ExtractorFactory> singleton("extractorFactory", ExtractorFactory.class, factory -> {

import jcifs.internal.smb2.ServerMessageBlock2Request;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;

/**
 * Test class for Smb2ReadRequest functionality
 */
@DisplayName("Smb2ReadRequest Tests")
class Smb2ReadRequestTest {

    @Mock
    private Configuration mockConfig;

    @Mock
    private CIFSContext mockContext;

    private byte[] testFileId;

    Files.write(ASCII, temp1, UTF_8);
    assertThrows(IllegalArgumentException.class, () -> Files.copy(temp1, temp2));
    assertEquals(ASCII, Files.toString(temp1, UTF_8));
  }

  public void testCopySameFile() throws IOException {
    File temp = createTempFile();
    Files.write(ASCII, temp, UTF_8);
    assertThrows(IllegalArgumentException.class, () -> Files.copy(temp, temp));
    assertEquals(ASCII, Files.toString(temp, UTF_8));

    }

    @Override
    protected Class<? extends WebConfig> typeOfSelectedEntity() {
        return WebConfig.class;
    }

    @Override
    protected Class<WebConfig> typeOfHandlingEntity() {
        return WebConfig.class;
    }

    @Override
    protected Class<WebConfigCB> typeOfHandlingConditionBean() {
        return WebConfigCB.class;
    }

import jakarta.annotation.Resource;

/**
 * Implementation of the {@link UrlQueueService} interface.
 * This class provides methods for managing a queue of URLs to be crawled,
 * including adding, deleting, and retrieving URLs from the queue.
 * It uses a {@link MemoryDataHelper} to store the URL queue data in memory.
 *
 * <p>
 * The class is responsible for:
 * </p>
 * <ul>
 *   <li>Updating session IDs for URL queues.</li>

import jakarta.annotation.Resource;

/**
 * Service class for managing failure URLs that occur during web crawling.
 * Provides functionality to store, retrieve, and manage failed crawling attempts
 * with their associated error information.
 */
public class FailureUrlService {

    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(FailureUrlService.class);

    /**
     * Default constructor.

        mockConfig = Mockito.mock(Configuration.class);
        mockCredentials = Mockito.mock(Credentials.class);
        mockCredentialsInternal = Mockito.mock(CredentialsInternal.class);

        Mockito.when(mockContext.getConfig()).thenReturn(mockConfig);
        Mockito.when(mockContext.getCredentials()).thenReturn(mockCredentials);
        Mockito.when(mockCredentials.unwrap(Mockito.any())).thenReturn(mockCredentialsInternal);