int exit = MavenUpCling.main(
                new String[] {"--help"},
                new ClassWorld("plexus.core", Thread.currentThread().getContextClassLoader()),
                null,
                out,
                err);

        String help = out.toString(StandardCharsets.UTF_8);
        assertEquals(0, exit, "mvnup --help should exit 0");
        assertTrue(

            <li>{@code exists(path)}: Checks if a file matching the given glob pattern exists.</li>
            <li>{@code missing(path)}: Checks if a file matching the given glob pattern does not exist.</li>
            <li>{@code inrange(version, range)}: Checks if the given version is within the specified version range.</li>
            </ul>

import org.codelibs.fess.opensearch.config.exentity.ScheduledJob;

/**
 * Exception thrown when a scheduled job cannot be found.
 * This exception is typically thrown when attempting to access or
 * manipulate a job that does not exist in the system.
 */
public class JobNotFoundException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /**

                    crawlerContext.decrementAndGetAccessCount();
                    if (urlQueueService.visited(urlQueue)) {
                        // document already exists
                        if (logger.isDebugEnabled()) {
                            logger.debug("{} exists.", urlQueue.getUrl(), e);
                        }
                        return;
                    }
                    throw e;
                }

For example, let's say that you want to have a *path operation* that allows to update items, and returns HTTP status codes of 200 "OK" when successful.

But you also want it to accept new items. And when the items didn't exist before, it creates them, and returns an HTTP status code of 201 "Created".

To achieve that, import `JSONResponse`, and return your content there directly, setting the `status_code` that you want:

public interface GraphConflictResolver {
    String ROLE = GraphConflictResolver.class.getName();

    /**
     * Cleanses the supplied graph by leaving only one directed versioned edge\
     * between any two nodes, if multiple exists. Uses scope relationships, defined
     * in <code>ArtifactScopeEnum</code>
     *
     * @param graph the "dirty" graph to be simplified via conflict resolution
     * @param scope scope for which the graph should be resolved

    int FLAGS_VERIFY_ALL_WRITES = 0x0010;
    /** Tree copy flag */
    int FLAGS_TREE_COPY = 0x0020;

    // open function
    /** Open function fail if exists */
    int OPEN_FUNCTION_FAIL_IF_EXISTS = 0x0000;
    /** Open function overwrite if exists */
    int OPEN_FUNCTION_OVERWRITE_IF_EXISTS = 0x0020;

    /** Process ID */
    int PID = (int) (Math.random() * 65536d);

    /** Share level security */

import static java.util.stream.Collectors.toSet;

/**
 * Container for storing the request from the user to activate or deactivate certain projects and optionally fail the
 * build if those projects do not exist.
 */
public class ProjectActivation {

    /**
     * ProjectActivationSettings
     * @param selector the selector of a project, which can be the project directory, [groupId]:[artifactId] or :[artifactId]

    @Mock
    private DfsReferralData mockReferralData;

    @Test
    @DisplayName("Should define interface methods")
    void testDfsReferralDataInterface() {
        // Verify interface methods exist
        assertDoesNotThrow(() -> {
            mockReferralData.unwrap(DfsReferralData.class);
            mockReferralData.getServer();
            mockReferralData.getDomain();
            mockReferralData.getShare();

        final int dosErr = 0x00010001;
        final int expectedNt = 0xc0000002;
        Optional<Integer> actual = findNtStatus(dosErr);
        assertTrue(actual.isPresent(), String.format("Mapping for %08x should exist", dosErr));
        assertEquals(expectedNt, actual.get(), String.format("NTSTATUS for %08x should be %08x", dosErr, expectedNt));
    }

    @Test
    @DisplayName("Unknown DOS error code yields empty Optional")