下面列出了java.security.cert.PKIXRevocationChecker.Option#java.util.EnumSet 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
protected void dropConstraints(Metadata metadata) {
File tempFile = null;
try {
tempFile = File.createTempFile("schema", ".sql");
new SchemaExport().setOutputFile(tempFile.getAbsolutePath())
.setFormat(false).drop(EnumSet.of(TargetType.SCRIPT), metadata);
List<String> sqls = new ArrayList<>();
for (String sql: FileUtils.readLines(tempFile, Charset.defaultCharset())) {
if (isDroppingConstraints(sql))
sqls.add(sql);
}
execute(sqls, false);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (tempFile != null)
tempFile.delete();
}
}
public void testCopyAddedFile2UnversionedFolder_DO() throws Exception {
// init
File fromFile = new File(repositoryLocation, "file");
fromFile.createNewFile();
File toFolder = new File(repositoryLocation.getParentFile(), "toFolder");
toFolder.mkdirs();
File toFile = new File(toFolder, fromFile.getName());
// add
add(fromFile);
// copy
copyDO(fromFile, toFile);
getCache().refreshAllRoots(Collections.singleton(fromFile));
getCache().refreshAllRoots(Collections.singleton(toFile));
// test
assertTrue(fromFile.exists());
assertTrue(toFile.exists());
assertEquals(EnumSet.of(Status.NEW_HEAD_INDEX, Status.NEW_HEAD_WORKING_TREE), getCache().getStatus(fromFile).getStatus());
assertEquals(EnumSet.of(Status.NOTVERSIONED_NOTMANAGED), getCache().getStatus(toFile).getStatus());
}
@Test
@junitparams.Parameters(method = "commandMethodArgs")
public void testCommandMethod(String args,
InvokedSub invokedSub,
ArgGroupTest.SomeMixin expectedMixin,
ArgGroupTest.Composite expectedArgGroup,
int[] expectedPositionalInt,
String[] expectedStrings) {
ArgGroupTest.CommandMethodsWithGroupsAndMixins bean = new ArgGroupTest.CommandMethodsWithGroupsAndMixins();
new CommandLine(bean).execute(args.split(" "));
assertTrue(bean.invoked.contains(invokedSub));
EnumSet<InvokedSub> notInvoked = EnumSet.allOf(InvokedSub.class);
notInvoked.remove(invokedSub);
for (InvokedSub sub : notInvoked) {
assertFalse(bean.invoked.contains(sub));
}
assertTrue(bean.invoked.contains(invokedSub));
assertEquals(expectedMixin, bean.myMixin);
assertEquals(expectedArgGroup, bean.myComposite);
assertArrayEquals(expectedPositionalInt, bean.myPositionalInt);
assertArrayEquals(expectedStrings, bean.myStrings);
}
@Override
public EnumSet<Casts> prepareForDissect(final String inputname, final String outputname) {
EnumSet<Casts> result = super.prepareForDissect(inputname, outputname);
if (!result.isEmpty()) {
return result;
}
String name = extractFieldName(inputname, outputname);
switch (name) {
case "isp.name":
wantIspName = true;
return STRING_ONLY;
case "isp.organization":
wantIspOrganization = true;
return STRING_ONLY;
default:
return NO_CASTS;
}
}
@Test
public void providerAssignedMessageId_UuidMode_10_010() throws Exception
{
assumeTrue(EnumSet.of(Protocol.AMQP_1_0).contains(getPublisherProtocolVersion())
&& EnumSet.of(Protocol.AMQP_0_10).contains(getSubscriberProtocolVersion()));
List<ClientMessage> clientResults = performProviderAssignedMessageIdTest(Collections.singletonMap(
JMS_MESSAGE_IDPOLICY_MESSAGE_IDTYPE, "UUID"));
ClientMessage publishedMessage = clientResults.get(0);
ClientMessage subscriberMessage = clientResults.get(1);
// On the wire the message-id is a message-id-uuid
final String publishedJmsMessageID = publishedMessage.getJMSMessageID();
assertThat(publishedJmsMessageID, startsWith("ID:AMQP_UUID:"));
String barePublishedJmsMessageID = publishedJmsMessageID.substring("ID:AMQP_UUID:".length());
String expectedSubscriberJmsMessageID = String.format("ID:%s", barePublishedJmsMessageID);
assertThat(subscriberMessage.getJMSMessageID(), equalTo(expectedSubscriberJmsMessageID));
}
@Test
public void testSetMetadataFileLeaveOtherFeatures() throws Exception {
final Path container = new Path("test-us-east-1-cyberduck", EnumSet.of(Path.Type.volume));
final Path test = new Path(container, UUID.randomUUID().toString(), EnumSet.of(Path.Type.file));
new S3TouchFeature(session).touch(test, new TransferStatus());
final String v = UUID.randomUUID().toString();
final S3StorageClassFeature storage = new S3StorageClassFeature(session);
storage.setClass(test, S3Object.STORAGE_CLASS_REDUCED_REDUNDANCY);
assertEquals(S3Object.STORAGE_CLASS_REDUCED_REDUNDANCY, storage.getClass(test));
final S3EncryptionFeature encryption = new S3EncryptionFeature(session);
encryption.setEncryption(test, S3EncryptionFeature.SSE_AES256);
assertEquals("AES256", encryption.getEncryption(test).algorithm);
final S3MetadataFeature feature = new S3MetadataFeature(session, new S3AccessControlListFeature(session));
feature.setMetadata(test, Collections.singletonMap("Test", v));
final Map<String, String> metadata = feature.getMetadata(test);
assertFalse(metadata.isEmpty());
assertTrue(metadata.containsKey("test"));
assertEquals(v, metadata.get("test"));
assertEquals(S3Object.STORAGE_CLASS_REDUCED_REDUNDANCY, storage.getClass(test));
assertEquals("AES256", encryption.getEncryption(test).algorithm);
new S3DefaultDeleteFeature(session).delete(Collections.singletonList(test), new DisabledLoginCallback(), new Delete.DisabledCallback());
}
public static void main(String[] args) throws Exception {
cf = CertificateFactory.getInstance("X.509");
X509Certificate taCert = getX509Cert(TRUST_ANCHOR);
X509Certificate eeCert = getX509Cert(EE_CERT);
CertPath cp = cf.generateCertPath(Collections.singletonList(eeCert));
CertPathValidator cpv = CertPathValidator.getInstance("PKIX");
PKIXRevocationChecker prc =
(PKIXRevocationChecker)cpv.getRevocationChecker();
prc.setOptions(EnumSet.of(Option.SOFT_FAIL, Option.NO_FALLBACK));
byte[] response = base64Decoder.decode(OCSP_RESPONSE);
prc.setOcspResponses(Collections.singletonMap(eeCert, response));
TrustAnchor ta = new TrustAnchor(taCert, null);
PKIXParameters params = new PKIXParameters(Collections.singleton(ta));
params.addCertPathChecker(prc);
try {
cpv.validate(cp, params);
throw new Exception("FAILED: expected CertPathValidatorException");
} catch (CertPathValidatorException cpve) {
cpve.printStackTrace();
}
}
@Test(expected = InteroperabilityException.class)
public void testToUrlInvalidSMSRecipients() throws Exception {
final SDSNodeIdProvider nodeid = new SDSNodeIdProvider(session).withCache(cache);
final Path room = new SDSDirectoryFeature(session, nodeid).mkdir(new Path(new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.directory, Path.Type.volume, Path.Type.triplecrypt)), null, new TransferStatus());
final Path test = new SDSTouchFeature(session, nodeid).touch(new Path(room, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file)), new TransferStatus());
try {
final DescriptiveUrl url = new SDSSharesUrlProvider(session, nodeid).toDownloadUrl(test,
new CreateDownloadShareRequest()
.expiration(new ObjectExpiration().enableExpiration(false))
.notifyCreator(false)
.sendMail(false)
.mailRecipients(null)
.sendSms(true)
.smsRecipients("invalid")
.password("p")
.mailSubject(null)
.mailBody(null)
.maxDownloads(null), new DisabledPasswordCallback());
}
finally {
new SDSDeleteFeature(session, nodeid).delete(Collections.singletonList(room), new DisabledLoginCallback(), new Delete.DisabledCallback());
}
}
public final TXStateProxy resumeTX(final TXManagerImpl.TXContext context,
final IsolationLevel isolationLevel,
final EnumSet<TransactionFlag> txFlags, TXId txid) {
checkClosed();
TXId txId = context.getTXId();
context.remoteBatching(false);
if (txId != null) {
throw new IllegalTransactionStateException(
LocalizedStrings.TXManagerImpl_TRANSACTION_0_ALREADY_IN_PROGRESS
.toLocalizedString(txId));
}
txId = txid;
// Do we have a proxy here
TXStateProxy txState = this.hostedTXStates.get(txId);
if (txState != null) {
return txState;
}
txState = this.hostedTXStates.create(txId,
txStateProxyCreator, isolationLevel, txFlags, false);
// context.setTXState(txState);
return txState;
}
private synchronized void checkAndHandleSessionTimeout() {
if (EnumSet.of(DAGAppMasterState.RUNNING,
DAGAppMasterState.RECOVERING).contains(this.state)
|| sessionStopped.get()) {
// DAG running or session already completed, cannot timeout session
return;
}
long currentTime = clock.getTime();
if (currentTime < (lastDAGCompletionTime + sessionTimeoutInterval)) {
return;
}
LOG.info("Session timed out"
+ ", lastDAGCompletionTime=" + lastDAGCompletionTime + " ms"
+ ", sessionTimeoutInterval=" + sessionTimeoutInterval + " ms");
shutdownTezAM();
}
/**
* Generate an block token for specified user, blockId. Service field for
* token is set to blockId.
*
* @param user
* @param blockId
* @param modes
* @param maxLength
* @return token
*/
public Token<OzoneBlockTokenIdentifier> generateToken(String user,
String blockId, EnumSet<AccessModeProto> modes, long maxLength) {
OzoneBlockTokenIdentifier tokenIdentifier = createIdentifier(user,
blockId, modes, maxLength);
if (LOG.isTraceEnabled()) {
long expiryTime = tokenIdentifier.getExpiryDate();
String tokenId = tokenIdentifier.toString();
LOG.trace("Issued delegation token -> expiryTime:{}, tokenId:{}",
expiryTime, tokenId);
}
// Pass blockId as service.
return new Token<>(tokenIdentifier.getBytes(),
createPassword(tokenIdentifier), tokenIdentifier.getKind(),
new Text(blockId));
}
@SuppressWarnings("ConvertToStringSwitch")
Bundle(String id, String cldrPath, String bundles, String currencies) {
this.id = id;
this.cldrPath = cldrPath;
if ("localenames".equals(bundles)) {
bundleTypes = EnumSet.of(Type.LOCALENAMES);
} else if ("currencynames".equals(bundles)) {
bundleTypes = EnumSet.of(Type.CURRENCYNAMES);
} else {
bundleTypes = Type.ALL_TYPES;
}
if (currencies == null) {
currencies = "local";
}
this.currencies = currencies;
addBundle();
}
@Override
public void actionPerformed (ActionEvent e)
{
// Populate with shape names found in selected folders
List<String> folders = folderSelector.list.getSelectedValuesList();
if (folders.isEmpty()) {
logger.warn("No folders selected in Folder Selector");
} else {
EnumSet<Shape> shapeSet = EnumSet.noneOf(Shape.class);
for (String folder : folders) {
File dir = getActualDir(folder);
// Add all glyphs files from this directory
for (File file : repository.getGlyphsIn(dir)) {
shapeSet.add(Shape.valueOf(radixOf(file.getName())));
}
}
populateWith(shapeSet);
}
}
void testPackage(String packageName) throws IOException {
JavaFileObject object
= fm.getJavaFileForInput(PLATFORM_CLASS_PATH, "java.lang.Object", CLASS);
Iterable<? extends JavaFileObject> files
= fm.list(CLASS_OUTPUT, packageName, EnumSet.of(CLASS), false);
boolean found = false;
String binaryPackageName = packageName.replace('/', '.');
for (JavaFileObject file : files) {
System.out.println("Found " + file.getName() + " in " + packageName);
String name = fm.inferBinaryName(CLASS_OUTPUT, file);
found |= name.equals(binaryPackageName + ".package-info");
JavaFileObject other = fm.getJavaFileForInput(CLASS_OUTPUT, name, CLASS);
if (!fm.isSameFile(file, other))
throw new AssertionError(file + " != " + other);
if (fm.isSameFile(file, object))
throw new AssertionError(file + " == " + object);
}
if (!found)
throw new AssertionError("Did not find " + binaryPackageName + ".package-info");
}
@Test
public void testInvalidQueryChecker() throws Exception {
HashMap<INodeSet, HashMap<String, HashMap<String, ArrayList<EnumSet<Filter>>>>>
setSumTypeFilterConfig = getInvalidCombinations();
String[] parameters = new String[4];
for (INodeSet set : INodeSet.values()) {
String setType = set.toString();
parameters[0] = setType;
HashMap<String, HashMap<String, ArrayList<EnumSet<Filter>>>> sumTypeFilters =
setSumTypeFilterConfig.get(set);
for (Map.Entry<String, HashMap<String, ArrayList<EnumSet<Filter>>>> sumTypeFilter :
sumTypeFilters.entrySet()) {
HashMap<String, ArrayList<EnumSet<Filter>>> typeFilters = sumTypeFilter.getValue();
String sum = sumTypeFilter.getKey();
parameters[1] = sum;
for (Map.Entry<String, ArrayList<EnumSet<Filter>>> typeFilter : typeFilters.entrySet()) {
String type = typeFilter.getKey();
parameters[2] = type;
String testingURL = buildQuery(parameters);
testQuery(testingURL, false);
}
}
}
}
public void testEnumStringConversion() {
EnumSet<TLSVersion> versions = EnumSet.of(TLSVersion.TLSv1_2, TLSVersion.TLSv1_1);
TLSArguments arguments = new TLSArguments(versions);
String[] stringVersions = arguments.getVersions();
assertTrue(Arrays.asList(stringVersions).contains("TLSv1.2"));
assertTrue(Arrays.asList(stringVersions).contains("TLSv1.1"));
}
/**
* Initializes the caching HTTP Headers Filter.
*/
private void initCachingHttpHeadersFilter(ServletContext servletContext, EnumSet<DispatcherType> disps) {
log.debug("Registering Caching HTTP Headers Filter");
FilterRegistration.Dynamic cachingHttpHeadersFilter = servletContext.addFilter("cachingHttpHeadersFilter",
new CachingHttpHeadersFilter(applicationProperties));
cachingHttpHeadersFilter.addMappingForUrlPatterns(disps, true, "/statics/*", "/WEB-INF/views/*");
cachingHttpHeadersFilter.setAsyncSupported(true);
}
/**
* Returns the strategies.
*
* @return the strategies.
*/
@NonNull
public Set<ChangeRequestCheckoutStrategy> getStrategies() {
switch (strategyId) {
case 1:
return EnumSet.of(ChangeRequestCheckoutStrategy.MERGE);
case 2:
return EnumSet.of(ChangeRequestCheckoutStrategy.HEAD);
case 3:
return EnumSet.of(ChangeRequestCheckoutStrategy.HEAD, ChangeRequestCheckoutStrategy.MERGE);
default:
return EnumSet.noneOf(ChangeRequestCheckoutStrategy.class);
}
}
/**
* Test of stop method, of class com.sun.jmx.examples.scandir.ScanManager.
*/
public void testStop() throws Exception {
System.out.println("stop");
final ScanManagerMXBean manager = ScanManager.register();
try {
manager.schedule(1000000,0);
assertContained(EnumSet.of(SCHEDULED),manager.getState());
final Call op = new Call() {
public void call() throws Exception {
manager.stop();
assertEquals(STOPPED,manager.getState());
}
public void cancel() throws Exception {
if (manager.getState() != STOPPED)
manager.stop();
}
};
doTestOperation(manager,op,EnumSet.of(STOPPED),"stop");
} finally {
try {
ManagementFactory.getPlatformMBeanServer().
unregisterMBean(ScanManager.SCAN_MANAGER_NAME);
} catch (Exception x) {
System.err.println("Failed to cleanup: "+x);
}
}
}
/**
* Test of addNotificationListener method, of class com.sun.jmx.examples.scandir.DirectoryScanner.
*/
public void testAddNotificationListener() throws Exception {
System.out.println("addNotificationListener");
final ScanManagerMXBean manager = ScanManager.register();
final Call op = new Call() {
public void call() throws Exception {
manager.start();
}
public void cancel() throws Exception {
manager.stop();
}
};
try {
final String tmpdir = System.getProperty("java.io.tmpdir");
final ScanDirConfigMXBean config = manager.getConfigurationMBean();
final DirectoryScannerConfig bean =
config.addDirectoryScanner("test1",tmpdir,".*",0,0);
manager.applyConfiguration(true);
final DirectoryScannerMXBean proxy =
manager.getDirectoryScanners().get("test1");
doTestOperation(proxy,op,
EnumSet.of(RUNNING,SCHEDULED),
"scan");
} finally {
try {
ManagementFactory.getPlatformMBeanServer().
unregisterMBean(ScanManager.SCAN_MANAGER_NAME);
} catch (Exception x) {
System.err.println("Failed to cleanup: "+x);
}
}
}
/**
* Report the template notes suitable for the provided sheet.
*
* @param sheet provided sheet or null
* @return the template notes, perhaps limited by sheet processing switches
*/
public static EnumSet<Shape> getTemplateNotes (Sheet sheet)
{
final EnumSet<Shape> set = EnumSet.of(
NOTEHEAD_BLACK,
NOTEHEAD_VOID,
WHOLE_NOTE,
NOTEHEAD_BLACK_SMALL,
NOTEHEAD_VOID_SMALL,
WHOLE_NOTE_SMALL);
if (sheet == null) {
return set;
}
final ProcessingSwitches switches = sheet.getStub().getProcessingSwitches();
if (!switches.getValue(Switch.smallBlackHeads)) {
set.remove(NOTEHEAD_BLACK_SMALL);
}
if (!switches.getValue(Switch.smallVoidHeads)) {
set.remove(NOTEHEAD_VOID_SMALL);
}
if (!switches.getValue(Switch.smallWholeHeads)) {
set.remove(WHOLE_NOTE_SMALL);
}
return set;
}
@Test
public void testDirectoryWhitespace() throws Exception {
final Path bucket = new Path("test.cyberduck.ch", EnumSet.of(Path.Type.directory, Path.Type.volume));
final Path test = new GoogleStorageDirectoryFeature(session).mkdir(new Path(bucket,
String.format("%s %s", new AlphanumericRandomStringService().random(), new AlphanumericRandomStringService().random()), EnumSet.of(Path.Type.directory)), null, new TransferStatus());
assertTrue(new GoogleStorageFindFeature(session).find(test));
assertTrue(new DefaultFindFeature(session).find(test));
new GoogleStorageDeleteFeature(session).delete(Collections.<Path>singletonList(test), new DisabledLoginCallback(), new Delete.DisabledCallback());
}
private boolean solveBasic(List<Type> varsToSolve, EnumSet<InferenceStep> steps) {
boolean changed = false;
for (Type t : varsToSolve.intersect(restvars())) {
UndetVar uv = (UndetVar)asFree(t);
for (InferenceStep step : steps) {
if (step.accepts(uv, this)) {
uv.inst = step.solve(uv, this);
changed = true;
break;
}
}
}
return changed;
}
@Override
public EnumSet<Script.VerifyFlag> getTransactionVerificationFlags(
final Block block,
final Transaction transaction,
final VersionTally tally,
final Integer height)
{
final EnumSet<Script.VerifyFlag> flags = super.getTransactionVerificationFlags(block, transaction, tally, height);
if (height >= SEGWIT_ENFORCE_HEIGHT) flags.add(Script.VerifyFlag.SEGWIT);
return flags;
}
public LogBlobIterator(final CloudBlobDirectory logDirectory, final Date startDate, final Date endDate,
final EnumSet<LoggingOperations> operations, final EnumSet<BlobListingDetails> details,
final BlobRequestOptions options, final OperationContext opContext) {
TimeZone gmtTime = TimeZone.getTimeZone("GMT");
HOUR_FORMAT.setTimeZone(gmtTime);
DAY_FORMAT.setTimeZone(gmtTime);
MONTH_FORMAT.setTimeZone(gmtTime);
YEAR_FORMAT.setTimeZone(gmtTime);
this.logDirectory = logDirectory;
this.operations = operations;
this.details = details;
this.opContext = opContext;
if (options == null) {
this.options = new BlobRequestOptions();
}
else {
this.options = options;
}
if (startDate != null) {
this.startDate = new GregorianCalendar();
this.startDate.setTime(startDate);
this.startDate.add(GregorianCalendar.MINUTE, (-this.startDate.get(GregorianCalendar.MINUTE)));
this.startDate.setTimeZone(gmtTime);
}
if (endDate != null) {
this.endDate = new GregorianCalendar();
this.endDate.setTime(endDate);
this.endDate.setTimeZone(gmtTime);
this.endPrefix = this.logDirectory.getPrefix() + HOUR_FORMAT.format(this.endDate.getTime());
}
}
/**
* Tests the effect of a {@link Ehcache#remove(Object)} for
* <ul>
* <li>key not present in {@code Store}</li>
* </ul>
*/
@Test
public void testRemoveNoStoreEntry() throws Exception {
final FakeStore fakeStore = new FakeStore(Collections.<String, String>emptyMap());
this.store = spy(fakeStore);
final Ehcache<String, String> ehcache = this.getEhcache();
ehcache.remove("key");
verify(this.store).remove(eq("key"));
verifyZeroInteractions(this.resilienceStrategy);
assertThat(fakeStore.getEntryMap().containsKey("key"), is(false));
validateStats(ehcache, EnumSet.of(CacheOperationOutcomes.RemoveOutcome.NOOP));
}
@Test
public void testCreateFor_INSERT_UPDATE_3_0_both() throws SQLException {
expectDatabaseVersionCheck(3, 0);
GeneratedKeysSupport generatedKeysSupport = GeneratedKeysSupportFactory
.createFor("INSERT,UPDATE", dbMetadata);
assertThat(generatedKeysSupport.supportedQueryTypes(),
equalTo(EnumSet.of(GeneratedKeysSupport.QueryType.INSERT, GeneratedKeysSupport.QueryType.UPDATE)));
}
public static void writeFile(FileContext fc, Path path, byte b[])
throws IOException {
FSDataOutputStream out =
fc.create(path,EnumSet.of(CreateFlag.CREATE), CreateOpts.createParent());
out.write(b);
out.close();
}
public static Object getValue(int ordinal) {
if (valArray == null) {
valArray = (FMValues[])EnumSet.allOf(FMValues.class).toArray(new FMValues[0]);
}
for (int i=0;i<valArray.length;i++) {
if (valArray[i].ordinal() == ordinal) {
return valArray[i];
}
}
return valArray[0];
}
private Server initJetty() throws Exception {
Server server = new Server(0);
ServletContextHandler handler = new ServletContextHandler(server, null);
handler.addFilter(RequestLoggingFilter.class, "/*", EnumSet.of(DispatcherType.INCLUDE, DispatcherType.REQUEST,
DispatcherType.ERROR, DispatcherType.FORWARD, DispatcherType.ASYNC));
handler.addServlet(TestServlet.class, "/test");
server.start();
return server;
}