They tend to require more complex configurations, a message/job queue manager, like RabbitMQ or Redis, but they allow you to run background tasks in multiple processes, and especially, in multiple servers.

* Data conversion
* Data validation
* Automatic documentation

## Special types and validation { #special-types-and-validation }

Apart from normal singular types like `str`, `int`, `float`, etc. you can use more complex singular types that inherit from `str`.

        RankFusionSearcher simpleSearcher = new SimpleSearcher();
        assertEquals("simple", simpleSearcher.getName());
    }

    public void test_getName_complexCamelCaseSearcher() {
        // Test with complex camel case naming
        RankFusionSearcher complexSearcher = new VeryComplexRankFusionSearcher();
        assertEquals("very_complex_rank_fusion", complexSearcher.getName());
    }

        }
        return baseQuery + " sort:" + sortField;
    }

    /**
     * Appends a query string to the query buffer with proper formatting.
     * Handles OR operators and wraps complex queries in parentheses when necessary.
     *
     * @param queryBuf the StringBuilder to append to
     * @param query the query string to append
     */

        assertTrue(result instanceof BoolQueryBuilder);

        BoolQueryBuilder boolResult = (BoolQueryBuilder) result;
        assertEquals(5, boolResult.should().size());
    }

    // Test complex query with all clause types
    public void test_convertBooleanQuery_complexQuery() {
        BooleanQuery.Builder boolQueryBuilder = new BooleanQuery.Builder();

        // Add multiple clauses of each type

# About HTTPS { #about-https }

It is easy to assume that HTTPS is something that is just "enabled" or not.

But it is way more complex than that.

/// tip

If you are in a hurry or don't care, continue with the next sections for step by step instructions to set everything up with different techniques.

///

        assertNotSame(unknownException.getMessageCode(), parseException.getMessageCode());
    }

    public void test_complexMessageCode() {
        // Setup - test with a complex message code that includes parameters
        final String queryString = "field:value AND (";
        final VaMessenger<FessMessages> complexMessageCode =

 * Due to the iterator's constructor calling advance() immediately, which requires
 * the adapt() method to be functional, we test the behavior using simple mock
 * scenarios that don't require complex filter setups.
 */
@ExtendWith(MockitoExtension.class)
class DirFileEntryAdapterIteratorTest {

    @Mock
    private SmbResource mockParent;

    @Mock
    private CloseableIterator<FileEntry> mockDelegate;

        assertNull(testDfs.getTrustedDomains(auth));
    }

    @Test
    void testGetTrustedDomains_Success() throws IOException, SmbAuthException {
        // This test is complex due to static method dependencies and reflection access
        // For now, we'll test the disabled path which is safer
        testDfs.setDisabled(true);
        assertNull(testDfs.getTrustedDomains(auth));
    }

You can use the same type declarations with `str`, `float`, `bool` and many other complex data types.

Several of these are explored in the next chapters of the tutorial.

## Order matters { #order-matters }

When creating *path operations*, you can find situations where you have a fixed path.