Discovery and Request Building

/**
 * DSL for generating LauncherDiscoveryRequest instances
 */
class LauncherDiscoveryRequestBuilder {
    /**
     * Create a new LauncherDiscoveryRequestBuilder
     * @return New builder instance
     */
    static LauncherDiscoveryRequestBuilder request();
    
    /**
     * Add discovery selectors to specify what tests to discover
     * @param selectors - DiscoverySelector instances (packages, classes, methods, etc.)
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder selectors(DiscoverySelector... selectors);
    
    /**
     * Add discovery selectors from a list
     * @param selectors - List of DiscoverySelector instances
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder selectors(List<? extends DiscoverySelector> selectors);
    
    /**
     * Add filters to control test discovery and execution
     * @param filters - Filter instances for engines, tags, methods, etc.
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder filters(Filter<?>... filters);
    
    /**
     * Add a configuration parameter
     * @param key - Configuration parameter key
     * @param value - Configuration parameter value
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder configurationParameter(String key, String value);
    
    /**
     * Add multiple configuration parameters
     * @param parameters - Map of configuration parameters
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder configurationParameters(Map<String, String> parameters);
    
    /**
     * Add configuration parameters from resource files
     * @param paths - Paths to configuration resource files
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder configurationParametersResources(String... paths);
    
    /**
     * Set parent configuration parameters
     * @param parent - Parent ConfigurationParameters instance
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder parentConfigurationParameters(ConfigurationParameters parent);
    
    /**
     * Enable or disable implicit configuration parameters
     * @param enabled - Whether to enable implicit configuration
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder enableImplicitConfigurationParameters(boolean enabled);
    
    /**
     * Add discovery listeners to monitor discovery process
     * @param listeners - LauncherDiscoveryListener instances
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder listeners(LauncherDiscoveryListener... listeners);
    
    /**
     * Set output directory provider for test execution
     * @param provider - OutputDirectoryProvider instance
     * @return This builder for method chaining
     */
    LauncherDiscoveryRequestBuilder outputDirectoryProvider(OutputDirectoryProvider provider);
    
    /**
     * Build the LauncherDiscoveryRequest
     * @return Configured LauncherDiscoveryRequest instance
     */
    LauncherDiscoveryRequest build();
}

import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
import org.junit.platform.launcher.TagFilter;
import org.junit.platform.launcher.EngineFilter;
import static org.junit.platform.engine.discovery.DiscoverySelectors.*;

// Basic request with package selector
LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
    .selectors(selectPackage("com.example.tests"))
    .build();

// Complex request with multiple selectors and filters
LauncherDiscoveryRequest complexRequest = LauncherDiscoveryRequestBuilder.request()
    .selectors(
        selectPackage("com.example.unit"),
        selectClass("com.example.integration.DatabaseTest")
    )
    .filters(
        EngineFilter.includeEngines("junit-jupiter"),
        TagFilter.excludeTags("slow")
    )
    .configurationParameter("junit.jupiter.execution.parallel.enabled", "true")
    .configurationParameter("junit.jupiter.execution.parallel.mode.default", "concurrent")
    .build();

// Request with configuration parameters
LauncherDiscoveryRequest configuredRequest = LauncherDiscoveryRequestBuilder.request()
    .selectors(selectPackage("com.example"))
    .configurationParameters(Map.of(
        "junit.platform.output.capture.stdout", "true",
        "junit.platform.output.capture.stderr", "true"
    ))
    .build();

/**
 * Extends EngineDiscoveryRequest with launcher-specific filters
 */
interface LauncherDiscoveryRequest extends EngineDiscoveryRequest {
    /**
     * Get engine filters for this request
     * @return List of EngineFilter instances
     */
    List<EngineFilter> getEngineFilters();
    
    /**
     * Get post-discovery filters for this request
     * @return List of PostDiscoveryFilter instances
     */
    List<PostDiscoveryFilter> getPostDiscoveryFilters();
    
    /**
     * Get the discovery listener for this request
     * @return LauncherDiscoveryListener instance, may be composite
     */
    LauncherDiscoveryListener getDiscoveryListener();
}

/**
 * Encapsulates result of test discovery by TestEngine
 */
class EngineDiscoveryResult {
    /**
     * Create a successful discovery result
     * @return EngineDiscoveryResult indicating success
     */
    static EngineDiscoveryResult successful();
    
    /**
     * Create a failed discovery result with exception
     * @param throwable - Exception that caused the failure
     * @return EngineDiscoveryResult indicating failure
     */
    static EngineDiscoveryResult failed(Throwable throwable);
    
    /**
     * Get the status of this discovery result
     * @return Status enum value (SUCCESSFUL, FAILED)
     */
    Status getStatus();
    
    /**
     * Get the throwable associated with this result if failed
     * @return Optional containing throwable if failed, empty if successful
     */
    Optional<Throwable> getThrowable();
}

// Package-based discovery
selectPackage("com.example.tests")

// Class-based discovery
selectClass(MyTestClass.class)
selectClass("com.example.MyTestClass")

// Method-based discovery
selectMethod("com.example.MyTestClass#testMethod")
selectMethod(MyTestClass.class, "testMethod")

// URI-based discovery
selectUri("file:///path/to/test/directory")

// Classpath resource discovery
selectClasspathResource("/test-data/sample.xml")