From a6395298d52a476c93cd8bb5a7752069ce2728f9 Mon Sep 17 00:00:00 2001 From: yifeizhuang Date: Mon, 12 Jul 2021 17:22:04 -0700 Subject: [PATCH 1/3] api: use shcme to provider list map in nameResoverRegistry --- .../java/io/grpc/NameResolverRegistry.java | 54 ++++++++++++------- .../io/grpc/NameResolverRegistryTest.java | 35 ++++++++---- 2 files changed, 59 insertions(+), 30 deletions(-) diff --git a/api/src/main/java/io/grpc/NameResolverRegistry.java b/api/src/main/java/io/grpc/NameResolverRegistry.java index 2e914e2fbc1..02f9bf4e07d 100644 --- a/api/src/main/java/io/grpc/NameResolverRegistry.java +++ b/api/src/main/java/io/grpc/NameResolverRegistry.java @@ -23,6 +23,7 @@ import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; +import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.logging.Level; @@ -47,9 +48,11 @@ public final class NameResolverRegistry { @GuardedBy("this") private final LinkedHashSet allProviders = new LinkedHashSet<>(); - /** Immutable, sorted version of {@code allProviders}. Is replaced instead of mutating. */ + /** Generated from {@code allProviders}. Is mapped from scheme key to its sorted provider list in + * decreasing priority order. */ @GuardedBy("this") - private List effectiveProviders = Collections.emptyList(); + private LinkedHashMap> effectiveProviders = + new LinkedHashMap<>(); /** * Register a provider. @@ -81,16 +84,27 @@ public synchronized void deregister(NameResolverProvider provider) { } private synchronized void refreshProviders() { - List providers = new ArrayList<>(allProviders); - // Sort descending based on priority. - // sort() must be stable, as we prefer first-registered providers - Collections.sort(providers, Collections.reverseOrder(new Comparator() { - @Override - public int compare(NameResolverProvider o1, NameResolverProvider o2) { - return o1.priority() - o2.priority(); + LinkedHashMap> refreshedProviders = new LinkedHashMap<>(); + for (NameResolverProvider provider : allProviders) { + String scheme = provider.getDefaultScheme(); + List providersForScheme = refreshedProviders.get(scheme); + if (providersForScheme == null) { + providersForScheme = new ArrayList<>(); } - })); - effectiveProviders = Collections.unmodifiableList(providers); + providersForScheme.add(provider); + refreshedProviders.put(scheme, providersForScheme); + } + for (List providers : refreshedProviders.values()) { + // Sort descending based on priority. + // sort() must be stable, as we prefer first-registered providers + Collections.sort(providers, Collections.reverseOrder(new Comparator() { + @Override + public int compare(NameResolverProvider o1, NameResolverProvider o2) { + return o1.priority() - o2.priority(); + } + })); + } + effectiveProviders = refreshedProviders; } /** @@ -120,11 +134,11 @@ public static synchronized NameResolverRegistry getDefaultRegistry() { } /** - * Returns effective providers, in priority order. + * Returns effective providers map from scheme to the provider list. The list in priority order. */ @VisibleForTesting - synchronized List providers() { - return effectiveProviders; + synchronized LinkedHashMap> providers() { + return new LinkedHashMap<>(effectiveProviders); } public NameResolver.Factory asFactory() { @@ -149,8 +163,11 @@ private final class NameResolverFactory extends NameResolver.Factory { @Override @Nullable public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) { - List providers = providers(); - for (NameResolverProvider provider : providers) { + List providerList = providers().get(targetUri.getScheme()); + if (providerList == null) { + return null; + } + for (NameResolverProvider provider : providerList) { NameResolver resolver = provider.newNameResolver(targetUri, args); if (resolver != null) { return resolver; @@ -161,11 +178,10 @@ public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) { @Override public String getDefaultScheme() { - List providers = providers(); - if (providers.isEmpty()) { + if (providers().isEmpty()) { return "unknown"; } - return providers.get(0).getDefaultScheme(); + return providers().entrySet().iterator().next().getKey(); } } diff --git a/api/src/test/java/io/grpc/NameResolverRegistryTest.java b/api/src/test/java/io/grpc/NameResolverRegistryTest.java index 6002dcdaf57..3082bc5220f 100644 --- a/api/src/test/java/io/grpc/NameResolverRegistryTest.java +++ b/api/src/test/java/io/grpc/NameResolverRegistryTest.java @@ -24,6 +24,7 @@ import io.grpc.internal.DnsNameResolverProvider; import java.lang.Thread.UncaughtExceptionHandler; import java.net.URI; +import java.util.LinkedHashMap; import java.util.List; import org.junit.Test; import org.junit.runner.RunWith; @@ -59,12 +60,13 @@ public void deregister() { NameResolverProvider p1 = new BaseProvider(true, 5); NameResolverProvider p2 = new BaseProvider(true, 5); NameResolverProvider p3 = new BaseProvider(true, 5); + String sameScheme = p1.getDefaultScheme(); reg.register(p1); reg.register(p2); reg.register(p3); - assertThat(reg.providers()).containsExactly(p1, p2, p3).inOrder(); + assertThat(reg.providers().get(sameScheme)).containsExactly(p1, p2, p3).inOrder(); reg.deregister(p2); - assertThat(reg.providers()).containsExactly(p1, p3).inOrder(); + assertThat(reg.providers().get(sameScheme)).containsExactly(p1, p3).inOrder(); } @Test @@ -75,12 +77,13 @@ public void provider_sorted() { NameResolverProvider p3 = new BaseProvider(true, 8); NameResolverProvider p4 = new BaseProvider(true, 3); NameResolverProvider p5 = new BaseProvider(true, 8); + String sameScheme = p1.getDefaultScheme(); reg.register(p1); reg.register(p2); reg.register(p3); reg.register(p4); reg.register(p5); - assertThat(reg.providers()).containsExactly(p3, p5, p1, p2, p4).inOrder(); + assertThat(reg.providers().get(sameScheme)).containsExactly(p3, p5, p1, p2, p4).inOrder(); } @Test @@ -107,7 +110,7 @@ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) @Test public void newNameResolver_providerReturnsNonNull() { NameResolverRegistry registry = new NameResolverRegistry(); - registry.register(new BaseProvider(true, 5) { + registry.register(new BaseProvider(true, 5, uri.getScheme()) { @Override public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) { return null; @@ -127,14 +130,14 @@ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) } }; registry.register( - new BaseProvider(true, 4) { + new BaseProvider(true, 4, uri.getScheme()) { @Override public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) { return nr; } }); registry.register( - new BaseProvider(true, 3) { + new BaseProvider(true, 3, uri.getScheme()) { @Override public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) { fail("Should not be called"); @@ -152,12 +155,14 @@ public void newNameResolver_noProvider() { @Test public void baseProviders() { - List providers = NameResolverRegistry.getDefaultRegistry().providers(); - assertThat(providers).hasSize(2); + LinkedHashMap> providers = + NameResolverRegistry.getDefaultRegistry().providers(); + assertThat(providers).hasSize(1); + assertThat(providers.get("dns")).hasSize(2); // 2 name resolvers from grpclb and core, ordered with decreasing priorities. - assertThat(providers.get(0).getClass().getName()) + assertThat(providers.get("dns").get(0).getClass().getName()) .isEqualTo("io.grpc.grpclb.SecretGrpclbNameResolverProvider$Provider"); - assertThat(providers.get(1).getClass().getName()) + assertThat(providers.get("dns").get(1).getClass().getName()) .isEqualTo("io.grpc.internal.DnsNameResolverProvider"); assertThat(NameResolverRegistry.getDefaultRegistry().asFactory().getDefaultScheme()) .isEqualTo("dns"); @@ -184,10 +189,18 @@ NameResolverProvider.class, getClass().getClassLoader())) { private static class BaseProvider extends NameResolverProvider { private final boolean isAvailable; private final int priority; + private final String scheme; public BaseProvider(boolean isAvailable, int priority) { this.isAvailable = isAvailable; this.priority = priority; + this.scheme = null; + } + + public BaseProvider(boolean isAvailable, int priority, String scheme) { + this.isAvailable = isAvailable; + this.priority = priority; + this.scheme = scheme; } @Override @@ -207,7 +220,7 @@ public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) { @Override public String getDefaultScheme() { - return "scheme" + getClass().getSimpleName(); + return scheme == null ? "scheme" + getClass().getSimpleName() : scheme; } } } From 15440af179d3e49def30b5ac5b8997ff0ee16900 Mon Sep 17 00:00:00 2001 From: yifeizhuang Date: Mon, 12 Jul 2021 19:34:29 -0700 Subject: [PATCH 2/3] remove list --- .../java/io/grpc/NameResolverRegistry.java | 52 ++++++----------- .../io/grpc/NameResolverRegistryTest.java | 57 +++++++++++++++---- .../io/grpc/xds/XdsSdsClientServerTest.java | 8 +-- 3 files changed, 67 insertions(+), 50 deletions(-) diff --git a/api/src/main/java/io/grpc/NameResolverRegistry.java b/api/src/main/java/io/grpc/NameResolverRegistry.java index 02f9bf4e07d..96627fd286e 100644 --- a/api/src/main/java/io/grpc/NameResolverRegistry.java +++ b/api/src/main/java/io/grpc/NameResolverRegistry.java @@ -22,7 +22,6 @@ import java.net.URI; import java.util.ArrayList; import java.util.Collections; -import java.util.Comparator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; @@ -48,11 +47,10 @@ public final class NameResolverRegistry { @GuardedBy("this") private final LinkedHashSet allProviders = new LinkedHashSet<>(); - /** Generated from {@code allProviders}. Is mapped from scheme key to its sorted provider list in - * decreasing priority order. */ + /** Generated from {@code allProviders}. Is mapping from scheme key to the highest priority + * {@link NameResolverProvider}. */ @GuardedBy("this") - private LinkedHashMap> effectiveProviders = - new LinkedHashMap<>(); + private LinkedHashMap effectiveProviders = new LinkedHashMap<>(); /** * Register a provider. @@ -84,25 +82,14 @@ public synchronized void deregister(NameResolverProvider provider) { } private synchronized void refreshProviders() { - LinkedHashMap> refreshedProviders = new LinkedHashMap<>(); + LinkedHashMap refreshedProviders = new LinkedHashMap<>(); + // We prefer first-registered providers for (NameResolverProvider provider : allProviders) { String scheme = provider.getDefaultScheme(); - List providersForScheme = refreshedProviders.get(scheme); - if (providersForScheme == null) { - providersForScheme = new ArrayList<>(); + NameResolverProvider existing = refreshedProviders.get(scheme); + if (existing == null || existing.priority() < provider.priority()) { + refreshedProviders.put(scheme, provider); } - providersForScheme.add(provider); - refreshedProviders.put(scheme, providersForScheme); - } - for (List providers : refreshedProviders.values()) { - // Sort descending based on priority. - // sort() must be stable, as we prefer first-registered providers - Collections.sort(providers, Collections.reverseOrder(new Comparator() { - @Override - public int compare(NameResolverProvider o1, NameResolverProvider o2) { - return o1.priority() - o2.priority(); - } - })); } effectiveProviders = refreshedProviders; } @@ -134,10 +121,11 @@ public static synchronized NameResolverRegistry getDefaultRegistry() { } /** - * Returns effective providers map from scheme to the provider list. The list in priority order. + * Returns effective providers map from scheme to the highest priority NameResolverProvider of + * that scheme. */ @VisibleForTesting - synchronized LinkedHashMap> providers() { + synchronized LinkedHashMap providers() { return new LinkedHashMap<>(effectiveProviders); } @@ -163,25 +151,17 @@ private final class NameResolverFactory extends NameResolver.Factory { @Override @Nullable public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) { - List providerList = providers().get(targetUri.getScheme()); - if (providerList == null) { - return null; - } - for (NameResolverProvider provider : providerList) { - NameResolver resolver = provider.newNameResolver(targetUri, args); - if (resolver != null) { - return resolver; - } - } - return null; + NameResolverProvider provider = providers().get(targetUri.getScheme()); + return provider == null ? null : provider.newNameResolver(targetUri, args); } @Override public String getDefaultScheme() { - if (providers().isEmpty()) { + LinkedHashMap providers = providers(); + if (providers.isEmpty()) { return "unknown"; } - return providers().entrySet().iterator().next().getKey(); + return providers.entrySet().iterator().next().getKey(); } } diff --git a/api/src/test/java/io/grpc/NameResolverRegistryTest.java b/api/src/test/java/io/grpc/NameResolverRegistryTest.java index 3082bc5220f..f3258c7ee90 100644 --- a/api/src/test/java/io/grpc/NameResolverRegistryTest.java +++ b/api/src/test/java/io/grpc/NameResolverRegistryTest.java @@ -64,9 +64,12 @@ public void deregister() { reg.register(p1); reg.register(p2); reg.register(p3); - assertThat(reg.providers().get(sameScheme)).containsExactly(p1, p2, p3).inOrder(); + assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p1); reg.deregister(p2); - assertThat(reg.providers().get(sameScheme)).containsExactly(p1, p3).inOrder(); + assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p1); + reg.deregister(p1); + assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p3); + } @Test @@ -83,7 +86,7 @@ public void provider_sorted() { reg.register(p3); reg.register(p4); reg.register(p5); - assertThat(reg.providers().get(sameScheme)).containsExactly(p3, p5, p1, p2, p4).inOrder(); + assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p3); } @Test @@ -144,26 +147,60 @@ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) throw new AssertionError(); } }); - assertThat(registry.asFactory().newNameResolver(uri, args)).isSameInstanceAs(nr); + assertThat(registry.asFactory().newNameResolver(uri, args)).isNull(); + } + + @Test + public void newNameResolver_multipleScheme() { + NameResolverRegistry registry = new NameResolverRegistry(); + registry.register(new BaseProvider(true, 5, uri.getScheme()) { + @Override + public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) { + return null; + } + }); + final NameResolver nr = new NameResolver() { + @Override public String getServiceAuthority() { + throw new UnsupportedOperationException(); + } + + @Override public void start(Listener2 listener) { + throw new UnsupportedOperationException(); + } + + @Override public void shutdown() { + throw new UnsupportedOperationException(); + } + }; + registry.register( + new BaseProvider(true, 4, "other") { + @Override + public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) { + return nr; + } + }); + + assertThat(registry.asFactory().newNameResolver(uri, args)).isNull(); + assertThat(registry.asFactory().newNameResolver(URI.create("other:///0.0.0.0:80"), args)) + .isSameInstanceAs(nr); + assertThat(registry.asFactory().getDefaultScheme()).isEqualTo("dns"); } @Test public void newNameResolver_noProvider() { NameResolver.Factory factory = new NameResolverRegistry().asFactory(); assertThat(factory.newNameResolver(uri, args)).isNull(); + assertThat(factory.getDefaultScheme()).isEqualTo("unknown"); } @Test public void baseProviders() { - LinkedHashMap> providers = + LinkedHashMap providers = NameResolverRegistry.getDefaultRegistry().providers(); assertThat(providers).hasSize(1); - assertThat(providers.get("dns")).hasSize(2); - // 2 name resolvers from grpclb and core, ordered with decreasing priorities. - assertThat(providers.get("dns").get(0).getClass().getName()) + // 2 name resolvers from grpclb and core, higher priority one is returned. + assertThat(providers.get("dns").getClass().getName()) .isEqualTo("io.grpc.grpclb.SecretGrpclbNameResolverProvider$Provider"); - assertThat(providers.get("dns").get(1).getClass().getName()) - .isEqualTo("io.grpc.internal.DnsNameResolverProvider"); assertThat(NameResolverRegistry.getDefaultRegistry().asFactory().getDefaultScheme()) .isEqualTo("dns"); } diff --git a/xds/src/test/java/io/grpc/xds/XdsSdsClientServerTest.java b/xds/src/test/java/io/grpc/xds/XdsSdsClientServerTest.java index 321d5503cc3..c71841b2678 100644 --- a/xds/src/test/java/io/grpc/xds/XdsSdsClientServerTest.java +++ b/xds/src/test/java/io/grpc/xds/XdsSdsClientServerTest.java @@ -88,8 +88,11 @@ public class XdsSdsClientServerTest { private TlsContextManagerImpl tlsContextManagerForServer; @Before - public void setUp() throws IOException { + public void setUp() throws Exception { port = XdsServerTestHelper.findFreePort(); + URI expectedUri = new URI("sdstest://localhost:" + port); + fakeNameResolverFactory = new FakeNameResolverFactory.Builder(expectedUri).build(); + NameResolverRegistry.getDefaultRegistry().register(fakeNameResolverFactory); } @After @@ -410,9 +413,6 @@ static EnvoyServerProtoData.Listener buildListener( private SimpleServiceGrpc.SimpleServiceBlockingStub getBlockingStub( final UpstreamTlsContext upstreamTlsContext, String overrideAuthority) throws URISyntaxException { - URI expectedUri = new URI("sdstest://localhost:" + port); - fakeNameResolverFactory = new FakeNameResolverFactory.Builder(expectedUri).build(); - NameResolverRegistry.getDefaultRegistry().register(fakeNameResolverFactory); ManagedChannelBuilder channelBuilder = Grpc.newChannelBuilder( "sdstest://localhost:" + port, From 3ff8eb1ddb471c1450b22ce88c908ee93aca3807 Mon Sep 17 00:00:00 2001 From: yifeizhuang Date: Thu, 15 Jul 2021 15:28:04 -0700 Subject: [PATCH 3/3] compute default scheme for registry when refresh --- .../java/io/grpc/NameResolverProvider.java | 14 ++++++++ .../java/io/grpc/NameResolverRegistry.java | 35 ++++++++++++------- .../io/grpc/NameResolverRegistryTest.java | 8 +++-- 3 files changed, 42 insertions(+), 15 deletions(-) diff --git a/api/src/main/java/io/grpc/NameResolverProvider.java b/api/src/main/java/io/grpc/NameResolverProvider.java index 5decd7e9150..2c337cd5052 100644 --- a/api/src/main/java/io/grpc/NameResolverProvider.java +++ b/api/src/main/java/io/grpc/NameResolverProvider.java @@ -16,6 +16,8 @@ package io.grpc; +import io.grpc.NameResolver.Factory; + /** * Provider of name resolvers for name agnostic consumption. * @@ -48,4 +50,16 @@ public abstract class NameResolverProvider extends NameResolver.Factory { * @since 1.0.0 */ protected abstract int priority(); + + /** + * Returns the scheme associated with the provider. The provider normally should only create a + * {@link NameResolver} when target URI scheme matches the provider scheme. It temporarily + * delegates to {@link Factory#getDefaultScheme()} before {@link NameResolver.Factory} is + * deprecated in https://github.com/grpc/grpc-java/issues/7133. + * + * @since 1.40.0 + * */ + protected String getScheme() { + return getDefaultScheme(); + } } diff --git a/api/src/main/java/io/grpc/NameResolverRegistry.java b/api/src/main/java/io/grpc/NameResolverRegistry.java index 96627fd286e..2e12bb77483 100644 --- a/api/src/main/java/io/grpc/NameResolverRegistry.java +++ b/api/src/main/java/io/grpc/NameResolverRegistry.java @@ -19,12 +19,14 @@ import static com.google.common.base.Preconditions.checkArgument; import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableMap; import java.net.URI; import java.util.ArrayList; import java.util.Collections; -import java.util.LinkedHashMap; +import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; +import java.util.Map; import java.util.logging.Level; import java.util.logging.Logger; import javax.annotation.Nullable; @@ -44,13 +46,17 @@ public final class NameResolverRegistry { private static NameResolverRegistry instance; private final NameResolver.Factory factory = new NameResolverFactory(); + private static final String UNKNOWN_SCHEME = "unknown"; + @GuardedBy("this") + private String defaultScheme = UNKNOWN_SCHEME; @GuardedBy("this") private final LinkedHashSet allProviders = new LinkedHashSet<>(); /** Generated from {@code allProviders}. Is mapping from scheme key to the highest priority - * {@link NameResolverProvider}. */ + * {@link NameResolverProvider}. Is replaced instead of mutating. */ @GuardedBy("this") - private LinkedHashMap effectiveProviders = new LinkedHashMap<>(); + private ImmutableMap effectiveProviders = ImmutableMap.of(); + /** * Register a provider. @@ -82,16 +88,23 @@ public synchronized void deregister(NameResolverProvider provider) { } private synchronized void refreshProviders() { - LinkedHashMap refreshedProviders = new LinkedHashMap<>(); + Map refreshedProviders = new HashMap<>(); + int maxPriority = Integer.MIN_VALUE; + String refreshedDefaultScheme = UNKNOWN_SCHEME; // We prefer first-registered providers for (NameResolverProvider provider : allProviders) { - String scheme = provider.getDefaultScheme(); + String scheme = provider.getScheme(); NameResolverProvider existing = refreshedProviders.get(scheme); if (existing == null || existing.priority() < provider.priority()) { refreshedProviders.put(scheme, provider); } + if (maxPriority < provider.priority()) { + maxPriority = provider.priority(); + refreshedDefaultScheme = provider.getScheme(); + } } - effectiveProviders = refreshedProviders; + effectiveProviders = ImmutableMap.copyOf(refreshedProviders); + defaultScheme = refreshedDefaultScheme; } /** @@ -125,8 +138,8 @@ public static synchronized NameResolverRegistry getDefaultRegistry() { * that scheme. */ @VisibleForTesting - synchronized LinkedHashMap providers() { - return new LinkedHashMap<>(effectiveProviders); + synchronized Map providers() { + return effectiveProviders; } public NameResolver.Factory asFactory() { @@ -157,11 +170,9 @@ public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) { @Override public String getDefaultScheme() { - LinkedHashMap providers = providers(); - if (providers.isEmpty()) { - return "unknown"; + synchronized (NameResolverRegistry.this) { + return defaultScheme; } - return providers.entrySet().iterator().next().getKey(); } } diff --git a/api/src/test/java/io/grpc/NameResolverRegistryTest.java b/api/src/test/java/io/grpc/NameResolverRegistryTest.java index f3258c7ee90..55e43128109 100644 --- a/api/src/test/java/io/grpc/NameResolverRegistryTest.java +++ b/api/src/test/java/io/grpc/NameResolverRegistryTest.java @@ -24,8 +24,8 @@ import io.grpc.internal.DnsNameResolverProvider; import java.lang.Thread.UncaughtExceptionHandler; import java.net.URI; -import java.util.LinkedHashMap; import java.util.List; +import java.util.Map; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @@ -99,7 +99,7 @@ public void getDefaultScheme_noProvider() { public void newNameResolver_providerReturnsNull() { NameResolverRegistry registry = new NameResolverRegistry(); registry.register( - new BaseProvider(true, 5) { + new BaseProvider(true, 5, "noScheme") { @Override public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) { assertThat(passedUri).isSameInstanceAs(uri); @@ -108,6 +108,7 @@ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) } }); assertThat(registry.asFactory().newNameResolver(uri, args)).isNull(); + assertThat(registry.asFactory().getDefaultScheme()).isEqualTo("noScheme"); } @Test @@ -148,6 +149,7 @@ public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) } }); assertThat(registry.asFactory().newNameResolver(uri, args)).isNull(); + assertThat(registry.asFactory().getDefaultScheme()).isEqualTo(uri.getScheme()); } @Test @@ -195,7 +197,7 @@ public void newNameResolver_noProvider() { @Test public void baseProviders() { - LinkedHashMap providers = + Map providers = NameResolverRegistry.getDefaultRegistry().providers(); assertThat(providers).hasSize(1); // 2 name resolvers from grpclb and core, higher priority one is returned.