proxyMetadata:
  ANNOTATION: something
drainDuration: 5s
extraStatTags: ["b"]
proxyStatsMatcher:
  inclusionPrefixes: ["a"]
  inclusionSuffixes: ["e"]
  inclusionRegexps: ["f"]
`,
			expect: func() *meshconfig.ProxyConfig {
				m := mesh.DefaultProxyConfig()
				m.DiscoveryAddress = "annotation:123"
				m.ProxyMetadata = map[string]string{"ANNOTATION": "something", "SOME": "setting"}

                return directory(location, [])
            } as Supplier<FileSystemLocationSnapshot>)
        }
        async {
            thread.blockUntil.snapshottingStarted
            vfs.invalidate(['/my/location/new/something'])
            instant.invalidated
        }
        then:
        instant.snapshottingStarted < instant.invalidated
        instant.invalidated < instant.snapshottingFinished
        !vfs.findSnapshot(location).present

@app.exception_handler(UnicornException)
async def unicorn_exception_handler(request: Request, exc: UnicornException):
    return JSONResponse(
        status_code=418,
        content={"message": f"Oops! {exc.name} did something. There goes a rainbow..."},
    )


@app.get("/unicorns/{name}")
async def read_unicorn(name: str):
    if name == "yolo":
        raise UnicornException(name=name)

"""
        buildFile << """
// Build script contains only methods
def broken() {
    throw new RuntimeException('failure')
}

def doSomething() {
    broken()
}
"""
        final childBuildFile = file("child/build.gradle")
        childBuildFile << """
    doSomething()
"""

        when:
        fails()

        then:

    def "can detect deletion of class used as method parameter type"() {
        //executer.requireOwnGradleUserHomeDir()  //use when debugging to bypass cache

        source "interface A { void doSomething(Deleted d); }"
        def deleted = source "interface Deleted { }"
        outputs.snapshot { run language.compileTaskName }

        expect:
        deleted.delete()

				},
			},
			expectedValue: "b70b3269-858e-12a8-9cf2-1232a194038a",
		},
		{
			name:      "ok - label",
			fieldPath: "metadata.labels['something']",
			obj: &v1.Pod{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{
						"something": "label value",
					},
				},
			},
			expectedValue: "label value",
		},
		{
			name:      "invalid expression",

    topology.kubernetes.io/region: us-central1
    topology.kubernetes.io/zone: us-central1-b
    kubernetes.io/hostname: node-default-pool-something
  name: node-default-pool-something
  resourceVersion: "211582541"
  selfLink: /api/v1/nodes/node-default-pool-something
  uid: 0c24d0e1-a265-11e9-abe4-42010a80026b
spec:
  podCIDR: 10.0.0.1/24
  providerID: some-provider-id-of-some-sort
status:
  addresses:

// Checks to make sure that the compiler can catch a specific invalid
// method type expression. NB: gccgo and gc have slightly different
// error messages, hence the generic test for 'method' and not something
// more specific.

package issue15722

type T int
type P *T

func (T) t() {}

func _(p P) {
	P.t(p) // ERROR "method"

            target.apply<ProjectPlugin>()
            verify(configurationAction).plugin(ProjectPlugin::class.java)
        }
    }

    @Test
    fun `reified apply to extension`() {
        val arbitraryTarget = "something"

        newPluginAwareMock<PluginAware>().run {
            target.applyTo<AnyPlugin>(arbitraryTarget)
            inOrder(configurationAction) {
                verify(configurationAction).plugin(AnyPlugin::class.java)

    val handshake = makeRequest(client)

    assertThat(handshake.cipherSuite).isIn(*expectedModernTls12CipherSuites.toTypedArray())

    // Probably something like
    // TLS_AES_128_GCM_SHA256
    // TLS_AES_256_GCM_SHA384
    // TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
    // TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
    // TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384