import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.lang.reflect.Field;

import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import org.ietf.jgss.GSSContext;

		Transport: globalRemoteTargetTransport,
		Region:    conf.Region,
	}
	client, err := minio.New(u.Host, opts)
	if err != nil {
		return nil, err
	}
	client.SetAppInfo(fmt.Sprintf("s3-tier-%s", tier), ReleaseTag)

	core := &minio.Core{Client: client}
	return &warmBackendS3{
		client:       client,
		core:         core,
		Bucket:       conf.Bucket,

        assertFalse(filter.accept(mockDir, null), "Should reject null names");

        // Verify getPath was called three times (once for each accept call)
        verify(mockDir, times(3)).getPath();
        verifyNoMoreInteractions(mockDir);
    }

    /**
     * Defensive behavior: implementation throws NPE on null inputs by design.
     */
    @Test

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;

import org.junit.jupiter.api.BeforeEach;

        // Test toggling ShowReport multiple times
        assertFalse(valve.isShowReport());

        valve.setShowReport(true);
        assertTrue(valve.isShowReport());

        valve.setShowReport(false);
        assertFalse(valve.isShowReport());

        valve.setShowReport(true);
        assertTrue(valve.isShowReport());

        // Test toggling ShowServerInfo multiple times
        assertFalse(valve.isShowServerInfo());

package jcifs.smb1.smb1;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

/**

/**
 * A unit of work that can be executed one or more times.
 *
 * Recurrence
 * ----------
 *
 * Tasks control their recurrence schedule. The [runOnce] function returns -1L to signify that the
 * task should not be executed again. Otherwise it returns a delay until the next execution.
 *
 * A task has at most one next execution. If the same task instance is scheduled multiple times, the

            handler.handle(WinError.WINERR_CODES[i], WinError.WINERR_MESSAGES[i]);
        }

        // Verify the collaborator is invoked exactly N times
        verify(handler, times(WinError.WINERR_CODES.length)).handle(anyInt(), anyString());

        // Capture one known interaction to verify argument integrity

        // Verify interactions with dependency are meaningful and ordered
        InOrder order = inOrder(mockContext);
        order.verify(mockContext, times(1)).getConfig();
        order.verify(mockContext, times(1)).getCredentials();
        verifyNoMoreInteractions(mockContext);
    }

    @Test
    @DisplayName("createContext throws on null CIFSContext")

        });

        // When: Create iterator and close multiple times
        NetServerEnumIterator iterator = new NetServerEnumIterator(parent, treeHandle, "*", 0, null);

        iterator.close();
        iterator.close(); // Second close should be safe

        // Then: Tree handle should be released only once
        verify(treeHandle, times(1)).release();
    }

    @Test