virtualFileSystem.invalidateAll()
        graph.remove(sourceFile)
        sourceFile.delete()
    }

    def "detects unchanged source files"() {
        given:
        initialFiles()

        expect:
        checkCompile recompiled: [], removed: []
    }

    def "detects new source files"() {
        given:
        initialFiles()

        when:
        def file3 = sourceFile("file3")

* Validación de datos
* Documentación automática

## Configuraciones por defecto

Como los parámetros de query no están fijos en una parte del path pueden ser opcionales y pueden tener valores por defecto.

El ejemplo arriba tiene `skip=0` y `limit=10` como los valores por defecto.

Entonces, si vas a la URL:

```
http://127.0.0.1:8000/items/
```

Sería lo mismo que ir a:

    }

    def "detects change of an isolated class"() {
        source "class A {}", "class B {}"

        outputs.snapshot { run language.compileTaskName }

        when:
        source "class A { /* change */ }"
        run language.compileTaskName

        then:
        outputs.recompiledClasses 'A'
    }

    def "detects deletion of an inner class"() {

    def setup() {
        buildFile << """
            dependencies {
                api 'org:moda:1.0'
            }
        """
    }

    def "detects changes in module-info file"() {
        when:
        publishJavaModule('moda')
        consumingModuleInfo()
        consumingModuleClass('moda.ModaClass')

        then:
        fails ':compileJava'

    successfulExtensions("permessage-deflate")
  }

  @Test
  @Throws(Exception::class)
  fun compressedMessagesNoClientContextTakeover() {
    successfulExtensions("permessage-deflate; client_no_context_takeover")
  }

  @Test
  @Throws(Exception::class)
  fun compressedMessagesNoServerContextTakeover() {
    successfulExtensions("permessage-deflate; server_no_context_takeover")
  }

}

func ExampleWriter_RegisterCompressor() {
	// Override the default Deflate compressor with a higher compression level.

	// Create a buffer to write our archive to.
	buf := new(bytes.Buffer)

	// Create a new zip archive.
	w := zip.NewWriter(buf)

	// Register a custom Deflate compressor.
	w.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {

// Uses FwdRef ops to find all uses of variables, and s.defvars to find
// all definitions.
// Phi values are inserted, and all FwdRefs are changed to a Copy
// of the appropriate phi or definition.
// TODO: make this part of cmd/compile/internal/ssa somehow?
func (s *state) insertPhis() {
	if len(s.f.Blocks) <= smallBlocks {
		sps := simplePhiState{s: s, f: s.f, defvars: s.defvars}
		sps.insertPhis()
		return
	}

# Devolver una respuesta directamente

Cuando creas una *operación de path* normalmente puedes devolver cualquier dato: un `dict`, una `list`, un modelo Pydantic, un modelo de base de datos, etc.

Por defecto, **FastAPI** convertiría automáticamente ese valor devuelto a JSON usando el `jsonable_encoder` explicado en [Codificador Compatible JSON](../tutorial/encoder.md){.internal-link target=_blank}.

import org.gradle.internal.snapshot.RegularFileSnapshot
import spock.lang.Specification

class DefaultOverlappingOutputDetectorTest extends Specification {
    def detector = new DefaultOverlappingOutputDetector()

    def "detects no overlap when there are none"() {
        def previousOutputFiles = ImmutableSortedMap.<String, FileSystemSnapshot> of(
            "output", FileSystemSnapshot.EMPTY
        )

    @Test
    fun `defers evaluation of Callable objects`() {
        assertDeferredEvaluationOf(callable()) {
            call()
        }
    }

    @Test
    fun `defers evaluation of dynamic Callable fields`() {
        assertDeferredEvaluationOf(BeanOf(callable())) {
            value.call()
        }
    }

    @Test
    fun `defers evaluation of static Callable fields`() {