if (result instanceof TermQueryBuilder) {
            TermQueryBuilder termQueryBuilder = (TermQueryBuilder) result;
            assertEquals("field", termQueryBuilder.fieldName());
            assertEquals("value", termQueryBuilder.value());
            assertEquals(2.5f, termQueryBuilder.boost());
        }
    }

    @Test
    public void test_execute_withMatchAllDocsQuery() {

        assertNotNull(deleteQuery);
        assertTrue(deleteQuery instanceof RangeQueryBuilder);
        RangeQueryBuilder rangeQuery = (RangeQueryBuilder) deleteQuery;
        assertEquals("expires", rangeQuery.fieldName());
        assertEquals("now", rangeQuery.to());

        // Assert result is empty when successful
        assertEquals("", result);
    }

    @Test
    public void test_execute_withException() {

                    resultMap.put("index", index);
                    resultMap.put("id", termQueryBuilder.value().toString());
                    resultMap.put("field", termQueryBuilder.fieldName());
                    return 1;
                }
                return 0;
            }
        };
        ComponentUtil.register(client, "searchEngineClient");

        final String id = "001";

private
fun getSinceJavaFieldVisitorFor(field: JApiField) =
    object : SinceVisitor() {

        override fun visit(declaration: FieldDeclaration, arg: Unit?): SinceTagStatus? =
            declaration.takeIf { matchesName(it.fieldName, field.name) }?.getSince()?.let { SinceTagStatus.Present(it) }

        override fun visit(declaration: EnumConstantDeclaration, arg: Unit?): SinceTagStatus? =
            declaration.getSinceIfMatchesName(field.name)
    }

        assertNotNull(builder);
        assertTrue(builder instanceof MatchPhrasePrefixQueryBuilder);

        MatchPhrasePrefixQueryBuilder mpqb = (MatchPhrasePrefixQueryBuilder) builder;
        assertEquals("title", mpqb.fieldName());
        assertEquals("test", mpqb.value());

        // Query was processed successfully
    }

    @Test
    public void test_convertPrefixQuery_withNotAnalyzedField() throws Exception {

		}
		if field.Unique != unique {
			t.Fatalf("%v: %q column %q unique should be %v but got %v", utils.FileWithLineNum(), stmt.Schema.Table, fieldName, unique, field.Unique)
		}
		if field.UniqueIndex != uniqueIndex {
			t.Fatalf("%v: %q column %q uniqueIndex should be %v but got %v", utils.FileWithLineNum(), stmt.Schema, fieldName, uniqueIndex, field.UniqueIndex)
		}
	}

	type ( // not unique

        assertTrue(builder instanceof RangeQueryBuilder);

        // Query was processed successfully
        RangeQueryBuilder rqb = (RangeQueryBuilder) builder;
        assertEquals("title", rqb.fieldName());
    }

        // Query was processed successfully

        // Query was processed successfully
        WildcardQueryBuilder wqb = (WildcardQueryBuilder) queryBuilder;
        assertEquals("title", wqb.fieldName());
    }

    @Test
    public void test_convertWildcardQuery_nonSearchField() throws Exception {
        // Test with DEFAULT_FIELD when field is not a search field

        // Verify that the query was processed successfully
        assertTrue(result instanceof FuzzyQueryBuilder);
        FuzzyQueryBuilder fqb = (FuzzyQueryBuilder) result;
        assertEquals("title", fqb.fieldName());
        assertEquals(searchText, fqb.value());
    }

    // Test with special characters in term text
    @Test
    public void test_convertFuzzyQuery_withSpecialCharacters() {

 * <li><code>merge<i>Classname</i>( <i>Classname</i> target, <i>Classname</i> source, boolean sourceDominant,
 * Map&lt;Object, Object&gt; context )</code> for each model class</li>
 * <li><code>merge<i>Classname</i>_<i>FieldName</i>( <i>Classname</i> target, <i>Classname</i> source, boolean
 * sourceDominant, Map&lt;Object, Object&gt; context )</code> for each field of each model class</li>