"test-headless.com:8888": {"test-headless.com:8888": true, "*.test-headless.com:8888": true},
				"test-private-2.com:60": {
					"test-private-2.com:60": true, "9.9.9.10:60": true,
				},
				"test-private.com:70": {
					"test-private.com:70": true, "9.9.9.9:70": true,
				},
				"test-private.com:80": {

	if !got.Equal(want) {
		t.Errorf("getPodsForStatefulSet() = %v, want %v", got, want)
	}
}

func TestOrphanedPodsWithPVCDeletePolicy(t *testing.T) {
	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StatefulSetAutoDeletePVC, true)

	testFn := func(t *testing.T, scaledownPolicy, deletionPolicy apps.PersistentVolumeClaimRetentionPolicyType) {
		set := newStatefulSet(4)
		*set.Spec.Replicas = 2

}
dependencies {
    debug 'test:a:1.2'
    release 'test:a:1.2'
}
"""
        resolve.prepare {
            config("debug")
            config("release")
        }

        when:
        run("checkDebug")

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("test:a:1.2") {
                    artifact(classifier: "debug")

	if err != nil {
		panic(err)
	}
	// Get a slice pointing to the last byte of the good page.
	x := b[p-one : p]

	test16(x)
	test16i(x, 0)
	test32(x)
	test32i(x, 0)
	test64(x)
	test64i(x, 0)
}

func test16(x []byte) uint16 {
	defer func() {
		r := recover()
		if r == nil {
			panic("no fault or bounds check failure happened")
		}
		s := fmt.Sprintf("%s", r)

        then:
        executedAndNotSkipped ":b:jar", ":c:jar"
        resolve.expectGraph {
            root(":a", "test:a:") {
                project(":b", "test:b:") {
                    project(":c", "test:c:") {
                        project(":a", "test:a:")
                    }
                }
            }
        }
    }

    @NotYetImplemented
    @Issue('GRADLE-3280')

		println("BUG: got", f, "want 0.0")
		return
	}
}

func test64(f float64) {
	if f != 0 || math.Signbit(f) {
		println("BUG: got", f, "want 0.0")
		return
	}
}

func main() {
	if f := -x0; f != 0 || !math.Signbit(float64(f)) {
		println("BUG: got", f, "want -0.0")
	}

	test32(-0.0)
	test32(x0)
	test32(x1)
	test32(x2)
	test32(x3)

	if f := -y0; f != 0 || !math.Signbit(f) {

)

func main() {
	test32(float32(m0000p149), f32(m0000p149))
	test32(float32(m1000p149), f32(m1000p149))
	test32(float32(m1001p149), f32(m1001p149))
	test32(float32(m1011p149), f32(m1011p149))
	test32(float32(m1100p149), f32(m1100p149))

	test64(float64(m0000p1074), f64(m0000p1074))
	test64(float64(m1000p1074), f64(m1000p1074))
	test64(float64(m1001p1074), f64(m1001p1074))

env GO111MODULE=off

# smoke test for complex build configuration
go build -o complex.exe complex
[!cross] [exec:gccgo] go build -compiler=gccgo -o complex.exe complex

-- complex/main.go --
package main

import (
	_ "complex/nest/sub/test12"
	_ "complex/nest/sub/test23"
	"complex/w"
	"v"
)

func main() {
	println(v.Hello + " " + w.World)
}

-- complex/nest/sub/test12/p.go --
package test12

                    compile project(':a')
                }
            }
        """

        expect:
        succeeds "b:checkDeps"
        resolve.expectGraph {
            root(":b", "test:b:") {
                project(":a", "test:a:") {
                    artifact(name: 'foo', type: '')
                    artifact(name: 'foo', type: 'txt')
                }
            }
        }
    }

# WebSockets testen

Sie können den schon bekannten `TestClient` zum Testen von WebSockets verwenden.

Dazu verwenden Sie den `TestClient` in einer `with`-Anweisung, eine Verbindung zum WebSocket herstellend:

```Python hl_lines="27-31"
{!../../../docs_src/app_testing/tutorial002.py!}
```

!!! note "Hinweis"