functionScoreQueryBuilder.scoreMode(FunctionScoreQuery.ScoreMode.MULTIPLY);

        return functionScoreQueryBuilder;
    }

    /**
     * Creates a SuggestResponse from the OpenSearch SearchResponse.
     * @param searchResponse The OpenSearch SearchResponse.
     * @return A SuggestResponse instance.
     */

        assertArgumentNotNull("in", in);
        assertArgumentNotNull("out", out);

        final FileInputStream is = InputStreamUtil.create(in);
        try {
            final FileOutputStream os = OutputStreamUtil.create(out);
            try {
                return copyInternal(is, os);
            } finally {
                CloseableUtil.close(os);
            }
        } finally {

        void testPropertiesOrderPreservedInImmutableModel() {
            // Create properties with specific insertion order using LinkedHashMap
            Map<String, String> orderedMap = new LinkedHashMap<>();
            orderedMap.put("third", "3");
            orderedMap.put("first", "1");
            orderedMap.put("second", "2");

            // Create model and set properties
            Model model = new Model();

    if token is None:
        return {"msg": "Create an account first"}
    return {"token": token}


client = TestClient(app)


def test_no_token():
    response = client.get("/items")
    assert response.status_code == 200, response.text
    assert response.json() == {"msg": "Create an account first"}


def test_token():

    pass


@app.post("/invoices/", callbacks=invoices_callback_router.routes)
def create_invoice(invoice: Invoice, callback_url: Union[HttpUrl, None] = None):
    """
    Create an invoice.

    This will (let's imagine) let the API user (some external developer) create an
    invoice.

    And this path operation will:

    * Send the invoice to the client.
    * Collect the money from the client.

  private TestCallable firstCallable;

  @Override
  public void setUp() throws Exception {
    executor = newCachedThreadPool();
    serializer = ExecutionSequencer.create();
    firstFuture = SettableFuture.create();
    firstCallable = new TestCallable(firstFuture);
  }

  @Override
  public void tearDown() throws Exception {
    executor.shutdown();
  }

    TestSuite suite = new TestSuite();

    suite.addTest(
        SetTestSuiteBuilder.using(
                new TestStringSetGenerator() {
                  @Override
                  protected Set<String> create(String[] elements) {
                    return union(emptySet(), emptySet());
                  }
                })
            .named("empty U empty")

    }

    /**
     * Helper method to create a factory with specific settings
     */
    private <U> CrawlerPooledObjectFactory<U> createFactory(String componentName) {
        CrawlerPooledObjectFactory<U> f = new CrawlerPooledObjectFactory<>();
        f.setCrawlerContainer(container);
        f.setComponentName(componentName);
        return f;
    }

    /**
     * Helper method to create a factory with listener
     */

                DirectoryCacheScope.IMMEDIATE_CHILDREN);

        assertNotNull(leaseKey);

        // Step 2: Verify cache entry was created
        DirectoryCacheEntry cacheEntry = directoryLeaseManager.getCacheEntry(directoryPath);
        assertNotNull(cacheEntry);
        assertEquals(directoryPath, cacheEntry.getDirectoryPath());

    void testNullConfiguration() {
        // When - constructor accepts null config without throwing
        Smb2TreeDisconnectResponse responseWithNull = new Smb2TreeDisconnectResponse(null);

        // Then - response is created successfully
        assertNotNull(responseWithNull);
    }

    @Test
    @DisplayName("Should return consistent bytes read for valid structure")