private final Property<Package> packageProperty;

    public GenerateSwiftPackageManagerManifest() {
        ObjectFactory objectFactory = getProject().getObjects();
        manifestFile = objectFactory.fileProperty();
        packageProperty = objectFactory.property(Package.class);
    }

    @Input
    public Property<Package> getPackage() {
        return packageProperty;
    }

    protected final JavaForkOptions forkOptions;

    @Inject
    public DefaultProcessWorkerSpec(JavaForkOptions forkOptions, ObjectFactory objectFactory) {
        super(objectFactory);
        this.forkOptions = forkOptions;
        this.forkOptions.setEnvironment(sanitizeEnvironment(forkOptions));
    }

    /**

import spock.lang.Specification

import javax.xml.namespace.QName

import static org.gradle.util.TestUtil.objectFactory

class DefaultIvyModuleDescriptorSpecTest extends Specification {
    def spec = objectFactory().newInstance(DefaultIvyModuleDescriptorSpec, objectFactory(), objectFactory().newInstance(IvyPublicationCoordinates))

    def "getExtraInfo returns IvyExtraInfo with immutable map" () {
        when:

    AbstractAuthenticationSupportedRepository(Instantiator instantiator, AuthenticationContainer authenticationContainer, ObjectFactory objectFactory, ProviderFactory providerFactory, VersionParser versionParser) {
        super(objectFactory, versionParser);
        this.delegate = new AuthenticationSupporter(instantiator, objectFactory, authenticationContainer, providerFactory);
        this.providerFactory = providerFactory;
    }

    @Override

        Project project = getProject();
        ObjectFactory objectFactory = project.getObjects();
        this.dependencyCoordinateResolverFactory = ((ProjectInternal) project).getServices().get(DependencyCoordinateResolverFactory.class);

        publication = Transient.of(objectFactory.property(Publication.class));
        publications = Transient.of(objectFactory.listProperty(Publication.class));

    }

    class TestBinary extends DefaultNativeBinary {
        @Inject
        TestBinary(String name, ObjectFactory objectFactory, Configuration componentImplementation) {
            super(Names.of(name), objectFactory, componentImplementation)
        }

        @Override
        Provider<String> getBaseName() {
            throw new UnsupportedOperationException()
        }

        }
    }

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()
        return Stub(TargetMachine) {
            getOperatingSystemFamily() >> objectFactory.named(OperatingSystemFamily.class, os)
            getArchitecture() >> objectFactory.named(MachineArchitecture.class, arch)
        }
    }

    public MainLibraryVariant(String name, Configuration dependencies, AttributeContainer attributeContainer, ObjectFactory objectFactory) {
        this.name = name;
        this.dependencies = dependencies;
        this.attributeContainer = attributeContainer;
        this.variants = objectFactory.domainObjectSet(SoftwareComponent.class);
    }

    @Override
    public String getName() {
        return name;
    }

        }
    }

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()
        return Stub(TargetMachine) {
            getOperatingSystemFamily() >> objectFactory.named(OperatingSystemFamily.class, os)
            getArchitecture() >> objectFactory.named(MachineArchitecture.class, arch)
        }
    }

    def buildOperationRunner = Mock(BuildOperationRunner)
    def asyncWorkTracker = Mock(AsyncWorkTracker)
    def forkOptionsFactory = TestFiles.execFactory(temporaryFolder.testDirectory)
    def objectFactory = Stub(ObjectFactory) {
        fileCollection() >> { TestFiles.fileCollectionFactory().configurableFiles() }
    }
    def workerDirectoryProvider = Stub(WorkerDirectoryProvider) {