@Test
public void createSubchannelForwarded() {
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  LoadBalancer lb0 = balancers.get(lbPolicies[0]);
  Helper helper0 = helpers.get(lb0);
  SubchannelPicker picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(READY, picker);

  CreateSubchannelArgs createSubchannelArgs = newFakeCreateSubchannelArgs();
  helper0.createSubchannel(createSubchannelArgs);
  verify(mockHelper).createSubchannel(createSubchannelArgs);

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
  LoadBalancer lb1 = balancers.get(lbPolicies[1]);
  Helper helper1 = helpers.get(lb1);
  createSubchannelArgs = newFakeCreateSubchannelArgs();
  helper1.createSubchannel(createSubchannelArgs);
  verify(mockHelper).createSubchannel(createSubchannelArgs);

  createSubchannelArgs = newFakeCreateSubchannelArgs();
  helper0.createSubchannel(createSubchannelArgs);
  verify(mockHelper).createSubchannel(createSubchannelArgs);

  verifyNoMoreInteractions(lb0, lb1);
}
 

@Test
public void newPolicyNameTheSameAsPendingPolicy_shouldHaveNoEffect() {
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  LoadBalancer lb0 = balancers.get(lbPolicies[0]);
  Helper helper0 = helpers.get(lb0);
  SubchannelPicker picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(READY, picker);

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
  LoadBalancer lb1 = balancers.get(lbPolicies[1]);

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
  assertThat(balancers.get(lbPolicies[1])).isSameInstanceAs(lb1);

  verifyNoMoreInteractions(lb0, lb1);
}
 

@SuppressWarnings("unchecked")
@Test
public void nameResolutionErrorWithActiveChannels() throws Exception {
  final Subchannel readySubchannel = subchannels.values().iterator().next();
  loadBalancer.handleResolvedAddressGroups(servers, affinity);
  loadBalancer.handleSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
  loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError"));

  verify(mockHelper, times(3)).createSubchannel(any(List.class), any(Attributes.class));
  verify(mockHelper, times(3))
      .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());

  Iterator<ConnectivityState> stateIterator = stateCaptor.getAllValues().iterator();
  assertEquals(CONNECTING, stateIterator.next());
  assertEquals(READY, stateIterator.next());
  assertEquals(TRANSIENT_FAILURE, stateIterator.next());

  LoadBalancer.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
  assertEquals(readySubchannel, pickResult.getSubchannel());
  assertEquals(Status.OK.getCode(), pickResult.getStatus().getCode());

  LoadBalancer.PickResult pickResult2 = pickerCaptor.getValue().pickSubchannel(mockArgs);
  assertEquals(readySubchannel, pickResult2.getSubchannel());
  verifyNoMoreInteractions(mockHelper);
}
 

@Test
public void allMethodsForwarded() throws Exception {
  final SocketAddress mockAddr = mock(SocketAddress.class);
  ForwardingTestUtil.testMethodsForwarded(
      LoadBalancer.Helper.class,
      mockDelegate,
      new TestHelper(),
      Collections.<Method>emptyList(),
      new ForwardingTestUtil.ArgumentProvider() {
        @Override
        public Object get(Method method, int argPos, Class<?> clazz) {
          if (clazz.equals(EquivalentAddressGroup.class)) {
            return new EquivalentAddressGroup(Arrays.asList(mockAddr));
          } else if (clazz.equals(List.class)) {
            return Collections.<Object>emptyList();
          }
          return null;
        }
      });
}
 

@Test
public void handleResolvedAddressGroups_keepOldBalancer() {
  final List<EquivalentAddressGroup> servers =
      Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
  Helper helper = new TestHelper() {
    @Override
    public Subchannel createSubchannel(CreateSubchannelArgs args) {
      assertThat(args.getAddresses()).isEqualTo(servers);
      return new TestSubchannel(args);
    }
  };
  AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
  LoadBalancer oldDelegate = lb.getDelegate();

  Status handleResult = lb.tryHandleResolvedAddresses(
      ResolvedAddresses.newBuilder()
          .setAddresses(servers)
          .setAttributes(Attributes.EMPTY)
          .setLoadBalancingPolicyConfig(null)
          .build());

  assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
  assertThat(lb.getDelegate()).isSameInstanceAs(oldDelegate);
}
 

@Test
public void newPolicyNameTheSameAsCurrentPolicy_shouldShutdownPendingLb() {
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  LoadBalancer lb0 = balancers.get(lbPolicies[0]);

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  assertThat(balancers.get(lbPolicies[0])).isSameInstanceAs(lb0);

  Helper helper0 = helpers.get(lb0);
  SubchannelPicker picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(READY, picker);

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
  LoadBalancer lb1 = balancers.get(lbPolicies[1]);

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  verify(lb1).shutdown();
  assertThat(balancers.get(lbPolicies[0])).isSameInstanceAs(lb0);

  verifyNoMoreInteractions(lb0, lb1);
}
 

@VisibleForTesting
static OrcaReportingHelperWrapper newOrcaReportingHelperWrapper(
    LoadBalancer.Helper delegate,
    OrcaOobReportListener listener,
    BackoffPolicy.Provider backoffPolicyProvider,
    Supplier<Stopwatch> stopwatchSupplier) {
  final OrcaReportingHelper orcaHelper =
      new OrcaReportingHelper(delegate, listener, backoffPolicyProvider, stopwatchSupplier);

  return new OrcaReportingHelperWrapper() {
    @Override
    public void setReportingConfig(OrcaReportingConfig config) {
      orcaHelper.setReportingConfig(config);
    }

    @Override
    public Helper asHelper() {
      return orcaHelper;
    }
  };
}
 

@Override
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
  logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
  if (xdsClientPool == null) {
    xdsClientPool = resolvedAddresses.getAttributes().get(XdsAttributes.XDS_CLIENT_POOL);
    checkNotNull(xdsClientPool, "missing xDS client pool");
    xdsClient = xdsClientPool.getObject();
  }

  Object lbConfig = resolvedAddresses.getLoadBalancingPolicyConfig();
  checkNotNull(lbConfig, "missing CDS lb config");
  CdsConfig newCdsConfig = (CdsConfig) lbConfig;
  logger.log(
      XdsLogLevel.INFO,
      "Received CDS lb config: cluster={0}", newCdsConfig.name);

  // If cluster is changed, do a graceful switch.
  if (!newCdsConfig.name.equals(clusterName)) {
    LoadBalancer.Factory clusterBalancerFactory = new ClusterBalancerFactory(newCdsConfig.name);
    switchingLoadBalancer.switchTo(clusterBalancerFactory);
  }
  switchingLoadBalancer.handleResolvedAddresses(resolvedAddresses);
  clusterName = newCdsConfig.name;
}
 

private void startFallbackChildPolicy() {
  String defaultTarget = lbPolicyConfig.getRouteLookupConfig().getDefaultTarget();
  fallbackChildPolicyWrapper = refCountedChildPolicyWrapperFactory.createOrGet(defaultTarget);

  LoadBalancerProvider lbProvider =
      lbPolicyConfig.getLoadBalancingPolicy().getEffectiveLbProvider();
  final LoadBalancer lb =
      lbProvider.newLoadBalancer(fallbackChildPolicyWrapper.getHelper());
  final ConfigOrError lbConfig =
      lbProvider
          .parseLoadBalancingPolicyConfig(
              lbPolicyConfig
                  .getLoadBalancingPolicy()
                  .getEffectiveChildPolicy(defaultTarget));
  helper.getSynchronizationContext().execute(
      new Runnable() {
        @Override
        public void run() {
          lb.handleResolvedAddresses(
              childLbResolvedAddressFactory.create(lbConfig.getConfig()));
          lb.requestConnection();
        }
      });
}
 

@Test
public void shutdownTriggeredWhenSwitchAndForwardedWhenSwitchLbShutdown() {
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  LoadBalancer lb0 = balancers.get(lbPolicies[0]);
  Helper helper0 = helpers.get(lb0);
  SubchannelPicker picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(READY, picker);

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
  LoadBalancer lb1 = balancers.get(lbPolicies[1]);
  verify(lb1, never()).shutdown();

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
  verify(lb1).shutdown();
  LoadBalancer lb2 = balancers.get(lbPolicies[2]);
  verify(lb0, never()).shutdown();
  helpers.get(lb2).updateBalancingState(READY, mock(SubchannelPicker.class));
  verify(lb0).shutdown();

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[3]));
  LoadBalancer lb3 = balancers.get(lbPolicies[3]);
  verify(lb2, never()).shutdown();
  verify(lb3, never()).shutdown();

  gracefulSwitchLb.shutdown();
  verify(lb2).shutdown();
  verify(lb3).shutdown();

  verifyNoMoreInteractions(lb0, lb1, lb2, lb3);
}
 

@Override
public LoadBalancer newLoadBalancer(final Helper helper) {
  return new LoadBalancer() {

    @Override
    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
      // TODO: make the picker accessible
      helper.updateBalancingState(ConnectivityState.READY, mock(SubchannelPicker.class));
    }

    @Override
    public void handleNameResolutionError(final Status error) {
      class ErrorPicker extends SubchannelPicker {
        @Override
        public PickResult pickSubchannel(PickSubchannelArgs args) {
          return PickResult.withError(error);
        }
      }

      helper.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, new ErrorPicker());
    }

    @Override
    public void shutdown() {
    }
  };
}
 

@Test
public void canHandleEmptyAddressListFromNameResolutionForwardedToLatestPolicy() {
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  LoadBalancer lb0 = balancers.get(lbPolicies[0]);
  Helper helper0 = helpers.get(lb0);
  SubchannelPicker picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(READY, picker);

  assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isFalse();
  doReturn(true).when(lb0).canHandleEmptyAddressListFromNameResolution();
  assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isTrue();

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
  LoadBalancer lb1 = balancers.get(lbPolicies[1]);

  assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isFalse();

  doReturn(true).when(lb1).canHandleEmptyAddressListFromNameResolution();
  assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isTrue();

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
  LoadBalancer lb2 = balancers.get(lbPolicies[2]);

  assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isFalse();

  doReturn(true).when(lb2).canHandleEmptyAddressListFromNameResolution();
  assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isTrue();
}
 

@Override
public void updateSubchannelAddresses(
    LoadBalancer.Subchannel subchannel, List<EquivalentAddressGroup> addrs) {
  checkArgument(subchannel instanceof SubchannelImpl,
      "subchannel must have been returned from createSubchannel");
  ((SubchannelImpl) subchannel).subchannel.updateAddresses(addrs);
}
 

@Override
public void handleResolvedAddressGroups(
    List<EquivalentAddressGroup> servers, Attributes attributes) {
  Map<String, Object> configMap = attributes.get(GrpcAttributes.NAME_RESOLVER_SERVICE_CONFIG);
  LoadBalancerProvider newlbp;
  try {
    newlbp = decideLoadBalancerProvider(servers, configMap);
  } catch (PolicyNotFoundException e) {
    Status s = Status.INTERNAL.withDescription(e.getMessage());
    helper.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, new FailingPicker(s));
    delegate.shutdown();
    delegateProvider = null;
    delegate = new NoopLoadBalancer();
    return;
  }

  if (delegateProvider == null
      || !newlbp.getPolicyName().equals(delegateProvider.getPolicyName())) {
    helper.updateBalancingState(ConnectivityState.CONNECTING, new EmptyPicker());
    delegate.shutdown();
    delegateProvider = newlbp;
    LoadBalancer old = delegate;
    delegate = delegateProvider.newLoadBalancer(helper);
    helper.getChannelLogger().log(
        ChannelLogLevel.INFO, "Load balancer changed from {0} to {1}",
        old.getClass().getSimpleName(), delegate.getClass().getSimpleName());
  }
  getDelegate().handleResolvedAddressGroups(servers, attributes);
}
 

@Test
public void switchWhileOldPolicyGoesFromReadyToNotReady() {
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  LoadBalancer lb0 = balancers.get(lbPolicies[0]);
  Helper helper0 = helpers.get(lb0);
  SubchannelPicker picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(READY, picker);

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
  verify(lb0, never()).shutdown();

  LoadBalancer lb1 = balancers.get(lbPolicies[1]);
  Helper helper1 = helpers.get(lb1);
  SubchannelPicker picker1 = mock(SubchannelPicker.class);
  helper1.updateBalancingState(CONNECTING, picker1);
  verify(mockHelper, never()).updateBalancingState(CONNECTING, picker1);

  picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(CONNECTING, picker);
  verify(lb0).shutdown();
  verify(mockHelper, never()).updateBalancingState(CONNECTING, picker);
  verify(mockHelper).updateBalancingState(CONNECTING, picker1);

  picker1 = mock(SubchannelPicker.class);
  helper1.updateBalancingState(READY, picker1);
  verify(mockHelper).updateBalancingState(READY, picker1);

  verifyNoMoreInteractions(lb0, lb1);
}
 

@Test
public void requestConnectionForwardedToLatestPolicies() {
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  LoadBalancer lb0 = balancers.get(lbPolicies[0]);
  Helper helper0 = helpers.get(lb0);
  SubchannelPicker picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(READY, picker);

  gracefulSwitchLb.requestConnection();
  verify(lb0).requestConnection();

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
  LoadBalancer lb1 = balancers.get(lbPolicies[1]);
  gracefulSwitchLb.requestConnection();
  verify(lb1).requestConnection();

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
  verify(lb1).shutdown();
  LoadBalancer lb2 = balancers.get(lbPolicies[2]);
  gracefulSwitchLb.requestConnection();
  verify(lb2).requestConnection();

  // lb2 reports READY
  helpers.get(lb2).updateBalancingState(READY, mock(SubchannelPicker.class));
  verify(lb0).shutdown();

  gracefulSwitchLb.requestConnection();
  verify(lb2, times(2)).requestConnection();

  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[3]));
  LoadBalancer lb3 = balancers.get(lbPolicies[3]);
  gracefulSwitchLb.requestConnection();
  verify(lb3).requestConnection();

  verifyNoMoreInteractions(lb0, lb1, lb2, lb3);
}
 

@Test
public void allMethodsForwarded() throws Exception {
  ForwardingTestUtil.testMethodsForwarded(
      LoadBalancer.class,
      mockDelegate,
      new TestBalancer(),
      Collections.<Method>emptyList());
}
 

@Test
public void clusterWatcher_resourceRemoved() {
  ResolvedAddresses resolvedAddresses = ResolvedAddresses.newBuilder()
      .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
      .setAttributes(Attributes.newBuilder()
          .set(XdsAttributes.XDS_CLIENT_POOL, xdsClientPool)
          .build())
      .setLoadBalancingPolicyConfig(new CdsConfig("foo.googleapis.com"))
      .build();
  cdsLoadBalancer.handleResolvedAddresses(resolvedAddresses);

  ArgumentCaptor<ClusterWatcher> clusterWatcherCaptor = ArgumentCaptor.forClass(null);
  verify(xdsClient).watchClusterData(eq("foo.googleapis.com"), clusterWatcherCaptor.capture());

  ClusterWatcher clusterWatcher = clusterWatcherCaptor.getValue();
  ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(null);
  clusterWatcher.onClusterChanged(
      ClusterUpdate.newBuilder()
          .setClusterName("foo.googleapis.com")
          .setEdsServiceName("edsServiceFoo.googleapis.com")
          .setLbPolicy("round_robin")
          .build());
  assertThat(edsLoadBalancers).hasSize(1);
  assertThat(edsLbHelpers).hasSize(1);
  LoadBalancer edsLoadBalancer = edsLoadBalancers.poll();
  Helper edsHelper = edsLbHelpers.poll();
  SubchannelPicker subchannelPicker = mock(SubchannelPicker.class);
  edsHelper.updateBalancingState(READY, subchannelPicker);
  verify(helper).updateBalancingState(eq(READY), same(subchannelPicker));

  clusterWatcher.onResourceDoesNotExist("foo.googleapis.com");
  verify(edsLoadBalancer).shutdown();
  verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
  PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
  assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
  assertThat(result.getStatus().getDescription())
      .isEqualTo("Resource foo.googleapis.com is unavailable");
}
 

@Deprecated
@Override
public void updateSubchannelAddresses(
    LoadBalancer.Subchannel subchannel, List<EquivalentAddressGroup> addrs) {
  checkArgument(subchannel instanceof SubchannelImpl,
      "subchannel must have been returned from createSubchannel");
  logWarningIfNotInSyncContext("updateSubchannelAddresses()");
  ((InternalSubchannel) subchannel.getInternalSubchannel()).updateAddresses(addrs);
}
 

@Override
public void requestConnection() {
    LoadBalancer.Subchannel subchannel = result.getSubchannel();
    if (subchannel != null) {
        subchannel.requestConnection();
    }
}
 

@Override
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
  LrsConfig config = (LrsConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
  LoadStatsStore store =
      resolvedAddresses.getAttributes().get(XdsAttributes.ATTR_CLUSTER_SERVICE_LOAD_STATS_STORE);
  checkNotNull(config, "missing LRS lb config");
  checkNotNull(store, "missing cluster service stats object");
  checkAndSetUp(config, store);

  if (switchingLoadBalancer == null) {
    loadStatsStore.addLocality(config.locality);
    final ClientLoadCounter counter = loadStatsStore.getLocalityCounter(config.locality);
    LoadBalancer.Helper loadRecordingHelper = new ForwardingLoadBalancerHelper() {
      @Override
      protected Helper delegate() {
        return helper;
      }

      @Override
      public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
        SubchannelPicker loadRecordingPicker =
            new LoadRecordingSubchannelPicker(counter, newPicker);
        super.updateBalancingState(newState, loadRecordingPicker);
      }
    };
    switchingLoadBalancer = new GracefulSwitchLoadBalancer(loadRecordingHelper);
  }
  String updatedChildPolicyName = config.childPolicy.getProvider().getPolicyName();
  if (!Objects.equals(childPolicyName, updatedChildPolicyName)) {
    switchingLoadBalancer.switchTo(config.childPolicy.getProvider());
    childPolicyName = updatedChildPolicyName;
  }
  ResolvedAddresses downStreamResult =
      resolvedAddresses.toBuilder()
          .setLoadBalancingPolicyConfig(config.childPolicy.getConfig())
          .build();
  switchingLoadBalancer.handleResolvedAddresses(downStreamResult);
}
 

@Test
public void healthCheckingConfigPropagated() throws Exception {
  LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
  try {
    FakeNameResolverFactory nameResolverFactory =
        new FakeNameResolverFactory.Builder(expectedUri)
            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
            .build();
    channelBuilder.nameResolverFactory(nameResolverFactory);

    Map<String, Object> rawServiceConfig =
        parseConfig("{\"healthCheckConfig\": {\"serviceName\": \"service1\"}}");
    ManagedChannelServiceConfig managedChannelServiceConfig =
        createManagedChannelServiceConfig(rawServiceConfig, null);
    nameResolverFactory.nextConfigOrError.set(
        ConfigOrError.fromConfig(managedChannelServiceConfig));

    createChannel();

    ArgumentCaptor<ResolvedAddresses> resultCaptor =
        ArgumentCaptor.forClass(ResolvedAddresses.class);
    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
    assertThat(resultCaptor.getValue().getAttributes()
        .get(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG))
        .containsExactly("serviceName", "service1");
  } finally {
    LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
  }
}
 

@Test
public void switchWhileOldPolicyIsNotReady() {
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
  LoadBalancer lb0 = balancers.get(lbPolicies[0]);
  Helper helper0 = helpers.get(lb0);
  SubchannelPicker picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(READY, picker);
  picker = mock(SubchannelPicker.class);
  helper0.updateBalancingState(CONNECTING, picker);

  verify(lb0, never()).shutdown();
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
  verify(lb0).shutdown();
  LoadBalancer lb1 = balancers.get(lbPolicies[1]);

  Helper helper1 = helpers.get(lb1);
  picker = mock(SubchannelPicker.class);
  helper1.updateBalancingState(CONNECTING, picker);
  verify(mockHelper).updateBalancingState(CONNECTING, picker);

  verify(lb1, never()).shutdown();
  gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
  verify(lb1).shutdown();
  LoadBalancer lb2 = balancers.get(lbPolicies[2]);

  verifyNoMoreInteractions(lb0, lb1, lb2);
}
 

@Override
public OrcaReportingHelperWrapper newOrcaReportingHelperWrapper(
    LoadBalancer.Helper delegate,
    OrcaOobReportListener listener) {
  return newOrcaReportingHelperWrapper(
      delegate,
      listener,
      new ExponentialBackoffPolicy.Provider(),
      GrpcUtil.STOPWATCH_SUPPLIER);
}
 

@Test
public void util_newHealthCheckingLoadBalancer() {
  Factory hcFactory =
      new Factory() {
        @Override
        public LoadBalancer newLoadBalancer(Helper helper) {
          return HealthCheckingLoadBalancerUtil.newHealthCheckingLoadBalancer(
              origLbFactory, helper);
        }
      };

  // hcLb and wrappedHelper are already set in setUp().  For this special test case, we
  // clear wrappedHelper so that we can create hcLb again with the util.
  wrappedHelper = null;
  hcLb = hcFactory.newLoadBalancer(origHelper);

  // Verify that HC works
  Attributes resolutionAttrs = attrsWithHealthCheckService("BarService");
  ResolvedAddresses result = ResolvedAddresses.newBuilder()
      .setAddresses(resolvedAddressList)
      .setAttributes(resolutionAttrs)
      .build();
  hcLbEventDelivery.handleResolvedAddresses(result);
  verify(origLb).handleResolvedAddresses(result);
  createSubchannel(0, Attributes.EMPTY);
  assertThat(healthImpls[0].calls).isEmpty();
  deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
  assertThat(healthImpls[0].calls).hasSize(1);
}
 

OrcaReportingHelper(
    LoadBalancer.Helper delegate,
    OrcaOobReportListener listener,
    BackoffPolicy.Provider backoffPolicyProvider,
    Supplier<Stopwatch> stopwatchSupplier) {
  this.delegate = checkNotNull(delegate, "delegate");
  this.listener = checkNotNull(listener, "listener");
  this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
  this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
  syncContext = checkNotNull(delegate.getSynchronizationContext(), "syncContext");
}
 

@Override
public void handleNameResolutionError(Status error) {
  logger.log(XdsLogLevel.WARNING, "Received name resolution error: {0}", error);
  if (childBalancers.isEmpty()) {
    helper.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(error));
  }
  for (LoadBalancer childBalancer : childBalancers.values()) {
    childBalancer.handleNameResolutionError(error);
  }
}
 

@Override
public LoadBalancer newLoadBalancer(Helper helper) {
  childHelpers.add(helper);
  LoadBalancer childBalancer = mock(LoadBalancer.class);
  childBalancers.add(childBalancer);
  fooLbCreated++;
  return childBalancer;
}
 

@Override
public LoadBalancer newLoadBalancer(Helper helper) {
  childHelpers.add(helper);
  LoadBalancer childBalancer = mock(LoadBalancer.class);
  childBalancers.add(childBalancer);
  barLbCreated++;
  return childBalancer;
}
 

@After
public void tearDown() {
  weightedTargetLb.shutdown();
  for (LoadBalancer childBalancer : childBalancers) {
    verify(childBalancer).shutdown();
  }
}