assertArrayEquals(originalContext.getHashAlgos(), decodedContext.getHashAlgos());
            assertArrayEquals(originalContext.getSalt(), decodedContext.getSalt());
            assertEquals(originalContext.size(), decodedContext.size());
        }

        @Test
        @DisplayName("Should handle buffer boundaries correctly")

        // Assert - Verify URL components
        assertEquals("smb", url1.getProtocol());
        assertEquals("host", url1.getHost());
        assertEquals(445, url1.getPort());
        assertEquals("/share", url1.getPath());

        assertEquals("smb", url2.getProtocol());
        assertEquals("host", url2.getHost());
        assertEquals(1234, url2.getPort());
        assertEquals("/share/file.txt", url2.getPath());

    E duplicate = arrayAndDuplicate.duplicate;

    int firstIndex = getList().indexOf(duplicate);
    int initialSize = getList().size();
    assertTrue("remove(present) should return true", getList().remove(duplicate));
    assertTrue(
        "After remove(duplicate), a list should still contain the duplicate element",
        getList().contains(duplicate));
    assertFalse(

            assertEquals(PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE, context.getContextType());
            assertArrayEquals(hashAlgos, context.getHashAlgos());
            assertArrayEquals(salt, context.getSalt());
        }

        @Test
        @DisplayName("Should create context with default constructor")
        void testDefaultConstructor() {
            context = new PreauthIntegrityNegotiateContext();

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListIndexOfTester<E> extends AbstractListIndexOfTester<E> {
  @Override
  protected int find(Object o) {
    return getList().indexOf(o);
  }

  @Override
  protected String getMethodName() {
    return "indexOf";
  }

  @CollectionFeature.Require(absent = REJECTS_DUPLICATES_AT_CREATION)

  @CollectionSize.Require(SEVERAL)
  public void testRetainAll_countIgnored() {
    resetContainer(getSubjectGenerator().create(e0(), e2(), e1(), e0()));
    assertTrue(getList().retainAll(asList(e0(), e1())));
    assertContentsInOrder(getList(), e0(), e1(), e0());
  }

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListLastIndexOfTester<E> extends AbstractListIndexOfTester<E> {
  @Override
  protected int find(Object o) {
    return getList().lastIndexOf(o);
  }

  @Override
  protected String getMethodName() {
    return "lastIndexOf";
  }

  @CollectionFeature.Require(absent = REJECTS_DUPLICATES_AT_CREATION)

    assertTrue(
        "addAll(allPresent) should return true", getList().addAll(MinimalCollection.of(e0())));
    expectAdded(e0());
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAll_unsupportedAllPresent() {
    assertThrows(
        UnsupportedOperationException.class, () -> getList().addAll(MinimalCollection.of(e0())));
    expectUnchanged();
  }

        ftpInfo = new FtpClient.FtpInfo(value, Constants.UTF_8);
        assertEquals(value, ftpInfo.toUrl());
        assertEquals("123.123.123.123:9999", ftpInfo.getCacheKey());
        assertEquals("123.123.123.123", ftpInfo.getHost());
        assertEquals(9999, ftpInfo.getPort());
        assertEquals("/", ftpInfo.getParent());
        assertNull(ftpInfo.getName());

        value = "ftp://123.123.123.123/test.txt";

    assertTrue(
        "removeAll(intersectingCollection) should return true",
        getList().removeAll(MinimalCollection.of(duplicate)));
    assertFalse(
        "after removeAll(e), a collection should not contain e even "
            + "if it initially contained e more than once.",
        getList().contains(duplicate));
  }

  // All other cases are covered by CollectionRemoveAllTester.