private boolean containsColumn(Collection columns, String column) { if (columns.contains(column)) return true; for (Iterator it = columns.iterator(); it.hasNext(); ) { if (((String) it.next()).equalsIgnoreCase(column)) return true; } return false; }
public static MultiMap<PsiElement, UsageInfo> classifyUsages( Collection<? extends PsiElement> elements, UsageInfo[] usages) { final MultiMap<PsiElement, UsageInfo> result = new MultiMap<PsiElement, UsageInfo>(); for (UsageInfo usage : usages) { LOG.assertTrue(usage instanceof MoveRenameUsageInfo); if (usage.getReference() instanceof LightElement) { continue; // filter out implicit references (e.g. from derived class to super class' default // constructor) } MoveRenameUsageInfo usageInfo = (MoveRenameUsageInfo) usage; if (usage instanceof RelatedUsageInfo) { final PsiElement relatedElement = ((RelatedUsageInfo) usage).getRelatedElement(); if (elements.contains(relatedElement)) { result.putValue(relatedElement, usage); } } else { PsiElement referenced = usageInfo.getReferencedElement(); if (elements.contains(referenced)) { result.putValue(referenced, usage); } else if (referenced != null) { PsiElement indirect = referenced.getNavigationElement(); if (elements.contains(indirect)) { result.putValue(indirect, usage); } } } } return result; }
public static void testDetermineMergeParticipantsAndMergeCoords4() { Address a = Util.createRandomAddress(), b = Util.createRandomAddress(), c = Util.createRandomAddress(), d = Util.createRandomAddress(); org.jgroups.util.UUID.add(a, "A"); org.jgroups.util.UUID.add(b, "B"); org.jgroups.util.UUID.add(c, "C"); org.jgroups.util.UUID.add(d, "D"); View v1 = View.create(a, 1, a, b); View v2 = View.create(c, 1, c, d); Map<Address, View> map = new HashMap<>(); map.put(a, v1); map.put(b, v1); map.put(d, v2); StringBuilder sb = new StringBuilder("map:\n"); for (Map.Entry<Address, View> entry : map.entrySet()) sb.append(entry.getKey() + ": " + entry.getValue() + "\n"); System.out.println(sb); Collection<Address> merge_participants = Util.determineMergeParticipants(map); System.out.println("merge_participants = " + merge_participants); assert merge_participants.size() == 3; assert merge_participants.contains(a) && merge_participants.contains(c) && merge_participants.contains(d); Collection<Address> merge_coords = Util.determineMergeCoords(map); System.out.println("merge_coords = " + merge_coords); assert merge_coords.size() == 2; assert merge_coords.contains(a) && merge_coords.contains(c); }
public void testRegularAndOOBUnicasts2() throws Exception { DISCARD discard = new DISCARD(); ProtocolStack stack = a.getProtocolStack(); stack.insertProtocol( discard, ProtocolStack.BELOW, (Class<? extends Protocol>[]) Util.getUnicastProtocols()); Address dest = b.getAddress(); Message m1 = new Message(dest, 1); Message m2 = new Message(dest, 2).setFlag(Message.Flag.OOB); Message m3 = new Message(dest, 3).setFlag(Message.Flag.OOB); Message m4 = new Message(dest, 4); MyReceiver receiver = new MyReceiver("B"); b.setReceiver(receiver); a.send(m1); discard.setDropDownUnicasts(2); a.send(m2); // dropped a.send(m3); // dropped a.send(m4); Collection<Integer> list = receiver.getMsgs(); int count = 10; while (list.size() < 4 && --count > 0) { Util.sleep(500); // time for potential retransmission sendStableMessages(a, b); } System.out.println("list = " + list); assert list.size() == 4 : "list is " + list; assert list.contains(1) && list.contains(2) && list.contains(3) && list.contains(4); }
public void testGetFeedsXmlURLs() throws MalformedURLException { assertEquals("Please remove all guides from set by this point.", 0, set.getGuidesCount()); StandardGuide guide1 = new StandardGuide(); guide1.setTitle("1"); StandardGuide guide2 = new StandardGuide(); guide2.setTitle("2"); DirectFeed feed1 = new DirectFeed(); feed1.setXmlURL(new URL("file://1")); DirectFeed feed2 = new DirectFeed(); feed2.setXmlURL(new URL("file://2")); DirectFeed feed3 = new DirectFeed(); feed3.setXmlURL(new URL("file://3")); DirectFeed feed4 = new DirectFeed(); feed4.setXmlURL(new URL("file://1")); SearchFeed feed5 = new SearchFeed(); feed5.setBaseTitle("5"); guide1.add(feed1); guide1.add(feed5); guide2.add(feed2); guide2.add(feed3); guide2.add(feed4); set.add(guide1); set.add(guide2); Collection urls = set.getFeedsXmlURLs(); assertEquals("URL's of network feeds (de-duplicated) should be returned.", 3, urls.size()); assertTrue(urls.contains(feed1.getXmlURL())); assertTrue(urls.contains(feed2.getXmlURL())); assertTrue(urls.contains(feed3.getXmlURL())); }
/** @param node Node to remove. */ public void removeMappedNode(GridNode node) { if (mappedDhtNodes.contains(node)) mappedDhtNodes = new ArrayList<>(F.view(mappedDhtNodes, F.notEqualTo(node))); if (mappedNearNodes != null && mappedNearNodes.contains(node)) mappedNearNodes = new ArrayList<>(F.view(mappedNearNodes, F.notEqualTo(node))); }
public void testRegularAndOOBMulticasts() throws Exception { DISCARD discard = new DISCARD(); ProtocolStack stack = a.getProtocolStack(); stack.insertProtocol(discard, ProtocolStack.BELOW, NAKACK2.class); a.setDiscardOwnMessages(true); Address dest = null; // send to all Message m1 = new Message(dest, null, 1); Message m2 = new Message(dest, null, 2); m2.setFlag(Message.OOB); Message m3 = new Message(dest, null, 3); MyReceiver receiver = new MyReceiver("C2"); b.setReceiver(receiver); a.send(m1); discard.setDropDownMulticasts(1); a.send(m2); a.send(m3); Util.sleep(500); Collection<Integer> list = receiver.getMsgs(); for (int i = 0; i < 10; i++) { System.out.println("list = " + list); if (list.size() == 3) break; Util.sleep(1000); // give the asynchronous msgs some time to be received sendStableMessages(a, b); } assert list.size() == 3 : "list is " + list; assert list.contains(1) && list.contains(2) && list.contains(3); }
/** * JUnit. * * @throws Exception If failed. */ public void testGetAndIncrement() throws Exception { Collection<Long> res = new HashSet<>(); String seqName = UUID.randomUUID().toString(); for (int i = 0; i < GRID_CNT; i++) { Set<Long> retVal = compute(grid(i).cluster().forLocal()).call(new GetAndIncrementJob(seqName, RETRIES)); for (Long l : retVal) assert !res.contains(l) : "Value already was used " + l; res.addAll(retVal); } assert res.size() == GRID_CNT * RETRIES; int gapSize = 0; for (long i = 0; i < GRID_CNT * RETRIES; i++) { if (!res.contains(i)) gapSize++; else gapSize = 0; assert gapSize <= BATCH_SIZE + 1 : "Gap above id " + i + " is " + gapSize + " more than batch size: " + (BATCH_SIZE + 1); } }
@Test public void testResolveTransitiveDups() throws BundleException, InvalidSyntaxException { region(REGION_A).connectRegion(region(REGION_B), createFilter(PACKAGE_B)); region(REGION_A).connectRegion(region(REGION_C), createFilter(PACKAGE_DUP)); region(REGION_A).connectRegion(region(REGION_D), createFilter(PACKAGE_DUP)); region(REGION_B).connectRegion(region(REGION_C), createFilter(PACKAGE_DUP)); region(REGION_C).connectRegion(region(REGION_D), createFilter(PACKAGE_DUP)); region(REGION_D).connectRegion(region(REGION_A), createFilter(PACKAGE_DUP)); this.candidates.add(packageCapability(BUNDLE_A, PACKAGE_DUP)); this.candidates.add(packageCapability(BUNDLE_B, PACKAGE_DUP)); this.candidates.add(packageCapability(BUNDLE_C, PACKAGE_DUP)); this.candidates.add(packageCapability(BUNDLE_D, PACKAGE_DUP)); Collection<BundleCapability> testCandidates = new ArrayList<BundleCapability>(this.candidates); this.resolverHook.filterMatches(bundleRequirement(BUNDLE_A), testCandidates); assertTrue(testCandidates.contains(packageCapability(BUNDLE_A, PACKAGE_DUP))); assertFalse(testCandidates.contains(packageCapability(BUNDLE_B, PACKAGE_DUP))); assertTrue(testCandidates.contains(packageCapability(BUNDLE_C, PACKAGE_DUP))); assertTrue(testCandidates.contains(packageCapability(BUNDLE_D, PACKAGE_DUP))); testCandidates = new ArrayList<BundleCapability>(this.candidates); this.resolverHook.filterMatches(bundleRequirement(BUNDLE_B), testCandidates); assertTrue(testCandidates.contains(packageCapability(BUNDLE_A, PACKAGE_DUP))); assertTrue(testCandidates.contains(packageCapability(BUNDLE_B, PACKAGE_DUP))); assertTrue(testCandidates.contains(packageCapability(BUNDLE_C, PACKAGE_DUP))); assertTrue(testCandidates.contains(packageCapability(BUNDLE_D, PACKAGE_DUP))); }
/** * Tests sending 1, 2 (OOB) and 3, where they are received in the order 1, 3, 2. Message 3 should * not get delivered until message 4 is received (http://jira.jboss.com/jira/browse/JGRP-780) */ public void testRegularAndOOBUnicasts() throws Exception { DISCARD discard = new DISCARD(); ProtocolStack stack = a.getProtocolStack(); stack.insertProtocol(discard, ProtocolStack.BELOW, UNICAST.class, UNICAST2.class); Address dest = b.getAddress(); Message m1 = new Message(dest, null, 1); Message m2 = new Message(dest, null, 2); m2.setFlag(Message.OOB); Message m3 = new Message(dest, null, 3); MyReceiver receiver = new MyReceiver("C2"); b.setReceiver(receiver); a.send(m1); discard.setDropDownUnicasts(1); a.send(m2); a.send(m3); Collection<Integer> list = receiver.getMsgs(); int count = 10; while (list.size() < 3 && --count > 0) { Util.sleep(500); // time for potential retransmission sendStableMessages(a, b); } assert list.size() == 3 : "list is " + list; assert list.contains(1) && list.contains(2) && list.contains(3); }
/** {@inheritDoc} */ @Override public Map<K, V> peekAll( @Nullable Collection<? extends K> keys, @Nullable Collection<GridCachePeekMode> modes) throws GridException { if (keys == null || keys.isEmpty()) return emptyMap(); final Collection<K> skipped = new GridLeanSet<K>(); final Map<K, V> map = !modes.contains(PARTITIONED_ONLY) ? peekAll0(keys, modes, ctx.tm().localTxx(), skipped) : new GridLeanMap<K, V>(0); if (map.size() != keys.size() && !modes.contains(NEAR_ONLY)) { map.putAll( dht.peekAll( F.view( keys, new P1<K>() { @Override public boolean apply(K k) { return !map.containsKey(k) && !skipped.contains(k); } }), modes)); } return map; }
public Collection<PsiElement> getAdditionalElementsToDelete( @NotNull final PsiElement element, @NotNull final Collection<PsiElement> allElementsToDelete, final boolean askUser) { if (element instanceof PsiField) { PsiField field = (PsiField) element; final Project project = element.getProject(); String propertyName = JavaCodeStyleManager.getInstance(project) .variableNameToPropertyName(field.getName(), VariableKind.FIELD); PsiClass aClass = field.getContainingClass(); if (aClass != null) { boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC); PsiMethod[] getters = GetterSetterPrototypeProvider.findGetters(aClass, propertyName, isStatic); if (getters != null) { final List<PsiMethod> validGetters = new ArrayList<>(1); for (PsiMethod getter : getters) { if (!allElementsToDelete.contains(getter) && (getter != null && getter.isPhysical())) { validGetters.add(getter); } } getters = validGetters.isEmpty() ? null : validGetters.toArray(new PsiMethod[validGetters.size()]); } PsiMethod setter = PropertyUtil.findPropertySetter(aClass, propertyName, isStatic, false); if (allElementsToDelete.contains(setter) || setter != null && !setter.isPhysical()) setter = null; if (askUser && (getters != null || setter != null)) { final String message = RefactoringMessageUtil.getGetterSetterMessage( field.getName(), RefactoringBundle.message("delete.title"), getters != null ? getters[0] : null, setter); if (!ApplicationManager.getApplication().isUnitTestMode() && Messages.showYesNoDialog( project, message, RefactoringBundle.message("safe.delete.title"), Messages.getQuestionIcon()) != Messages.YES) { getters = null; setter = null; } } List<PsiElement> elements = new ArrayList<>(); if (setter != null) elements.add(setter); if (getters != null) Collections.addAll(elements, getters); return elements; } } return null; }
/** * First positive integer that is not present in started set. * * @param started Already started indices. * @return First positive integer that is not present in started set. */ private int nextIndex(Collection<Integer> started) { assert started.contains(0); for (int i = 1; i < 10000; i++) { if (!started.contains(i)) return i; } throw new IllegalStateException(); }
/** values collection contains all values */ public void testDescendingValues() { ConcurrentNavigableMap map = dmap5(); Collection s = map.values(); assertEquals(5, s.size()); assertTrue(s.contains("A")); assertTrue(s.contains("B")); assertTrue(s.contains("C")); assertTrue(s.contains("D")); assertTrue(s.contains("E")); }
@SuppressWarnings("squid:S1244") private static String selectBestEncoding(String acceptEncodingHeader) { // multiple encodings are accepted; determine best one Collection<String> bestEncodings = new HashSet<>(3); double bestQ = 0.0; Collection<String> unacceptableEncodings = new HashSet<>(3); boolean willAcceptAnything = false; for (String token : COMMA.split(acceptEncodingHeader)) { ContentEncodingQ contentEncodingQ = parseContentEncodingQ(token); String contentEncoding = contentEncodingQ.getContentEncoding(); double q = contentEncodingQ.getQ(); if (ANY_ENCODING.equals(contentEncoding)) { willAcceptAnything = q > 0.0; } else if (SUPPORTED_ENCODINGS.contains(contentEncoding)) { if (q > 0.0) { // This is a header quality comparison. // So it is safe to suppress warning squid:S1244 if (q == bestQ) { bestEncodings.add(contentEncoding); } else if (q > bestQ) { bestQ = q; bestEncodings.clear(); bestEncodings.add(contentEncoding); } } else { unacceptableEncodings.add(contentEncoding); } } } if (bestEncodings.isEmpty()) { // nothing was acceptable to us if (willAcceptAnything) { if (unacceptableEncodings.isEmpty()) { return SUPPORTED_ENCODINGS.get(0); } else { for (String encoding : SUPPORTED_ENCODINGS) { if (!unacceptableEncodings.contains(encoding)) { return encoding; } } } } } else { for (String encoding : SUPPORTED_ENCODINGS) { if (bestEncodings.contains(encoding)) { return encoding; } } } return NO_ENCODING; }
public boolean testContainsAddDiff() { description = "membership status is not affected by adding other"; precondition = Boolean.TRUE; ; Object e = new Object(); boolean before = c.contains(e); Object a = new Object(); c.add(a); boolean after = c.contains(e); return before == after; }
@SmallTest @MediumTest @LargeTest public void testCollectionContains() throws JSONException { JSONArray array = new JSONArray(); array.put(5); Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class); assertTrue(collection.contains(5)); assertFalse(collection.contains(6)); }
public void process(String projectId, Date from, Date to) { reset(); Collection<VcsCommitInfo> allCommits = getCommitsForProject(projectId, from, to); generateTestAndTrainSets(allCommits); System.out.println("Processing commits..."); int total = allCommits.size(); int counter = 0; long startTime = System.currentTimeMillis(); for (VcsCommitInfo commitInfo : allCommits) { counter++; if (counter % 100 == 0) { System.out.println( counter + " / " + total + " | last 100 processed in " + (System.currentTimeMillis() - startTime) + " ms"); startTime = System.currentTimeMillis(); } for (String filename : commitInfo.getAffectedFiles()) { if (!commitAffections.containsKey(filename)) { commitAffections.put(filename, new ArrayList<VcsCommitInfo>()); } commitAffections.get(filename).add(commitInfo); } if (VcsCommitInfoUtils.isRelatedToBugIssue(commitInfo)) { for (String filename : commitInfo.getAffectedFiles()) { if (!bugFixCommitAffections.containsKey(filename)) { bugFixCommitAffections.put(filename, new ArrayList<VcsCommitInfo>()); } bugFixCommitAffections.get(filename).add(commitInfo); } } for (PredictionModel model : myModels) { if (trainSet.contains(commitInfo.getCommitId())) { // train the model model.update(commitInfo, true); } if (testSet.contains(commitInfo.getCommitId())) { // update the model without training and get prediction data Map<String, List<VcsCommitInfo>> topAppearanceMapForCurrentModel = appearancesInTop.get(model); for (String fileInTop : model.getPredictionData().keySet()) { if (!topAppearanceMapForCurrentModel.containsKey(fileInTop)) { topAppearanceMapForCurrentModel.put(fileInTop, new ArrayList<VcsCommitInfo>()); } topAppearanceMapForCurrentModel.get(fileInTop).add(commitInfo); } } } } }
public void putAny(String key, String value) { // guess the type if (BOOLEAN_SETTINGS.contains(key)) { putBoolean(key, "yes".equals(value)); } else if (INT_SETTINGS.contains(key)) { putInt(key, Integer.parseInt(value)); } else if (STRING_SETTINGS.contains(key)) { putString(key, value); } else { System.err.println("Unknown key: " + key); } }
// Indicates if the classLoad should be overridden for the passed className. // Returns true in case the class should NOT be loaded by parent classLoader. protected boolean shouldOverrideLoadClass(String name) { if (shouldOverrideLoadClassForCollectionMembers) { // Override classLoad if the name is in collection return (classNames != null) && classNames.contains(name); } else { // Directly opposite: Override classLoad if the name is NOT in collection. // Forced to check for java. and javax. packages here, because even if the class // has been loaded by parent loader we would load it again // (see comment in loadClass) return !name.startsWith("java.") && !name.startsWith("javax.") && ((classNames == null) || !classNames.contains(name)); } }
/** * Retain in this vector only the elements contained in the given collection. * * @param c the collection to filter by * @return true if this vector changed * @throws NullPointerException if c is null * @since 1.2 */ public synchronized boolean retainAll(Collection c) { if (c == null) throw new NullPointerException(); int i; int j; for (i = 0; i < elementCount; i++) if (!c.contains(elementData[i])) break; if (i == elementCount) return false; modCount++; for (j = i++; i < elementCount; i++) if (c.contains(elementData[i])) elementData[j++] = elementData[i]; elementCount -= i - j; return true; }
@Nullable private static PyGenericType getGenericType( @NotNull PsiElement element, @NotNull Context context) { if (element instanceof PyCallExpression) { final PyCallExpression assignedCall = (PyCallExpression) element; final PyExpression callee = assignedCall.getCallee(); if (callee != null) { final Collection<String> calleeQNames = resolveToQualifiedNames(callee, context.getTypeContext()); if (calleeQNames.contains("typing.TypeVar")) { final PyExpression[] arguments = assignedCall.getArguments(); if (arguments.length > 0) { final PyExpression firstArgument = arguments[0]; if (firstArgument instanceof PyStringLiteralExpression) { final String name = ((PyStringLiteralExpression) firstArgument).getStringValue(); if (name != null) { return new PyGenericType(name, getGenericTypeBound(arguments, context)); } } } } } } return null; }
@Nullable private static PyType getCallableType(@NotNull PsiElement resolved, @NotNull Context context) { if (resolved instanceof PySubscriptionExpression) { final PySubscriptionExpression subscriptionExpr = (PySubscriptionExpression) resolved; final PyExpression operand = subscriptionExpr.getOperand(); final Collection<String> operandNames = resolveToQualifiedNames(operand, context.getTypeContext()); if (operandNames.contains("typing.Callable")) { final PyExpression indexExpr = subscriptionExpr.getIndexExpression(); if (indexExpr instanceof PyTupleExpression) { final PyTupleExpression tupleExpr = (PyTupleExpression) indexExpr; final PyExpression[] elements = tupleExpr.getElements(); if (elements.length == 2) { final PyExpression parametersExpr = elements[0]; final PyExpression returnTypeExpr = elements[1]; if (parametersExpr instanceof PyListLiteralExpression) { final List<PyCallableParameter> parameters = new ArrayList<>(); final PyListLiteralExpression listExpr = (PyListLiteralExpression) parametersExpr; for (PyExpression argExpr : listExpr.getElements()) { parameters.add(new PyCallableParameterImpl(null, getType(argExpr, context))); } final PyType returnType = getType(returnTypeExpr, context); return new PyCallableTypeImpl(parameters, returnType); } if (isEllipsis(parametersExpr)) { return new PyCallableTypeImpl(null, getType(returnTypeExpr, context)); } } } } } return null; }
public boolean retainAll(Collection<?> c) { List<K> toRemove = new ArrayList<K>(); for (K key : this) { if (!c.contains(key)) toRemove.add(key); } return removeAll(toRemove); }
/** * This method receives a normalized list of non-dominated solutions and return the inverted one. * This operation is needed for minimization problem * * @param solutionList The front to invert * @return The inverted front */ public static <S extends Solution<?>> List<S> selectNRandomDifferentSolutions( int numberOfSolutionsToBeReturned, List<S> solutionList) { if (null == solutionList) { throw new JMetalException("The solution list is null"); } else if (solutionList.size() == 0) { throw new JMetalException("The solution list is empty"); } else if (solutionList.size() < numberOfSolutionsToBeReturned) { throw new JMetalException( "The solution list size (" + solutionList.size() + ") is less than " + "the number of requested solutions (" + numberOfSolutionsToBeReturned + ")"); } JMetalRandom randomGenerator = JMetalRandom.getInstance(); List<S> resultList = new ArrayList<>(numberOfSolutionsToBeReturned); if (solutionList.size() == 1) { resultList.add(solutionList.get(0)); } else { Collection<Integer> positions = new HashSet<>(numberOfSolutionsToBeReturned); while (positions.size() < numberOfSolutionsToBeReturned) { int nextPosition = randomGenerator.nextInt(0, solutionList.size() - 1); if (!positions.contains(nextPosition)) { positions.add(nextPosition); resultList.add(solutionList.get(nextPosition)); } } } return resultList; }
private static void checkForUnexpectedErrors() { AnalyzeExhaust exhaust = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile((JetFile) getFile()); Collection<Diagnostic> diagnostics = exhaust.getBindingContext().getDiagnostics(); if (diagnostics.size() != 0) { String[] expectedErrorStrings = InTextDirectivesUtils.findListWithPrefix("// ERROR:", getFile().getText()); System.out.println(getFile().getText()); Collection<String> expectedErrors = new HashSet<String>(Arrays.asList(expectedErrorStrings)); StringBuilder builder = new StringBuilder(); boolean hasErrors = false; for (Diagnostic diagnostic : diagnostics) { if (diagnostic.getSeverity() == Severity.ERROR) { String errorText = IdeErrorMessages.RENDERER.render(diagnostic); if (!expectedErrors.contains(errorText)) { hasErrors = true; builder.append("// ERROR: ").append(errorText).append("\n"); } } } Assert.assertFalse( "There should be no unexpected errors after applying fix (Use \"// ERROR:\" directive): \n" + builder.toString(), hasErrors); } }
/** Tests https://jira.jboss.org/jira/browse/JGRP-1079 for unicast messages */ public void testOOBUnicastMessageLoss() throws Exception { MyReceiver receiver = new MySleepingReceiver("C2", 1000); b.setReceiver(receiver); a.getProtocolStack().getTransport().setOOBRejectionPolicy("discard"); final int NUM = 10; final Address dest = b.getAddress(); for (int i = 1; i <= NUM; i++) { Message msg = new Message(dest, null, i); msg.setFlag(Message.OOB); a.send(msg); } Collection<Integer> msgs = receiver.getMsgs(); for (int i = 0; i < 20; i++) { if (msgs.size() == NUM) break; Util.sleep(1000); // sendStableMessages(c1,c2); // not needed for unicasts ! } assert msgs.size() == NUM : "expected " + NUM + " messages but got " + msgs.size() + ", msgs=" + Util.print(msgs); for (int i = 1; i <= NUM; i++) { assert msgs.contains(i); } }
/** Tests https://jira.jboss.org/jira/browse/JGRP-1079 */ public void testOOBMessageLoss() throws Exception { Util.close(b); // we only need 1 channel MyReceiver receiver = new MySleepingReceiver("C1", 1000); a.setReceiver(receiver); TP transport = a.getProtocolStack().getTransport(); transport.setOOBRejectionPolicy("discard"); final int NUM = 10; for (int i = 1; i <= NUM; i++) { Message msg = new Message(null, null, i); msg.setFlag(Message.OOB); a.send(msg); } STABLE stable = (STABLE) a.getProtocolStack().findProtocol(STABLE.class); if (stable != null) stable.runMessageGarbageCollection(); Collection<Integer> msgs = receiver.getMsgs(); for (int i = 0; i < 20; i++) { if (msgs.size() == NUM) break; Util.sleep(1000); sendStableMessages(a, b); } System.out.println("msgs = " + Util.print(msgs)); assert msgs.size() == NUM : "expected " + NUM + " messages but got " + msgs.size() + ", msgs=" + Util.print(msgs); for (int i = 1; i <= NUM; i++) { assert msgs.contains(i); } }
private static Collection<? extends File> findFiles( Collection<String> extensions, File directory) { Set<File> result = new HashSet<File>(); File[] children = directory.listFiles(); if (children == null) { return result; // No permission? } for (File child : children) { if (child.isDirectory()) { result.addAll(UtilFindFiles.findFiles(extensions, child)); } else { String extension = FileUtil.getFileExtension(child); if (extension != null) { if (extensions.contains(extension)) { result.add(child); } } } } return result; }
/** {@inheritDoc} */ @Override public V peek(K key, @Nullable Collection<GridCachePeekMode> modes) throws GridException { V val = null; if (!modes.contains(PARTITIONED_ONLY)) { try { val = peek0(true, key, modes, ctx.tm().txx()); } catch (GridCacheFilterFailedException ignored) { if (log.isDebugEnabled()) log.debug("Filter validation failed for key: " + key); return null; } } return val == null && !modes.contains(NEAR_ONLY) ? dht.peek(key, modes) : val; }