* @author higa
 * @param <E> the element type
 */
public class SLinkedList<E> implements Cloneable, Externalizable {

    static final long serialVersionUID = 1L;

    private transient Entry header = new Entry(null, null, null);

    private transient int size = 0;

    /**
     * Creates an {@link SLinkedList}.
     */
    public SLinkedList() {
        header.next = header;
        header.previous = header;
    }

        queue.setMethod(null);
        assertNull(queue.getMethod());
    }

    public void test_urlGetterSetter() {
        // Test URL getter/setter
        UrlQueueImpl<Long> queue = new UrlQueueImpl<>();

        String url = "https://example.com/path";
        queue.setUrl(url);
        assertEquals(url, queue.getUrl());

        queue.setUrl(null);
        assertNull(queue.getUrl());
    }

     * @param url the URL to convert
     * @return the converted URL after applying all duplicate host rules,
     *         or null if the input URL is null
     */
    public String convert(final String url) {
        if (url == null) {
            return null;
        }

        if (duplicateHostList == null) {
            init();
        }

        String newUrl = url;

 * NullPointerException} or {@link UnsupportedOperationException} whenever null is passed to a
 * parameter whose declaration or type isn't annotated with an annotation with the simple name
 * {@code Nullable}, {@code CheckForNull}, {@code NullableType}, or {@code NullableDecl}.
 *
 * <p>The tested methods and constructors are invoked -- each time with one parameter being null and
 * the rest not null -- and the test fails if no expected exception is thrown. {@code

        if (scopesToCollect == null) {
            scopesToCollect = Collections.emptySet();
        }
        if (scopesToResolve == null) {
            scopesToResolve = Collections.emptySet();
        }

        if (scopesToCollect.isEmpty() && scopesToResolve.isEmpty()) {
            return new SetWithResolutionResult(null, new LinkedHashSet<>());
        }

                    plugin, session.getCurrentProject().getRemotePluginRepositories(), session.getRepositorySession());

            pluginManager.setupPluginRealm(pluginDescriptor, session, null, null, null);
        } catch (Exception e) {
            throw new PluginManagerException(plugin, e.getMessage(), e);
        }

        ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();

     * @return The effective repositories or {@code null} if the input was {@code null}.
     */
    List<ArtifactRepository> getEffectiveRepositories(List<ArtifactRepository> repositories);

    /**
     * Determines the mirror for the specified repository.
     *
     * @param repository The repository to determine the mirror for, must not be {@code null}.

 *
 * <p>A converter always converts {@code null} to {@code null} and non-null references to non-null
 * references. It would not make sense to consider {@code null} and a non-null reference to be
 * "different representations of the same information", since one is distinguishable from
 * <i>missing</i> information and the other is not. The {@link #convert} method handles this null

        pageSize = getDefaultPageSize();
        currentPageNumber = getDefaultCurrentPageNumber();

        id = null;
        regex = null;
        replacement = null;
        processType = null;
        sortOrder = null;
        createdBy = null;
        createdTime = null;
        versionNo = null;

    }

    /**
     * Gets the default current page number.
     *

        ProjectBuildLogAppender.setProjectId(null);
    }

    @Override
    public void forkedProjectFailed(ExecutionEvent event) {
        setMdc(event);
        delegate.forkedProjectFailed(event);
        ProjectBuildLogAppender.setProjectId(null);
    }

    private void setMdc(ExecutionEvent event) {
        if (event.getProject() != null) {