Java Examples for java.util.Set

/**
	 * @tests java.util.Set#add(java.lang.Object)
	 */
public void test_addLjava_lang_Object() {
    // Test for method boolean java.util.Set.add(java.lang.Object)
    int size = hs.size();
    hs.add(new Integer(8));
    assertTrue("Added element already contained by set", hs.size() == size);
    hs.add(new Integer(-9));
    assertTrue("Failed to increment set size after add", hs.size() == size + 1);
    assertTrue("Failed to add element to set", hs.contains(new Integer(-9)));
}

/**
     * Deserialize from a String to type T
     * 
     * @param serialized
     *            String representation of object type T
     * @param format
     *            Format of the String
     * @return T deserialized object
     * @throws AnzoException
     *             if there was a problem deserializing the object
     */
@SuppressWarnings("unchecked")
public static java.util.Set<org.openanzo.rdf.URI>[] deserialize(String serialized, String format) throws AnzoException {
    if (serialized == null || serialized.length() == 0)
        return new java.util.Set[] { Collections.<org.openanzo.rdf.URI>emptySet(), Collections.<org.openanzo.rdf.URI>emptySet() };
    ArrayList<java.util.Set<org.openanzo.rdf.URI>> sets = new ArrayList<java.util.Set<org.openanzo.rdf.URI>>();
    BufferedReader br = new BufferedReader(new StringReader(serialized));
    try {
        String line = br.readLine();
        while (line != null) {
            sets.add(org.openanzo.rdf.utils.SerializationUtils.convertStringToSet(serialized, format));
            line = br.readLine();
        }
    } catch (IOException ioe) {
    }
    return sets.toArray(new java.util.Set[0]);
}

/**
	 * @see com.ibm.etools.archive.SaveFilter
	 */
@Override
public boolean shouldSave(String uri, Archive anArchive) {
    String extension = org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil.getFileNameExtension(uri);
    if (//$NON-NLS-1$
    extension.equals(""))
        return true;
    Set excluded;
    if (isCaseSensitive()) {
        excluded = getExcludedExtensions();
    } else {
        excluded = getExcludedExtensionsAsUppercase();
        extension = extension.toUpperCase();
    }
    return !excluded.contains(extension);
}

@Override
public void render(StringBuilder sb, Object obj) {
    Set<?> set = (Set<?>) obj;
    int size = set.size();
    int cloudSpan = (int) Math.ceil(Math.sqrt(size));
    Iterator<?> iterator = set.iterator();
    sb.append("<style>");
    sb.append("table.java-util-Set > tbody > tr > td > div {border: 1px dotted silver; -webkit-border-radius: 10px; -moz-border-radius: 10px; border-radius: 10px; padding: 10px}");
    sb.append("</style>");
    sb.append("<table class=\"java-util-Set\"><tbody>");
    for (int i = 0; i < cloudSpan; i++) {
        sb.append("<tr>");
        for (int j = 0; j < cloudSpan; j++) {
            if (iterator.hasNext()) {
                sb.append("<td><div>").append(VisualDebuggerAid.toString(iterator.next())).append("</div></td>");
            } else {
                sb.append("<td></td>");
            }
        }
        sb.append("</tr>");
    }
    sb.append("</tbody></table>");
}

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n = Integer.parseInt(in.nextLine());
    Set<String> set = new HashSet<>();
    int count = 0;
    for (int i = 0; i < n; i++) {
        String s = in.nextLine();
        if (set.contains(s))
            count++;
        else
            set.add(s);
    }
    System.out.println(count);
}

public static String deduceTask(TaskMeta meta) {
    final Set<Number160> files = new TreeSet<>();
    files.add(meta.getModule().getDhtKey());
    for (FileDep file : meta.getDependencies()) {
        files.add(file.getDhtKey());
    }
    String answer = "";
    for (Number160 s : files) {
        answer += s.toString();
    }
    return answer;
}

/**
   * Intersects two sets
   */
public static <T> Set<T> intersect(final Set<T> set1, final Set<T> set2) {
    if (set1.equals(set2)) {
        return set1;
    }
    final HashSet<T> result = new HashSet<>();
    Set<T> minSet;
    Set<T> otherSet;
    if (set1.size() < set2.size()) {
        minSet = set1;
        otherSet = set2;
    } else {
        minSet = set2;
        otherSet = set1;
    }
    for (T s : minSet) {
        if (otherSet.contains(s)) {
            result.add(s);
        }
    }
    return result;
}

@Test
public void testGetAsLowerCaseSet() {
    String src[] = { "Test1", "Test2", "Test3" };
    Set<String> expected = new HashSet<String>();
    expected.add("test1");
    expected.add("test2");
    expected.add("test3");
    Set<String> result = new OpenSourceLicenseCheckMojo().getAsLowerCaseSet(src);
    assertTrue(result.containsAll(expected));
}

public static MessagesSupportedVendorMessage makeMSVMWithoutOOBProxyControl() throws Exception {
    Set<SupportedMessageBlock> supportedMessageBlocks = new HashSet<SupportedMessageBlock>();
    MessagesSupportedVendorMessage.addSupportedMessages(supportedMessageBlocks);
    supportedMessageBlocks.remove(new MessagesSupportedVendorMessage.SupportedMessageBlock(VendorMessage.F_LIME_VENDOR_ID, VendorMessage.F_OOB_PROXYING_CONTROL, OOBProxyControlVendorMessage.VERSION));
    return new MessagesSupportedVendorMessage(supportedMessageBlocks);
}

public static String findExtensionFromPossibilities(String fileName, Set<String> fileExtensions) {
    String name = fileName.toLowerCase();
    List<String> possibleExtensions = new ArrayList<String>();
    for (String extention : fileExtensions) {
        if (name.endsWith('.' + extention)) {
            possibleExtensions.add(extention);
        }
    }
    String longestExtension = null;
    for (String possibleExtension : possibleExtensions) {
        if (null == longestExtension) {
            longestExtension = possibleExtension;
            continue;
        } else {
            if (longestExtension.length() < possibleExtension.length())
                longestExtension = possibleExtension;
        }
    }
    return longestExtension;
}

public static char[] pointsUnion(final Iterable<Automaton> automata) {
    Set<Character> points = new TreeSet<>();
    for (Automaton automaton : automata) {
        for (char c : automaton.getStartPoints()) {
            points.add(c);
        }
    }
    char[] pointsArr = new char[points.size()];
    int i = 0;
    for (Character c : points) {
        pointsArr[i] = c;
        i++;
    }
    return pointsArr;
}

@Test
public void basicTest() {
    SetWrapper<String> set = new SetWrapper<String>() {

        Set<String> hashSet = new HashSet<>(10);

        @Override
        protected Set<String> set() {
            return hashSet;
        }
    };
    SetRunnable<String> test = new SetRunnable<>(set, "a", "b", "c");
    test.run();
}

public static void main(String[] args) {
    HostInfo hostInfo1 = new HostInfo("11", 11, 0);
    HostInfo hostInfo2 = new HostInfo("11", 11, 1);
    Set<HostInfo> hostInfos = Sets.newHashSet();
    hostInfos.add(hostInfo1);
    hostInfos.remove(hostInfo2);
    hostInfos.add(hostInfo2);
    for (HostInfo hostInfo : hostInfos) {
        System.out.println(hostInfo);
    }
}

public static Set<Field> getFieldsIncludeSuperClass(Class clazz) {
    Set<Field> fields = new LinkedHashSet<Field>();
    Class current = clazz;
    while (current != null) {
        Field[] currentFields = current.getDeclaredFields();
        for (Field currentField : currentFields) {
            fields.add(currentField);
        }
        current = current.getSuperclass();
    }
    return fields;
}

/**
	 * Test method for {@link org.ebayopensource.turmeric.eclipse.utils.collections.CollectionUtil#intersection(java.util.Set, java.util.Set)}.
	 */
@Test
public void testIntersection() {
    Set<String> collection = new HashSet<String>();
    collection.add("3dfx");
    collection.add("Nvidia");
    collection.add("ATI");
    Set<String> collection2 = new HashSet<String>();
    collection2.add("3dfx");
    collection2.add("ATI");
    collection2.add("Trident");
    Set<String> expected = new HashSet<String>();
    expected.add("3dfx");
    expected.add("ATI");
    Set<String> data = CollectionUtil.intersection(collection, collection2);
    TestSetUtil.assertSetEquals(expected, data);
}

/**
	 * Test case for {@link MicroPipelineValidator#validateQueue(StreamingMessageQueueConfiguration, Set)} being provided a 
	 * configuration with non-unique id
	 */
@Test
public void testValidateQueue_withDuplicateQueueId() {
    Set<String> queueIdentifiers = new HashSet<String>();
    queueIdentifiers.add("test-id");
    Assert.assertEquals("Missing queue configuration", MicroPipelineValidationResult.NON_UNIQUE_QUEUE_ID, new MicroPipelineValidator().validateQueue(new StreamingMessageQueueConfiguration("test-id"), queueIdentifiers));
}

@Override
public Formula replaceEquivalences(Formula topLeveFormula, Map<EqualityFormula, String> replacements, Set<Token> noDependenceVars) {
    ArrayList<Term> terms2 = new ArrayList<Term>();
    for (int i = 0; i < terms.size(); i++) {
        PropositionalTerm term = (PropositionalTerm) terms.get(i);
        Formula newterm = term.replaceEquivalences(topLeveFormula, replacements, noDependenceVars);
        terms2.add((PropositionalTerm) newterm);
    }
    try {
        return EqualityFormula.create(terms2, equal);
    } catch (IncomparableTermsException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}

private String criteriaCleanup(java.util.Set<String> criteriaSet, String criteriaName) {
    java.util.Iterator criteria = criteriaSet.iterator();
    StringBuilder result = new StringBuilder();
    while (criteria.hasNext()) {
        result.append(" " + criteriaName + "=");
        String criterion = (String) criteria.next();
        // remove any punctuation
        criterion = criterion.replaceAll("\\p{Punct}", " ");
        criterion = criterion.trim();
        // take care of any adjacent spaces
        criterion = criterion.replaceAll("\\s+", " ");
        // replace spaces with +
        criterion = criterion.replaceAll("\\s", "+");
        // append this keyword
        result.append(criterion);
    }
    return (result.toString().trim().equals("")) ? null : result.toString().trim();
}

private String criteriaCleanup(java.util.Set<String> criteriaSet, String criteriaName) {
    java.util.Iterator criteria = criteriaSet.iterator();
    StringBuilder result = new StringBuilder();
    while (criteria.hasNext()) {
        result.append(" " + criteriaName + "=");
        String criterion = (String) criteria.next();
        // remove any punctuation
        criterion = criterion.replaceAll("\\p{Punct}", " ");
        criterion = criterion.trim();
        // take care of any adjacent spaces
        criterion = criterion.replaceAll("\\s+", " ");
        // replace spaces with +
        criterion = criterion.replaceAll("\\s", "+");
        // append this keyword
        result.append(criterion);
    }
    return (result.toString().trim().equals("")) ? null : result.toString().trim();
}

public Serializable getSnapshot(CollectionPersister persister) throws HibernateException {
    EntityMode entityMode = getSession().getEntityMode();
    //if (set==null) return new Set(session);
    HashMap clonedSet = new HashMap(set.size());
    Iterator iter = set.iterator();
    while (iter.hasNext()) {
        Object copied = persister.getElementType().deepCopy(iter.next(), entityMode, persister.getFactory());
        clonedSet.put(copied, copied);
    }
    return clonedSet;
}

public Serializable getSnapshot(CollectionPersister persister) throws HibernateException {
    EntityMode entityMode = getSession().getEntityMode();
    //if (set==null) return new Set(session);
    HashMap clonedSet = new HashMap(set.size());
    Iterator iter = set.iterator();
    while (iter.hasNext()) {
        Object copied = persister.getElementType().deepCopy(iter.next(), entityMode, persister.getFactory());
        clonedSet.put(copied, copied);
    }
    return clonedSet;
}

/**
   * Test method for 'java.util.Set.add(Object)'.
   * 
   * @see java.util.Set#add(Object)
   */
public void testAdd_entries3() {
    // verify that the method is not supported.
    if (isAddSupported) {
        // populate the set
        Set<E> set = createSet();
        set.add(getKeys()[0]);
        set.add(getKeys()[1]);
        set.add(getKeys()[2]);
        // test contents
        assertFalse(set.isEmpty());
        assertEquals(3, set.size());
        Collection<E> keys = set;
        // test contains all keys
        assertTrue(keys.contains(getKeys()[0]));
        assertTrue(keys.contains(getKeys()[1]));
        assertTrue(keys.contains(getKeys()[2]));
    }
}

/**
   * Test method for 'java.util.Set.add(Object)'.
   * 
   * @see java.util.Set#add(Object)
   */
public void testAdd_entries3() {
    // verify that the method is not supported.
    if (isAddSupported) {
        // populate the set
        Set<E> set = createSet();
        set.add(getKeys()[0]);
        set.add(getKeys()[1]);
        set.add(getKeys()[2]);
        // test contents
        assertFalse(set.isEmpty());
        assertEquals(3, set.size());
        Collection<E> keys = set;
        // test contains all keys
        assertTrue(keys.contains(getKeys()[0]));
        assertTrue(keys.contains(getKeys()[1]));
        assertTrue(keys.contains(getKeys()[2]));
    }
}

/**
   * Test method for 'java.util.Set.add(Object)'.
   * 
   * @see java.util.Set#add(Object)
   */
public void testAdd_entries3() {
    // verify that the method is not supported.
    if (isAddSupported) {
        // populate the set
        Set<E> set = createSet();
        set.add(getKeys()[0]);
        set.add(getKeys()[1]);
        set.add(getKeys()[2]);
        // test contents
        assertFalse(set.isEmpty());
        assertEquals(3, set.size());
        Collection<E> keys = set;
        // test contains all keys
        assertTrue(keys.contains(getKeys()[0]));
        assertTrue(keys.contains(getKeys()[1]));
        assertTrue(keys.contains(getKeys()[2]));
    }
}

/**
   * Test method for 'java.util.Set.add(Object)'.
   * 
   * @see java.util.Set#add(Object)
   */
public void testAdd_entries3() {
    // verify that the method is not supported.
    if (isAddSupported) {
        // populate the set
        Set<E> set = createSet();
        set.add(getKeys()[0]);
        set.add(getKeys()[1]);
        set.add(getKeys()[2]);
        // test contents
        assertFalse(set.isEmpty());
        assertEquals(3, set.size());
        Collection<E> keys = set;
        // test contains all keys
        assertTrue(keys.contains(getKeys()[0]));
        assertTrue(keys.contains(getKeys()[1]));
        assertTrue(keys.contains(getKeys()[2]));
    }
}

public java.util.Set<String> getTokenNames() {
    // EnumerationTerminals are associated with multiple tokens, one for each literal
    // that was mapped to a string
    java.util.Set<String> tokenNames = new java.util.LinkedHashSet<String>();
    java.util.Map<String, String> mapping = enumerationTerminal.getLiteralMapping();
    for (String literalName : mapping.keySet()) {
        String text = mapping.get(literalName);
        if (text != null && !"".equals(text)) {
            tokenNames.add("'" + text + "'");
        }
    }
    return tokenNames;
}

public java.util.Set<String> getTokenNames() {
    // BooleanTerminals are associated with two or one token(s)
    java.util.Set<String> tokenNames = new java.util.LinkedHashSet<String>(2);
    String trueLiteral = booleanTerminal.getTrueLiteral();
    if (!"".equals(trueLiteral)) {
        tokenNames.add("'" + trueLiteral + "'");
    }
    String falseLiteral = booleanTerminal.getFalseLiteral();
    if (!"".equals(falseLiteral)) {
        tokenNames.add("'" + falseLiteral + "'");
    }
    return tokenNames;
}

/**
     * Use AUTHORIZATION_PREDICATE instead
     */
@Deprecated
public Set<AccountabilityType> getAccountabilityTypesThatAuthorize() {
    final Set<AccountabilityType> accountabilityTypes = new HashSet<AccountabilityType>();
    for (final MissionAuthorizationAccountabilityType missionAuthorizationAccountabilityType : getMissionAuthorizationAccountabilityTypesSet()) {
        accountabilityTypes.addAll(missionAuthorizationAccountabilityType.getAccountabilityTypesSet());
    }
    return accountabilityTypes;
}

/**
     * Running time = O(n)
     *
     * @param singlyLinkedListNode
     * @return
     */
public static SinglyLinkedListNode removeDuplicates(SinglyLinkedListNode singlyLinkedListNode) {
    SinglyLinkedListNode dedupedListNode = singlyLinkedListNode;
    SinglyLinkedListNode currentNode = singlyLinkedListNode;
    Set<String> duplicateDetectionSet = new HashSet<>();
    duplicateDetectionSet.add(dedupedListNode.getPayload());
    currentNode = currentNode.getNext();
    while (currentNode != null) {
        if (duplicateDetectionSet.add(currentNode.getPayload())) {
            dedupedListNode.setNext(currentNode);
            dedupedListNode = dedupedListNode.getNext();
        }
        currentNode = currentNode.getNext();
    }
    return singlyLinkedListNode;
}

/**
     * Ustala alfabet.
     */
public static Set<Character> getAlphabet(AutomatonSpecification automaton, Set<Character> superset) {
    Set<Character> alphabet = new HashSet<Character>();
    for (State s : automaton.allStates()) {
        for (OutgoingTransition ot : automaton.allOutgoingTransitions(s)) {
            for (Character c : superset) {
                boolean isAlreadyIn = false;
                for (Character ch : alphabet) {
                    if (ch.equals(c)) {
                        isAlreadyIn = true;
                        break;
                    }
                }
                if (!isAlreadyIn && ot.getTransitionLabel().canAcceptCharacter(c)) {
                    alphabet.add(c);
                }
            }
        }
    }
    return alphabet;
}

public static String getAccessToken(TreeMap<String, String> map, String app_secret) {
    String toMd5 = "";
    Set<String> keys = map.keySet();
    Iterator<String> iterator = keys.iterator();
    while (iterator.hasNext()) {
        String key = iterator.next();
        toMd5 += key + "=" + map.get(key) + "&";
    }
    toMd5 = toMd5.substring(0, toMd5.length() - 1);
    toMd5 += app_secret;
    return MD5.digest(toMd5);
}

public Set<String> check(String passage) {
    if ((passage == null) || (passage.length() == 0)) {
        return null;
    }
    Set<String> errorList = new HashSet<String>();
    StringTokenizer st = new StringTokenizer(passage, " ,.!?;:");
    while (st.hasMoreTokens()) {
        String word = st.nextToken();
        if (!dictionary.check(word)) {
            errorList.add(word);
        }
    }
    return errorList;
}

@Test
public void test() {
    Set<Character> optionsGiven, optionsComputed;
    optionsGiven = Sets.newHashSet();
    for (char c : AutoRefRegion.Flag.OPTIONS.toCharArray()) optionsGiven.add(c);
    optionsComputed = Sets.newHashSet();
    for (AutoRefRegion.Flag flag : AutoRefRegion.Flag.values()) optionsComputed.add(flag.getMark());
    Assert.assertEquals(optionsGiven, optionsComputed);
}

public Set<String> asStringSet() {
    Set<Long> sortedCommunities = new TreeSet<>();
    sortedCommunities.addAll(this);
    Set<String> strings = new LinkedHashSet<>();
    for (long communityLong : sortedCommunities) {
        String commmunityStr = CommonUtil.longToCommunity(communityLong);
        strings.add(commmunityStr);
    }
    return strings;
}

public static Map<String, String> decodeByDecodeNames(List<String> decodeNames, Map<String, String> map) {
    Set<String> keys = map.keySet();
    Iterator<String> it = keys.iterator();
    while (it.hasNext()) {
        String key = it.next();
        String value = map.get(key);
        for (String decodeName : decodeNames) {
            if (key.equals(decodeName)) {
                value = URLDecoder.decode(value);
                map.put(key, value);
            }
        }
    }
    return map;
}

@Test
public void testGetUniqueName() {
    Set<String> names = Sets.newHashSet();
    String name1 = ServiceUtil.getUniqueName("foo", names);
    Assert.assertEquals(name1, "foo");
    String name2 = ServiceUtil.getUniqueName("foo", names);
    Assert.assertEquals(name2, "foo_1");
    String name3 = ServiceUtil.getUniqueName("foo", names);
    Assert.assertEquals(name3, "foo_2");
}

public static Set<Issue> getAffectedIssuesSet(String affectedIssues) {
    Set<Issue> affectedIssuesSet = Sets.newHashSet();
    if (StringUtils.isNotBlank(affectedIssues)) {
        String[] issuePairs = affectedIssues.split(",");
        for (String pair : issuePairs) {
            String[] idAndUrl = pair.split(">>");
            if (idAndUrl.length == 3) {
                affectedIssuesSet.add(new Issue(idAndUrl[0], idAndUrl[1], idAndUrl[2]));
            }
        }
    }
    return affectedIssuesSet;
}

public static Set<Attribute> dissect(LdapName ldapName) throws NamingException {
    Set<Attribute> attributes = new HashSet<Attribute>();
    for (Rdn rdn : ldapName.getRdns()) {
        NamingEnumeration<? extends Attribute> ne = rdn.toAttributes().getAll();
        while (ne.hasMore()) {
            Attribute att = ne.next();
            attributes.add(att);
        }
    }
    return attributes;
}

public static void checkTopologyForResource(Set<TopologyResponse> publics, Long topologyId, String platform) {
    if (publics != null && topologyId != null) {
        for (TopologyResponse t : publics) {
            if (t.getId().equals(topologyId)) {
                if (t.getCloudPlatform().equals(platform)) {
                    return;
                } else {
                    throw new RuntimeException("The selected platform belongs to a different cloudplatform");
                }
            }
        }
        throw new RuntimeException("Not found platform with id: " + topologyId);
    }
}

@Override
public ContainerVm getContainerVm(List<ContainerVm> vmList, Object obj, Set<? extends ContainerVm> excludedVmList) {
    ContainerVm selectedVm = null;
    double maxMips = Double.MIN_VALUE;
    for (ContainerVm containerVm1 : vmList) {
        if (excludedVmList.contains(containerVm1)) {
            continue;
        }
        double containerUsage = containerVm1.getContainerScheduler().getAvailableMips();
        if (containerUsage > maxMips) {
            maxMips = containerUsage;
            selectedVm = containerVm1;
        }
    }
    return selectedVm;
}

public static void main(String[] args) {
    Set<String> names1 = Sets.newHashSet();
    names1.add("Tim");
    names1.add("Tom");
    names1.add("Ted");
    Set<String> names2 = Sets.newHashSet();
    names2.add("Susan");
    names2.add("Tony");
    names2.add("Ted");
    Set<String> union = Sets.union(names1, names2);
    for (String name : union) {
        System.out.printf("%s\n", name);
    }
}

public void testParse() {
    try {
        String text = "I am going to be in <LOC> Italy </LOC> sometime, soon. Specifically in <LOC> Tuscany </LOC> .";
        Set<String> labels = new HashSet<String>();
        labels.add("LOC");
        System.out.println(AnnotatedTextReader.parseFile(new BufferedReader(new StringReader(text)), labels, null, true, ""));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Bean
FormattingConversionServiceFactoryBean conversionService() {
    FormattingConversionServiceFactoryBean bean = new FormattingConversionServiceFactoryBean();
    Set<FormatterRegistrar> set = new HashSet<FormatterRegistrar>();
    JodaTimeFormatterRegistrar registrar = new JodaTimeFormatterRegistrar();
    registrar.setUseIsoFormat(true);
    set.add(registrar);
    bean.setFormatterRegistrars(set);
    return bean;
}

public static void main(String[] args) throws Exception {
    try (KafkaClient kafkaClient = new KafkaClient("localhost:9092")) {
        kafkaClient.init();
        Set<String> topics = kafkaClient.getTopics();
        System.out.println("Topics: " + topics);
        System.out.println(kafkaClient.getPartitionInfo("demo"));
        System.out.println(kafkaClient.getPartitionInfo("demo1"));
        System.out.println(kafkaClient.getPartitionInfo("demo2"));
        System.out.println(kafkaClient.getPartitionInfo("kotontai"));
        System.out.println(kafkaClient.getPartitionInfo("kotontai2"));
    }
}

/**
	 * @param args
	 */
public static void main(String[] args) {
    String[] cn = new String[] { "0", "14", "15", "20", "21", "23", "60", "63", "65", "74", "75", "79", "107", "121", "147", "193", "194", "197", "199", "200", "201", "229", "241", "263", "309", "325", "349", "370", "400" };
    String[] l = new String[] { "0", "14", "15", "20", "21", "22", "23", "27", "44", "50", "53", "60", "63", "65", "74", "75", "79", "86", "107", "111", "114", "121", "123", "125", "129", "136", "147", "153", "158", "160", "171", "180", "193", "194", "195", "196", "197", "198", "199", "200", "201", "219", "226", "228", "229", "234", "236", "241", "246", "251", "256", "258", "259", "260", "261", "262", "263", "264", "265", "266", "267", "279", "293", "297", "298", "304", "307", "309", "311", "313", "316", "318", "325", "327", "328", "334", "336", "340", "349", "350", "351", "353", "354", "355", "356", "360", "362", "364", "366", "367", "370", "392", "394", "395", "396", "397", "400", "402", "405", "406", "407", "408", "409", "410", "411" };
    Set<Integer> ls = new HashSet<Integer>();
    for (String s : l) {
        Integer v = Integer.valueOf(s);
        ls.add(v);
    }
    Set<Integer> cnn = new HashSet<Integer>();
    for (String s : cn) {
        Integer v = Integer.valueOf(s);
        cnn.add(v);
    }
    System.out.println(ls.containsAll(cnn));
}

public static String packagesToKey(Set<String> packages) {
    Set<String> sorted = new TreeSet<String>();
    sorted.addAll(packages);
    StringBuffer buffer = new StringBuffer();
    for (Iterator<String> iterator = sorted.iterator(); iterator.hasNext(); ) {
        String object = iterator.next();
        buffer.append("_").append(object);
    }
    return buffer.toString().replaceAll(":", "_");
}

public static void main(String[] args) {
    DataBase base = new DataBase("projectValter");
    Set<Table> tables = new TreeSet<Table>();
    base.setDataBaseTables(tables);
    Table table1 = new Table("CLIENTE");
    Table table2 = new Table("CLIENTE");
    base.getDataBaseTables().add(table1);
    base.getDataBaseTables().add(table2);
    System.out.println(base.getDataBaseTables().size());
}

public static Set<EInformationFlowModel> from(String str) {
    if (str == null)
        return null;
    Set<EInformationFlowModel> result = new HashSet<>();
    for (String s : str.split(Settings.getInstance().getSeparator1())) {
        switch(s.trim().toLowerCase()) {
            case "scope":
                result.add(SCOPE);
                break;
            case "quantities":
                result.add(QUANTITIES);
                break;
            case "structure":
                result.add(STRUCTURE);
                break;
        }
    }
    return result;
}

public void contextInitialized(ServletContextEvent arg0) {
    try {
        ClasspathScanner scanner = new ClasspathScanner("org.hibernate.annotations.common.reflection.*");
        System.out.println("Found the following classes");
        Set<String> classes = scanner.getClasses();
        System.out.println(classes);
        System.out.println("Scan correct: " + (classes.size() == 12));
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

@Override
public Set<OutputConfiguration> getOutputConfigurations() {
    OutputConfiguration defaultOutput = new OutputConfiguration(IFileSystemAccess.DEFAULT_OUTPUT);
    defaultOutput.setDescription("Output folder for generated Java files");
    defaultOutput.setOutputDirectory("src");
    defaultOutput.setOverrideExistingResources(true);
    defaultOutput.setCreateOutputDirectory(true);
    defaultOutput.setCanClearOutputDirectory(false);
    defaultOutput.setCleanUpDerivedResources(false);
    defaultOutput.setSetDerivedProperty(false);
    return newHashSet(defaultOutput);
}

public void hardLub() {
    java.util.List<String> list = new java.util.ArrayList<String>();
    java.util.Set<String> set = new java.util.HashSet<String>();
    lombok.val thisShouldBeCollection = (System.currentTimeMillis() > 0) ? list : set;
    thisShouldBeCollection.add("");
    String foo = thisShouldBeCollection.iterator().next();
}

public static void main(String[] args) {
    Set<Integer> set = new TreeSet<Integer>();
    List<Integer> list = new ArrayList<Integer>();
    for (int i = -3; i < 3; i++) {
        set.add(i);
        list.add(i);
    }
    for (int i = 0; i < 3; i++) {
        set.remove(i);
        list.remove(i);
    }
    System.out.println(set + " " + list);
}

public ErraiService locateService() {
    BeanManager beanManager = Util.lookupBeanManager();
    Set<Bean<?>> beans = beanManager.getBeans(ErraiService.class);
    Bean<?> bean = beanManager.resolve(beans);
    CreationalContext<?> context = beanManager.createCreationalContext(bean);
    return (ErraiService) beanManager.getReference(bean, ErraiService.class, context);
}

/**
     * 数组去除��元素
     */
public static List<String> removeDuplicateWithOrder(List<String> list) {
    Set<String> set = new HashSet<String>();
    List<String> newList = new ArrayList<String>();
    for (Iterator<String> iter = list.iterator(); iter.hasNext(); ) {
        String element = iter.next();
        if (set.add(element))
            newList.add(element);
    }
    list.clear();
    return newList;
}

@Test
public void dependencies() {
    final Set<ClassName> dependencies = SourceFile.fromClasspath("test-classes/ValidCoffee.java").dependencies();
    Assert.assertTrue(dependencies != null);
    Assert.assertTrue(dependencies.size() == 4);
    // I should not be able to change the state
    try {
        dependencies.add(new ClassName("a.name.that.should.Fail"));
    } catch (UnsupportedOperationException e) {
        return;
    }
    // awww
    Assert.fail();
}

@Test
public void testUnshared() {
    Set<Long> obj = new LinkedHashSet<>();
    obj.add(11373L);
    FSTConfiguration conf = FSTConfiguration.createDefaultConfiguration();
    conf.setShareReferences(false);
    conf.registerSerializer(LinkedHashSet.class, new FSTCollectionSerializer(), true);
    byte[] bytes = conf.asByteArray(obj);
    Object o = conf.asObject(bytes);
}

public static <T> Set<T> getEnumsWhichConstantNameStartsWith(Class<T> enumClass, String prefix) {
    HashSet<T> types = new HashSet<T>();
    for (Field field : enumClass.getFields()) {
        if (Modifier.isStatic(field.getModifiers()) && field.getType().equals(enumClass) && field.getName().startsWith(prefix)) {
            try {
                types.add((T) field.get(null));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
    return types;
}

public void testDemoText() {
    GoColorsAndFontsPage testee = new GoColorsAndFontsPage();
    String demoText = testee.getDemoText();
    Set<String> knownElements = testee.getAdditionalHighlightingTagToDescriptorMap().keySet();
    Matcher m = Pattern.compile("</?(\\w+)>").matcher(demoText);
    while (m.find()) {
        String name = m.group(1);
        if (!knownElements.contains(name)) {
            Assert.fail("Unknown element \"" + m.group() + "\".");
        }
    }
}

public Set<ElementId> read(String string) {
    final Set<ElementId> tagIds = new HashSet<ElementId>();
    if (string != null && string.length() > 0) {
        final String[] tagNames = string.split(",");
        for (String tagName : tagNames) {
            tagIds.add(new ElementId(tagName.substring(1, tagName.length() - 1)));
        }
    }
    return tagIds;
}

/**
     * Report the subscription methods declared on the subscriber.
     */
public Set<Method> subscriptionsOn(Object subscriber) {
    SubscriptionMethodFilter filter = new SubscriptionMethodFilter();
    Class<?> subscriberClass = subscriber.getClass();
    List<Method> methods = Arrays.asList(subscriberClass.getMethods());
    Set<Method> subscriptions = new HashSet<Method>();
    for (Method method : methods) {
        if (filter.accepts(method)) {
            subscriptions.add(method);
        }
    }
    return subscriptions;
}

public static void main(String[] args) {
    HazelcastInstance hz = Hazelcast.newHazelcastInstance();
    IMap<String, Customer> map = hz.getMap("map");
    map.put("1", new Customer("peter", true, 36));
    map.put("2", new Customer("john", false, 40));
    map.put("3", new Customer("roger", true, 20));
    Set<Customer> employees = (Set<Customer>) map.values(new SqlPredicate("active AND age < 30"));
    System.out.println("Employees: " + employees);
    Hazelcast.shutdownAll();
}

@Test
public void failFast() {
    //tag::include[]
    Validator validator = Validation.byProvider(HibernateValidator.class).configure().failFast(true).buildValidatorFactory().getValidator();
    Car car = new Car(null, false);
    Set<ConstraintViolation<Car>> constraintViolations = validator.validate(car);
    assertEquals(1, constraintViolations.size());
//end::include[]
}

@Override
public void execute() {
    Scenario s = editor.getScenario();
    Set<Integer> empty = new HashSet<Integer>();
    s.setFireBrigades(empty);
    s.setFireStations(empty);
    s.setPoliceForces(empty);
    s.setPoliceOffices(empty);
    s.setAmbulanceTeams(empty);
    s.setAmbulanceCentres(empty);
    editor.setChanged();
    editor.updateOverlays();
}

@Test
public void getPracticeIdsTest() {
    ProgramTypeProp programTypeProp = new ProgramTypeProp();
    assertEquals(0, programTypeProp.getPracticeIds().size());
    PracticeProp practiceProp1 = new PracticeProp();
    practiceProp1.practiceId = 1;
    PracticeProp practiceProp2 = new PracticeProp();
    practiceProp2.practiceId = 2;
    programTypeProp.practiceProps.add(practiceProp1);
    programTypeProp.practiceProps.add(practiceProp2);
    Set<Long> practiceIds = programTypeProp.getPracticeIds();
    assertEquals(2, practiceIds.size());
    assertTrue(practiceIds.contains((long) 1));
    assertTrue(practiceIds.contains((long) 2));
}

@Override
public Set<Class<?>> getClasses() {
    Set<Class<?>> classes = new HashSet<>();
    classes.add(SpamFilteringResource.class);
    classes.add(MultiPartFeature.class);
    classes.add(SpamFilteringAuthorizationFilter.class);
    classes.add(JacksonJaxbJsonProvider.class);
    // classes.add(LoggingFilter.class);
    return classes;
}

public void testUnique() throws IllegalAccessException {
    Class c = SerializationHeader.class;
    Set<Integer> s = new TreeSet<Integer>();
    for (Field f : c.getDeclaredFields()) {
        f.setAccessible(true);
        int value = f.getInt(null);
        assertTrue("Value already used: " + value, !s.contains(value));
        s.add(value);
    }
    assertTrue(!s.isEmpty());
}

public void testUnique() throws IllegalAccessException {
    Class c = SerializationHeader.class;
    Set<Integer> s = new TreeSet<Integer>();
    for (Field f : c.getDeclaredFields()) {
        f.setAccessible(true);
        int value = f.getInt(null);
        assertTrue("Value already used: " + value, !s.contains(value));
        s.add(value);
    }
    assertTrue(!s.isEmpty());
}

@Override
public Object create(Object request, SpecimenContext context) {
    if (!(request instanceof SpecimenType)) {
        return new NoSpecimen();
    }
    SpecimenType specimenType = (SpecimenType) request;
    Class requestClass = specimenType.getRawType();
    if (!Set.class.isAssignableFrom(requestClass)) {
        return new NoSpecimen();
    }
    if (!requestClass.isInterface()) {
        return new NoSpecimen();
    }
    return new HashSet();
}

@SuppressWarnings("rawtypes")
public String getXmlBody() {
    StringBuilder sb = new StringBuilder();
    Set es = super.getAllParameters().entrySet();
    Iterator it = es.iterator();
    while (it.hasNext()) {
        Map.Entry entry = (Map.Entry) it.next();
        String k = (String) entry.getKey();
        String v = (String) entry.getValue();
        if (!"appkey".equals(k)) {
            sb.append("<" + k + ">" + v + "<" + k + ">" + "\r\n");
        }
    }
    return sb.toString();
}

public static CDG newInstance(DominatorTree<CFGNode> dominatorTree) {
    CDG cdg = new CDG();
    cdg.dominatorTree = dominatorTree;
    for (CFGNode vertex : dominatorTree.getVertices()) {
        Set<CFGNode> frontier = dominatorTree.dominanceFrontier(vertex);
        if (frontier != null) {
            cdg.addVertex(vertex);
            for (CFGNode f : frontier) {
                cdg.addVertex(f);
                cdg.addEdge(new CDGEdge(f, vertex));
            }
        }
    }
    return cdg;
}

@Override
public Set<?> explore(Collection<?> entities, EntityExplorer entityExplorer) {
    Set<Object> explored = new HashSet<Object>();
    Set<?> next = new HashSet<Object>(entities);
    do {
        next = child.explore(next, entityExplorer);
        // remove already explored entities (optimization & prevention of cycles)
        next.removeAll(explored);
        explored.addAll(next);
    } while (!next.isEmpty());
    return explored;
}

public static void collectRecursively(File file, List<File> result, Set<File> excluded) {
    if (file.isDirectory()) {
        File current = file;
        while (current != null) {
            if (excluded.contains(current))
                return;
            current = current.getParentFile();
        }
        final File[] children = file.listFiles();
        if (children != null) {
            for (File child : children) {
                collectRecursively(child, result, excluded);
            }
        }
        return;
    }
    if (file.getName().endsWith(".java")) {
        result.add(file);
    }
}

@Override
public Set<Class<?>> getClasses() {
    final ImmutableSet.Builder<Class<?>> builder = ImmutableSet.builder();
    builder.add(SyntaxProcessing.class);
    builder.add(Index.class);
    builder.add(JJSchemaProcessing.class);
    builder.add(Schema2PojoProcessing.class);
    builder.add(AvroProcessing.class);
    builder.add(JsonPatch.class);
    return builder.build();
}

@Override
public Set<Class<?>> jsondocControllers() {
    Set<Class<?>> jsondocControllers = reflections.getTypesAnnotatedWith(Controller.class, true);
    jsondocControllers.addAll(reflections.getTypesAnnotatedWith(RestController.class, true));
    try {
        Class.forName("org.springframework.data.rest.webmvc.RepositoryRestController");
        jsondocControllers.addAll(reflections.getTypesAnnotatedWith(RepositoryRestController.class, true));
    } catch (ClassNotFoundException e) {
        log.debug(e.getMessage() + ".class not found");
    }
    return jsondocControllers;
}

@Test
public void testGenerateURLTokens() {
    String folder = rootDir + "followee-folder/";
    String filePath = folder + MemberURLTokenGenerator.URLTOKEN_FILENAME;
    MemberURLTokenGenerator generator = new MemberURLTokenGenerator(folder, filePath);
    int tokenCount = 20;
    Set<String> tokens = generator.generateURLTokens();
    File file = new File(filePath);
    Assert.assertTrue(file.exists());
    Assert.assertEquals(tokenCount, tokens.size());
}

@Override
protected LibraryUrls detectInternal(Set<String> javaClassNames) {
    LibraryUrls result = new LibraryUrls();
    for (String javaClassName : javaClassNames) {
        if (javaClassName.contains(Ext.class.getPackage().getName())) {
            result.getJavaScriptUrls().add("webjars/extjs/4.2.1.883/ext-debug.js");
            result.getCssUrls().add("webjars/extjs/4.2.1.883/resources/css/ext-all.css");
            break;
        }
    }
    return result;
}

public Set<String> findParonyms(String input) {
    Set<String> paronyms = Sets.newHashSet();
    int maxDistance = input.length() / 3;
    for (String word : Checker.formsDictionary.keySet()) {
        if (!word.startsWith(input) && StringUtils.getLevenshteinDistance(input, word, maxDistance) != -1) {
            paronyms.add(word);
        }
    }
    return paronyms;
}

@Test
public void twoConnections() throws Exception {
    RedisAsyncConnection<String, String> connection1 = client.connectAsync();
    RedisAsyncConnection<String, String> connection2 = client.connectAsync();
    connection1.sadd("key", "member1", "member2").get();
    Future<Set<String>> members = connection2.smembers("key");
    assertThat(members.get()).hasSize(2);
    connection1.close();
    connection2.close();
}

@Override
public String apply(final TestOrder parentTestEntity) {
    Set<String> lineItemsDescriptions = newLinkedHashSet();
    for (TestLineItem lineItems : parentTestEntity.getLineItems()) {
        lineItemsDescriptions.add("LineItem Id: " + lineItems.getId() + "; Product Name: " + lineItems.getProduct().getName());
    }
    return StringUtils.collectionToDelimitedString(lineItemsDescriptions, "<br/>");
}

public void hardLub() {
    java.util.List<String> list = new java.util.ArrayList<String>();
    java.util.Set<String> set = new java.util.HashSet<String>();
    lombok.val thisShouldBeCollection = (System.currentTimeMillis() > 0) ? list : set;
    thisShouldBeCollection.add("");
    String foo = thisShouldBeCollection.iterator().next();
}

public void hardLub() {
    java.util.List<String> list = new java.util.ArrayList<String>();
    java.util.Set<String> set = new java.util.HashSet<String>();
    lombok.val thisShouldBeCollection = (System.currentTimeMillis() > 0) ? list : set;
    thisShouldBeCollection.add("");
    String foo = thisShouldBeCollection.iterator().next();
}

@Override
public Set<OutputConfiguration> getOutputConfigurations() {
    Set<OutputConfiguration> outputConfigurations = super.getOutputConfigurations();
    OutputConfiguration defaultOutput = new OutputConfiguration(DEFAULT_STUB_OUTPUT);
    defaultOutput.setDescription("Stub Folder");
    defaultOutput.setOutputDirectory("./src");
    defaultOutput.setOverrideExistingResources(false);
    defaultOutput.setCreateOutputDirectory(false);
    defaultOutput.setCleanUpDerivedResources(false);
    defaultOutput.setSetDerivedProperty(false);
    defaultOutput.setCanClearOutputDirectory(false);
    outputConfigurations.add(defaultOutput);
    return outputConfigurations;
}

@Override
public Set<OutputConfiguration> getOutputConfigurations() {
    Set<OutputConfiguration> outputConfigurations = super.getOutputConfigurations();
    OutputConfiguration defaultOutput = new OutputConfiguration(DEFAULT_STUB_OUTPUT);
    defaultOutput.setDescription("Stub Folder");
    defaultOutput.setOutputDirectory("./src");
    defaultOutput.setOverrideExistingResources(false);
    defaultOutput.setCreateOutputDirectory(false);
    defaultOutput.setCleanUpDerivedResources(false);
    defaultOutput.setSetDerivedProperty(false);
    defaultOutput.setCanClearOutputDirectory(false);
    outputConfigurations.add(defaultOutput);
    return outputConfigurations;
}

@Override
public Set<OutputConfiguration> getOutputConfigurations() {
    Set<OutputConfiguration> outputConfigurations = super.getOutputConfigurations();
    OutputConfiguration defaultOutput = new OutputConfiguration(DEFAULT_STUB_OUTPUT);
    defaultOutput.setDescription("Stub Folder");
    defaultOutput.setOutputDirectory("./src");
    defaultOutput.setOverrideExistingResources(false);
    defaultOutput.setCreateOutputDirectory(false);
    defaultOutput.setCleanUpDerivedResources(false);
    defaultOutput.setSetDerivedProperty(false);
    defaultOutput.setCanClearOutputDirectory(false);
    outputConfigurations.add(defaultOutput);
    return outputConfigurations;
}

public static void main(String[] args) {
    MockNeat m = MockNeat.threadLocal();
    Map<String, List<Map<Set<Integer>, List<Integer>>>> result = m.ints().list(// List<Integer>
    2).mapKeys(// Map<Set<Integer>, List<Integer>>
    2, m.ints().set(3)::val).list(// List<Map<Set<Integer>, List<Integer>>>
    LinkedList.class, 2).mapKeys(// Map<String, List<Map<Set<Integer>, List<Integer>>>>
    4, m.strings()::val).val();
}

@Override
protected void loadCollections() throws Exception {
    DB db = ((Database) getParent()).getDB();
    Set<String> names = MongoShellCommandManager.getInstance().showCollections(getServer(), db);
    for (String name : names) {
        Collection collection = new Collection(name);
        collections.add(collection);
        super.addNode(collection);
    }
}

/**
	 * 根� 请求 url，获�控制模型
	 * 
	 * @param webUrl
	 * @return
	 */
public static ControlModel getControllModel(String webUrl) {
    ControlModel cm = null;
    // �索普通url
    cm = CoreQueue.controlMap.get(webUrl);
    // �索rest
    if (cm == null) {
        Set<String> restUrls = CoreQueue.restControlMap.keySet();
        for (String restUrl : restUrls) {
            if (webUrl.matches(restUrl)) {
                cm = CoreQueue.restControlMap.get(restUrl);
                break;
            }
        }
    }
    return cm;
}

@Test
public void testMapperCreation() {
    PropertiesKeyMapper propertiesKeyMapper = PropertiesKeyMapper.create("controller-properties.map");
    Set<String> allKeys = propertiesKeyMapper.getAllKeys();
    List<String> all = newArrayList();
    all.addAll(allKeys);
    Collections.sort(all);
    for (String each : all) {
        System.out.println("public static final String PROP_" + each.toUpperCase().replace(".", "_") + " = \"" + each + "\";");
    }
}

public static Set<String> findAllClassesInPackage(String packageName) {
    try {
        ClassPath cp = ClassPath.from(ReflectionsHelper.class.getClassLoader());
        ImmutableSet<ClassPath.ClassInfo> classes = cp.getTopLevelClasses(packageName);
        Set<String> classNames = new LinkedHashSet<>();
        for (ClassPath.ClassInfo ci : classes) {
            classNames.add(ci.getName());
        }
        return classNames;
    } catch (IOException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}

public void testOpInfoForClass() {
    VanillaServerHandlerFactory<LogPollable> test = new VanillaServerHandlerFactory<LogPollable>(LogPollable.class);
    MBeanOperationInfo[] results = test.getMBeanOperationInfo();
    assertEquals(4, results.length);
    Set<String> set = new HashSet<String>();
    for (MBeanOperationInfo result : results) {
        set.add(result.getName());
    }
    assertTrue(set.contains("url"));
}

static boolean checkRange(Set<String> CIDR_networks, String ip) {
    for (String network : CIDR_networks) {
        System.out.println("Looking at range: " + network + " and ip " + ip);
        SubnetUtils utils = new SubnetUtils(network);
        if (utils.getInfo().isInRange(ip)) {
            System.out.println(ip + " in range " + network);
            return true;
        }
    }
    //no matches
    return false;
}

protected boolean proceed(INode node) {
    if (node == topNode) {
        return true;
    }
    INode parent = node.parent();
    Set<INode> visited = new HashSet<INode>();
    while (parent != null && !visited.contains(parent) && this.topNode != parent) {
        visited.add(parent);
        parent = parent.parent();
    }
    return this.topNode == parent;
}

@Test
public void testAuditLogTypeValueUniqueness() {
    BitSet bitset = new BitSet(bitsetSize);
    Set<Integer> nonUniqueValues = new TreeSet<>();
    for (AuditLogType alt : AuditLogType.values()) {
        if (bitset.get(alt.getValue())) {
            nonUniqueValues.add(alt.getValue());
        } else {
            bitset.set(alt.getValue());
        }
    }
    assertTrue("AuditLogType contains the following non unique values: " + nonUniqueValues, nonUniqueValues.isEmpty());
}

@Test
public void shouldHaveUniqueNodes() {
    // given
    Set<String> nodes = new HashSet<>();
    // when/then
    for (PlayerPermission permission : PlayerPermission.values()) {
        if (nodes.contains(permission.getNode())) {
            fail("More than one enum value defines the node '" + permission.getNode() + "'");
        }
        nodes.add(permission.getNode());
    }
}

protected String getReturnVarName(String returnVarNameRoot) {
    Set<String> fieldNames = new LinkedHashSet<String>();
    for (FieldBinding fieldBinding : getFields()) {
        fieldNames.add(fieldBinding.getName());
    }
    String returnVarName = returnVarNameRoot;
    int count = 0;
    while (fieldNames.contains(returnVarName)) {
        returnVarName = returnVarNameRoot + ++count;
    }
    return returnVarName;
}

public static Set<Class<?>> getInterfaces(Class<?> type) {
    Set<Class<?>> interfaces = new HashSet<Class<?>>();
    // check super class
    Class<?> sclass = type.getSuperclass();
    if (sclass != null) {
        interfaces.addAll(getInterfaces(sclass));
    }
    // and this class
    for (Class<?> interf : type.getInterfaces()) {
        if (Modifier.isPublic(interf.getModifiers())) {
            interfaces.add(interf);
            interfaces.addAll(getInterfaces(interf));
        }
    }
    return interfaces;
}

protected void validateEntity(Object entity) {
    SystemDAO systemDAO = DAOFactory.getInstance().getSystemDAO();
    Set<ConstraintViolation<Object>> constraintViolations = systemDAO.validateEntity(entity);
    if (!constraintViolations.isEmpty()) {
        String message = "";
        for (ConstraintViolation<Object> constraintViolation : constraintViolations) {
            message += constraintViolation.getMessage() + '\n';
        }
        throw new PersistenceException(message);
    }
}

@Override
public boolean judge(PacketProblem problem, String playerAnswer) {
    if (Strings.isNullOrEmpty(playerAnswer)) {
        return false;
    }
    Set<String> selected = ImmutableSet.copyOf(playerAnswer.split(Constant.DELIMITER_GENERAL));
    Set<String> answerSet = ImmutableSet.copyOf(problem.getShuffledAnswerList());
    return selected.equals(answerSet);
}

@Override
public List<String> list(String path) {
    List<String> list = list();
    Set<String> set = new HashSet<String>();
    for (String uri : list) {
        if (uri.startsWith(path)) {
            String u = uri.substring(path.length());
            if (u.contains("/")) {
                set.add(u.substring(0, u.indexOf('/')));
            } else {
                set.add(u);
            }
        }
    }
    return new ArrayList<String>(set);
}

@Override
public Set<Player> selectPlayers(String worldNames) {
    Set<Player> players = new HashSet<>();
    if (!worldNames.isEmpty()) {
        String[] arrWorlds = worldNames.split(",\\s*");
        for (String worldName : arrWorlds) {
            World world = Bukkit.getWorld(worldName);
            if (world == null)
                continue;
            players.addAll(world.getPlayers());
        }
    }
    return players;
}

public static Set<String> getHttpMethods(Method method) {
    HashSet<String> methods = new HashSet<String>();
    for (Annotation annotation : method.getAnnotations()) {
        HttpMethod http = annotation.annotationType().getAnnotation(HttpMethod.class);
        if (http != null)
            methods.add(http.value());
    }
    if (methods.size() == 0)
        return null;
    return methods;
}