setInfoType(Smb2Constants.SMB2_0_INFO_FILE);
        setFileInfoClass(fi.getFileInformationLevel());
        setInfo(fi);
    }


    /**
     * @param info
     *            the info to set
     */
    public void setInfo ( Encodable info ) {
        this.info = info;
    }


    /**
     * {@inheritDoc}
     *

        then:
        projectsInLayer.isEmpty()

        when:
        def depInfo = dependencyGenerator.createDependencies()

        then:
        depInfo.dependencies.isEmpty()
        depInfo.layerSizes.isEmpty()
    }

    def "can generate #num project dependencies"() {
        given:
        def dependencyGenerator = new DependencyGenerator()

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package disk

import (
	"errors"
	"fmt"

	"golang.org/x/sys/unix"
)

// GetInfo returns total and free bytes available in a directory, e.g. `/`.
func GetInfo(path string, _ bool) (info Info, err error) {
	s := unix.Statvfs_t{}
	if err = unix.Statvfs(path, &s); err != nil {
		return Info{}, err
	}

## gRPC Service Lifecycle

For any discovered plugin, kubelet will issue a Registration.GetInfo gRPC call
to get plugin type, name, endpoint and supported service API versions.

If any of the following steps in registration fails, on retry registration will
start from scratch:
- Registration.GetInfo is called against socket.
- Validate is called against internal plugin type handler.

		gpstore2       = regInfo{inputs: []regMask{gpspsbg, gpg, gpg}}
		gpxchg         = regInfo{inputs: []regMask{gpspsbg, gpg}, outputs: []regMask{gp}}
		gpcas          = regInfo{inputs: []regMask{gpspsbg, gpg, gpg}, outputs: []regMask{gp}}
		fp01           = regInfo{inputs: nil, outputs: []regMask{fp}}
		fp11           = regInfo{inputs: []regMask{fp}, outputs: []regMask{fp}}

package org.gradle.plugins.signing

class SigningClosureBlockIntegrationSpec extends SigningIntegrationSpec {

    def "use groovy closure when signing"() {
        given:
        buildFile << """
            ${keyInfo.addAsPropertiesScript()}

            signing {
                sign {
                    sign(tasks.jar)
                }
            }
        """

        when:
        run "sign"

//
// NOTE: This package is a copy of golang.org/x/sys/windows/registry
// with KeyInfo.ModTime removed to prevent dependency cycles.
package registry

import (
	"runtime"
	"syscall"
)

const (
	// Registry key security and access rights.
	// See https://learn.microsoft.com/en-us/windows/win32/sysinfo/registry-key-security-and-access-rights
	// for details.
	ALL_ACCESS         = 0xf003f

			defer wg.Done()

			if err := target.Save(event); err != nil {
				list.eventsErrorsTotal.Add(1)
				list.incFailedEvents(id)
				reqInfo := &logger.ReqInfo{}
				reqInfo.AppendTags("targetID", id.String())
				logger.LogOnceIf(logger.SetReqInfo(context.Background(), reqInfo), logSubsys, err, id.String())
			}
		}(id, target)
	}
	wg.Wait()
	list.totalEvents.Add(1)
}

    }


    /**
     * @return the information
     */
    public Decodable getInfo () {
        return this.info;
    }


    /**
     * @param clazz
     * @return the information
     * @throws CIFSException
     */
    @SuppressWarnings ( "unchecked" )
    public <T extends Decodable> T getInfo ( Class<T> clazz ) throws CIFSException {
        if ( !clazz.isAssignableFrom(this.info.getClass()) ) {

            asProperties(name).collect { k, v ->
                "${addTo}[\"${escapeString(k)}\"] = \"${escapeString(v)}\""
            }.join(System.lineSeparator())
        }
    }

    KeyInfo getKeyInfo(set = "default") {
        new KeyInfo(
            keyId: file(set, "keyId.txt").text.trim(),
            password: file(set, "password.txt").text.trim(),
            keyRingFilePath: file(set, "secring.gpg")
        )
    }