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

     */
    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,

			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{

		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:

  rules:
  - to:
    - operation:
        paths: ["/token1"]
        methods: ["GET"]
    from:
    - source:
        requestPrincipals: ["******@****.***/sub-1"]
  - to:
    - operation:
        paths: ["/token2"]
        methods: ["GET"]
    when:
    - key: request.auth.claims[groups]
      values: ["group-2"]
  - to:
    - operation:
        paths: ["/tokenAny"]
        methods: ["GET"]
    from:

        doLast {
            println "text: " + (symlink.exists() ? symlink.text:"missing")
        }
    }
"""
        when: "symlink is used as input and exists"
        Files.createSymbolicLink(Paths.get(symlink.toURI()), Paths.get(sourceFile.toURI()))
        then:
        succeeds("echo")
        executedAndNotSkipped(":echo")
        output.contains("text: original")
        when: "symlink is deleted"
        symlink.delete()