public class IngestFactoryTest extends UnitFessTestCase {

    public void test_add_1() {
        IngestFactory factory = new IngestFactory();
        factory.add(new TestIngester(1));
        factory.add(new TestIngester(2));
        factory.add(new TestIngester(3));
        Ingester[] ingesters = factory.getIngesters();
        assertEquals(1, ingesters[0].getPriority());
        assertEquals(2, ingesters[1].getPriority());

        expect:
        factory.fromVariablePath(null) == null
    }

    def "file references are equal when they point to the same file"() {
        TestFile file = rootDir.file("a/file.txt")
        def reference = factory.fromFile(file)
        def sameFile = factory.fromFile(file)
        def differentFile = factory.fromFile(rootDir)

        expect:
        reference Matchers.strictlyEqual(sameFile)

    }

    def "reuses a provider with same identity"() {
        expect:
        factory.provide(PasswordCredentials, 'id') == factory.provide(PasswordCredentials, 'id')
    }

    def "creates distinct providers for different identities"() {
        expect:
        factory.provide(PasswordCredentials, 'id') != factory.provide(PasswordCredentials, 'id2')
    }

import org.gradle.internal.Factory;
import org.gradle.internal.hash.HashCode;

public abstract class AbstractLocallyAvailableResource implements LocallyAvailableResource {
    private Factory<HashCode> factory;
    // Calculated on demand
    private HashCode sha1;
    private Long contentLength;
    private Long lastModified;

    protected AbstractLocallyAvailableResource(Factory<HashCode> factory) {

        def factory = instantiator.factoryFor(HasInjectConstructor)

        then:
        factory.requiresService(String)
        factory.requiresService(Number)
        !factory.requiresService(Runnable)
    }

    def "can query whether service is required when declared as getter"() {
        when:
        def factory = instantiator.factoryFor(HasGetterInjection)

        then:

    private final ManagedFactory factory;
    private final Class<?> targetType;

    public IsolatedManagedValue(Class<?> targetType, ManagedFactory factory, Isolatable<?> state) {
        super(state);
        this.targetType = targetType;
        this.factory = factory;
    }

    @Override
    public ValueSnapshot asSnapshot() {

import javax.annotation.Nullable;
import java.util.Map;

public class ProjectDependencyFactory {
    private final DefaultProjectDependencyFactory factory;

    public ProjectDependencyFactory(DefaultProjectDependencyFactory factory) {
        this.factory = factory;
    }

    public ProjectDependency createFromMap(ProjectFinder projectFinder, Map<? extends String, ?> map) {

import org.junit.jupiter.api.Test

class AddressTest {
  private val factory =
    TestValueFactory().apply {
      uriHost = "example.com"
      uriPort = 80
    }

  @AfterEach fun tearDown() {
    factory.close()
  }

  @Test fun equalsAndHashcode() {
    val a = factory.newAddress()
    val b = factory.newAddress()
    assertThat(b).isEqualTo(a)
    assertThat(b.hashCode()).isEqualTo(a.hashCode())

    }

    /**
     * <p>Creates a container that instantiates using the given factory.<p>
     *
     * @param type The concrete type of element in the container
     * @param instantiator The instantiator to use to create any other collections based on this one
     * @param namer The naming strategy to use

    def factory = new BaseSerializerFactory()

    def "uses efficient serialization for Strings"() {
        expect:
        def serializer = factory.getSerializerFor(String)
        usesEfficientSerialization("hi", serializer, 3) == "hi"
    }

    def "uses efficient serialization for Files"() {
        expect:
        def serializer = factory.getSerializerFor(File)