after(VALIDATE),
                                    phase(SOURCES),
                                    phase(RESOURCES),
                                    phase(COMPILE, after(SOURCES), dependencies(SCOPE_COMPILE, READY)),
                                    phase(READY, after(COMPILE), after(RESOURCES)),
                                    phase(PACKAGE, after(READY), dependencies(SCOPE_RUNTIME, PACKAGE))),

    )
    if response.status_code != 200:
        logging.error(f"Response was not 200, after: {after}")
        logging.error(response.text)
        raise RuntimeError(response.text)
    data = response.json()
    if "errors" in data:
        logging.error(f"Errors in response, after: {after}")
        logging.error(data["errors"])
        logging.error(response.text)

		t.Fatalf("Blog should has three tags after Append")
	}

	if DB.Model(&blog).Association("SharedTags").Count() != 3 {
		t.Fatalf("Blog should has three tags after Append")
	}

	if DB.Model(&blog2).Association("SharedTags").Count() != 3 {
		t.Fatalf("Blog should has three tags after Append")
	}

	var tags []Tag
	DB.Model(&blog).Association("SharedTags").Find(&tags)

                .build();
    }

    /** Indicates the phase is after the phases given in arguments */
    static Lifecycle.Link after(String phase) {
        return new Lifecycle.Link() {
            @Override
            public Kind kind() {
                return Kind.AFTER;
            }

            @Override
            public Lifecycle.Pointer pointer() {

Using `Depends(scope="function")`, the exit code after `yield` is executed right after the *path operation function* is finished, before the response is sent back to the client.

And when using `Depends(scope="request")` (the default), the exit code after `yield` is executed after the response is sent.

    if response.status_code != 200:
        logging.error(
            f"Response was not 200, after: {after}, category_id: {category_id}"
        )
        logging.error(response.text)
        raise RuntimeError(response.text)
    data = response.json()
    if "errors" in data:
        logging.error(f"Errors in response, after: {after}, category_id: {category_id}")
        logging.error(data["errors"])

        // Verify iterator still works after multiple removes
        assertFalse(emptyIterator.hasNext(), "Iterator should still work after multiple removes");
        assertNull(emptyIterator.next(), "Iterator should still return null after multiple removes");
    }

    @Test
    @DisplayName("EmptyIterator should maintain state after all operations")
    void testStateConsistencyAfterOperations() {

	left, err := v2.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) != 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
	if !reflect.DeepEqual(v, v2) {
		t.Errorf("MSS: %v != %v", v, v2)
	}
}

        // Test release (still in use because of initial transport acquire)
        session.release();
        assertTrue(session.isInUse(), "Session should still be in use after one release");

        // Test final release
        session.release();
        assertFalse(session.isInUse(), "Session should not be in use after all releases");

				}
			} else if idx := getRIndex(names, c.after); idx != -1 {
				// if after callback exists but haven't sorted
				// set after callback's before callback to current callback
				after := cs[idx]

				if after.before == "" {
					after.before = c.name
				}

				if err := sortCallback(after); err != nil {
					return err
				}