pkglist     output list of package import paths
func        output coverage profile information for each function
merge       merge data files together
subtract    subtract one set of data files from another set
intersect   generate intersection of two sets of data files
debugdump   dump data in human-readable format for debugging purposes
`)
	fmt.Fprintf(os.Stderr, "\nFor help on a specific subcommand, try:\n")

					break
				}
				t.Errorf("set.AllocateNext() = %v, want %v", err, cidrset.ErrCIDRRangeNoCIDRsRemaining)
				continue TestCase
			}
			cidrs = append(cidrs, cidr)
		}
		// No allocated CIDR range should intersect with serviceCIDR.
		for _, c := range cidrs {
			if c.Contains(serviceCIDR.IP) || serviceCIDR.Contains(c.IP) {
				t.Errorf("test case %+v: allocated CIDR %v from service range", tc, c)
			}
		}
	}

        Spec<BuildOperationRecord> typeSpec = {
            it.detailsType && detailsType.isAssignableFrom(it.detailsType)
        }
        search(parent, Specs.intersect(typeSpec, predicate))
    }

    @SuppressWarnings(["GrMethodMayBeStatic", "GrUnnecessaryPublicModifier"])

		{"~int | string | myInt", "~string | int", "int | string"},
	} {
		xl := maketl(test.xl)
		yl := maketl(test.yl)
		got := xl.intersect(yl).String()
		if got != test.want {
			t.Errorf("(%v).intersect(%v) = %v; want %v", test.xl, test.yl, got, test.want)
		}
	}
}

func TestTermlistEqual(t *testing.T) {
	for _, test := range []struct {
		xl, yl string
		want   bool

        return filter(element) != null;
    }

    public <S extends T> CollectionFilter<S> and(CollectionFilter<S> other) {
        return new CollectionFilter<>(other.type, Specs.intersect(spec, other.spec));
    }

	targetAuds, ok := AudiencesFrom(ctx)
	// We can remove this once api audiences is never empty. That will probably
	// be N releases after TokenRequest is GA.
	if !ok {
		return authenticate()
	}
	auds := implicitAuds.Intersect(targetAuds)
	if len(auds) == 0 {
		return nil, false, nil
	}
	resp, ok, err := authenticate()
	if err != nil || !ok {
		return nil, false, err
	}
	if len(resp.Audiences) > 0 {

        super(other);
        this.other = other;
    }

    public PatternSet getOther() {
        return other;
    }

    @Override
    public Spec<FileTreeElement> getAsSpec() {
        return Specs.intersect(super.getAsSpec(), other.getAsSpec());
    }

    @Override
    public Object addToAntBuilder(Object node, String childNodeName) {
        return PatternSetAntBuilderDelegate.and(node, new Action<Object>() {

		{"~int | string | myInt", "~string | int", "int | string"},
	} {
		xl := maketl(test.xl)
		yl := maketl(test.yl)
		got := xl.intersect(yl).String()
		if got != test.want {
			t.Errorf("(%v).intersect(%v) = %v; want %v", test.xl, test.yl, got, test.want)
		}
	}
}

func TestTermlistEqual(t *testing.T) {
	for _, test := range []struct {
		xl, yl string
		want   bool

        return (leftType.isInstance(left) && rightType.isInstance(right))
                || (leftType.isInstance(right) && rightType.isInstance(left));
    }

    @Override
    @Nullable
    public ExcludeSpec intersect(ExcludeSpec left, ExcludeSpec right, ExcludeFactory factory) {
        if (leftType.isInstance(left) && rightType.isInstance(right)) {
            return doIntersect(leftType.cast(left), rightType.cast(right), factory);

     * @param factory the factory that can be used to create a new exclude spec
     * @return the simplified exclude spec, or {@code null} if the given exclude specs cannot be simplified
     */
    @Nullable
    ExcludeSpec intersect(ExcludeSpec left, ExcludeSpec right, ExcludeFactory factory);