barrier.await(1, SECONDS);

                        // WAIT #2
                        barrier.await(1, SECONDS);
                        assertTrue(executor.isShutdown());
                        assertFalse(executor.isTerminated());

                        // WAIT #3
                        barrier.await(1, SECONDS);
                        return null;
                      });

import org.apache.logging.log4j.Logger;
import org.codelibs.core.io.CopyUtil;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.curl.CurlResponse;
import org.codelibs.fess.Constants;
import org.codelibs.fess.annotation.Secured;
import org.codelibs.fess.app.web.base.FessAdminAction;
import org.codelibs.fess.mylasta.direction.FessConfig.SimpleImpl;
import org.codelibs.fess.opensearch.client.SearchEngineClient;
import org.codelibs.fess.util.ComponentUtil;

				)

				if orchestrated && hostResolveToLocalhost(endpoints[i]) {
					// time elapsed
					timeElapsed := time.Since(startTime)
					// log error only if more than a second has elapsed
					if timeElapsed > time.Second {
						reqInfo.AppendTags("elapsedTime",
							humanize.RelTime(startTime,
								startTime.Add(timeElapsed),
								"elapsed",
								"",
							))

		TotalTicks:   currentStats.TotalTicks - initialStats.TotalTicks,
	}
}

func getDriveIOStatMetrics(ioStats madmin.DiskIOStats, duration time.Duration) (m driveIOStatMetrics) {
	durationSecs := duration.Seconds()

	m.readsPerSec = float64(ioStats.ReadIOs) / durationSecs
	m.readsKBPerSec = float64(ioStats.ReadSectors) * float64(sectorSize) / kib / durationSecs
	if ioStats.ReadIOs > 0 {

Isso é bastante simples (e não muito útil), mas irá nos ajudar a focar em como as subdependências funcionam.

## Segunda dependência, "dependable" e "dependente" { #second-dependency-dependable-and-dependant }

Então, você pode criar uma outra função para uma dependência (um "dependable") que ao mesmo tempo declara sua própria dependência (o que faz dela um "dependente" também):

    //      last modified: 105 seconds ago
    //             served:   5 seconds ago
    //   default lifetime: (105 - 5) / 10 = 10 seconds
    //            expires:  10 seconds from served date = 5 seconds from now
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Last-Modified: " + formatDate(-105, TimeUnit.SECONDS))
        .addHeader("Date: " + formatDate(-5, TimeUnit.SECONDS))

Declara un parámetro de query opcional `q` como un `str`, y luego simplemente lo devuelve.

Esto es bastante simple (no muy útil), pero nos ayudará a centrarnos en cómo funcionan las sub-dependencias.

## Segunda dependencia, "dependable" y "dependant" { #second-dependency-dependable-and-dependant }

Luego puedes crear otra función de dependencia (un "dependable") que al mismo tiempo declare una dependencia propia (por lo que también es un "dependant"):

		// Init and run test on ErasureSD backend with signature v4.
		{serverType: "ErasureSD", signer: signerV4},
		// Init and run test on ErasureSD backend, with tls enabled.
		{serverType: "ErasureSD", signer: signerV4, secure: true},
		// Init and run test on Erasure backend.
		{serverType: "Erasure", signer: signerV4},
		// Init and run test on ErasureSet backend.
		{serverType: "ErasureSet", signer: signerV4},
	}

     */
    private long determinePollInterval(ChangeNotificationHandle handle) {
        int failures = getFailureCount(handle);

        // Base interval starts at 1 second, increases with failures
        // Max interval is 30 seconds for inactive directories
        return Math.min(MAX_POLL_INTERVAL, BASE_POLL_INTERVAL + (failures * 2000));
    }

    /**
     * Get failure count for a handle
     *

		avg = l.rttMsSum / float64(l.successRequestCount)
	}
	now := time.Now().UTC()
	return Metrics{
		LastReachableSecs:   now.Sub(o.serviceMetrics.LastCheckSuccess).Seconds(),
		LastUnreachableSecs: now.Sub(o.serviceMetrics.LastCheckFailure).Seconds(),
		TotalRequests:       l.failedRequestCount + l.successRequestCount,
		FailedRequests:      l.failedRequestCount,
		AvgSuccRTTMs:        avg,
		MaxSuccRTTMs:        l.maxRttMs,