the new API. This helps with our end-of-cycle audit of new APIs.
The same requirement applies to next/* (described below), which will
become a go1.XX.txt for XX >= 19.

The next/ directory contains the only files intended to be mutated.
Each file in that directory contains a list of features that may be added
to the next release of Go. The files in this directory only affect the
warning output from the go api tool. Each file should be named

			}
			if want, got := copy.ObjectMeta.Annotations, test.in.ObjectMeta.Annotations; !cmp.Equal(want, got) {
				t.Errorf("Did not expect the 'Annotations' field of the source to be mutated, diff: %s", cmp.Diff(want, got))
			}
		})
	}
}

func TestConvert_flowcontrol_PriorityLevelConfiguration_To_v1beta3_PriorityLevelConfiguration(t *testing.T) {

        ImmutableFilteredList.allOf([1, 2, 3]) != [1, 2]
        [1, 2] != ImmutableFilteredList.allOf([1, 2, 3])
        ImmutableFilteredList.allOf([1, 2, 3]) != [3, 1, 2]
    }

    def "list cannot be mutated"() {
        given:
        def list = ImmutableFilteredList.allOf([1, 2, 3])

        when:
        list.add(4)

        then:
        thrown(UnsupportedOperationException)

        when:

     *
     * @param dataset the dataset to do the calculation on, which must be non-empty, which will be
     *     cast to doubles (with any associated lost of precision), and which will not be mutated by
     *     this call (it is copied instead)
     * @return the quantile value
     */
    public double compute(Collection<? extends Number> dataset) {
      return computeInPlace(Doubles.toArray(dataset));
    }

/**
 * A set of managed model objects.
 * <p>
 * {@link org.gradle.model.Managed} types may declare managed set properties.
 * Managed sets can only contain managed types.
 * <p>
 * Managed set objects cannot be mutated via the mutative methods of the {@link java.util.Set} interface (e.g. {@link java.util.Set#add(Object)}, {@link java.util.Set#clear()}).
 * To add elements to the set, the {@link #create(Action)} method can be used.
 *

    @Override
    ImmutableAttributes getAttributes();

    ImmutableCapabilities getCapabilities();

    VariantGraphResolveMetadata getMetadata();

    /**
     * Does this instance represent some temporary or mutated view of the variant?
     *
     * See {@link ComponentGraphResolveState#isAdHoc()} for a definition of "ad hoc".
     */
    boolean isAdHoc();

    /**
     * Returns the public view for this variant.
     */

	if len(errs) == 0 {
		t.Errorf("Expected error from update validation for ipAddress, got none")
	}
	if invalidIPAddress.ResourceVersion != "4" {
		t.Errorf("Incoming resource version on update should not be mutated")
	}

     *
     * @param dataset the dataset to do the calculation on, which must be non-empty, which will be
     *     cast to doubles (with any associated lost of precision), and which will not be mutated by
     *     this call (it is copied instead)
     * @return the quantile value
     */
    public double compute(Collection<? extends Number> dataset) {
      return computeInPlace(Doubles.toArray(dataset));
    }

	walker := schemamutation.Walker{
		SchemaCallback: func(schema *spec.Schema) *spec.Schema {
			orig := schema
			clone := func() {
				if orig == schema { // if schema has not been mutated yet
					schema = new(spec.Schema)
					*schema = *orig // make a clone from orig to schema
				}
			}
			if headerIndex := strings.Index(schema.Description, enumTypeDescriptionHeader); headerIndex != -1 {

import org.gradle.internal.hash.HashCode;

import javax.annotation.Nullable;
import java.util.function.Function;

/**
 * A simplified scope that provides only a single local classpath and no exports, and that cannot be mutated.
 */
public class ImmutableClassLoaderScope extends AbstractClassLoaderScope {
    private final ClassLoaderScope parent;
    private final ClassPath classPath;
    @Nullable