}
        }

        /**
         * Adds a disallowed path to this directive.
         * @param path the path to disallow
         */
        public void addDisallow(final String path) {
            if (!disallowedPaths.contains(path)) {
                disallowedPaths.add(path);
            }
        }

        /**
         * Gets all allowed paths for this directive.

            assertEquals(Integer.valueOf(expire), provider.provideDefaultExpire());
        }
    }

    // Test with different path values
    public void test_differentPathValues() {
        String[] testPaths = { "/", "/app", "/test/path", "/a/b/c/d", "" };

        for (String path : testPaths) {
            ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
                private static final long serialVersionUID = 1L;

        return conscryptVersion.minor() > minor
      }

      return conscryptVersion.patch() >= patch
    }
  }

It is just a function that can take all the same parameters that a *path operation function* can take:

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8:9] *}

That's it.

**2 lines**.

And it has the same shape and structure that all your *path operation functions* have.

You can think of it as a *path operation function* without the "decorator" (without the `@app.get("/some-path")`).

And it can return anything you want.

        if (path.length() > MAX_PATH_SIZE) {
            failedValidations.incrementAndGet();
            log.warn("Path exceeds maximum length: {}", path.length());
            throw new SmbException("Path exceeds maximum length");
        }

        // Check for directory traversal
        if (path.contains("..") || path.contains("./") || path.contains(".\\")) {
            failedValidations.incrementAndGet();

        // dunc is "\\" + path + remaining  - note: path may not have leading backslashes
        assertTrue(newUnc.contains("dfs/path") || newUnc.contains("dfs\\path"));
        assertEquals(dr, l.getDfsReferral());
        assertEquals("dfs-server", l.getServerWithDfs());
        assertEquals("smb://dfs-server/dfs-share" + l.getUNCPath().replace('\\', '/'), l.getDfsPath());

    protected static final String GROOVY_MATCHER = "groovy:";

    /** Map of path mappings by process type. */
    protected final Map<String, List<PathMapping>> pathMappingMap = new HashMap<>();

    /** Cached list of path mappings. */
    protected volatile List<PathMapping> cachedPathMappingList = null;

    /**
     * Initializes the path mapping helper.
     */
    @PostConstruct
    public void init() {

        // Test task creation with null document map
        String path = "/path/to/document.pdf";

        Tuple3<String, String, String> task = thumbnailGenerator.createTask(path, null);
        assertNull(task);
    }

    public void test_createTask_withEmptyDocMap() {
        // Test task creation with empty document map
        String path = "/path/to/document.pdf";
        Map<String, Object> docMap = new HashMap<>();

		}

		// As this is path in the URL, we should use path package, not filepath package.
		// On MS Windows, filepath.Clean() converts into Windows path style ie `/foo` becomes `\foo`
		u.Path = path.Clean(u.Path)
		if isEmptyPath(u.Path) {
			return ep, fmt.Errorf("empty or root path is not supported in URL endpoint")
		}

     * Implementation may override with absolute path instead.
     */
    default Path directory() {
        Path src = Path.of("src");
        return module().map(src::resolve)
                .orElse(src)
                .resolve(scope().id())
                .resolve(language().id());
    }

    /**
     * {@return the list of patterns for the files to include}.