import org.gradle.api.Incubating;

import java.util.List;

/**
 * Represents a list of aggregated problems. These are sent at the end of the build.
 * All Problems that occurred more than once during the build are aggregated and sent as a {@link ProblemAggregation}.
 * They won't be sent in between the build only the first one.
 *
 * @since 8.6
 */
@Incubating
public interface ProblemAggregation {

    /**

Strings and slices of bytes are sent as an unsigned count followed by that many
uninterpreted bytes of the value.

All other slices and arrays are sent as an unsigned count followed by that many
elements using the standard gob encoding for their type, recursively.

Maps are sent as an unsigned count followed by that many key, element
pairs. Empty but non-nil maps are sent, so if the receiver has not allocated

	notificationEventsSentTotalMD       = NewCounterMD(notificationEventsSentTotal, "Total number of events sent to the targets")
	notificationEventsSkippedTotalMD    = NewCounterMD(notificationEventsSkippedTotal, "Events that were skipped to be sent to the targets due to the in-memory queue being full")
)

 * limitations under the License.
 */

package org.gradle.launcher.daemon.protocol;

/**
 * Sent from the daemon client to the daemon to indicate it has finished with the connection. This is the last
 * message sent from the client to the daemon.
 */
public class Finished extends Message {

    /**
     * Sent when the cache is cleaned up.
     */
    public interface Details {

        /**
         * Returns the location of the cache.
         */
        File getCacheLocation();
    }

    /**
     * Sent after the cache has been cleaned up.
     */
    public interface Result {

        /**

		return errors.New("tls: server sent an unnecessary HelloRetryRequest message")
	}

	if hs.serverHello.cookie != nil {
		hello.cookie = hs.serverHello.cookie
	}

	if hs.serverHello.serverShare.group != 0 {
		c.sendAlert(alertDecodeError)
		return errors.New("tls: received malformed key_share extension")
	}

	// If the server sent a key_share extension selecting a group, ensure it's

		}
		return nil
	})
}

// Issue 54784: test that the Server's ReadHeaderTimeout only starts once the
// beginning of a request has been received, rather than including time the
// connection spent idle.
func TestServerCancelsReadHeaderTimeoutWhenIdle(t *testing.T) {
	run(t, testServerCancelsReadHeaderTimeoutWhenIdle, []testMode{http1Mode})
}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.launcher.daemon.protocol;

/**
 * The supertype of all objects sent from the daemon server back to the client.
 * <p>
 * Specific subclass types carry extra context, e.g. whether it was a failure or successful result.
 * <p>

    client.webSocket!!.finishReader()
    assertThat(client.closed).isTrue()
    client.listener.assertFailure(
      ProtocolException::class.java,
      "Server-sent frames must not be masked.",
    )
    server.listener.assertClosing(1000, "Hello")
    server.listener.assertExhausted() // Client should not have sent second close.
  }

  @Test

	// Ingress is a list containing ingress points for the load-balancer;
	// traffic intended for the service should be sent to these ingress points.
	// +optional
	Ingress []LoadBalancerIngress
}

// LoadBalancerIngress represents the status of a load-balancer ingress point:
// traffic intended for the service should be sent to an ingress point.
type LoadBalancerIngress struct {