exception.message.contains("Expected a single non-private constructor, or one constructor annotated with @Inject for")
    }

    def "can add a type to registry that has an annotated package private constructor and a private constructor"() {
        when:
        def registry = new DefaultServiceRegistry()
        registry.register {

    private
    fun newConstructorForSerialization(beanType: Class<*>, constructor: Constructor<*>): Constructor<out Any> =
        ReflectionFactory.getReflectionFactory().newConstructorForSerialization(beanType, constructor)

        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;
            }

    public static <R> Binding<R> to(Key<R> originalKey, TupleConstructorN<R> constructor, Class<?>[] types) {
        return Binding.to(
                originalKey, constructor, Stream.of(types).map(Key::of).toArray(Key<?>[]::new));
    }

    public static <R> Binding<R> to(Key<R> originalKey, TupleConstructorN<R> constructor, Key<?>[] dependencies) {
        return to(originalKey, constructor, dependencies, 0);
    }

    public static <R> Binding<R> to(

     * @param constructor
     *            コンストラクタ。{@literal null}であってはいけません
     */
    public ConstructorDescImpl(final BeanDesc beanDesc, final Constructor<?> constructor) {
        assertArgumentNotNull("beanDesc", beanDesc);
        assertArgumentNotNull("constructor", constructor);

        this.beanDesc = beanDesc;
        this.constructor = constructor;

    @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

    def "creates instance with constructor parameters"() {
        CharSequence param = Mock()

        expect:
        def result = instantiator.newInstance(SomeType, param)
        result instanceof SomeType
        result.result == param
    }

    def "creates instance with subtypes of constructor parameters"() {
        expect:

            List.class,
            KeyFingerPrintCalculator.class
        );
        constructor.setAccessible(true);
        return constructor;
    }

    private static Constructor<PGPPublicKey> getSubkeyConstructor() throws NoSuchMethodException {
        Constructor<PGPPublicKey> constructor = PGPPublicKey.class.getDeclaredConstructor(
            PublicKeyPacket.class,
            TrustPacket.class,

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

    Test pass for freezing read only variables in the graph.
  }];

  let constructor = "::mlir::tf_test::CreateFreezeVariableTestPass()";
}

def InitTextFileToImportTestPass : Pass<"tf-init-text-file-to-import-test",
  "ModuleOp"> {
  let summary = "generate a temporary file and invoke InitTextFileToImportPass";
  let constructor = "::mlir::tf_test::CreateInitTextFileToImportTestPass()";
}