if err != nil {
		log.Fatalf("Failed to create HTTP server: %v", err)
	}
	// Store the port for test only.
	s.httpPort <- listener.Addr().(*net.TCPAddr).Port
	s.httpServer = &http.Server{Handler: s}

	log.Printf("Starting HTTP server at %s", listener.Addr())
	if err := s.httpServer.Serve(listener); err != nil {
		log.Fatalf("Failed to start HTTP server: %v", err)
	}
}

func (s *JWTServer) startHTTPS(address string, wg *sync.WaitGroup) {

package main

import (
	"container/heap"
	"container/ring"
)

// Return a chan of odd numbers, starting from 5.
func odds() chan int {
	out := make(chan int, 50)
	go func() {
		n := 5
		for {
			out <- n
			n += 2
		}
	}()
	return out
}

// Return a chan of odd multiples of the prime number p, starting from p*p.
func multiples(p int) chan int {
	out := make(chan int, 10)
	go func() {
		n := p * p

  def get_min_max_value(self) -> tuple[float, float]:
    """Finds min and max starting from the center index.

    The HistogramMseSymmetric method starts from the center bin and expands the
    range to both sides. This works better when the data is well-centered.

    Returns:
      (min_value, max_value): Min and max calculated using the method starting
      from center and expanding.
    """

@GwtIncompatible
@ElementTypesAreNonnullByDefault
public interface FinalizableReference {
  /**
   * Invoked on a background thread after the referent has been garbage collected unless security
   * restrictions prevented starting a background thread, in which case this method is invoked when
   * new references are created.
   */
  void finalizeReferent();

    def "health information is present in build log"() {
        when:
        def result = succeeds("help", "--info")

        then:
        result.output ==~ /(?s).*Starting build in new daemon \[memory: [0-9].*/
    }

            includeGroup "my.company"
        }
    }
    mavenCentral {
        content {
            // this repository contains everything BUT artifacts with group starting with "my.company"
            excludeGroupByRegex "my\\.company.*"
        }
    }
}
// end::repository-filter[]

// tag::exclusive-repository-filter[]
repositories {

                    @org.gradle.api.Generated
                    class `MyPluginGroup`(internal val plugins: PluginDependenciesSpec)


                    /**
                     * Plugin ids starting with `my`.
                     */
                    val `PluginDependenciesSpec`.`my`: `MyPluginGroup`
                        get() = `MyPluginGroup`(this)


                    /**

            includeGroup("my.company")
        }
    }
    mavenCentral {
        content {
            // this repository contains everything BUT artifacts with group starting with "my.company"
            excludeGroupByRegex("my\\.company.*")
        }
    }
}
// end::repository-filter[]

// tag::exclusive-repository-filter[]
repositories {

            searchClassPath = Collections.emptyList();
        }
        if (classpath.isEmpty()) {
            throw new IllegalStateException("Unable to construct a bootstrap classpath when starting the daemon");
        }

        versionValidator.validate(resolvedJvm);

        List<String> daemonArgs = new ArrayList<>();
        daemonArgs.addAll(getPriorityArgs(daemonParameters.getPriority()));

/**
 * Thrown when connected to a stale daemon address.
 *
 * This is thrown instead of using an initial handshake on the connection, to avoid the latency of a round trip to the
 * daemon before starting the build.
 */
public class StaleDaemonAddressException extends DaemonConnectionException {
    public StaleDaemonAddressException(String message, Throwable cause) {
        super(message, cause);
    }