ArtifactRepositoryLayout repoLayout;

    @Inject
    PlexusContainer container;

    public PlexusContainer getContainer() {
        return container;
    }

    @BeforeEach
    public void setUp() throws Exception {
        RepositorySystemSession repoSession = initRepoSession();
        MavenSession session = new MavenSession(

testing/distributions-integ-tests       @gradle/bt-developer-productivity
testing/public-api-tests                @gradle/bt-developer-productivity
testing/integ-test/
version.txt
released-versions.json

# Dev setup
.idea                                   @gradle/bt-developer-productivity
.editorconfig                           @gradle/bt-developer-productivity
.gitignore                              @gradle/bt-developer-productivity

	MissingContentLength
	TooBigObject
	TooBigDecodedLength
	BadSignature
	BadMD5
	MissingUploadID
)

// Wrapper for calling HeadObject API handler tests for both Erasure multiple disks and FS single drive setup.
func TestAPIHeadObjectHandler(t *testing.T) {
	ExecObjectLayerAPITest(ExecObjectLayerAPITestArgs{t: t, objAPITest: testAPIHeadObjectHandler, endpoints: []string{"HeadObject"}})
}

	}
	_, err := s.adm.SetConfigKV(ctx, strings.Join(configCmds, " "))
	if err != nil {
		c.Fatalf("unable to setup LDAP for tests: %v", err)
	}

	s.RestartIAMSuite(c)
}

// SetUpLDAPWithNonNormalizedBaseDN - expects to setup an LDAP test server using
// the test LDAP container and canned data from
// https://github.com/minio/minio-ldap-testing
//

import org.ietf.jgss.Oid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSException;
import jcifs.spnego.NegTokenInit;

/**
 * This class used to provide Kerberos feature when setup GSSContext.
 *
 * @author Shun
 */
class Kerb5Context implements SSPContext {

    private static final Logger log = LoggerFactory.getLogger(Kerb5Context.class);

    @Mock
    private CommonServerMessageBlock messageBlock;

    @Mock
    private CommonServerMessageBlockResponse response;

    @Mock
    private SMBSigningDigest digest;

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

    @Test
    @DisplayName("Test decode method with valid buffer")
    void testDecodeWithValidBuffer() throws SMBProtocolDecodingException {
        // Given

 */
class TransWaitNamedPipeResponseTest {

    @Mock
    private Configuration mockConfig;

    private TransWaitNamedPipeResponse response;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        response = new TransWaitNamedPipeResponse(mockConfig);
    }

    @Test
    @DisplayName("Constructor should initialize TransWaitNamedPipeResponse")

 */
@TestInstance(Lifecycle.PER_METHOD)
public class SecureCredentialStorageTest {

    private SecureCredentialStorage storage;
    private char[] masterPassword;

    @BeforeEach
    public void setUp() throws Exception {
        masterPassword = "MasterPassword123!@#".toCharArray();
        storage = new SecureCredentialStorage(masterPassword.clone());
    }

    @AfterEach
    public void tearDown() throws Exception {

        client = runner.client();
    }

    @AfterClass
    public static void afterClass() throws Exception {
        runner.close();
        runner.clean();
    }

    @Before
    public void setUp() {
        builder = new SuggestSettingsBuilder();
    }

    @Test
    public void testConstructor() {
        // Test default constructor
        SuggestSettingsBuilder testBuilder = new SuggestSettingsBuilder();

        when(mockTree.isSMB2()).thenReturn(true); // default SMB2 for simple happy-path
        return new SmbFileInputStream(mockFile, mockTree, mockHandle);
    }

    @BeforeEach
    void setUp() throws Exception {
        // Common, safe defaults for collaborators
        when(mockHandle.isValid()).thenReturn(true);
        when(mockHandle.acquire()).thenReturn(mockHandle);