* mask of the ACE, the whole access check fails. If the ACE is an "allow"
 * ACE and <i>all</i> of the bits in the desired access bits match bits in
 * the access mask of the ACE, the access check is successful. Otherwise,
 * more ACEs are evaluated until all desired access bits (combined)
 * are "allowed". If all of the desired access bits are not "allowed"

					if !reflect.DeepEqual(origin, response.Header.Get("Access-Control-Allow-Origin")) {
						t.Errorf("Expected %#v, Got %#v", origin, response.Header.Get("Access-Control-Allow-Origin"))
					}

					if response.Header.Get("Access-Control-Allow-Credentials") == "" {
						t.Errorf("Expected Access-Control-Allow-Credentials header to be set")
					}

					if response.Header.Get("Access-Control-Allow-Headers") == "" {

            extensions["aValue"] = "hello"

            assert extensions["aValue"] == "hello" : "Can access inside buildscript"
        }

        assert extensions["aValue"] == "hello" : "Can access outside buildscript"

        apply from: '$answerFile'

        assert(extensions["theAnswer"]() == 42) : "Can access from applied file"
        """
        then:
        succeeds('help')
    }

    /**
     * Adds a field to the generated type.
     */
    protected void addField(int access, String fieldName, Class<?> type) {
        addField(access, fieldName, getDescriptor(type));
    }

    /**
     * Adds a field to the generated type.
     */
    protected void addField(int access, String fieldName, Type type) {
        addField(access, fieldName, type.getDescriptor());
    }

    /**

    private final int access;

    public AccessibleMember(int access, String name) {
        super(name);
        this.access = access;
    }

    public int getAccess() {
        return access;
    }

    protected ComparisonChain compare(AccessibleMember o) {
        return super.compare(o).compare(access, o.access);
    }

	return p.exited()
}

// Success reports whether the program exited successfully,
// such as with exit status 0 on Unix.
func (p *ProcessState) Success() bool {
	return p.success()
}

// Sys returns system-dependent exit information about
// the process. Convert it to the appropriate underlying
// type, such as [syscall.WaitStatus] on Unix, to access its contents.
func (p *ProcessState) Sys() any {

    @Shared
    def forbidden = status(403)
    @Shared
    def unauthorized = status(401)

    @Subject
    ErrorHandlingModuleComponentRepository.ErrorHandlingModuleComponentRepositoryAccess access

    private ErrorHandlingModuleComponentRepository.ErrorHandlingModuleComponentRepositoryAccess createAccess(int maxRetries = 1, int backoff = 0) {

     * an instance that behaves correctly regarding cross project model access.
     *
     * @param referrerProject The project that is going to use the Gradle instance
     * @param gradle The Gradle instance that the project has direct access to.
     * @return A Gradle instance that implements correct cross-project model access.
     */

                private final Access access;
                private final ObjectFactory objects;

                public Access getAccess() {
                    return access;
                }

                @Inject
                public Extension(ObjectFactory objects) {
                    this.objects = objects;
                    this.access = objects.newInstance(Access.class);
                }

* The client doesn't have access to that resource.
* The item the client was trying to access doesn't exist.
* etc.

In these cases, you would normally return an **HTTP status code** in the range of **400** (from 400 to 499).

This is similar to the 200 HTTP status codes (from 200 to 299). Those "200" status codes mean that somehow there was a "success" in the request.