// spec.namespace means "in all namespaces".
type SubjectAccessReview struct {
	metav1.TypeMeta
	metav1.ObjectMeta

	// Spec holds information about the request being evaluated
	Spec SubjectAccessReviewSpec

	// Status is filled in by the server and indicates whether the request is allowed or not
	Status SubjectAccessReviewStatus
}

    }

    @Override
    public void settingsEvaluated(Settings settings) {
        SettingsInternal settingsInternal = (SettingsInternal) settings;
        if (logger.isInfoEnabled()) {
            logger.info("Settings evaluated using {}.",
                settingsInternal.getSettingsScript().getDisplayName());
        }
    }

    @Override
    public void projectsLoaded(Gradle gradle) {
        if (logger.isInfoEnabled()) {

    /**
     * Sets the working directory for the process. The supplied argument is evaluated as per {@link
     * org.gradle.api.Project#file(Object)}.
     *
     * @param dir The working directory. Must not be null.
     */
    void setWorkingDir(Object dir);

    /**
     * Sets the working directory for the process. The supplied argument is evaluated as per {@link
     * org.gradle.api.Project#file(Object)}.
     *

					},
				},
			},
			messageEvaluations: []cel.EvaluationResult{
				{
					EvalResult: celtypes.String("evaluated message"),
				},
			},
			policyDecision: []PolicyDecision{
				{
					Action:  ActionDeny,
					Message: "evaluated message",
					Reason:  forbiddenReason,
				},
			},
		},
		{
			name: "messageExpression for multiple validations",

package main

import "fmt"

var v int64 = 0x80000000

func main() {
	s := fmt.Sprintf("%v", v>>32 == 0)
	if s != "true" {
		fmt.Printf("BUG: v>>32 == 0 evaluated as %q\n", s)
	}

    public void beforeEvaluate(Project project) {
        logger.lifecycle("LOGGER: evaluating $project.path")
    }

    public void afterEvaluate(Project project, ProjectState state) {
        logger.info("LOGGER: evaluated project $project.path")
    }

    public void beforeExecute(Task task) {
        logger.lifecycle("LOGGER: executing $task.path")
    }

    public void afterExecute(Task task, TaskState state) {

	//'params' - Parameter resource referred to by the policy binding being evaluated. Only populated if the policy has a ParamKind.
	//'namespaceObject' - The namespace object that the incoming object belongs to. The value is null for cluster-scoped resources.
	//'variables' - Map of composited variables, from its name to its lazily evaluated value.
	//  For example, a variable named 'foo' can be accessed as 'variables.foo'

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Make sure we don't start marshaling (writing to the stack)
// arguments until those arguments are evaluated and known
// not to unconditionally panic. If they unconditionally panic,
// we write some args but never do the call. That messes up
// the logic which decides how big the argout section needs to be.

package main

request([ref](/pkg/apis/admission/types.go#AdmissionRequest)). - 'params' - Parameter resource referred to by the policy binding being evaluated. Only populated if the policy has a ParamKind. - 'namespaceObject' - The namespace object that the incoming object belongs to. The value is null for cluster-scoped resources. - 'variables' - Map of composited variables, from its name to its lazily evaluated value.\n  For example, a variable named 'foo' can be accessed as 'variables.foo'.\n- 'authorizer' - A CEL Authorizer....

     *         dependency.useTarget "org.myorg:" + dependency.requested.path + ":+"
     *       }
     *     }
     *   }
     * }
     * </pre>
     *
     * The rules are evaluated in order they are declared. Rules are evaluated after forced modules are applied (see {@link ResolutionStrategy#force(Object...)}
     *
     * @return this
     */
    DependencySubstitutions all(Action<? super DependencySubstitution> rule);