new RuntimeException('Something went wrong')                                                                                  | 'Something went wrong'        | 'exception having no parent cause'

        }

        @Override
        public void addAttributesAction(ImmutableAttributesFactory attributesFactory, VariantAction<? super AttributeContainer> action) {
            throw new UnsupportedOperationException("You are probably trying to add a variant attribute to something that wasn't supposed to be mutable");
        }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package c

import (
	"./a"
	"./b"
)

type BI interface {
	Something(s int64) int64
	Another(pxp a.G) int32
}

func BRS(sd *b.ServiceDesc, server BI, xyz int) *b.Service {
	return b.RS(sd, server, 7)

  workflow_dispatch:

permissions: {}

jobs:
  feedback:
    permissions:
      issues: write
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
      # Feedback loop: ask for something on PR/Issue and close if not provided or return to the queue on update.
      # https://github.com/gradle/issue-management-action/blob/main/src/feedback.ts
      - uses: gradle/issue-management-action@v1
        with:

	if labels == nil {
		return labelMap(nil)
	}
	return *labels
}

// labelMap is the representation of the label set held in the context type.
// This is an initial implementation, but it will be replaced with something
// that admits incremental immutable modification more efficiently.
type labelMap map[string]string

// String satisfies Stringer and returns key, value pairs in a consistent
// order.

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

"""
        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",