if len(errs) == 0 {
		t.Errorf("Expected a validation error")
	}
	if invalidIngress.ResourceVersion != "4" {
		t.Errorf("Incoming resource version on update should not be mutated")
	}
}

func TestIngressStatusStrategy(t *testing.T) {
	ctx := genericapirequest.NewDefaultContext()
	if !StatusStrategy.NamespaceScoped() {
		t.Errorf("Ingress must be namespace scoped")
	}

     * as defined by {@link org.gradle.api.Project#files(Object...)}.
     *
     * This method can also be used to create an empty collection, but the collection may not be mutated later.
     *
     * @param paths The paths to the files. May be empty.
     * @return The file collection.
     * @since 6.0
     */
    FileCollection files(Object... paths);

        Created(true), // Private data has been created, initial rules discovered
        DefaultsApplied(true), // Default values have been applied
        Initialized(true),
        Mutated(true),
        Finalized(false),
        SelfClosed(false),
        GraphClosed(false);

        public final boolean mutable;

        State(boolean mutable) {
            this.mutable = mutable;
        }

    assertSideEffectFree(hash);
    assertReadableBytes(hash);
  }

  private static void assertSideEffectFree(HashCode hash) {
    byte[] original = hash.asBytes();
    byte[] mutated = hash.asBytes();
    mutated[0]++;
    assertTrue(Arrays.equals(original, hash.asBytes()));
  }

  private static void assertReadableBytes(HashCode hashCode) {
    assertTrue(hashCode.bits() >= 32); // sanity

     * as defined by {@link org.gradle.api.Project#files(Object...)}.
     *
     * This method can also be used to create an empty collection, but the collection may not be mutated later.
     *
     * @param paths The paths to the files. May be empty.
     * @return The file collection.
     * @since 6.0
     */
    FileCollection files(Object... paths);

                                  std::vector<VariableInfo>* result);

// variables_updated is a set containing the indices of the variables that are
// going to be mutated. If variables_updated is empty, then in LockVariables all
// variables would only be reader-locked. If variables_updated is null, then we
// consider this information unknown and will acquire writer-lock for all
// variables.

    ModelType<ModelMap<T>> getModelMapType() {
        ModelTypes.modelMap(itemType)
    }

    void mutate(@DelegatesTo(ModelMap) Closure<?> action) {
        registry.mutate(ModelReference.of(path, modelMapType), ClosureBackedAction.of(action))
    }

    void mutateWithoutDelegation(Action<ModelMap<T>> action) {
        registry.mutate(ModelReference.of(path, modelMapType), action)
    }

    void realize() {

        boolean isImplicit,
        BuildState owner,
        BuildTreeState buildTree,
        Instantiator instantiator
    ) {
        // Use a defensive copy of the build definition, as it may be mutated during build execution
        super(buildTree, buildDefinition.newInstance(), owner);
        this.buildIdentifier = buildIdentifier;
        this.identityPath = Path.path(buildIdentifier.getBuildPath());

limitations under the License.
*/

package lifecycle

import "k8s.io/api/core/v1"

// PodAdmitAttributes is the context for a pod admission decision.
// The member fields of this struct should never be mutated.
type PodAdmitAttributes struct {
	// the pod to evaluate for admission
	Pod *v1.Pod
	// all pods bound to the kubelet excluding the pod being evaluated
	OtherPods []*v1.Pod
}

            }
        }
        registry.configure(ModelActionRole.Mutate) {
            it.path("b").descriptor("b-mutate").action { Bean b ->
                b.value = "b-mutate"
            }
        }
        registry.configure(ModelActionRole.Mutate) {
            it.path("a").descriptor("a-mutate").action { Bean a ->
                a.value = "a-mutate"
            }
        }