limitations under the License.
*/

package unstructured

import (
	"github.com/google/cel-go/common/types"
	"github.com/google/cel-go/common/types/ref"

	"k8s.io/apiserver/pkg/cel/mutation/common"
)

// TypeRef is the implementation of TypeRef for an unstructured object.
// This is especially usefully when the schema is not known or available.
type TypeRef struct {
	celObjectType *types.Type

    @ToBeFixedForConfigurationCache
    @Issue("https://github.com/gradle/gradle/issues/13555")
    @Unroll("consistent resolution using rules=#displayName")
    // If this test becomes flaky it means we broke the code which prevents mutation of in-memory cached module metadata
    def "selected variants are consistent using concurrent resolution of graphs from cache having different derivation strategies"() {
        executer.requireOwnGradleUserHomeDir()

        }

        public void cache(LocalComponentGraphResolveState state, boolean useStrongReference) {
            if (useStrongReference) {
                // Keep a hard reference to the state for re-evaluation on mutation
                // and to force the value to be reused for resolution of other configurations
                reference = null;
                cachedValue = state;
            } else {

    void setTargetConfiguration(@Nullable String name);

    /**
     * {@inheritDoc}
     */
    @Override
    ModuleDependency copy();

    /**
     * Returns the attributes for this dependency. Mutation of the attributes of a dependency must be done through
     * the {@link #attributes(Action)} method.
     *
     * @return the attributes container for this dependency
     *
     * @since 4.8
     */

        noExceptionThrown()

        when:
        fails("mutateAfterResolve")

        then:
        failure.assertHasCause "Cannot change attributes of configuration ':compile' after it has been locked for mutation"
    }

    @ToBeFixedForConfigurationCache(because = "Task uses the Configuration API")
    def "cannot add outgoing variants after configuration is resolved"() {
        given:
        buildFile << """

[dotdotpwn](https://github.com/wireghoul/dotdotpwn)) and [wfuzz](https://github.com/xmendez/wfuzz) to generate a
large number of fuzzed requests. The mutation is based on a predefined path (`/private/secret.html`) that should be
rejected by either the request authentication or the authorization policy.

        if (!mutable) {
            throw new InvalidUserCodeException("Mutation of dependency resolution management in settings is only allowed during settings evaluation");
        }
    }

    private void mutationDisallowed(ArtifactRepository artifactRepository) {
        throw new InvalidUserCodeException("Mutation of repositories declared in settings is only allowed during settings evaluation");
    }

    @Override
    ModuleComponentIdentifier getId();

    /**
     * Creates a mutable copy of this metadata.
     *
     * Note that this method can be expensive. Often it is more efficient to use a more specialised mutation method such as {@link #withSources(ModuleSources)} rather than this method.
     */
    MutableModuleComponentResolveMetadata asMutable();

    /**
     * Creates a copy of this meta-data with the given sources.
     */

import java.util.Set;
import java.util.TreeMap;

/**
 * Joins a primary and fallback attribute container to each other. Any attribute in the primary
 * container will override attributes in the fallback container. All mutation operations are
 * forwarded to the primary container.
 */
public class HierarchicalAttributeContainer extends AbstractAttributeContainer {
    private final ImmutableAttributesFactory attributesFactory;

	}

	for _, test := range tests {
		capacity := make([]string, 0, 1024)
		user := test.inputUser
		user.Groups = append(capacity, user.Groups...) // make sure there is capacity in the groups array to trigger potential mutation
		response := &authenticator.Response{User: user}
		orig := toJson(response)

		adder := authenticator.Request(
			NewAuthenticatedGroupAdder(