public static Method[] getPropertyMethods(PropertyDescriptor[] properties, boolean read, boolean write) { Set methods = new HashSet(); for (int i = 0; i < properties.length; i++) { PropertyDescriptor pd = properties[i]; if (read) { methods.add(pd.getReadMethod()); } if (write) { methods.add(pd.getWriteMethod()); } } methods.remove(null); return (Method[]) methods.toArray(new Method[methods.size()]); }
@Override TypeVariable<?> captureAsTypeVariable(Type[] upperBounds) { Set<Type> combined = new LinkedHashSet<>(asList(upperBounds)); // Since this is an artifically generated type variable, we don't bother checking // subtyping between declared type bound and actual type bound. So it's possible that we // may generate something like <capture#1-of ? extends Foo&SubFoo>. // Checking subtype between declared and actual type bounds // adds recursive isSubtypeOf() call and feels complicated. // There is no contract one way or another as long as isSubtypeOf() works as expected. combined.addAll(asList(typeParam.getBounds())); if (combined.size() > 1) { // Object is implicit and only useful if it's the only bound. combined.remove(Object.class); } return super.captureAsTypeVariable(combined.toArray(new Type[0])); } };
@Implementation protected @Nullable String[] getPackagesForUid(int uid) { String[] packageNames = packagesForUid.get(uid); if (packageNames != null) { return packageNames; } Set<String> results = new HashSet<>(); for (PackageInfo packageInfo : packageInfos.values()) { if (packageInfo.applicationInfo != null && packageInfo.applicationInfo.uid == uid) { results.add(packageInfo.packageName); } } return results.isEmpty() ? null : results.toArray(new String[results.size()]); }
Set<K> keySet = map.keySet(); Collection<V> valueCollection = map.values(); Set<Entry<K, V>> entrySet = map.entrySet(); V value = map.get(key); expectedKeySetHash += key != null ? key.hashCode() : 0; assertTrue(map.containsKey(key)); assertEquals(map.size(), valueCollection.size()); assertEquals(valueCollection.size() == 0, valueCollection.isEmpty()); assertEquals(!valueCollection.isEmpty(), valueCollection.iterator().hasNext()); Object[] entrySetToArray1 = entrySet.toArray(); assertEquals(map.size(), entrySetToArray1.length); assertTrue(Arrays.asList(entrySetToArray1).containsAll(entrySet)); Entry<?, ?>[] entrySetToArray2 = new Entry<?, ?>[map.size() + 2]; entrySetToArray2[map.size()] = mapEntry("foo", 1); assertSame(entrySetToArray2, entrySet.toArray(entrySetToArray2)); assertNull(entrySetToArray2[map.size()]); assertTrue(Arrays.asList(entrySetToArray2).containsAll(entrySet)); assertEquals(map.size(), valuesToArray1.length); assertTrue(Arrays.asList(valuesToArray1).containsAll(valueCollection)); Object[] valuesToArray2 = new Object[map.size() + 2];
@Override public int getAvailableRestoreSets(IRestoreObserver observer, IBackupManagerMonitor monitor) throws RemoteException { post( () -> { Set<Long> restoreTokens = serviceState.restoreData.keySet(); Set<RestoreSet> restoreSets = new HashSet<>(); for (long token : restoreTokens) { restoreSets.add(new RestoreSet("RestoreSet-" + token, "device", token)); } observer.restoreSetsAvailable(restoreSets.toArray(new RestoreSet[restoreSets.size()])); }); return BackupManager.SUCCESS; }
@CheckNoWriter @CheckNoStats @Test(dataProvider = "caches") @CacheSpec(removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void keySetToArray(Map<Integer, Integer> map, CacheContext context) { int length = context.original().size(); Integer[] ints = map.keySet().toArray(new Integer[length]); assertThat(ints.length, is(length)); assertThat(Arrays.asList(ints).containsAll(context.original().keySet()), is(true)); Object[] array = map.keySet().toArray(); assertThat(array.length, is(length)); assertThat(Arrays.asList(array).containsAll(context.original().keySet()), is(true)); }
/** * Returns a new proxy for {@code interfaceType}. Proxies of the same interface are equal to each * other if the {@link DummyProxy} instance that created the proxies are equal. */ final <T> T newProxy(TypeToken<T> interfaceType) { Set<Class<?>> interfaceClasses = Sets.newLinkedHashSet(); interfaceClasses.addAll(interfaceType.getTypes().interfaces().rawTypes()); // Make the proxy serializable to work with SerializableTester interfaceClasses.add(Serializable.class); Object dummy = Proxy.newProxyInstance( interfaceClasses.iterator().next().getClassLoader(), interfaceClasses.toArray(new Class<?>[interfaceClasses.size()]), new DummyHandler(interfaceType)); @SuppressWarnings("unchecked") // interfaceType is T T result = (T) dummy; return result; }
/** * Return all the MIME types known to this mailcap file. */ public String[] getMimeTypes() { Set types = new HashSet(type_hash.keySet()); types.addAll(fallback_hash.keySet()); types.addAll(native_commands.keySet()); String[] mts = new String[types.size()]; mts = (String[])types.toArray(mts); return mts; }
private static URL[] combineURLs(final Set<URL> instanceUrls, final Set<URL> additionalResourceUrls) { final Set<URL> allUrls = new LinkedHashSet<>(); if (instanceUrls != null) { allUrls.addAll(instanceUrls); } if (additionalResourceUrls != null) { allUrls.addAll(additionalResourceUrls); } return allUrls.toArray(new URL[allUrls.size()]); }
protected OAuth2Authentication getOAuth2Authentication(ClientDetails client, TokenRequest tokenRequest) { Map<String, String> params = tokenRequest.getRequestParameters(); String username = params.containsKey("username") ? params.get("username") : "guest"; List<GrantedAuthority> authorities = params.containsKey("authorities") ? AuthorityUtils .createAuthorityList(OAuth2Utils.parseParameterList(params.get("authorities")).toArray(new String[0])) : AuthorityUtils.NO_AUTHORITIES; Authentication user = new UsernamePasswordAuthenticationToken(username, "N/A", authorities); OAuth2Authentication authentication = new OAuth2Authentication(tokenRequest.createOAuth2Request(client), user); return authentication; } }
@CheckNoWriter @CheckNoStats @Test(dataProvider = "caches") @CacheSpec(removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void entriesToArray(Map<Integer, Integer> map, CacheContext context) { int length = context.original().size(); Object[] ints = map.entrySet().toArray(new Object[length]); assertThat(ints.length, is(length)); assertThat(Arrays.asList(ints).containsAll(context.original().entrySet()), is(true)); Object[] array = map.entrySet().toArray(); assertThat(array.length, is(length)); assertThat(Arrays.asList(array).containsAll(context.original().entrySet()), is(true)); }