expected: Audiences{},
		},
	}
	for _, c := range cs {
		t.Run("auds", func(t *testing.T) {
			if got, want := c.auds.Intersect(c.tauds), c.expected; !reflect.DeepEqual(got, want) {
				t.Errorf("unexpected intersection.\ngot:\t%v\nwant:\t%v", got, want)
			}
		})
	}

    public ExcludeSpec allOf(Set<ExcludeSpec> specs) {
        return caches.getAllOf(new ExcludesKey(specs), key -> delegate.allOf(key.specs));
    }

    /**
     * A special key which recognizes the fact union and intersection
     * are commutative.
     */
    private final static class ExcludePair {
        private final ExcludeSpec left;
        private final ExcludeSpec right;
        private final int hashCode;

 * to the current closures chain and can potentially be intercepted. The implementation must ensure that all the closures in the scope are processed in a way that
 * ensures call interception if a call is dispatched to them.
 */
@NonNullApi
public interface InstrumentedClosuresTracker {
    void enterClosure(InstrumentableClosure thisClosure);
    void leaveClosure(InstrumentableClosure thisClosure);

            plugins {
                id 'java'
            }
            sourceSets {
                main.resources.srcDir 'src/main/java'
                main.resources.exclude '**/*.kt' // Forces an intersection pattern set to be created behind the scenes
            }
        '''
        createDir('src/main') {
            dir('java') {
                file('Test.java') << 'class Test {}'
            }

	AXB := tree([]int32{1, 2, 5, 6, 7})

	aib1 := A.Intersection(B, first)
	assert(t, AIB, aib1, "aib1")
	if A.Find(3) != aib1.Find(3) {
		t.Errorf("Failed aliasing/reuse check, A/aib1")
	}
	aib2 := A.Intersection(B, second)
	assert(t, AIB, aib2, "aib2")
	if B.Find(3) != aib2.Find(3) {
		t.Errorf("Failed aliasing/reuse check, B/aib2")
	}
	aib3 := B.Intersection(A, first)
	assert(t, AIB, aib3, "aib3")

- Get working code on a personal branch with tests before you submit a PR.
- OkHttp is a small and light dependency.  Don't introduce new dependencies or major new functionality.
- OkHttp targets the intersection of RFC correct *and* widely implemented.  Incorrect implementations that are very widely implemented e.g. a bug in Apache, Nginx, Google, Firefox should also be handled.

 * It only intercepts the calls where the receiver is the class of interest.
 * <p>
 * It is possible but not strictly necessary to use this interceptor to intercept constructors.
 * Due to the way constructor interception works, having an {@link InterceptScope#constructorsOf(Class)
 * as a scope already guarantees that the invocation would have the given class object as the receiver.
 */

import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.stream.Collectors;

/**
 * Writes all instrumented types with inherited method interception to a resources
 */
public class InstrumentedTypesResourceGenerator implements InstrumentationResourceGenerator {
    @Override

    super(domain);
    this.range = range;
  }

  private ContiguousSet<C> intersectionInCurrentDomain(Range<C> other) {
    return range.isConnected(other)
        ? ContiguousSet.create(range.intersection(other), domain)
        : new EmptyContiguousSet<C>(domain);
  }

  @Override
  ContiguousSet<C> headSetImpl(C toElement, boolean inclusive) {

                    .map(RequestExtra.InterceptGroovyCalls::getInterceptionType)
                    .orElseThrow(() -> new IllegalStateException("Interception type name is not set for " + request.getInterceptedCallable().getOwner().getType()));
                CallableInfo callable = request.getInterceptedCallable();
                CallableKindInfo kind = callable.getKind();