import org.gradle.internal.service.scopes.ServiceScope;

import javax.annotation.Nullable;

@ServiceScope(Scope.BuildTree.class)
public interface EnvironmentChangeTracker {

    /**
     * System properties mutated in runtime
     * */
    void systemPropertyChanged(Object key, @Nullable Object value, @Nullable String consumer);

    /**
     * System properties loaded from included build/buildSrc gradle.properties
     * */

/**
 * A map-like data structure that wraps a backing map and caches values while iterating through
 * {@link #unmodifiableKeySet()}. By design, the cache is cleared when this structure is mutated. If
 * this structure is never mutated, it provides a thread-safe view of the backing map.
 *
 * <p>The {@link MapIteratorCache} assumes ownership of the backing map, and cannot guarantee

	Attributes
	// VersionedOldObject holds Attributes.OldObject (if non-nil), converted to VersionedKind.
	// It must never be mutated.
	VersionedOldObject runtime.Object
	// VersionedObject holds Attributes.Object (if non-nil), converted to VersionedKind.
	// If mutated, Dirty must be set to true by the mutator.
	VersionedObject runtime.Object
	// VersionedKind holds the fully qualified kind

//
//	acc(obj) == x
//	reflect.DeepEqual(acc(DeepCopy(obj), x) == x
//
// where x is the original instance for slices and maps.
//
// If after computation of acc the node holding x in obj is mutated (e.g. pruned),
// the accessor will return that mutated node value (e.g. the pruned x).
//
// Example (ignoring the last two return values):
//
//	NewRootObjectFunc()(x) == x
//	NewRootObjectFunc().Index()(x) == [x]

    Defaults(ModelNode.State.DefaultsApplied, true), // Allows a mutation to setup default values for an element
    Initialize(ModelNode.State.Initialized, true), // Mutation action provided when an element is defined
    Mutate(ModelNode.State.Mutated, true), // Customisations
    Finalize(ModelNode.State.Finalized, true), // Post customisation default values
    Validate(ModelNode.State.SelfClosed, true); // Post mutation validations

				t.Errorf("%v: overflow addition mutated source: %d", test, c)
			}
		}

		// addition is commutative
		c = test.b
		if ok := c.Add(test.a); ok != test.ok {
			t.Errorf("%v: unexpected ok: %t", test, ok)
		}
		if ok {
			if c != test.c {
				t.Errorf("%v: unexpected result: %d", test, c)
			}
		} else {
			if c != test.b {
				t.Errorf("%v: overflow addition mutated source: %d", test, c)
			}
		}
	}
}

 * limitations under the License.
 */

package org.gradle.internal.logging.config;

/**
 * Some configurable logging system, whose state can be snapshot, mutated and restored.
 */
public interface LoggingSystem {
    /**
     * Snapshots the current configuration state of this logging system.
     */
    Snapshot snapshot();

    /**

package org.gradle.execution.plan;

import org.gradle.api.Describable;

import javax.annotation.concurrent.ThreadSafe;
import java.io.Closeable;

/**
 * An execution plan that has been finalized and can no longer be mutated.
 */
@ThreadSafe
public interface FinalizedExecutionPlan extends Describable, Closeable {
    FinalizedExecutionPlan EMPTY = new FinalizedExecutionPlan() {
        @Override

public interface PluginRepositoryHandlerProvider {
    /**
     * Returns the {@link RepositoryHandler} that will contain the shared repositories to be used to resolve plugins for all project of this build.
     * Should be mutated only during settings configuration.
     */
    RepositoryHandler getPluginRepositoryHandler();

				m.r = newPcgRand()
				m.mutate([]any{t}, workerSharedMemSize)
			}
		})
	}
}

func TestStringImmutability(t *testing.T) {
	v := []any{"hello"}
	m := newMutator()
	m.mutate(v, 1024)
	original := v[0].(string)
	originalCopy := make([]byte, len(original))
	copy(originalCopy, []byte(original))
	for i := 0; i < 25; i++ {
		m.mutate(v, 1024)
	}