public UsernamePassword getUsernamePassword(URIish uri) {
  addDefaultCredentials(credentials);

  String username = uri.getUser();
  String password = uri.getPass();

  CredentialItem.Username u = new CredentialItem.Username();
  CredentialItem.Password p = new CredentialItem.Password();

  if (supports(u, p) && get(uri, u, p)) {
    username = u.getValue();
    char[] v = p.getValue();
    password = (v == null) ? null : new String(p.getValue());
    p.clear();
  }

  return new UsernamePassword(username, password);
}
 

@Override
public boolean get(URIish uri, CredentialItem... items) throws UnsupportedCredentialItem {
    for (CredentialItem i : items) {
        if (i instanceof Identity) {
            ((Identity) i).setValue(identityFile);
            continue;
        }
        if (i instanceof KnownHosts) {
            ((KnownHosts) i).setValue(knownHostsFile);
            continue;
        }
        throw new UnsupportedCredentialItem(uri, i.getClass().getName()
                + ":" + i.getPromptText()); //$NON-NLS-1$
    }
    return true;
}
 

@Override
public boolean get(URIish uri, CredentialItem... items) throws UnsupportedCredentialItem {

	if (!matchesKey(items)) {
		return false;
	}

	for (CredentialItem item : items) {
		if (item instanceof CharArrayType) {
			((CharArrayType) item).setValueNoCopy(gpg.getPassword().toString().toCharArray());

			return true;
		}
	}
	return false;
}
 

/**
 * We support username and password credential items only.
 * @see org.eclipse.jgit.transport.CredentialsProvider#supports(org.eclipse.jgit.transport.CredentialItem[])
 */
@Override
public boolean supports(CredentialItem... items) {
	for (CredentialItem i : items) {
		if (i instanceof CredentialItem.Username) {
			continue;
		}
		else if (i instanceof CredentialItem.Password) {
			continue;
		}
		else {
			return false;
		}
	}
	return true;
}
 

@Test
public void testSupportsSslValidationYesNoTypes() {
	CredentialItem yesNoType = new CredentialItem.YesNoType(
			JGitText.get().sslTrustNow);
	assertThat(this.skipSslValidationCredentialsProvider.supports(yesNoType)).as(
			"GitSkipSslValidationCredentialsProvider should always support the trust now YesNoType item")
			.isTrue();

	yesNoType = new CredentialItem.YesNoType(
			MessageFormat.format(JGitText.get().sslTrustForRepo, "/a/path.git"));
	assertThat(this.skipSslValidationCredentialsProvider.supports(yesNoType)).as(
			"GitSkipSslValidationCredentialsProvider should always support the trust repo YesNoType item")
			.isTrue();

	yesNoType = new CredentialItem.YesNoType(JGitText.get().sslTrustAlways);
	assertThat(this.skipSslValidationCredentialsProvider.supports(yesNoType)).as(
			"GitSkipSslValidationCredentialsProvider should always support the trust always YesNoType item")
			.isTrue();

	yesNoType = new CredentialItem.YesNoType("unrelated");
	assertThat(this.skipSslValidationCredentialsProvider.supports(yesNoType)).as(
			"GitSkipSslValidationCredentialsProvider should not support unrelated YesNoType items")
			.isFalse();
}
 

@Test
public void testSupportsUnrelatedCredentialItemTypesWithDelegate() {
	this.skipSslValidationCredentialsProvider = new GitSkipSslValidationCredentialsProvider(
			this.mockDelegateCredentialsProvider);
	CredentialItem usernameCredentialItem = new CredentialItem.Username();

	when(this.mockDelegateCredentialsProvider.supports(usernameCredentialItem))
			.thenReturn(true);

	boolean supportsItems = this.skipSslValidationCredentialsProvider
			.supports(usernameCredentialItem);

	assertThat(supportsItems).as(
			"GitSkipSslValidationCredentialsProvider must support the types supported by its delegate CredentialsProvider")
			.isTrue();
}
 

@Test
public void testGetUnrelatedCredentialItemTypesWithDelegate()
		throws URISyntaxException {
	this.skipSslValidationCredentialsProvider = new GitSkipSslValidationCredentialsProvider(
			this.mockDelegateCredentialsProvider);
	URIish uri = new URIish("https://example.com/repo.git");
	CredentialItem usernameCredentialItem = new CredentialItem.Username();
	CredentialItem passwordCredentialItem = new CredentialItem.Password();

	when(this.mockDelegateCredentialsProvider.get(uri, usernameCredentialItem,
			passwordCredentialItem)).thenReturn(true);

	boolean getSuccessful = this.skipSslValidationCredentialsProvider.get(uri,
			usernameCredentialItem, passwordCredentialItem);

	assertThat(getSuccessful).as("GitSkipSslValidationCredentialsProvider "
			+ "must successfully get the types supported by its delegate CredentialsProvider")
			.isTrue();
}
 

@Test
public void testGetSslTrustItems() throws URISyntaxException {
	URIish uri = new URIish("https://example.com/repo.git");
	CredentialItem message = new CredentialItem.InformationalMessage(
			JGitText.get().sslFailureTrustExplanation);
	CredentialItem.YesNoType trustNow = new CredentialItem.YesNoType(
			JGitText.get().sslTrustNow);
	CredentialItem.YesNoType trustAlways = new CredentialItem.YesNoType(
			JGitText.get().sslTrustAlways);

	boolean getSuccessful = this.skipSslValidationCredentialsProvider.get(uri,
			message, trustNow, trustAlways);

	assertThat(getSuccessful).as(
			"SkipSSlValidationCredentialsProvider must successfully get the types required for SSL validation skipping")
			.isTrue();
	assertThat(trustNow.getValue()).as(
			"SkipSSlValidationCredentialsProvider should trust the current repo operation")
			.isTrue();
	assertThat(trustAlways.getValue())
			.as("We should not globally skip all SSL validation").isFalse();
}
 

@Test
public void testNotSupportsOther() {
	assertThat(this.provider.supports(
			new CredentialItem[] { new CredentialItem.YesNoType("OK To Login?") // this
			// is
			// not
			// ok
			})).isFalse();
	assertThat(this.provider.supports(
			new CredentialItem[] { new CredentialItem.StringType("OK To Login?", true) // this
			// is
			// not
			// ok
			})).isFalse();
	assertThat(this.provider
			.supports(new CredentialItem[] { new CredentialItem.Username(), // this
					// is
					// ok
					new CredentialItem.Password(), // this is ok
					new CredentialItem.StringType("OK To Login?", true) // this is not
			// ok
			})).isFalse();
}
 

@Test
public void testReturnsCredentials() throws URISyntaxException {
	CredentialItem[] credentialItems = makeCredentialItems();
	assertThat(this.provider.get(new URIish(AWS_REPO), credentialItems)).isTrue();

	String theUsername = ((CredentialItem.Username) credentialItems[0]).getValue();
	char[] thePassword = ((CredentialItem.Password) credentialItems[1]).getValue();

	assertThat(theUsername).isEqualTo(USER);
	assertThat(thePassword).isNotNull();

	// The password will always begin with a timestamp like
	// 20161113T121314Z
	assertThat(thePassword.length > 16).isTrue();
	assertThat(thePassword[8]).isEqualTo('T');
	assertThat(thePassword[15]).isEqualTo('Z');
}
 

@Override
public boolean get(URIish uri, CredentialItem... items)
        throws UnsupportedCredentialItem {
    for (CredentialItem item : items) {
        if (item instanceof CredentialItem.Username) {
            ((CredentialItem.Username) item).setValue(username);
        } else if (item instanceof CredentialItem.Password) {
            ((CredentialItem.Password) item).setValue(password.toCharArray());
        } else if (item instanceof CredentialItem.StringType) {
            ((CredentialItem.StringType) item).setValue(password);
        } else if (item instanceof CredentialItem.InformationalMessage) {
            throw new UnsupportedCredentialItem(uri, "Not supported");
        } else if (item instanceof CredentialItem.YesNoType) {
            // TODO handle strict host key checking here
            throw new UnsupportedCredentialItem(uri, "Not supported");
        } else {
            throw new UnsupportedCredentialItem(uri, "Not supported");
        }
    }
    return true;
}
 

/** {@inheritDoc} */
@Override
public synchronized boolean supports(CredentialItem... credentialItems) {
    items:
    for (CredentialItem item : credentialItems) {
        if (supports(defaultCredentials, item)) {
            continue;
        }
        for (StandardCredentials c : specificCredentials.values()) {
            if (supports(c, item)) {
                continue items;
            }
        }
        return false;
    }
    return true;
}
 

/**
 * {@inheritDoc}
 *
 * If username/password is given, use it for HTTP auth.
 */
@Override
public boolean supports(CredentialItem... items) {
    if (!(cred instanceof StandardUsernamePasswordCredentials))
        return false;

    for (CredentialItem i : items) {
        if (i instanceof CredentialItem.Username)
            continue;

        else if (i instanceof CredentialItem.Password)
            continue;

        else
            return false;
    }
    return true;
}
 

@Before
public void setUp() {
    listener = StreamTaskListener.fromStdout();
    provider = new SmartCredentialsProvider(listener);
    username = new CredentialItem.Username();
    password = new CredentialItem.Password();

    maskedUsername = new StandardUsernameCredentialsCredentialItem(MASKED_USER_NAME_PROMPT, true);
    unmaskedUsername = new StandardUsernameCredentialsCredentialItem(UNMASKED_USER_NAME_PROMPT, false);

    maskedStringType = new CredentialItem.StringType(MASKED_STRING_TYPE_PROMPT, true);
    unmaskedStringType = new CredentialItem.StringType(UNMASKED_STRING_TYPE_PROMPT, false);
    specialStringType = new CredentialItem.StringType(SPECIAL_STRING_TYPE_PROMPT, false);

    assertNull(username.getValue());
    assertNull(password.getValue());
    assertNull(maskedUsername.getValue());
    assertNull(unmaskedUsername.getValue());
    assertNull(maskedStringType.getValue());
    assertNull(unmaskedStringType.getValue());
}
 

@Override
public boolean get(URIish uri, CredentialItem... items) throws UnsupportedCredentialItem {
	for(CredentialItem item : items){
		if(item instanceof CredentialItem.YesNoType){
			((CredentialItem.YesNoType) item).setValue(true);
			return true;
		}
	}
	return false;
}
 

@Override
public boolean supports(CredentialItem... items) {
	for(CredentialItem item : items){
		if(item instanceof CredentialItem.YesNoType){
			return true;
		}
	}
	return false;
}
 

@Override
public boolean supports (CredentialItem... items) {
    for (CredentialItem i : items) {
        if (!(i instanceof CredentialItem.Username
                || i instanceof CredentialItem.Password)) {
            return false;
        }
    }
    return true;
}
 

@Override
public boolean get (URIish uriish, CredentialItem... items) throws UnsupportedCredentialItem {
    String user = uriish.getUser();
    if (user == null) {
        user = "";
    }
    String password = uriish.getPass();
    if (password == null) {
        password = "";
    }
    for (CredentialItem i : items) {
        if (i instanceof CredentialItem.Username) {
            ((CredentialItem.Username) i).setValue(user);
            continue;
        }
        if (i instanceof CredentialItem.Password) {
            ((CredentialItem.Password) i).setValue(password.toCharArray());
            continue;
        }
        if (i instanceof CredentialItem.StringType) {
            if (i.getPromptText().equals("Password: ")) { //NOI18N
                ((CredentialItem.StringType) i).setValue(password);
                continue;
            }
        }
        throw new UnsupportedCredentialItem(uriish, i.getClass().getName()
                + ":" + i.getPromptText()); //NOI18N
    }
    return true;
}
 

protected final URIish getUriWithUsername (boolean pushUri) throws URISyntaxException {
    URIish uri = getUri(pushUri);
    if (credentialsProvider != null) {
        CredentialItem.Username itm = new CredentialItem.Username();
        credentialsProvider.get(uri, itm);
        if (itm.getValue() != null) {
            if (itm.getValue().isEmpty()) {
                uri = uri.setUser(null);
            } else {
                uri = uri.setUser(itm.getValue());
            }
        }
    }
    return uri;
}
 

@Override
public synchronized RemoteSession getSession (URIish uri, CredentialsProvider credentialsProvider, FS fs, int tms) throws TransportException {
    boolean agentUsed = false;
    String host = uri.getHost();
    CredentialItem.StringType identityFile = null;
    if (credentialsProvider != null) {
        identityFile = new JGitCredentialsProvider.IdentityFileItem("Identity file for " + host, false);
        if (credentialsProvider.isInteractive() && credentialsProvider.get(uri, identityFile) && identityFile.getValue() != null) {
            LOG.log(Level.FINE, "Identity file for {0}: {1}", new Object[] { host, identityFile.getValue() }); //NOI18N
            agentUsed = setupJSch(fs, host, identityFile, uri, true);
            LOG.log(Level.FINE, "Setting cert auth for {0}, agent={1}", new Object[] { host, agentUsed }); //NOI18N
        }
    }
    try {
        LOG.log(Level.FINE, "Trying to connect to {0}, agent={1}", new Object[] { host, agentUsed }); //NOI18N
        return super.getSession(uri, credentialsProvider, fs, tms);
    } catch (Exception ex) {
        // catch rather all exceptions. In case jsch-agent-proxy is broken again we should
        // at least fall back on key/pasphrase
        if (agentUsed) {
            LOG.log(ex instanceof TransportException ? Level.FINE : Level.INFO, null, ex);
            setupJSch(fs, host, identityFile, uri, false);
            LOG.log(Level.FINE, "Trying to connect to {0}, agent={1}", new Object[] { host, false }); //NOI18N
            return super.getSession(uri, credentialsProvider, fs, tms);
        } else {
            LOG.log(Level.FINE, "Connection failed: {0}", host); //NOI18N
            throw ex;
        }
    }
}
 

private boolean setupJSch (FS fs, String host, CredentialItem.StringType identityFile, URIish uri, boolean preferAgent) throws TransportException {
    boolean agentUsed;
    if (sshConfig == null) {
        sshConfig = OpenSshConfig.get(fs);
    }
    final OpenSshConfig.Host hc = sshConfig.lookup(host);
    try {
        JSch jsch = getJSch(hc, fs);
        agentUsed = setupJSchIdentityRepository(jsch, identityFile.getValue(), preferAgent);
    } catch (JSchException ex) {
        throw new TransportException(uri, ex.getMessage(), ex);
    }
    return agentUsed;
}
 

@Override
public boolean supports(CredentialItem... items) {
    for (CredentialItem i : items) {
        if (i instanceof Identity) {
            continue;
        } else if (i instanceof KnownHosts) {
            continue;
        } else {
            return false;
        }

    }
    return true;
}
 

@Override
public boolean get(URIish uri, CredentialItem... items) throws UnsupportedCredentialItem {

    // only handle HTTP(s)
    if (uri.getScheme() != null && !uri.getScheme().startsWith("http")) {
        return false;
    }

    CredentialsPair credentialsPair = credentials.computeIfAbsent(uri, u -> {
        try {
            return lookupCredentials(uri);
        } catch (IOException | InterruptedException | RuntimeException e) {
            logger.warn("Failed to look up credentials via 'git credential fill' for: " + uri, e);
            return null;
        }
    });
    if (credentialsPair == null) {
        return false;
    }

    // map extracted credentials to CredentialItems, see also: org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider
    for (CredentialItem item : items) {
        if (item instanceof CredentialItem.Username) {
            ((CredentialItem.Username) item).setValue(credentialsPair.username);
        } else if (item instanceof CredentialItem.Password) {
            ((CredentialItem.Password) item).setValue(credentialsPair.password);
        } else if (item instanceof CredentialItem.StringType && item.getPromptText().equals("Password: ")) {
            ((CredentialItem.StringType) item).setValue(new String(credentialsPair.password));
        } else {
            throw new UnsupportedCredentialItem(uri, item.getClass().getName() + ":" + item.getPromptText());
        }
    }

    return true;
}
 

@Override
public boolean supports(CredentialItem... items) {

	boolean matchesKey = matchesKey(items);
	boolean hasSettableCharArray = Arrays.stream(items).anyMatch(CharArrayType.class::isInstance);

	return matchesKey && hasSettableCharArray;
}
 

@Override
public boolean supports(CredentialItem... items) {
    for (CredentialItem i : items) {
        if (!(i instanceof CredentialItem.Username) && !(i instanceof CredentialItem.Password)) {
            return false;
        }
    }
    return true;
}
 

@Override
public boolean supports(CredentialItem... items) {
	List<CredentialItem> unprocessedItems = new ArrayList<>();

	for (CredentialItem item : items) {
		if (item instanceof CredentialItem.InformationalMessage
				&& item.getPromptText() != null && item.getPromptText()
						.contains(JGitText.get().sslFailureTrustExplanation)) {
			continue;
		}

		if (item instanceof CredentialItem.YesNoType && item.getPromptText() != null
				&& (item.getPromptText().equals(JGitText.get().sslTrustNow)
						|| item.getPromptText()
								.startsWith(stripFormattingPlaceholders(
										JGitText.get().sslTrustForRepo))
						|| item.getPromptText()
								.equals(JGitText.get().sslTrustAlways))) {
			continue;
		}

		unprocessedItems.add(item);
	}

	return unprocessedItems.isEmpty() || (this.delegate != null && this.delegate
			.supports(unprocessedItems.toArray(new CredentialItem[0])));
}
 

@Override
public boolean get(URIish uri, CredentialItem... items)
		throws UnsupportedCredentialItem {
	List<CredentialItem> unprocessedItems = new ArrayList<>();

	for (CredentialItem item : items) {
		if (item instanceof CredentialItem.YesNoType) {
			CredentialItem.YesNoType yesNoItem = (CredentialItem.YesNoType) item;
			String prompt = yesNoItem.getPromptText();
			if (prompt == null) {
				unprocessedItems.add(item);
			}
			else if (prompt.equals(JGitText.get().sslTrustNow) || prompt.startsWith(
					stripFormattingPlaceholders(JGitText.get().sslTrustForRepo))) {
				yesNoItem.setValue(true);
			}
			else if (prompt.equals(JGitText.get().sslTrustAlways)) {
				yesNoItem.setValue(false);
			}
			else {
				unprocessedItems.add(item);
			}
		}
		else if (!item.getPromptText()
				.contains(JGitText.get().sslFailureTrustExplanation)) {
			unprocessedItems.add(item);
		}
	}

	if (unprocessedItems.isEmpty()) {
		return true;
	}
	if (this.delegate != null) {
		return this.delegate.get(uri,
				unprocessedItems.toArray(new CredentialItem[0]));
	}
	throw new UnsupportedCredentialItem(uri,
			unprocessedItems.size() + " credential items not supported");
}
 

/**
 * {@inheritDoc}
 */
@Override
public boolean supports(CredentialItem... items) {
	for (final CredentialItem item : items) {
		if (item instanceof CredentialItem.StringType
				&& item.getPromptText().startsWith(PROMPT)) {
			continue;
		}
		else {
			return false;
		}
	}
	return true;
}
 

/**
 * Ask for the credential items to be populated with the passphrase.
 * @param uri the URI of the remote resource that needs authentication.
 * @param items the items the application requires to complete authentication.
 * @return {@code true} if the request was successful and values were supplied;
 * {@code false} if the user canceled the request and did not supply all requested
 * values.
 * @throws UnsupportedCredentialItem if one of the items supplied is not supported.
 */
@Override
public boolean get(URIish uri, CredentialItem... items)
		throws UnsupportedCredentialItem {
	for (final CredentialItem item : items) {
		if (item instanceof CredentialItem.StringType
				&& item.getPromptText().startsWith(PROMPT)) {
			((CredentialItem.StringType) item).setValue(this.passphrase);
			continue;
		}
		throw new UnsupportedCredentialItem(uri,
				item.getClass().getName() + ":" + item.getPromptText());
	}
	return true;
}
 

@Test
public void testSupportsSslFailureInformationalMessage() {
	CredentialItem informationalMessage = new CredentialItem.InformationalMessage(
			"text " + JGitText.get().sslFailureTrustExplanation + " more text");
	assertThat(this.skipSslValidationCredentialsProvider
			.supports(informationalMessage)).as(
					"GitSkipSslValidationCredentialsProvider should always support SSL failure InformationalMessage")
					.isTrue();

	informationalMessage = new CredentialItem.InformationalMessage("unrelated");
	assertThat(this.skipSslValidationCredentialsProvider
			.supports(informationalMessage)).as(
					"GitSkipSslValidationCredentialsProvider should not support unrelated InformationalMessage items")
					.isFalse();
}