assertNull(projectRegistry.getProject(otherRoot.getPath()));
        assertEquals(new TreeSet<ProjectInternal>(), projectRegistry.getAllProjects(otherRoot.getPath()));
        assertEquals(new TreeSet<ProjectInternal>(), projectRegistry.getSubProjects(otherRoot.getPath()));
        assertNull(projectRegistry.getProject(otherRoot.getProjectDir()));
    }

    @Test

 * new "API class" with them.
 */
public class ApiMemberSelector extends ClassVisitor {

    private final SortedSet<MethodMember> methods = new TreeSet<>();
    private final SortedSet<FieldMember> fields = new TreeSet<>();
    private final SortedSet<InnerClassMember> innerClasses = new TreeSet<>();

    private final String className;
    private final ApiMemberWriter apiMemberWriter;
    private final boolean apiIncludesPackagePrivateMembers;

import java.util.SortedSet;
import java.util.TreeSet;

public class MethodMember extends TypedMember implements Comparable<MethodMember> {
    private static final Ordering<Iterable<String>> LEXICOGRAPHICAL_ORDERING = Ordering.<String>natural().lexicographical();
    private final SortedSet<String> exceptions = new TreeSet<>();
    private final SortedSet<AnnotationMember> parameterAnnotations = new TreeSet<>();

        return new TreeSet<>(projectRegistry.getSubProjects(relativeTo.getPath()));
    }

    @Override
    public Set<? extends ProjectInternal> getAllprojects(ProjectInternal referrer, ProjectInternal relativeTo) {
        return new TreeSet<>(projectRegistry.getAllProjects(relativeTo.getPath()));
    }

    @Override

import com.google.common.collect.ImmutableSortedSet;

import java.util.Collection;
import java.util.SortedSet;
import java.util.TreeSet;

public class AnnotationMember extends Member implements Comparable<AnnotationMember> {

    private final SortedSet<AnnotationValue<?>> values = new TreeSet<>();
    private final boolean visible;

    public AnnotationMember(String name, boolean visible) {
        super(name);

 */
package org.gradle.api.internal.artifacts.ivyservice.ivyresolve.verification.report;

import java.util.Set;
import java.util.TreeSet;

class ReportState implements VerificationHighLevelErrors {
    private final Set<String> affectedFiles = new TreeSet<>();
    private boolean maybeCompromised;
    private boolean hasMissing;
    private boolean failedSignatures;
    private boolean hasUntrustedKeys;

 */

package org.gradle.cache.internal;

import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory;
import org.gradle.util.GradleVersion;

import java.util.SortedSet;
import java.util.TreeSet;

public class UsedGradleVersionsFromGradleUserHomeCaches implements UsedGradleVersions {

    private final VersionSpecificCacheDirectoryScanner directoryScanner;

package org.gradle.execution.plan;

import java.util.ArrayList;
import java.util.List;
import java.util.NavigableSet;
import java.util.Set;
import java.util.TreeSet;

public final class NodeSets {

    public static NavigableSet<Node> newSortedNodeSet() {
        return new TreeSet<>(NodeComparator.INSTANCE);
    }

    public static List<Node> sortedListOf(Set<Node> nodes) {
        List<Node> sorted = new ArrayList<>(nodes);

import java.util.SortedSet;
import java.util.TreeSet;

public final class SetsFilterSortedSetTest
    extends AbstractFilteredSortedSetTest<SortedSet<Integer>> {
  @Override
  SortedSet<Integer> createUnfiltered(Iterable<Integer> contents) {
    final TreeSet<Integer> result = Sets.newTreeSet(contents);
    // we have to make the result not Navigable

        CopyOnWriteArrayList(readList())
    }
)


val treeSetCodec: Codec<TreeSet<Any?>> = codec(
    {
        write(it.comparator())
        writeCollection(it)
    },
    {
        @Suppress("unchecked_cast")
        val comparator = read() as Comparator<Any?>?
        readCollectionInto { TreeSet(comparator) }
    }
)


val copyOnWriteArraySetCodec: Codec<CopyOnWriteArraySet<Any?>> = codec(