import org.gradle.internal.exceptions.Contextual;

/**
 * Thrown when an object cannot be instantiated.
 *
 * @since 4.2
 */
@Contextual
public class ObjectInstantiationException extends RuntimeException {
    public ObjectInstantiationException(Class<?> targetType, Throwable throwable) {
        super(String.format("Could not create an instance of type %s.", targetType.getName()), throwable);
    }

        ObjectInstantiationException e = thrown()
        e.cause instanceof IllegalArgumentException
        e.cause.message == "Unable to determine constructor argument #1: value 12 is not assignable to type String, or no service of type String."
    }

    def "fails on non-static inner class"() {
        when:
        instantiator.newInstance(NonStatic, "param")

        then:
        ObjectInstantiationException e = thrown()

    /**
     * Create a new instance of T, using {@code parameters} as the construction parameters.
     *
     * @throws ObjectInstantiationException On failure to create the new instance.
     */
    <T> T newInstance(Class<? extends T> type, Object... parameters) throws ObjectInstantiationException;

            } catch (InvocationTargetException e) {
                throw new ObjectInstantiationException(implType, e.getCause());
            } catch (Exception e) {
                throw new ObjectInstantiationException(implType, e);
            }
        }
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.instantiation.generator

import org.gradle.api.reflect.ObjectInstantiationException
import org.gradle.internal.service.ServiceLookup
import org.gradle.util.internal.TextUtil
import spock.lang.Specification

class DependencyInjectionUsingLenientConstructorSelectorTest extends Specification {

        return factory.inject(serviceRegistry).newInstance(type, parameters);
    }

    public Instantiator capturing(final ImplicitInputRecorder registrar) {
        return new Instantiator() {
            @Override
            public <T> T newInstance(Class<? extends T> type, Object... parameters) throws ObjectInstantiationException {

import org.gradle.api.reflect.ObjectInstantiationException;

/**
 * Creates instance of objects in preparation for deserialization of their state.
 */
public interface DeserializationInstantiator {
    /**
     * Creates an instance of the given type without invoking its constructor. Invokes the constructor of the given base class.
     *
     * @throws ObjectInstantiationException On failure to create the new instance.
     */

 * limitations under the License.
 */

package org.gradle.api.internal.plugins;

import org.gradle.api.NonNullApi;
import org.gradle.api.reflect.ObjectInstantiationException;
import org.gradle.internal.reflect.Instantiator;

import java.lang.reflect.Modifier;

/**
 * An instantiator that uses the correct instantiation scheme depending on the plugin type.  This allows

     *
     * @throws ObjectInstantiationException On failure to create the new instance.
     */
    <T> T newInstanceWithDisplayName(Class<? extends T> type, Describable displayName, Object... parameters) throws ObjectInstantiationException;

            }
            return type.cast(match.newInstance(params));
        } catch (InvocationTargetException e) {
            throw new ObjectInstantiationException(type, e.getCause());
        } catch (Throwable t) {
            throw new ObjectInstantiationException(type, t);
        }
    }

    private Class<?>[] wrapArgs(Object[] params) {
        Class<?>[] result = new Class<?>[params.length];