下面列出了怎么用java.security.InvalidParameterException的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public Object newInstance(Object ctrParamObj)
throws NoSuchAlgorithmException {
String type = getType();
if (ctrParamObj != null) {
throw new InvalidParameterException
("constructorParameter not used with " + type +
" engines");
}
String algo = getAlgorithm();
try {
if (type.equals("GssApiMechanism")) {
if (algo.equals("1.2.840.113554.1.2.2")) {
return new Krb5MechFactory();
} else if (algo.equals("1.3.6.1.5.5.2")) {
return new SpNegoMechFactory();
}
}
} catch (Exception ex) {
throw new NoSuchAlgorithmException
("Error constructing " + type + " for " +
algo + " using SunJGSS", ex);
}
throw new ProviderException("No impl for " + algo +
" " + type);
}
/**
* Initializes this parameter generator for a certain strength
* and source of randomness.
*
* @param strength the strength (size of prime) in bits
* @param random the source of randomness
*/
protected void engineInit(int strength, SecureRandom random) {
if ((strength >= 512) && (strength <= 1024) && (strength % 64 == 0)) {
this.valueN = 160;
} else if (strength == 2048) {
this.valueN = 224;
// } else if (strength == 3072) {
// this.valueN = 256;
} else {
throw new InvalidParameterException
("Prime size should be 512 - 1024, or 2048");
}
this.valueL = strength;
this.seedLen = valueN;
this.random = random;
}
public void initialize(
int strength,
SecureRandom random)
{
this.strength = strength;
this.random = random;
ECGenParameterSpec ecParams = (ECGenParameterSpec)ecParameters.get(Integers.valueOf(strength));
if (ecParams == null)
{
throw new InvalidParameterException("unknown key size.");
}
try
{
initialize(ecParams, random);
}
catch (InvalidAlgorithmParameterException e)
{
throw new InvalidParameterException("key size not configurable.");
}
}
/**
* Determines the name of the domain parameters that were used for generating the key.
*
* @param key An EC key
* @return The name of the domain parameters that were used for the EC key,
* or an empty string if curve is unknown.
*/
public static String getNamedCurve(Key key) {
if (!(key instanceof ECKey)) {
throw new InvalidParameterException("Not a EC private key.");
}
ECKey ecKey = (ECKey) key;
ECParameterSpec params = ecKey.getParams();
if (!(params instanceof ECNamedCurveSpec)) {
return "";
}
ECNamedCurveSpec ecPrivateKeySpec = (ECNamedCurveSpec) params;
String namedCurve = ecPrivateKeySpec.getName();
return namedCurve;
}
/**
* Constructor.
*
* @param m degree of the finite field GF(2^m)
* @param t error correction capability of the code
* @throws InvalidParameterException if <tt>m < 1</tt> or <tt>m > 32</tt> or
* <tt>t < 0</tt> or <tt>t > n</tt>.
*/
public ECCKeyGenParameterSpec(int m, int t)
throws InvalidParameterException
{
if (m < 1)
{
throw new InvalidParameterException("m must be positive");
}
if (m > 32)
{
throw new InvalidParameterException("m is too large");
}
this.m = m;
n = 1 << m;
if (t < 0)
{
throw new InvalidParameterException("t must be positive");
}
if (t > n)
{
throw new InvalidParameterException("t must be less than n = 2^m");
}
this.t = t;
fieldPoly = PolynomialRingGF2.getIrreduciblePolynomial(m);
}
@Override
protected void build(final AnnotationData data, final Annotation annotation, final Class<? extends Annotation> expectedAnnotationClass,
final Method targetMethod) {
if (isReturnDataUpdateContent(targetMethod)) {
data.setReturnDataIndex(true);
return;
}
final Integer foundIndex = getIndexOfAnnotatedParam(targetMethod, ParameterDataUpdateContent.class);
if (foundIndex == null) {
throw new InvalidParameterException(String.format(
"No ReturnDataUpdateContent or ParameterDataUpdateContent annotation found on method [%s]", targetMethod.getName()));
}
data.setDataIndex(foundIndex);
}
public static HexagonMap.Direction getDirectionFromNumber(final int i) {
switch (i) {
case 0:
return HexagonMap.Direction.NORTHWEST;
case 1:
return HexagonMap.Direction.NORTHEAST;
case 2:
return HexagonMap.Direction.EAST;
case 3:
return HexagonMap.Direction.SOUTHEAST;
case 4:
return HexagonMap.Direction.SOUTHWEST;
case 5:
return HexagonMap.Direction.WEST;
default:
}
throw new InvalidParameterException("unknown direction: " + i);
}
/**
* See {@link IEventNotificationService#unsubscribe(String, String, Long, Long)
*/
protected void unsubscribe(Event event, Integer userId) throws InvalidParameterException {
if (userId == null) {
throw new InvalidParameterException("User ID can not be null.");
}
Iterator<Subscription> subscriptionIterator = event.getSubscriptions().iterator();
while (subscriptionIterator.hasNext()) {
Subscription subscription = subscriptionIterator.next();
if (subscription.getUserId().equals(userId)) {
subscriptionIterator.remove();
}
}
if (event.getSubscriptions().isEmpty()) {
eventDAO.delete(event);
} else {
eventDAO.insertOrUpdate(event);
}
}
public void setRefreshStyle(int type){
setRefreshing(false);
switch (type){
case STYLE_CIRCLES:
mRefreshDrawable = new CirclesDrawable(getContext(), this);
break;
case STYLE_WATER_DROP:
mRefreshDrawable = new WaterDropDrawable(getContext(), this);
break;
case STYLE_RING:
mRefreshDrawable = new RingDrawable(getContext(), this);
break;
default:
throw new InvalidParameterException("Type does not exist");
}
mRefreshDrawable.setColorSchemeColors(mColorSchemeColors);
mRefreshView.setImageDrawable(mRefreshDrawable);
}
public void setX(float x) {
if (x < 0.0f || x > 100.0f) {
throw new InvalidParameterException("X value must be defined in percentage between 0 and 100");
}
this.x = x;
}
/**
* @param xmin min. x range
* @param xmax max x range
* @param nsamples number of sample points
* @return DataSet representation of the function
*/
default DataSet getDataSetEstimate(final double xmin, final double xmax, final int nsamples) {
if (xmin > xmax || nsamples <= 0) {
throw new InvalidParameterException("AbstractFunciton1D::getDataSetEstimate(" + xmin + "," + xmax + ","
+ nsamples + ") - " + "invalid range");
}
final double[] xValues = new double[nsamples];
final double step = (xmax - xmin) / nsamples;
for (int i = 0; i < nsamples; i++) {
xValues[i] = xmin + i * step;
}
return getDataSetEstimate(xValues);
}
@Override
public boolean createOrUpdateCProxy(CProxyConfig config) throws Exception {
if (!config.validate()) {
LOGGER.error("invalid cproxy config, config={}", config);
throw new InvalidParameterException("invalid cproxy config");
}
setZkData(getProxyPath(CARRERA_CPROXY, config.getInstance()), config);
return true;
}
public KafkaClientPropertiesBuilder withSaslJassConfig(String clientId, String clientSecretName, String oauthTokenEndpointUri) {
if (clientId.isEmpty() || clientSecretName.isEmpty() || oauthTokenEndpointUri.isEmpty()) {
throw new InvalidParameterException("You do not specify client-id, client-secret name or oauth-token-endpoint-uri inside kafka client!");
}
this.properties.setProperty(SaslConfigs.SASL_JAAS_CONFIG,
"org.apache.kafka.common.security.oauthbearer.OAuthBearerLoginModule " +
"required " +
"oauth.client.id=\"" + clientId + "\" " +
"oauth.client.secret=\"" + clientSecretName + "\" " +
"oauth.token.endpoint.uri=\"" + oauthTokenEndpointUri + "\";");
return this;
}
/**
* validates a specific certificate inside of the keystore being passed in
*
* @param keyStore
* @param cert
* @throws CertificateException
*/
public void validate(KeyStore keyStore, Certificate cert) throws CertificateException
{
Certificate[] certChain = null;
if (cert != null && cert instanceof X509Certificate)
{
((X509Certificate)cert).checkValidity();
String certAlias = null;
try
{
if (keyStore == null)
{
throw new InvalidParameterException("Keystore cannot be null");
}
certAlias = keyStore.getCertificateAlias((X509Certificate)cert);
if (certAlias == null)
{
certAlias = "JETTY" + String.format("%016X",__aliasCount.incrementAndGet());
keyStore.setCertificateEntry(certAlias, cert);
}
certChain = keyStore.getCertificateChain(certAlias);
if (certChain == null || certChain.length == 0)
{
throw new IllegalStateException("Unable to retrieve certificate chain");
}
}
catch (KeyStoreException kse)
{
LOG.debug(kse);
throw new CertificateException("Unable to validate certificate" +
(certAlias == null ? "":" for alias [" +certAlias + "]") + ": " + kse.getMessage(), kse);
}
validate(certChain);
}
}
/**
* Retrieve the next message on the given topic from the {@link KafkaCluster}.
*/
public String getMessage(String topic) {
ZooKeeperNode zookeeper = cluster.getZooKeeper();
Optional<Entity> anyBrokerNodeInCluster = Iterables.tryFind(cluster.getCluster().getChildren(), Predicates.and(
Predicates.instanceOf(KafkaBroker.class),
EntityPredicates.attributeEqualTo(KafkaBroker.SERVICE_UP, true)));
if (anyBrokerNodeInCluster.isPresent()) {
KafkaBroker broker = (KafkaBroker)anyBrokerNodeInCluster.get();
Properties props = new Properties();
props.put("bootstrap.servers", format("%s:%d", broker.getAttribute(KafkaBroker.HOSTNAME), broker.getKafkaPort()));
props.put("zookeeper.connect", format(zookeeper.getHostname(), zookeeper.getZookeeperPort()));
props.put("group.id", "brooklyn");
props.put("partition.assignment.strategy", "RoundRobin");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
KafkaConsumer consumer = new KafkaConsumer(props);
consumer.subscribe(topic);
// FIXME unimplemented KafkaConsumer.poll
// Object consumerRecords = consumer.poll(Duration.seconds(3).toMilliseconds()).get(topic);
return "TEST_MESSAGE";
} else {
throw new InvalidParameterException("No kafka broker node found");
}
}
public void setAlgorithmParams(final Map<String, Double> mclParams) {
if (mclParams != null) {
this.algorithmParams = mclParams;
} else {
throw new InvalidParameterException("mclParams should not be null!");
}
}
/**
* Initializes this key generator for a certain keysize, using the given
* source of randomness.
*
* @param keysize the keysize. This is an algorithm-specific
* metric specified in number of bits.
* @param random the source of randomness for this key generator
*/
protected void engineInit(int keysize, SecureRandom random) {
if (((keysize % 8) != 0) ||
(!AESCrypt.isKeySizeValid(keysize/8))) {
throw new InvalidParameterException
("Wrong keysize: must be equal to 128, 192 or 256");
}
this.keySize = keysize/8;
this.engineInit(random);
}
@Override
public void validate(List<ValidationType> validationsToSkip) {
if ((!validationsToSkip.contains(ValidationType.SKIP_ASSET_VALIDATION)
&& !validationsToSkip.contains(ValidationType.SKIP_VALIDATION))
&& (!SteemJConfig.getInstance().getVestsSymbol().equals(this.getVestingShares().getSymbol()))) {
throw new InvalidParameterException("The vesting shares needs to be provided in VESTS.");
}
}
private static InstanceGroupV1Request getInstanceGroup(List<InstanceGroupV1Request> instanceGroups) {
return instanceGroups
.stream()
.filter(ig -> HostGroupType.MASTER.getName().equals(ig.getName()))
.findFirst()
.orElseThrow(() -> new InvalidParameterException("Unable to find valid instancegroup by type"));
}
public void setStrategy(AssertionFactory.Strategy strategy) {
if (strategy == null) {
throw new InvalidParameterException("'strategy' cannot be null.");
}
if (strategyReference.getAndSet(strategy) != strategy) {
currentFactory = createFactory(strategy, exceptionMapperReference.get());
}
}
/**
* Constructor.
*
* @param m degree of the finite field GF(2^m)
* @param t error correction capability of the code
* @param poly the field polynomial
* @throws InvalidParameterException if <tt>m < 1</tt> or <tt>m > 32</tt> or
* <tt>t < 0</tt> or <tt>t > n</tt> or
* <tt>poly</tt> is not an irreducible field polynomial.
*/
public ECCKeyGenParameterSpec(int m, int t, int poly)
throws InvalidParameterException
{
this.m = m;
if (m < 1)
{
throw new InvalidParameterException("m must be positive");
}
if (m > 32)
{
throw new InvalidParameterException(" m is too large");
}
this.n = 1 << m;
this.t = t;
if (t < 0)
{
throw new InvalidParameterException("t must be positive");
}
if (t > n)
{
throw new InvalidParameterException("t must be less than n = 2^m");
}
if ((PolynomialRingGF2.degree(poly) == m)
&& (PolynomialRingGF2.isIrreducible(poly)))
{
this.fieldPoly = poly;
}
else
{
throw new InvalidParameterException(
"polynomial is not a field polynomial for GF(2^m)");
}
}
private static String getErrorMessage(TYPE type){
switch(type){
case BAD_FILE: return "Bad file format!";
case ERROR_FILE_OPEN: return "Error while opening the file:";
case ERROR_FILE_SAVE: return "Error while saving the image!";
case ERROR_FILE_CHOOSE: return "Error while choosing the file!";
case ERROR_FILE_NOT_FOUND: return "Error! File not found:";
case NO_IMAGE_LOADED: return "No image loaded!";
case IMAGE_RELOAD: return "Error while reloading the image!";
case ERROR_PLUGIN_NOT_FOUND: return "Error: plug-in not found!";
default: throw new InvalidParameterException("Unknown error type");
}
}
@Override
public void setToken(String token) {
if (this.token != null) {
throw new InvalidParameterException("Token has already been set");
}
this.token = token;
}
@Override
protected String send(Integer fromUserId, Integer toUserId, String subject, String message, boolean isHtmlFormat,
String attachmentFilename) throws InvalidParameterException {
try {
User toUser = (User) DeliveryMethodMail.userManagementService.findById(User.class, toUserId);
if (toUser == null) {
return "Target user with ID " + toUserId + " was not found.";
}
String toEmail = toUser.getEmail();
if (!DeliveryMethodMail.emailValidator.isValid(toEmail)) {
return "Target user's e-mail address is invalid.";
}
if (fromUserId == null) {
Emailer.sendFromSupportEmail(subject, toEmail, message, isHtmlFormat, attachmentFilename);
} else {
User fromUser = (User) DeliveryMethodMail.userManagementService.findById(User.class, fromUserId);
if (fromUser == null) {
return "Source user with ID " + fromUserId + " was not found.";
}
String fromEmail = fromUser.getEmail();
if (!DeliveryMethodMail.emailValidator.isValid(fromEmail)) {
return "Source user's e-mail address is invalid.";
}
Emailer.send(subject, toEmail, "", fromEmail, "", message, isHtmlFormat, attachmentFilename);
}
return null;
} catch (Exception e) {
String error = e.toString();
logError(error);
return error;
}
}
@Test
public void testConstructor() {
try {
new PostToProfileCommand("");
} catch (InvalidParameterException ipe) {
fail("empty String as a parameter should be accepted.");
}
}
/**
* Creates a new {@link PdfPageTransition} instance.
*
* @param style
* @param transitionDuration
* @param displayDuration
* @return the newly created instance.
* @throws InvalidParameterException
* if the input transition or display duration is not positive. if the input style is null.
*/
public static PdfPageTransition newInstance(PdfPageTransitionStyle style, int transitionDuration,
int displayDuration) {
if (transitionDuration < 1) {
throw new InvalidParameterException("Input transition duration must be positive.");
}
if (displayDuration < 1) {
throw new InvalidParameterException("Input display duration must be positive.");
}
if (style == null) {
throw new InvalidParameterException("Input style cannot be null.");
}
return new PdfPageTransition(style, transitionDuration, displayDuration);
}
/**
* Encode the provided key in a PEM format and return a string.
* <p>
* Both values may no be null.
*
* @param key the key, this parameter may be of type <code>PrivateKey</code> <code>PublicKey</code>
* @return a PEM encoded key
*/
public String encode(Key key) {
if (key instanceof PrivateKey) {
return encode((PrivateKey) key, null);
} else if (key instanceof PublicKey) {
return encode(null, (PublicKey) key);
}
throw new PEMEncoderException(new InvalidParameterException("Unexpected key type. Expecting instance of [PrivateKey | PublicKey], found [" + key.getClass().getCanonicalName() + "]"));
}
/**
* Initializes this key generator for a certain keysize, using the given
* source of randomness.
*
* @param keysize the keysize. This is an algorithm-specific
* metric specified in number of bits.
* @param random the source of randomness for this key generator
*/
protected void engineInit(int keysize, SecureRandom random) {
if (((keysize % 8) != 0) ||
(!AESCrypt.isKeySizeValid(keysize/8))) {
throw new InvalidParameterException
("Wrong keysize: must be equal to 128, 192 or 256");
}
this.keySize = keysize/8;
this.engineInit(random);
}
/**
* Initializes this key generator for a certain keysize, using the given
* source of randomness.
*
* @param keysize the keysize. This is an algorithm-specific
* metric specified in number of bits.
* @param random the source of randomness for this key generator
*/
protected void engineInit(int keysize, SecureRandom random) {
if (((keysize % 8) != 0) ||
(!AESCrypt.isKeySizeValid(keysize/8))) {
throw new InvalidParameterException
("Wrong keysize: must be equal to 128, 192 or 256");
}
this.keySize = keysize/8;
this.engineInit(random);
}
public DefaultSQLCreateTableAction(final String[] fullTableName, final Schema schema, boolean createIfNotExists, boolean drop,
boolean dropIfExists) {
if (fullTableName == null || fullTableName.length < 1) {
throw new InvalidParameterException("Table name can't be null or empty");
}
this.fullTableName = fullTableName;
this.schema = schema;
this.createIfNotExists = createIfNotExists;
this.drop = drop || dropIfExists;
this.dropIfExists = dropIfExists;
}