import static java.util.stream.Collectors.toSet;

@NonNullApi
class Intersections {
    private final ExcludeFactory factory;
    private final List<Intersection<? extends ExcludeSpec, ? extends ExcludeSpec>> intersections = new ArrayList<>();

    public Intersections(ExcludeFactory factory) {
        this.factory = factory;

        // For the Any intersections, be sure to add the more specific type first, so it gets used if applicable

@CompileStatic
trait ExcludeTestSupport {

    @Shared
    ExcludeFactory factory = new DefaultExcludeFactory()

    ExcludeSpec group(String group) {
        factory.group(group)
    }

    ExcludeSpec module(String name) {
        factory.module(name)
    }

    ExcludeSpec moduleSet(String... names) {
        factory.moduleSet(RandomizedIteratorHashSet.of(names as Set<String>))
    }

        then:
        factory.communicationAddresses == [InetAddress.getByName(null)]
    }

    def "communication addresses are detected"() {
        when:
        loopbackAddresses([ip(127, 0, 0, 1), ip(127, 0, 0, 2)])

        then:
        factory.communicationAddresses.every {
            factory.isCommunicationAddress(it)
        }

        !factory.isCommunicationAddress(ip(127, 0, 0, 3))
    }

import org.gradle.api.internal.tasks.testing.TestClassRunInfo
import org.gradle.api.internal.tasks.testing.TestResultProcessor
import org.gradle.internal.Factory
import spock.lang.Specification

class RestartEveryNTestClassProcessorTest extends Specification {
    private final Factory<TestClassProcessor> factory = Mock();
    private final TestClassProcessor delegate = Mock();
    private final TestClassRunInfo test1 = Mock();

    private final CrawlerClientFactory factory;

    private final Map<String, Object> params = new HashMap<>();

    public CrawlerClientFactoryWrapper(final CrawlerClientFactory factory) {
        this.factory = factory;
    }

    public CrawlerClientFactory getParent() {
        return factory;
    }

    @Override

        when:
        def node = factory.getOrCreateNode(a)

        then:
        factory.getOrCreateNode(a).is(node)
    }

    void 'can add multiple nodes'() {
        when:
        factory.getOrCreateNode(a)
        factory.getOrCreateNode(b)

        then:
        factory.tasks == [a, b] as Set
    }

    void 'reset state'() {
        when:
        factory.getOrCreateNode(a)

        for (ManagedFactory factory : factories) {
            register(factory);
        }
        return this;
    }

    @Override
    @Nullable
    public ManagedFactory lookup(int id) {
        ManagedFactory factory = managedFactoryCache.getIfPresent(id);
        if (factory == null && parent != null) {
            factory = parent.lookup(id);
        }
        return factory;
    }

      throws InvocationTargetException, IllegalAccessException {
    T returnValue = factory.invoke(null, args.toArray());
    if (returnValue == null) {
      Assert.assertTrue(
          factory + " returns null but it's not annotated with @Nullable", isNullable(factory));
    }
    return returnValue;
  }

  /**

    <T> T withLocks(Collection<? extends ResourceLock> locks, Factory<T> factory) {
        return factory.create()
    }

    @Override
    void withLocks(Collection<? extends ResourceLock> locks, Runnable action) {
        action.run()
    }

    @Override
    <T> T withoutLocks(Collection<? extends ResourceLock> locks, Factory<T> factory) {
        return factory.create()
    }

    @Override

        def actor2 = factory.createActor(target)

        then:
        actor2.is(actor1)
    }

    def returnsTargetObjectIfTargetObjectIsAnActor() {
        when:
        def actor1 = factory.createActor(target)
        def actor2 = factory.createActor(actor1)

        then:
        actor2.is(actor1)
    }

    def nonBlockingActorAndProxyAreBothMarkedAsThreadSafe() {