@Mock
    private Address mockAddress;

    private NameServiceClientImpl nameServiceClient;

    @BeforeEach
    void setUp() throws UnknownHostException {
        // Configure mock context with fast timeouts
        when(mockContext.getConfig()).thenReturn(mockConfig);

        // Setup configuration with minimal timeouts for fast testing
        when(mockConfig.getNetbiosSoTimeout()).thenReturn(100); // Very short timeout

        @Param({ "100" })
        int topNSize;

        @Param({ "1", "10", "100" })
        int cardinalityFactor;

        List<InternalAggregations> aggsList;

        @Setup
        public void setup() {
            this.aggsList = new ArrayList<>();
            Random rand = new Random(seed);
            int cardinality = cardinalityFactor * topNSize;

    private MockRelatedContentBhv mockBhv;
    private VirtualHostHelper virtualHostHelper;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);

        // Setup system properties for DI container
        File file = File.createTempFile("test", ".properties");
        file.deleteOnExit();

    @TempDir
    File temporaryFolder

    @Subject AcceptedApiChangesJsonFileManager jsonFileManager = new AcceptedApiChangesJsonFileManager()

    def jsonFile

    def setup() {
        jsonFile = new File(temporaryFolder, 'acceptedChanges.json')
    }

    def "can clean existing API changes"() {
        given:
        jsonFile << existingAcceptedApiChanges()

        when:

public class SmbComQueryInformationTest {

    private static final String TEST_FILE_NAME = "testFile.txt";
    private SmbComQueryInformation smbComQueryInformation;

    @BeforeEach
    public void setUp() {
        smbComQueryInformation = new SmbComQueryInformation(TEST_FILE_NAME);
    }

    @Test
    public void testConstructor() {
        // Test if the constructor sets the file name and command correctly

    val message: String,
    val param: String?,
  ) {
    enum class Type {
      Handshake,
      Plaintext,
      Encrypted,
      Setup,
      Unknown,
    }

    val type: Type
      get() =
        when {
          message == "adding as trusted certificates" -> Type.Setup
          message == "Raw read" || message == "Raw write" -> Type.Encrypted

import jcifs.dcerpc.msrpc.samr;

class MsrpcEnumerateAliasesInDomainTest {

    @Mock
    private SamrDomainHandle mockDomainHandle;
    @Mock
    private samr.SamrSamArray mockSamArray;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void constructor_shouldInitializeFieldsCorrectly() {
        // Given
        int acctFlags = 123;

        // When

    private int ttype = TT_NOTHING;

    private String sval;

    private char[] buf = new char[20];

    private int peekc = NEED_CHAR;

    private byte peekct = 0;

    static {
        setup(defaultCtype);
    }

    /**
     * Creates a {@link Tokenizer}.
     *
     * @param str
     *            The string. Must not be {@literal null}.
     */
    public Tokenizer(final String str) {

import org.junit.jupiter.api.TestInfo;

public class CrawlerLogHelperTest extends UnitFessTestCase {

    private CrawlerLogHelper crawlerLogHelper;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        crawlerLogHelper = new CrawlerLogHelper();
    }

    @Test
    public void test_instantiation() {
        assertNotNull(crawlerLogHelper);
    }

    @Test

```
--ftp="tls-private-key=path/to/private.key" --ftp="tls-public-cert=path/to/public.crt"
```

> NOTE: if MinIO distributed setup is already configured to run under TLS, FTP will automatically use the relevant
> certs from the server certificate chain, this is mainly to add simplicity of setup. However if you wish to terminate
> TLS certificates via a different domain for your FTP servers you may choose the above command line options.