func Object(pkg *types.Package, p Path) (types.Object, error) {
	pathstr := string(p)
	if pathstr == "" {
		return nil, fmt.Errorf("empty path")
	}

	var pkgobj, suffix string
	if dot := strings.IndexByte(pathstr, opType); dot < 0 {
		pkgobj = pathstr
	} else {
		pkgobj = pathstr[:dot]
		suffix = pathstr[dot:] // suffix starts with "."
	}

	obj := pkg.Scope().Lookup(pkgobj)

        then:
        model.groups == ['group', ''] as Set
        def tasks = model.getTasksForGroup('') as List
        tasks*.path == [pathOf(task1), pathOf(task3), pathOf(task4), pathOf(task5)]
        def t = tasks.first()
        t.path == pathOf(task1)
    }

    def addsAGroupWhenThereAreNoTasksWithAGroup() {
        def task1 = task('task1')
        def task2 = task('task2', task1)

// passing the configuration to the application. This method must be kept up to date as new fields are added.
func KubeletConfigurationPathRefs(kc *KubeletConfiguration) []*string {
	paths := []*string{}
	paths = append(paths, &kc.StaticPodPath)
	paths = append(paths, &kc.Authentication.X509.ClientCAFile)
	paths = append(paths, &kc.TLSCertFile)

env GO111MODULE=on
mkdir $WORK/a/src/paths $WORK/b/src/paths
cp paths.go $WORK/a/src/paths
cp paths.go $WORK/b/src/paths
cp overlay.json $WORK/a/src/paths
cp overlay.json $WORK/b/src/paths
cp go.mod $WORK/a/src/paths/
cp go.mod $WORK/b/src/paths/


# A binary built without -trimpath should contain the module root dir
# and GOROOT for debugging and stack traces.
cd $WORK/a/src/paths
go build -o $WORK/paths-dbg.exe .

		for k, s := range staticSpec.Parameters {
			specToReturn.Parameters[k] = s
		}
	}
	if staticSpec.Paths != nil {
		specToReturn.Paths = &spec.Paths{
			Paths: make(map[string]spec.PathItem, len(staticSpec.Paths.Paths)),
		}
		for k, p := range staticSpec.Paths.Paths {
			specToReturn.Paths.Paths[k] = p
		}
	}

	crdSpec := &spec.Swagger{}
	for _, s := range crdSpecs {

	tests := []struct {
		name     string
		paths    []string
		expected bool
	}{
		{
			name: "non-existing cert paths",
			paths: []string{
				"/this-is-a-nonexisting-path-1", "/this-is-a-nonexisting-path-2",
				"/this-is-a-nonexisting-path-3",
			},
			expected: false,
		},
		{
			name:     "existing cert paths",
			paths:    []string{cert.Name(), cert.Name(), cert.Name()},
			expected: true,

			specs: []*spec3.OpenAPI{{
				Paths: &spec3.Paths{
					Paths: map[string]*spec3.Path{
						"/apis/stable.example.com/v1/crd1": {},
					},
				},
				Components: &spec3.Components{
					Schemas: map[string]*spec.Schema{
						"io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": {},
					},
				},
			},
			},
			expected: &spec3.OpenAPI{
				Paths: &spec3.Paths{
					Paths: map[string]*spec3.Path{

     */
    void setFrom(Iterable<?> paths);

    /**
     * Sets the source paths for this collection. The given paths are evaluated as per {@link org.gradle.api.Project#files(Object...)}.
     *
     * @param paths The paths.
     */
    void setFrom(Object... paths);

    /**
     * Specifies the value to use as the convention (default value) to be used when resolving this file collection,

		if err != nil || !fi.IsDir() {
			continue
		}
		paths = append(paths, spath)
	}

	paths = append(paths, inst.LibPaths...)

	return
}

// Return an importer that searches incpaths followed by the gcc installation's
// built-in search paths and the current directory.
func (inst *GccgoInstallation) GetImporter(incpaths []string, initmap map[*types.Package]InitData) Importer {

  rules:
  - to:
    - operation:
        paths: [ "/destination-ip-good" ]
    when:
    - key: destination.ip
      values: {{ .To.MustWorkloads.Addresses | toJson }}
  - to:
    - operation:
        paths: [ "/destination-ip-bad" ]
    when:
    - key: destination.ip
      values: [ "1.2.3.4" ]
  - to:
      - operation:
          paths: [ "/destination-ip-notValues" ]
    when: