}

    @Test
    @DisplayName("Test getNext returns null when no chained message")
    void testGetNextWithNoChainedMessage() {
        // Given
        when(request.getNext()).thenReturn(null);

        // When
        CommonServerMessageBlockRequest result = request.getNext();

        // Then
        assertNull(result);
        verify(request, times(1)).getNext();
    }

          if (last == UNSET) {
            // we need to update the root link from table[]
            table[tableIndex] = getNext(entries[next]);
          } else {
            // we need to update the link from the chain
            entries[last] = swapNext(entries[last], getNext(entries[next]));
          }

          moveLastEntry(next);
          size--;
          modCount++;
          return oldValue;

    }

    @Override
    public ServerMessageBlock2Request<T> ignoreDisconnect() {
        return this;
    }

    @Override
    public ServerMessageBlock2Request<?> getNext() {
        return (ServerMessageBlock2Request<?>) super.getNext();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Request#isCancel()
     */
    @Override
    public boolean isCancel() {

func (s3 *warmBackendS3) ToObjectError(err error, params ...string) error {
	object := ""
	if len(params) >= 1 {
		object = params[0]
	}

	return ErrorRespToObjectError(err, s3.Bucket, s3.getDest(object))
}

func (s3 *warmBackendS3) getDest(object string) string {
	destObj := object
	if s3.Prefix != "" {
		destObj = fmt.Sprintf("%s/%s", s3.Prefix, object)
	}
	return destObj
}

     * @return the new first entry for the table
     */
    @GuardedBy("this")
    @Nullable E removeFromChain(E first, E entry) {
      int newCount = count;
      E newFirst = entry.getNext();
      for (E e = first; e != entry; e = e.getNext()) {
        E next = copyEntry(e, newFirst);
        if (next != null) {
          newFirst = next;
        } else {
          newCount--;
        }
      }

  @CollectionFeature.Require(SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  public void testAdd_supportedPresent() {
    assertFalse("add(present) should return false", getSet().add(e0()));
    expectUnchanged();
  }

  @CollectionFeature.Require(value = {SUPPORTS_ADD, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)
  public void testAdd_supportedNullPresent() {

      expectedHashCode += (element == null) ? 0 : element.hashCode();
    }
    assertEquals(
        "A Set's hashCode() should be the sum of those of its elements.",
        expectedHashCode,
        getSet().hashCode());
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  @CollectionFeature.Require(ALLOWS_NULL_VALUES)
  public void testHashCode_containingNull() {

        ReferenceEntry<K, V> first, ReferenceEntry<K, V> entry) {
      int newCount = count;
      ReferenceEntry<K, V> newFirst = entry.getNext();
      for (ReferenceEntry<K, V> e = first; e != entry; e = e.getNext()) {
        ReferenceEntry<K, V> next = copyEntry(e, newFirst);
        if (next != null) {
          newFirst = next;
        } else {
          removeCollectedEntry(e);

        list.addLast("3");
        SLinkedList<String>.Entry e = list.getFirstEntry();
        assertThat(e.getPrevious(), is(nullValue()));
        assertThat(e.getNext().getElement(), is("2"));
        e = list.getLastEntry();
        assertThat(e.getNext(), is(nullValue()));
        assertThat(e.getPrevious().getElement(), is("2"));
        list.getEntry(1).remove();
        assertThat(list.getFirst(), is("1"));

        // Assert
        assertEquals("smb", url.getProtocol());
        assertEquals(SmbConstants.DEFAULT_PORT, url.getPort(), "Default port applied for root smb URL");
        assertNull(url.getRef(), "Ref should remain null for root URL");
    }

    @Test
    @DisplayName("parseURL: fragment is moved into path and ref cleared")
    void testParseURL_FragmentMovedToPath() throws MalformedURLException {