if index2 == index1 {
		index2 = (index2 + 1) % numConnections
	}

	return lb.get(index1), lb.get(index2)
}

func (lb *unweightedLeastRequest) Request(onDone func()) {
	if len(lb.conns) == 1 {
		lb.doRequest(lb.get(0), onDone)
		return
	}

	// Pick 2 endpoints at random.
	c1, c2 := lb.pick2()

	// Choose the endpoint with fewer active requests.
	selected := c1

[Unit]
Description=Fess
Documentation=http://fess.codelibs.org/
Wants=network-online.target
After=network-online.target opensearch.service
Requires=opensearch.service

[Service]
Environment=FESS_HOME=${packaging.fess.home.dir}
EnvironmentFile=-${packaging.env.file}

User=${packaging.fess.user}
Group=${packaging.fess.group}

ExecStart=${packaging.fess.bin.dir}/fess

# Connects standard output to /dev/null
StandardOutput=null

import "errors"

// errErasureReadQuorum - did not meet read quorum.
var errErasureReadQuorum = errors.New("Read failed. Insufficient number of drives online")

// errErasureWriteQuorum - did not meet write quorum.
var errErasureWriteQuorum = errors.New("Write failed. Insufficient number of drives online")

// errNoHealRequired - returned when healing is attempted on a previously healed disks.

        error.message.contains("              |       |  'notOne'")
    }

    def "fails with not equal values in sub-model check"() {
        when:
        ToolingApiModelChecker.checkModel(
            dummyCompositeModel(dummyModel("one")),
            dummyCompositeModel(dummyModel("notOne")),
            [
                [{ it.modelOne }, { a, e ->

IntegTestPreconditions$NotParallelExecutor,UnitTestPreconditions$StableGroovy
UnitTestPreconditions$NotWindowsJavaBefore9
UnitTestPreconditions$NotWindowsJavaBefore11
UnitTestPreconditions$Online
UnitTestPreconditions$Online,TestKitPreconditions$LowestMajorGradleIsAvailable
UnitTestPreconditions$Online,UnitTestPreconditions$Jdk11OrEarlier,IntegTestPreconditions$NotEmbeddedExecutor
UnitTestPreconditions$SmartTerminalAvailable
UnitTestPreconditions$StableGroovy

   *     can <i>usually</i> still preserve behavior by passing an explicit {@code null} cause. Note,
   *     however, that passing an explicit {@code null} cause prevents anyone from calling {@link
   *     #initCause} later, so it is not quite equivalent to using a constructor that omits the
   *     cause.
   */
  @Deprecated
  protected ExecutionError() {}

  /**

   *     cause. At the moment, you can <i>usually</i> still preserve behavior by passing an explicit
   *     {@code null} cause. Note, however, that passing an explicit {@code null} cause prevents
   *     anyone from calling {@link #initCause} later, so it is not quite equivalent to using a
   *     constructor that omits the cause.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**

    def addresses = new InetAddresses()

    def "always contains at least one loopback address"() {
        expect:
        !addresses.loopback.empty
    }

    @Requires(UnitTestPreconditions.Online)
    def "always contains at least one remote address"() {
        expect:
        !addresses.remote.empty
    }

    def "No remote addresses are loopback addresses"() {
        expect:

     * @return uses the Maven project and its child modules
     */
    boolean aggregator() default false;

    /**
     * does this Mojo need to be online to be executed?
     * @return need to be online
     */
    boolean onlineRequired() default false;

    /**
     * TODO: v4: add a SPI for the configurator
     * configurator bean name.
     * @return the configurator bean name

import org.gradle.integtests.fixtures.AbstractDependencyResolutionTest
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions

@Requires(UnitTestPreconditions.Online)
class GradlePluginPortalDependencyResolveIntegrationTest extends AbstractDependencyResolutionTest {

    def gradlePluginPortalRepository = """
        repositories {
            gradlePluginPortal()