"initContainerStatuses": [
      {
        "name": "nameValue",
        "state": {
          "waiting": {
            "reason": "reasonValue",
            "message": "messageValue"
          },
          "running": {
            "startedAt": "2001-01-01T01:01:01Z"
          },
          "terminated": {
            "exitCode": 1,
            "signal": 2,
            "reason": "reasonValue",

    type: typeValue
  containerStatuses:
  - allocatedResources:
      allocatedResourcesKey: "0"
    containerID: containerIDValue
    image: imageValue
    imageID: imageIDValue
    lastState:
      running:
        startedAt: "2001-01-01T01:01:01Z"
      terminated:
        containerID: containerIDValue
        exitCode: 1
        finishedAt: "2006-01-01T01:01:01Z"
        message: messageValue

// with apply.
type ContainerStateApplyConfiguration struct {
	Waiting    *ContainerStateWaitingApplyConfiguration    `json:"waiting,omitempty"`
	Running    *ContainerStateRunningApplyConfiguration    `json:"running,omitempty"`
	Terminated *ContainerStateTerminatedApplyConfiguration `json:"terminated,omitempty"`
}

tasks.register("task1"){  // <1>
    println("REGISTER TASK1: This is executed during the configuration phase")
}

tasks.named("task1"){  // <2>
    println("NAMED TASK1: This is executed during the configuration phase")
    doFirst {
        println("NAMED TASK1 - doFirst: This is executed during the execution phase")
    }
    doLast {
        println("NAMED TASK1 - doLast: This is executed during the execution phase")
    }
}
----

 */
public class ServiceLifecycle implements AsyncStoppable {
    private enum State {RUNNING, STOPPING, STOPPED}

    private final String displayName;
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private final Map<Thread, Integer> usages = new HashMap<>();
    private State state = State.RUNNING;

    public ServiceLifecycle(String displayName) {

	// HorizontalPodAutoscalerInitialReadinessDelay is period after pod start during which readiness
	// changes are treated as readiness being set for the first time. The only effect of this is that
	// HPA will disregard CPU samples from unready pods that had last readiness change during that
	// period.
	HorizontalPodAutoscalerInitialReadinessDelay metav1.Duration

    // pattern matching in DarwiNN.
    // This should never be used. Using this will generally result in an error.
    METHOD_UNSPECIFIED = 0;  // go/do-include-enum-unspecified

    // Apply default weight-only quantization. Weights are quantized during
    // conversion, then dequantized during inference.
    // Activation: f32, Weight: qi8, Bias: f32
    WEIGHT_ONLY = 1;

# Testing Dependencies with Overrides

## Overriding dependencies during testing

There are some scenarios where you might want to override a dependency during testing.

You don't want the original dependency to run (nor any of the sub-dependencies it might have).

 */

package org.gradle.internal.serialization;

import javax.annotation.Nullable;

/**
 * A value that gets discarded during serialization.
 */
public abstract class Transient<T> implements java.io.Serializable {

    /**
     * A mutable variable that gets discarded during serialization.
     */
    public static abstract class Var<T> extends Transient<T> {
        public abstract void set(T value);
    }

    static class TestDeploymentHandle implements DeploymentHandle {
        boolean running

        @Override
        void start(Deployment deploymentActivity) {
            running = true
        }

        @Override
        boolean isRunning() {
            return running
        }

        @Override
        void stop() {
            running = false
        }
    }