private Credentials creds;

    /**
     * Constructs a CIFS context wrapper with custom credentials.
     *
     * @param delegate the context to wrap
     * @param creds
     *            Credentials to use
     */
    public CIFSContextCredentialWrapper(final AbstractCIFSContext delegate, final Credentials creds) {
        super(delegate);
        this.creds = creds;
    }

    /**
     *

        TestCredentials creds = new TestCredentials("A", true, false, subject, false);

        // Act
        TestCredentials copy = creds.clone();

        // Assert
        assertNotSame(creds, copy, "clone must return a new instance");
        assertEquals(creds.getUserDomain(), copy.getUserDomain());
        assertEquals(creds.isAnonymous(), copy.isAnonymous());
        assertEquals(creds.isGuest(), copy.isGuest());

    void testWithCredentials() {
        // Given
        Credentials creds = mock(Credentials.class);
        CIFSContext newContext = mock(CIFSContext.class);
        when(mockContext.withCredentials(creds)).thenReturn(newContext);

        // When
        CIFSContext context = mockContext.withCredentials(creds);

        // Then
        assertEquals(newContext, context);

				conf.AWSRoleARN,
				sessionName,
			},
		}
		creds = credentials.New(&s3WebIdentityIAM)
	case conf.AccessKey != "" && conf.SecretKey != "":
		creds = credentials.NewStaticV4(conf.AccessKey, conf.SecretKey, "")
	default:
		return nil, errors.New("insufficient parameters for S3 backend authentication")
	}
	opts := &minio.Options{
		Creds:     creds,
		Secure:    u.Scheme == "https",

            result = root.find('AssumeRoleWithClientGrantsResult')
            creds = result.find('Credentials')
            return dict(
                access_key=creds.get_child_text('AccessKeyId'),
                secret_key=creds.get_child_text('SecretAccessKey'),
                token=creds.get_child_text('SessionToken'),
                expiry_time=parse(creds.get_child_text('Expiration')).isoformat())

        Runtime.getRuntime().addShutdownHook(this);
    }

    /**
     * @param creds the credentials to use
     * @return a wrapped context with the given credentials
     */
    @Override
    public CIFSContext withCredentials(final Credentials creds) {
        return new CIFSContextCredentialWrapper(this, creds);
    }

    /**
     *
     * {@inheritDoc}
     *

	stsEndpointURL, err := url.Parse(stsEndpoint)
	if err != nil {
		log.Fatalf("Error parsing sts endpoint: %v", err)
	}

	opts := &minio.Options{
		Creds:  li,
		Secure: stsEndpointURL.Scheme == "https",
	}

	mopts := &madmin.Options{
		Creds:  li,
		Secure: stsEndpointURL.Scheme == "https",
	}

	v, err := li.Get()
	if err != nil {
		log.Fatalf("Error retrieving STS credentials: %v", err)
	}

func mustNewSignedRequest(method string, urlStr string, contentLength int64, body io.ReadSeeker, t *testing.T) *http.Request {
	req := mustNewRequest(method, urlStr, contentLength, body, t)
	cred := globalActiveCred
	if err := signRequestV4(req, cred.AccessKey, cred.SecretKey); err != nil {
		t.Fatalf("Unable to initialized new signed http request %s", err)
	}
	return req
}

// This is similar to mustNewRequest but additionally the request

	creds := strings.SplitN(strings.TrimSpace(credElement), "=", 2)
	if len(creds) != 2 {
		return ch, ErrMissingFields
	}
	if creds[0] != "Credential" {
		return ch, ErrMissingCredTag
	}
	credElements := strings.Split(strings.TrimRight(strings.TrimSpace(creds[1]), SlashSeparator), SlashSeparator)
	if len(credElements) < 5 {
		return ch, ErrCredMalformed

        assertNull(b.getServer());
    }

    @Test
    @DisplayName("shouldForceSigning depends on config, creds, and IPC")
    void testShouldForceSigning() {
        when(config.isIpcSigningEnforced()).thenReturn(true);
        when(creds.isAnonymous()).thenReturn(false);

        // Case 1: share is IPC$ -> IPC
        SmbResourceLocatorImpl ipc = locator("smb://server/IPC$/");