}
}

func TestGet(t *testing.T) {
	storage, _, _, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)
	test.TestGet(validNewPod())
}

func TestList(t *testing.T) {
	storage, _, _, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)

        <td>{{.Hostname}}</td>
    </tr>

    <tr>
        <td>IP Address</td>
        <td>{{.IP}}</td>
    </tr>

    </tbody>
</table>

<br/>
<button id="terminate" class="btn btn-istio" onclick="terminateProcess()">Terminate Process</button>
<p id="terminated" style="display:none">Process Terminated</p>

{{ template "last-refresh" .}}

<script>
    "use strict"

    function refreshHomeInfo() {

	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.CustomResource.Store.DestroyFunc()
	test := registrytest.New(t, storage.CustomResource.Store)
	cr := validNewCustomResource()
	cr.SetNamespace("")
	test.TestCreate(
		cr,
	)
}

func TestGet(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.CustomResource.Store.DestroyFunc()

    /**
     * Continue visiting. When returned after visiting a directory,
     * the entries in the directory will be visited next.
     */
    CONTINUE,

    /**
     * Terminate visiting immediately.
     */
    TERMINATE,

    /**
     * If returned from visiting a directory, the directories entries will not be visited;
     * otherwise works as {@link #CONTINUE}.
     */
    SKIP_SUBTREE

func TestEmpty(t *testing.T) {
	storage, server, _, _ := newStorage(t)
	defer server.Terminate(t)
	if _, err := storage.Allocate(1); !strings.Contains(err.Error(), "cannot allocate resources of type serviceipallocations at this time") {
		t.Fatal(err)
	}
}

func TestStore(t *testing.T) {
	storage, server, backing, config := newStorage(t)
	defer server.Terminate(t)

# A script that let's gci preemptible nodes gracefully terminate in the event of a VM shutdown.
preemptible=$(curl "http://metadata.google.internal/computeMetadata/v1/instance/scheduling/preemptible" -H "Metadata-Flavor: Google")
if [ "${preemptible}" == "TRUE" ]; then
    echo "Shutting down! Sleeping for a minute to let the node gracefully terminate"

                visitor.leaveDirectory(this);
                return CONTINUE;
            case SKIP_SUBTREE:
                return CONTINUE;
            case TERMINATE:
                return SnapshotVisitResult.TERMINATE;
            default:
                throw new AssertionError();
        }
    }

    @Override

        given:
        def requestReceived = false
        def terminate = false
        setupLockOwner {
            requestReceived = true
            while(!terminate) { Thread.sleep(100) } //block the release action thread
        }

        when:
        def build = executer.withTasks("lock").start()

        then: 0 * _
    }

    def "can terminate type hierarchy walk"() {
        def visitor = Mock(Types.TypeVisitor)
        when:
        Types.walkTypeHierarchy(Child, [Object, GroovyObject], visitor)

        then: 1 * visitor.visitType(Child) >> Types.TypeVisitResult.CONTINUE
        then: 1 * visitor.visitType(Base) >> Types.TypeVisitResult.TERMINATE
        then: 0 * _
    }

      status: "True"
      type: Programmed
    - lastTransitionTime: fake
      message: No errors found
      reason: ResolvedRefs
      status: "True"
      type: ResolvedRefs
    name: terminate
    supportedKinds:
    - group: gateway.networking.k8s.io
      kind: HTTPRoute
    - group: gateway.networking.k8s.io
      kind: GRPCRoute
  - attachedRoutes: 0
    conditions:
    - lastTransitionTime: fake