&& (rootProject.getDefaultGoal() != null
                        && !rootProject.getDefaultGoal().isEmpty())) {
            tasks = Stream.of(rootProject.getDefaultGoal().split("\\s+"))
                    .filter(g -> !g.isEmpty())
                    .collect(Collectors.toList());
        }

        return calculateTaskSegments(session, tasks);
    }

    @Override

## Other middlewares { #other-middlewares }

There are many other ASGI middlewares.

For example:

* [Uvicorn's `ProxyHeadersMiddleware`](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)

        )
      val subject: List<List<AttributeTypeAndValue>> = subject()

      // Issuer/signer keys & identity. May be the subject if it is self-signed.
      val issuerKeyPair: KeyPair
      val issuer: List<List<AttributeTypeAndValue>>
      if (signedBy != null) {
        issuerKeyPair = signedBy!!.keyPair
        issuer =
          CertificateAdapters.rdnSequence.fromDer(
            signedBy!!

    }

    /**
     * Displays a paginated list of web authentication configurations.
     *
     * @param pageNumber the page number to display (optional)
     * @param form the search form containing filter criteria
     * @return HTML response with the web authentication list
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })

 *
 * <p>This service allows implementations to:</p>
 * <ul>
 *   <li>Pool identical objects to reduce memory footprint</li>
 *   <li>Intern objects for faster equality comparisons</li>
 *   <li>Apply custom optimization strategies</li>
 *   <li>Transform or modify objects during building</li>
 * </ul>
 *

// This function currently supports
// - SIPMOD
func sipHashMod(key string, cardinality int, id [16]byte) int {
	if cardinality <= 0 {
		return -1
	}
	// use the faster version as per siphash docs
	// https://github.com/dchest/siphash#usage
	k0, k1 := binary.LittleEndian.Uint64(id[0:8]), binary.LittleEndian.Uint64(id[8:16])
	sum64 := siphash.Hash(k0, k1, []byte(key))

   *
   * <p><b>Warning:</b> This method, which reencodes the input before hashing it, is useful only for
   * cross-language compatibility. For other use cases, prefer {@link #hashUnencodedChars}, which is
   * faster, produces the same output across Java releases, and hashes every {@code char} in the
   * input, even if some are invalid.
   */
  HashCode hashString(CharSequence input, Charset charset);

  /**

# their dependencies. It's a rewritten version of the "smoke test", an older
# Python script that was very difficult to understand. See
# https://github.com/tensorflow/tensorflow/blob/master/tensorflow/tools/pip_package/pip_smoke_test.py
@test "Pip package includes all required //tensorflow dependencies" {
  # grep patterns for packages whose dependencies can be ignored

    assertEquals(1, (int) iter.next());
    assertTrue(iter.hasNext());
    assertEquals(2, (int) iter.next());
    assertTrue(iter.hasNext());
    assertEquals(3, (int) iter.next());
    assertFalse(iter.hasNext());
  }

  public void testAsEnumerationEmpty() {
    Iterator<Integer> iter = emptyIterator();
    Enumeration<Integer> enumer = Iterators.asEnumeration(iter);

     *
     * @param cb the condition bean for building the database query
     * @param requestHeaderPager the pager containing search and filter criteria
     */
    protected void setupListCondition(final RequestHeaderCB cb, final ReqHeaderPager requestHeaderPager) {
        if (requestHeaderPager.id != null) {