}
    }

    def "reasonable error message when creating a non-constructible type"() {
        when:
        mutate {
            create("foo", NonConstructibleNamedThing)
        }
        realize()

        then:
        def e = thrown ModelRuleExecutionException
        e.cause instanceof ObjectInstantiationException
        e.cause.message == "Could not create an instance of type $NonConstructibleNamedThing.name."

        if (agentJarNames.isEmpty()) {
            return
        }
        var replacementsCount = 0
        // readLines eats EOLs, so we need to use postfix to make sure the last line ends with EOL too.
        writeBytes(readLines().joinToString(separator = separator, postfix = separator) { line ->
            when {
                // We assume that the declaration is not empty.

        @KotlinDefaultMask int mask,
        @CallerClassName String consumer
    ) throws Throwable {
        Instrumented.fileOpened(self, consumer);
        return mask == 0
            ? FilesKt.readLines(self, charset)
            : invokeKotlinStaticDefault(READ_LINES_DEFAULT, mask, self, charset);
    }

    @InterceptCalls
    @StaticMethod(ofClass = FilesKt.class)
    public static Object intercept_useLines(

# Despliegue - Introducción

Desplegar una aplicación hecha con **FastAPI** es relativamente fácil.

## ¿Qué significa desplegar una aplicación?

**Desplegar** una aplicación significa realizar una serie de pasos para hacerla **disponible para los usuarios**.

        when:
        dsl {
            apply plugin: BinaryBasePlugin
            model {
                baseBinary(BinarySpec) {
                }
            }
        }

        then:
        realize("baseBinary") instanceof BinarySpec
    }

    def "adds a 'binaries' container to the project model"() {
        when:
        dsl {
            apply plugin: BinaryBasePlugin
        }

        then:

    }

    @Issue("https://github.com/gradle/gradle/issues/18622")
    def "custom Test tasks eagerly realized prior to Java and Test Suite plugin application do not fail to be configured when combined with test suites"() {
        buildFile << """
            tasks.withType(Test) {
                // realize all test tasks
            }
            tasks.register("mytest", Test)
            apply plugin: 'java'

            return collector;
          }
        };
    assertThat(Files.readLines(temp, Charsets.UTF_8, collect)).isEmpty();

    PrintWriter w = new PrintWriter(Files.newWriter(temp, Charsets.UTF_8));
    w.println("hello");
    w.println("");
    w.println(" world  ");
    w.println("");
    w.close();
    Files.readLines(temp, Charsets.UTF_8, collect);

----
=====
====
Executing the `gradle check` task should execute `verificationTask`, but with this example, it won't.
This is because the dependency between `verificationTask` and `check` only happens when `verificationTask` is realized.
To avoid issues like this, you must only modify the task associated with the configuration action.
Other tasks should be modified in their own configuration action:
+
====
[.multi-language-sample]
=====

        return "other3"
    }

    @Override
    ManagedFactory managedFactory() {
        return new ManagedFactories.ProviderManagedFactory()
    }

    def "toString() does not realize value"() {
        given:
        def providerWithBadValue = new DefaultProvider<String>({
            throw new RuntimeException()
        })

        expect:
        providerWithBadValue.toString() == "provider(?)"

                tasks.create(it.name)
            }
            toBeRealized.get()

            task verify {
                doLast {
                    assert tasks.findByName("realized") != null
                    assert tasks.findByName("toBeRealized") != null
                }
            }
        """

        expect:
        succeeds "verify"
    }