/** * Filter the list of requested WebSocket extensions. * <p>As of 4.1, the default implementation of this method filters the list to * leave only extensions that are both requested and supported. * @param request the current request * @param requestedExtensions the list of extensions requested by the client * @param supportedExtensions the list of extensions supported by the server * @return the selected extensions or an empty list */ protected List<WebSocketExtension> filterRequestedExtensions(ServerHttpRequest request, List<WebSocketExtension> requestedExtensions, List<WebSocketExtension> supportedExtensions) { List<WebSocketExtension> result = new ArrayList<>(requestedExtensions.size()); for (WebSocketExtension extension : requestedExtensions) { if (supportedExtensions.contains(extension)) { result.add(extension); } } return result; }
@NonNull private synchronized List<Entry<?, ?>> getOrAddEntryList(@NonNull String bucket) { if (!bucketPriorityList.contains(bucket)) { // Add this unspecified bucket as a low priority bucket. bucketPriorityList.add(bucket); } List<Entry<?, ?>> entries = decoders.get(bucket); if (entries == null) { entries = new ArrayList<>(); decoders.put(bucket, entries); } return entries; }
public synchronized void subscribe(ClientIdentity clientIdentity) throws CanalMetaManagerException { List<ClientIdentity> clientIdentitys = destinations.get(clientIdentity.getDestination()); if (clientIdentitys.contains(clientIdentity)) { clientIdentitys.remove(clientIdentity); } clientIdentitys.add(clientIdentity); }
assertTrue(parameterNames.contains("getField")); assertEquals("value3", request.getParameter("field3")); List<String> parameterValues = Arrays.asList(request.getParameterValues("field3")); assertEquals(1, parameterValues.size()); assertTrue(parameterValues.contains("value3")); assertEquals("value4", request.getParameter("field4")); parameterValues = Arrays.asList(request.getParameterValues("field4")); assertEquals(2, parameterValues.size()); assertTrue(parameterValues.contains("value4")); assertTrue(parameterValues.contains("value5")); assertEquals("value4", request.getParameter("field4")); assertEquals("getValue", request.getParameter("getField")); assertEquals(3, parameterMapKeys.size()); assertTrue(field4Index != -1); assertTrue(getFieldIndex != -1); parameterValues = Arrays.asList((String[]) parameterMapValues.get(field3Index)); assertEquals(1, parameterValues.size()); assertTrue(parameterValues.contains("value3")); parameterValues = Arrays.asList((String[]) parameterMapValues.get(field4Index)); assertEquals(2, parameterValues.size()); assertTrue(parameterValues.contains("value4")); assertTrue(parameterValues.contains("value5")); parameterValues = Arrays.asList((String[]) parameterMapValues.get(getFieldIndex)); assertEquals(1, parameterValues.size()); assertTrue(parameterValues.contains("getValue"));
List<?> peerProtocols = (List) args[0]; for (int i = 0, size = peerProtocols.size(); i < size; i++) { String protocol = (String) peerProtocols.get(i); if (protocols.contains(protocol)) { return selected = protocol; return selected = protocols.get(0); // On no intersection, try peer's first protocol. } else if ((methodName.equals("protocolSelected") || methodName.equals("selected")) && args.length == 1) {
@Test public void normal() { List<Integer> list = new VolatileSizeArrayList<Integer>(); assertEquals(0, list.size()); assertFalse(list.contains(1)); assertFalse(list.remove((Integer)1)); assertTrue(list.contains(2)); assertFalse(list.remove((Integer)10)); assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6, 7), list); assertFalse(list.isEmpty()); assertEquals(7, list.size()); assertFalse(list.retainAll(Arrays.asList(1, 2, 3, 4, 5, 6, 7))); assertEquals(7, list.size()); assertEquals(i, list.get(i - 1).intValue()); assertFalse(list.equals(list3)); list3.add(7); assertTrue(list3.equals(list)); assertTrue(list.equals(list3));
private static boolean validParameters(String methodAnnotation, Class[] parameterTypes) { List<Class<?>> localMapping = mapping.get(methodAnnotation.replace("@", "")); if (localMapping == null) { return false; } for (Class<?> parameterType : parameterTypes) { if (!localMapping.contains(parameterType)) { return false; } } return true; }
@VisibleForTesting protected static void mergeParentProperties(Map<String, String> childProps, Map<String, String> parentProps) { for (Map.Entry<String, String> entry : parentProps.entrySet()) { String key = entry.getKey(); if ((!childProps.containsKey(key) || childProps.get(key).equals(entry.getValue())) && !NON_HERITED_PROPERTIES_FOR_CHILD.contains(key)) { childProps.put(entry.getKey(), entry.getValue()); } } }
/** * Test Filtering and limit to depth 1 */ @Test public void testFilterAndLimitB() { final List<File> results = new TestFileFinder(NOT_SVN, 1).find(javaDir); assertEquals("[B] Result Size", 2, results.size()); assertTrue("[B] Start Dir", results.contains(javaDir)); assertTrue("[B] Org Dir", results.contains(orgDir)); }
@Override public void addChangeListener(ConfigChangeListener listener, Set<String> interestedKeys, Set<String> interestedKeyPrefixes) { if (!m_listeners.contains(listener)) { m_listeners.add(listener); if (interestedKeys != null && !interestedKeys.isEmpty()) { m_interestedKeys.put(listener, Sets.newHashSet(interestedKeys)); } if (interestedKeyPrefixes != null && !interestedKeyPrefixes.isEmpty()) { m_interestedKeyPrefixes.put(listener, Sets.newHashSet(interestedKeyPrefixes)); } } }
@Override public void adjustSqlDigest(List<MeasureDesc> measureDescs, SQLDigest sqlDigest) { for (SQLCall call : sqlDigest.aggrSqlCalls) { if (FUNC_INTERSECT_COUNT_DISTINCT.equals(call.function)) { TblColRef col = (TblColRef) call.args.get(1); if (!sqlDigest.groupbyColumns.contains(col)) sqlDigest.groupbyColumns.add(col); } } } }
public synchronized void setBucketPriorityList(@NonNull List<String> buckets) { List<String> previousBuckets = new ArrayList<>(bucketPriorityList); bucketPriorityList.clear(); bucketPriorityList.addAll(buckets); for (String previousBucket : previousBuckets) { if (!buckets.contains(previousBucket)) { // Keep any buckets from the previous list that aren't included here, but but them at the // end. bucketPriorityList.add(previousBucket); } } }
@CollectionSize.Require(absent = {ZERO, ONE}) public void testSubList_contains() { List<E> list = getList(); int size = getNumElements(); List<E> copy = list.subList(0, size); List<E> head = list.subList(0, size - 1); List<E> tail = list.subList(1, size); assertTrue(copy.contains(list.get(0))); assertTrue(head.contains(list.get(0))); assertTrue(tail.contains(list.get(1))); // The following assumes all elements are distinct. assertTrue(copy.contains(list.get(size - 1))); assertTrue(head.contains(list.get(size - 2))); assertTrue(tail.contains(list.get(size - 1))); assertFalse(head.contains(list.get(size - 1))); assertFalse(tail.contains(list.get(0))); }
protected synchronized void addTypedEventListener(ActivitiEventListener listener, ActivitiEventType type) { List<ActivitiEventListener> listeners = typedListeners.get(type); if (listeners == null) { // Add an empty list of listeners for this type listeners = new CopyOnWriteArrayList<ActivitiEventListener>(); typedListeners.put(type, listeners); } if (!listeners.contains(listener)) { listeners.add(listener); } } }
List<Key> getCacheKeys() { if (!isCacheKeysSet) { isCacheKeysSet = true; cacheKeys.clear(); List<LoadData<?>> loadData = getLoadData(); //noinspection ForLoopReplaceableByForEach to improve perf for (int i = 0, size = loadData.size(); i < size; i++) { LoadData<?> data = loadData.get(i); if (!cacheKeys.contains(data.sourceKey)) { cacheKeys.add(data.sourceKey); } for (int j = 0; j < data.alternateKeys.size(); j++) { if (!cacheKeys.contains(data.alternateKeys.get(j))) { cacheKeys.add(data.alternateKeys.get(j)); } } } } return cacheKeys; }