first.parameterTypes >> [String]
        def second = Stub(ClassGenerator.GeneratedConstructor)
        second.parameterTypes >> [String, Boolean]
        def third = Stub(ClassGenerator.GeneratedConstructor)
        third.parameterTypes >> [String, Number, Boolean]

        def list = [second, third, first]
        expect:
        list.sort(false, comparator) == [first, second, third]
    }

                validateType(type);
                ClassGenerator.GeneratedClass<?> implClass = classGenerator.generate(type);
                ClassGenerator.GeneratedConstructor<?> generatedConstructor = InjectUtil.selectConstructor(implClass, type);
                return CachedConstructor.of(generatedConstructor);
            } catch (RuntimeException e) {
                return CachedConstructor.of(e);
            }
        });

        this.classGenerator = classGenerator;
    }

    @Override
    public void vetoParameters(ClassGenerator.GeneratedConstructor<?> constructor, Object[] parameters) {
        // Don't care
    }

    @Override
    public <T> ClassGenerator.GeneratedConstructor<? extends T> forType(Class<T> type) throws UnsupportedOperationException {

 * types of the parameters.
 *
 */
public class ConstructorComparator implements Comparator<ClassGenerator.GeneratedConstructor<?>> {
    @Override
    public int compare(ClassGenerator.GeneratedConstructor<?> o1, ClassGenerator.GeneratedConstructor<?> o2) {
        int parameterSort = Integer.compare(o1.getParameterTypes().length, o2.getParameterTypes().length);
        if (parameterSort == 0) {

     */
    public static <T> ClassGenerator.GeneratedConstructor<T> selectConstructor(ClassGenerator.GeneratedClass<T> type, Class<?> reportAs) {
        List<ClassGenerator.GeneratedConstructor<T>> constructors = type.getConstructors();

        if (constructors.size() == 1) {
            ClassGenerator.GeneratedConstructor<T> constructor = constructors.get(0);

            }

            @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

        /**
         * Returns the enclosing type, when this type is a non-static inner class.
         */
        @Nullable
        Class<?> getOuterType();

        List<GeneratedConstructor<T>> getConstructors();

        /**
         * Creates a serialization constructor. Note: this can be expensive and does not perform any caching.
         */

     */
    <T> ClassGenerator.GeneratedConstructor<? extends T> forParams(Class<T> type, Object[] params);

    /**
     * Locates the constructor that should be used to create instances of the given type.
     *
     * @throws UnsupportedOperationException When this selector requires the parameters in order to select a constructor.
     */

    }

    @Nonnull
    private <T> T doCreate(Class<? extends T> type, @Nullable Describable displayName, Object[] parameters) {
        try {
            ClassGenerator.GeneratedConstructor<? extends T> constructor = constructorSelector.forParams(type, parameters);
            Object[] resolvedParameters = convertParameters(type, constructor, services, parameters);
            try {

        private final Class<?> outerType;
        private final List<Class<?>> injectedServices;
        private final List<Class<? extends Annotation>> annotationsTriggeringServiceInjection;
        private final List<GeneratedConstructor<Object>> constructors;

        public GeneratedClassImpl(Class<?> generatedClass, @Nullable Class<?> outerType, List<Class<?>> injectedServices, List<Class<? extends Annotation>> annotationsTriggeringServiceInjection) {