return
	}

	cfg, err := readServerConfig(ctx, objectAPI, nil)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	if err = cfg.DelFrom(bytes.NewReader(kvBytes)); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	if err = validateConfig(ctx, cfg, subSys); err != nil {

        SmbFileHandleImpl hA = id1 != null ? new SmbFileHandleImpl(cfg, id1, tA, "//eq/a", 0, 0, 0, 0, 0L)
                : new SmbFileHandleImpl(cfg, 33, tA, "//eq/a", 0, 0, 0, 0, 0L);

        SmbFileHandleImpl hB = id2 != null ? new SmbFileHandleImpl(cfg, id2, tB, "//eq/b", 0, 0, 0, 0, 0L)
                : new SmbFileHandleImpl(cfg, 33, tB, "//eq/b", 0, 0, 0, 0, 0L);

        if (expectEqual) {

	var cfgList []madmin.IDPListItem
	var err error
	switch idpCfgType {
	case madmin.OpenidIDPCfg:
		cfg := globalServerConfig.Clone()
		cfgList, err = globalIAMSys.OpenIDConfig.GetConfigList(cfg)
	case madmin.LDAPIDPCfg:
		cfg := globalServerConfig.Clone()
		cfgList, err = globalIAMSys.LDAPConfig.GetConfigList(cfg)

	default:
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL)
		return
	}

    @Mock
    private Configuration cfg;
    @Mock
    private Address address;

    private SmbTransportImpl transport;

    @BeforeEach
    void setUp() throws Exception {
        when(ctx.getConfig()).thenReturn(cfg);
        when(cfg.isSigningEnforced()).thenReturn(false);
        when(cfg.getSessionTimeout()).thenReturn(30_000);
        when(cfg.getResponseTimeout()).thenReturn(5_000);

			cfg.S3.AccessKey = creds.AccessKey
			cfg.S3.SecretKey = creds.SecretKey
		}
	case madmin.Azure:
		if creds.SecretKey != "" {
			cfg.Azure.AccountKey = creds.SecretKey
		}
		if creds.AzSP.TenantID != "" {
			cfg.Azure.SPAuth.TenantID = creds.AzSP.TenantID
		}
		if creds.AzSP.ClientID != "" {
			cfg.Azure.SPAuth.ClientID = creds.AzSP.ClientID
		}
		if creds.AzSP.ClientSecret != "" {

	t.enableODirect = cfg.EnableODirect
	t.gzipObjects = cfg.GzipObjects
	t.rootAccess = cfg.RootAccess
	t.syncEvents = cfg.SyncEvents
	t.objectMaxVersions = cfg.ObjectMaxVersions

	if t.staleUploadsCleanupInterval != cfg.StaleUploadsCleanupInterval {
		t.staleUploadsCleanupInterval = cfg.StaleUploadsCleanupInterval

		// signal that cleanup interval has changed
		select {

        final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
        final CsvConfig cfg = new CsvConfig(',', '"', '"');
        cfg.setEscapeDisabled(false);
        cfg.setQuoteDisabled(false);
        @SuppressWarnings("resource")
        final CsvReader csvReader = new CsvReader(reader, cfg);
        try {
            List<String> list;
            csvReader.readValues(); // ignore header

	for name, cfg := range pcfgs {
		callback := getConsoleEndpoints()[0] + "/oauth_callback"
		if cfg.RedirectURI != "" {
			callback = cfg.RedirectURI
		}
		m[name] = consoleoauth2.ProviderConfig{
			URL:                     cfg.URL.String(),
			DisplayName:             cfg.DisplayName,
			ClientID:                cfg.ClientID,
			ClientSecret:            cfg.ClientSecret,

	}
}

// create minio-go clients for buckets having remote targets
func (sys *BucketTargetSys) set(bucket string, meta BucketMetadata) {
	cfg := meta.bucketTargetConfig
	if cfg == nil || cfg.Empty() {
		return
	}
	sys.Lock()
	defer sys.Unlock()
	for _, tgt := range cfg.Targets {
		tgtClient, err := sys.getRemoteTargetClient(&tgt)
		if err != nil {
			replLogIf(GlobalContext, err)
			continue
		}

        private CIFSContext ctxWithIgnore(boolean ignore) {
            CIFSContext ctx = mock(CIFSContext.class);
            Configuration cfg = mock(Configuration.class);
            when(cfg.isIgnoreCopyToException()).thenReturn(ignore);
            when(ctx.getConfig()).thenReturn(cfg);
            return ctx;
        }

        @Test
        @DisplayName("copyFile wraps and throws when ignoreCopyToException=false")