java.util.EnumSet Java Examples

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;
}