if (constructors.size() == 1) {
            return Cast.uncheckedCast(constructors.get(0));
        }

        ClassGenerator.GeneratedConstructor<?> match = null;
        // NOTE: this relies on the constructors being in a predictable order
        // sorted by the number of parameters the constructor requires

        if (constructors.size() == 1) {
            ClassGenerator.GeneratedConstructor<T> constructor = constructors.get(0);
            if (constructor.getParameterTypes().length == 0 && isPublicOrPackageScoped(type.getGeneratedClass(), constructor)) {
                return constructor;
            }
            if (constructor.getAnnotation(Inject.class) != null) {

    @Shared
    def cache = new DirectInstantiator.ConstructorCache()

    @Unroll("constructor cache returns the same constructors as 'getConstructors' for #clazz")
    def "constructor cache returns the same constructors as 'getConstructors'"() {
        given:
        def constructor = null
        int i = 0
        while (!constructor && ++i<50) {
            // need a loop because IBM JDK is much more proactive in cleaning weak references

        final Constructor<?>[] constructors = type.getDeclaredConstructors();
        if (constructors.length == 1) {
            Constructor<?> constructor = constructors[0];
            if (isPublicOrPackageScoped(constructor)) {
                // If there is a single constructor, and that constructor is public or package private we select it.
                return constructor;
            }

        e.message == "Cannot get an instance of NativeServices without first calling initialize()."
    }

    def "no public constructors on NativeServices" () {
        Constructor[] constructors = NativeServices.getConstructors()

        expect:
        constructors.size() == 0
    }

    private static URL jar(Class clazz) {
        clazz.getProtectionDomain().getCodeSource().getLocation()
    }

            @Override
            public List<GeneratedConstructor<T>> getConstructors() {
                List<GeneratedConstructor<T>> constructors = new ArrayList<GeneratedConstructor<T>>();
                for (final Constructor<?> constructor : type.getDeclaredConstructors()) {
                    constructors.add(new GeneratedConstructor<T>() {
                        @Override

    }

    def "order of constructors is based on number of parameters"() {
        // We rely on processing the constructors in a predictable order (fewest parameters -> most)
        def constructors = generator.generate(ManyConstructors).getConstructors()
        expect:
        int count = 0
        constructors.each { constructor ->
            assert count <= constructor.parameterTypes.length

        when:
        instantiator.newInstance(HasMixedConstructors, new StringBuilder("param"))

        then:
        ObjectInstantiationException e = thrown()
        e.cause.message == "Class DependencyInjectingInstantiatorTest.HasMixedConstructors has no constructor that is annotated with @Inject."
    }

  1. candidate: DependencyInjectionUsingLenientConstructorSelectorTest.HasConstructors(String, Number)
  2. best match: DependencyInjectionUsingLenientConstructorSelectorTest.HasConstructors(String, boolean)"""
    }

    def "uses exact match constructor when constructors could be ambiguous with multiple parameters"() {
        when:
        // HasSeveralParameters has 3 constructors

        }

        if (constructors.isEmpty()) {
            throw failedImplicitBinding(key, "inject annotation on interface");
        }
        if (constructors.size() > 1) {
            throw failedImplicitBinding(key, "inject annotation on class with multiple constructors");
        }
        Constructor<T> declaredConstructor =
                (Constructor<T>) constructors.iterator().next();