add test cases

Author: AgraVator

api/src/main/java/io/grpc/ChildChannelConfigurer.java

@@ -67,4 +67,4 @@ public interface ChildChannelConfigurer extends Consumer<ManagedChannelBuilder<?
    */
   @Override
   void accept(ManagedChannelBuilder<?> builder);
-}
+}

api/src/main/java/io/grpc/ChildChannelConfigurers.java

@@ -96,4 +96,4 @@ public static ChildChannelConfigurer conditional(boolean condition,
     checkNotNull(delegate, "delegate");
     return condition ? delegate : NO_OP;
   }
-}
+}

api/src/test/java/io/grpc/ChildChannelConfigurersTest.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2025 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ChildChannelConfigurersTest {
+
+  @Test
+  public void noOp_doesNothing() {
+    ManagedChannelBuilder<?> builder = mock(ManagedChannelBuilder.class);
+    ChildChannelConfigurers.noOp().accept(builder);
+    verifyNoInteractions(builder);
+  }
+
+  @Test
+  public void compose_runsInOrder() {
+    ManagedChannelBuilder<?> builder = mock(ManagedChannelBuilder.class);
+    ChildChannelConfigurer configurer1 = b -> b.userAgent("agent1");
+    ChildChannelConfigurer configurer2 = b -> b.maxInboundMessageSize(123);
+
+    ChildChannelConfigurers.compose(configurer1, configurer2).accept(builder);
+
+    verify(builder).userAgent("agent1");
+    verify(builder).maxInboundMessageSize(123);
+  }
+
+  @Test
+  public void compose_ignoresNulls() {
+    ManagedChannelBuilder<?> builder = mock(ManagedChannelBuilder.class);
+    ChildChannelConfigurer configurer = b -> b.userAgent("agent1");
+
+    ChildChannelConfigurers.compose(null, configurer, null).accept(builder);
+
+    verify(builder).userAgent("agent1");
+  }
+}

api/src/test/java/io/grpc/NameResolverTest.java

@@ -105,6 +105,7 @@ public void args() {
   }
 
   private NameResolver.Args createArgs() {
+    ManagedChannel parent = mock(ManagedChannel.class);
     return NameResolver.Args.newBuilder()
         .setDefaultPort(defaultPort)
         .setProxyDetector(proxyDetector)
@@ -116,9 +117,35 @@ private NameResolver.Args createArgs() {
         .setOverrideAuthority(overrideAuthority)
         .setMetricRecorder(metricRecorder)
         .setArg(FOO_ARG_KEY, customArgValue)
+        .setParentChannel(parent)
         .build();
   }
 
+  @Test
+  public void args_parentChannel() {
+    ManagedChannel parent = mock(ManagedChannel.class);
+
+    // Create a real SynchronizationContext instead of mocking it
+    SynchronizationContext realSyncContext = new SynchronizationContext(
+        new Thread.UncaughtExceptionHandler() {
+          @Override
+          public void uncaughtException(Thread t, Throwable e) {
+            throw new AssertionError(e);
+          }
+        });
+
+    NameResolver.Args args = NameResolver.Args.newBuilder()
+        .setDefaultPort(8080)
+        .setProxyDetector(mock(ProxyDetector.class))
+        .setSynchronizationContext(realSyncContext)
+        .setServiceConfigParser(mock(NameResolver.ServiceConfigParser.class))
+        .setChannelLogger(mock(ChannelLogger.class))
+        .setParentChannel(parent)
+        .build();
+
+    assertThat(args.getParentChannel()).isSameInstanceAs(parent);
+  }
+
   @Test
   @SuppressWarnings("deprecation")
   public void startOnOldListener_wrapperListener2UsedToStart() {

core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java

@@ -69,6 +69,7 @@
 import io.grpc.Channel;
 import io.grpc.ChannelCredentials;
 import io.grpc.ChannelLogger;
+import io.grpc.ChildChannelConfigurer;
 import io.grpc.ClientCall;
 import io.grpc.ClientInterceptor;
 import io.grpc.ClientInterceptors;
@@ -101,10 +102,12 @@
 import io.grpc.LoadBalancerRegistry;
 import io.grpc.LongCounterMetricInstrument;
 import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
 import io.grpc.MetricInstrumentRegistry;
+import io.grpc.MetricRecorder;
 import io.grpc.MetricSink;
 import io.grpc.NameResolver;
 import io.grpc.NameResolver.ConfigOrError;
@@ -302,9 +305,12 @@ public String getPolicyName() {
   private boolean panicExpected;
   @Captor
   private ArgumentCaptor<ResolvedAddresses> resolvedAddressCaptor;
-
   private ArgumentCaptor<ClientStreamListener> streamListenerCaptor =
       ArgumentCaptor.forClass(ClientStreamListener.class);
+  @Mock
+  private ChildChannelConfigurer mockChildChannelConfigurer;
+  @Mock
+  private MetricRecorder mockMetricRecorder;
 
   private void createChannel(ClientInterceptor... interceptors) {
     createChannel(false, interceptors);
@@ -5139,4 +5145,116 @@ private static ManagedChannelServiceConfig createManagedChannelServiceConfig(
     return ManagedChannelServiceConfig
         .fromServiceConfig(rawServiceConfig, true, 3, 4, policySelection);
   }
+
+  @Test
+  public void getChildChannelConfigurer_returnsConfiguredValue() {
+    ManagedChannelImplBuilder builder = new ManagedChannelImplBuilder(TARGET,
+        new ClientTransportFactoryBuilder() {
+          @Override
+          public ClientTransportFactory buildClientTransportFactory() {
+            return mockTransportFactory;
+          }
+        },
+        new FixedPortProvider(DEFAULT_PORT));
+
+    when(mockTransportFactory.getSupportedSocketAddressTypes())
+        .thenReturn(Collections.singleton(InetSocketAddress.class));
+
+    ManagedChannel channel = builder
+        .nameResolverFactory(new FakeNameResolverFactory(
+            Collections.singletonList(URI.create(TARGET)),
+            Collections.emptyList(),
+            true,
+            null))
+        .childChannelConfigurer(mockChildChannelConfigurer)
+        .build();
+
+    assertThat(channel.getChildChannelConfigurer()).isSameInstanceAs(mockChildChannelConfigurer);
+    channel.shutdownNow();
+  }
+
+  @Test
+  public void configureChannel_propagatesConfigurerToNewBuilder_endToEnd() {
+    when(mockTransportFactory.getSupportedSocketAddressTypes())
+        .thenReturn(Collections.singleton(InetSocketAddress.class));
+
+    // 1. Setup Interceptor
+    final AtomicInteger interceptorCalls = new AtomicInteger(0);
+    final ClientInterceptor trackingInterceptor = new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        interceptorCalls.incrementAndGet();
+        return next.newCall(method, callOptions);
+      }
+    };
+
+    // 2. Setup Configurer
+    ChildChannelConfigurer configurer = new ChildChannelConfigurer() {
+      @Override
+      public void accept(ManagedChannelBuilder<?> builder) {
+        builder.intercept(trackingInterceptor);
+      }
+    };
+
+    // 3. Create Parent Channel
+    ManagedChannelImplBuilder parentBuilder = new ManagedChannelImplBuilder("fake://parent-target",
+        new ClientTransportFactoryBuilder() {
+          @Override
+          public ClientTransportFactory buildClientTransportFactory() {
+            return mockTransportFactory;
+          }
+        },
+        new FixedPortProvider(DEFAULT_PORT));
+
+    ManagedChannel parentChannel = parentBuilder
+        // MATCH THE CONSTRUCTOR SIGNATURE: (List<URI>, List<EAG>, boolean, Status)
+        .nameResolverFactory(new FakeNameResolverFactory(
+            Collections.singletonList(URI.create("fake://parent-target")),
+            Collections.emptyList(),
+            true,
+            null))
+        .childChannelConfigurer(configurer)
+        .build();
+
+    // 4. Create Child Channel Builder
+    ManagedChannelImplBuilder childBuilder = new ManagedChannelImplBuilder("fake://child-target",
+        new ClientTransportFactoryBuilder() {
+          @Override
+          public ClientTransportFactory buildClientTransportFactory() {
+            return mockTransportFactory;
+          }
+        },
+        new FixedPortProvider(DEFAULT_PORT));
+
+    childBuilder.configureChannel(parentChannel);
+
+    // Ensure child also has a resolver factory
+    childBuilder.nameResolverFactory(new FakeNameResolverFactory(
+        Collections.singletonList(URI.create("fake://child-target")),
+        Collections.emptyList(),
+        true,
+        null));
+
+    ManagedChannel childChannel = childBuilder.build();
+
+    // 5. Verification
+    ClientCall<String, Integer> call = childChannel.newCall(
+        MethodDescriptor.<String, Integer>newBuilder()
+            .setType(MethodDescriptor.MethodType.UNARY)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(new StringMarshaller())
+            .setResponseMarshaller(new IntegerMarshaller())
+            .build(),
+        CallOptions.DEFAULT);
+
+    call.start(new ClientCall.Listener<Integer>() {
+    }, new Metadata());
+
+    assertThat(interceptorCalls.get())
+        .isEqualTo(1);
+
+    childChannel.shutdownNow();
+    parentChannel.shutdownNow();
+  }
 }

core/src/test/java/io/grpc/internal/MetricRecorderImplTest.java

@@ -16,6 +16,7 @@
 
 package io.grpc.internal;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyList;
@@ -326,4 +327,25 @@ public void recordLongGaugeMismatchedOptionalLabelValues() {
     callbackCaptor.getValue().run();
     registration.close();
   }
+
+  @Test
+  public void noOp_returnsSingleton() {
+    assertThat(MetricRecorder.noOp()).isSameInstanceAs(MetricRecorder.noOp());
+  }
+
+  @Test
+  public void noOp_methodsDoNotThrow() {
+    MetricRecorder recorder = MetricRecorder.noOp();
+
+    recorder.addDoubleCounter(null, 1.0,
+        null, null);
+    recorder.addLongCounter(null, 1,
+        null, null);
+    recorder.addLongUpDownCounter(null, 1,
+        null, null);
+    recorder.recordDoubleHistogram(null, 1.0,
+        null, null);
+    recorder.recordLongHistogram(null, 1,
+        null, null);
+  }
 }

xds/src/main/java/io/grpc/xds/SharedXdsClientPoolProvider.java

@@ -58,7 +58,10 @@ final class SharedXdsClientPoolProvider implements XdsClientPoolFactory {
   @Nullable
   private final Bootstrapper bootstrapper;
   private final Object lock = new Object();
-  // The first one wins, anything with the same target string uses the client created for the first one
+  /*
+     The first one wins.
+     Anything with the same target string uses the client created for the first one.
+  */
   private final Map<String, ObjectPool<XdsClient>> targetToXdsClientMap = new ConcurrentHashMap<>();
 
   SharedXdsClientPoolProvider() {