// This is like a filter but overrides all transitive versions
    private Map<String, Artifact> managedVersionMap;

    private boolean resolveRoot = true;

    private boolean resolveTransitively = false;

    private boolean offline;

    private boolean forceUpdate;

    private List<Server> servers;

    private List<Mirror> mirrors;

    private List<Proxy> proxies;

        }

        @Override
        public boolean isRequestedSessionIdFromCookie() {
            return false;
        }

        @Override
        public boolean isRequestedSessionIdFromURL() {
            return false;
        }

        @Override
        public boolean authenticate(jakarta.servlet.http.HttpServletResponse response) {
            return false;
        }

        @Override

    void testIsValidReturnsTrue() {
        // Arrange
        when(negotiationResponse.isValid(cifsContext, negotiationRequest)).thenReturn(true);

        // Act
        boolean result = negotiationResponse.isValid(cifsContext, negotiationRequest);

        // Assert
        assertTrue(result);
        verify(negotiationResponse).isValid(cifsContext, negotiationRequest);
    }

    @Test

    @Override
    public boolean addAll(final int index, final Collection<? extends Map<String, Object>> c) {
        return parent.addAll(index, c);
    }

    @Override
    public void clear() {
        parent.clear();
    }

    @Override
    public boolean contains(final Object o) {
        return parent.contains(o);
    }

    @Override
    public boolean containsAll(final Collection<?> c) {

        @Override
        public boolean removeAll(Collection<?> c) {
            throw uoe();
        }

        @Override
        public boolean add(E e) {
            throw uoe();
        }

        @Override
        public boolean remove(Object o) {
            throw uoe();
        }

        @Override
        public boolean retainAll(Collection<?> c) {
            throw uoe();

  public final boolean addAll(Collection<? extends E> newElements) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final boolean removeAll(Collection<?> oldElements) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final boolean removeIf(Predicate<? super E> predicate) {
    throw new UnsupportedOperationException();
  }

  @Override

    }

    @Override
    public String getPackaging() {
        return packaging;
    }

    public void setIncludesDependencies(boolean includesDependencies) {
        this.includesDependencies = includesDependencies;
    }

    @Override
    public boolean isIncludesDependencies() {
        return includesDependencies;
    }

    public void setLanguage(String language) {
        this.language = language;

            @Override
            public boolean isChangedClusterState(int status) {
                return true;
            }

            @Override
            public String getHostname() {
                return "test-hostname";
            }
        };

        FessConfig fessConfig = new TestFessConfig() {
            @Override
            public boolean hasNotification() {
                return true;

 * </p>
 *
 * @author koichik
 */
public class ClassIterator implements Iterator<Class<?>> {

    /** The class */
    protected Class<?> clazz;

    /** If {@link Object} class should also be iterated, set to {@literal true} */
    protected final boolean includeObject;

    /**

    }

    public boolean isVersionedVertices() {
        return versionedVertices;
    }

    public void setVersionedVertices(boolean versionedVertices) {
        this.versionedVertices = versionedVertices;
    }

    public boolean isScopedVertices() {
        return scopedVertices;
    }

    public void setScopedVertices(boolean scopedVertices) {