String actualString = request.toString();

        assertTrue(actualString.startsWith(expectedStringPrefix));
        assertTrue(actualString.endsWith("]"));
        // Further verification could involve mocking super.toString() if needed
    }

     */
    public ModelBuilderResult getResult() {
        return result;
    }

    /**
     * Gets the identifier of the POM whose effective model could not be built. The general format of the identifier is
     * {@code <groupId>:<artifactId>:<version>} but some of these coordinates may still be unknown at the point the

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = queryProcessor.execute(context, boostQuery, 1.0f);

        assertNotNull(result);
        // The result could be either a TermQueryBuilder or DefaultQueryBuilder depending on field configuration
        assertTrue(result instanceof TermQueryBuilder || result instanceof DefaultQueryBuilder);

        if (result instanceof TermQueryBuilder) {

            method.invoke(null, (Object[]) null);
        } catch (final ClassNotFoundException e) {
            // ignore
        } catch (final Exception e) {
            logger.warn("Could not shutdown Commons HttpClient.", e);
        }
    }

But you need `file_path` itself to contain a *path*, like `home/johndoe/myfile.txt`.

So, the URL for that file would be something like: `/files/home/johndoe/myfile.txt`.

### OpenAPI support { #openapi-support }

OpenAPI doesn't support a way to declare a *path parameter* to contain a *path* inside, as that could lead to scenarios that are difficult to test and define.

        // Check for PDF - could be either key format
        if (queryMap.containsKey("labels.facet_filetype_pdf")) {
            assertEquals("filetype:pdf", queryMap.get("labels.facet_filetype_pdf"));
        } else {
            assertEquals("filetype:pdf", queryMap.get("PDF"));
        }

        // Check for XLS - could be either key format

## Use `StaticFiles` { #use-staticfiles }

* Import `StaticFiles`.
* "Mount" a `StaticFiles()` instance in a specific path.

{* ../../docs_src/static_files/tutorial001.py hl[2,6] *}

/// note | Technical Details

You could also use `from starlette.staticfiles import StaticFiles`.

**FastAPI** provides the same `starlette.staticfiles` as `fastapi.staticfiles` just as a convenience for you, the developer. But it actually comes directly from Starlette.

as well as all the Python dependencies will be managed by bazel directly.

### Specifying Python version

The hermetic Python version is controlled by `HERMETIC_PYTHON_VERSION`
environment variable, which could be setin one of the following ways:

```
# Either add an entry to your `.bazelrc` file
build --repo_env=HERMETIC_PYTHON_VERSION=3.12

# OR pass it directly to your specific build command

      // It is possible due to races that we are currently in the expected state even though we
      // timed out. e.g. if we weren't event able to grab the lock within the timeout we would never
      // even check the guard. I don't think we care too much about this use case but it could lead
      // to a confusing error message.
      throw new TimeoutException("Timed out waiting for " + this + " to reach the RUNNING state.");
    }
  }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import okio.IOException

interface Callback {
  /**
   * Called when the request could not be executed due to cancellation, a connectivity problem or
   * timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(