}
		default:
			panic(fmt.Sprintf("unknown relocation type: %v", r.Type()))
		}

		ins := int64(uint32(val))
		ins = (ins &^ immMask) | int64(uint32(imm))
		return ins, 0, true

	case objabi.R_RISCV_CALL, objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE:
		// Generate AUIPC and second instruction immediates.

        model1.project.is(model2.project)

        def otherModel1 = converter.adapt(TestModel.class, protocolModel1)
        model1.is(otherModel1)
    }

    def "does not reuse views with different mix ins"() {
        TestProtocolModel protocolModel = Mock()
        TestProtocolProject protocolProject = Mock()
        _ * protocolModel.getProject() >> protocolProject

        expect:

* resources
* providers
* services
* injectables
* components

## **FastAPI** plug-ins

Integrations and "plug-ins" can be built using the **Dependency Injection** system. But in fact, there is actually **no need to create "plug-ins"**, as by using dependencies it's possible to declare an infinite number of integrations and interactions that become available to your *path operation functions*.

### <a href="https://apispec.readthedocs.io/en/stable/" class="external-link" target="_blank">APISpec</a>

Marshmallow e Webargs fornecem validação, análise e serialização como plug-ins.

Mas a documentação ainda está faltando. Então APISpec foi criado.

APISpec tem plug-ins para muitos frameworks (e tem um plug-in para Starlette também).

            file 'file1.txt'
            file 'file2.txt'
        }
        file('dest').create {
            file 'extra.txt'
        }
        // Intentionally hold open a file
        def ins = new FileInputStream(file("dest/extra.txt"))
        buildScript '''
            task syncIt {
                doLast {
                    project.sync {
                        from 'source'

* **Sin comprometerse** con bases de datos, frontend, etc. Pero permitiendo integración fácil con todos ellos.

### "Plug-ins" ilimitados

O dicho de otra manera, no hay necesidad para "plug-ins". Importa y usa el código que necesites.

            'flexmark-util', 'flexmark-formatter', 'autolink-0.6', 'flexmark-jira-converter', 'antlr-3', 'jackson-annotations', 'jackson-core',
            'jackson-databind', 'snakeyaml', 'flexmark-ext-tables', 'flexmark-ext-ins', 'flexmark-ext-superscript', 'antlr-runtime', 'ST4'
        ]
        hasProjectLibrary('root.ipr', 'scala-sdk-3.0.1', [], [], [], scalaLibs + scaladocLibsAndDeps)
        hasScalaSdk('project1/project1.iml', '2.11.2')

	for _, b := range bs {
		io.WriteString(&d, text(b))
		fmt.Fprintln(&d)
	}
	return d.String()
}

// inlineText returns all the next in a slice of inline nodes.
func inlineText(ins []md.Inline) string {
	var buf bytes.Buffer
	for _, in := range ins {
		in.PrintText(&buf)
	}
	return buf.String()
}

// Merge combines the markdown documents (files ending in ".md") in the tree rooted
// at fs into a single document.

I have been avoiding the creation of a new framework for several years. First I tried to solve all the features covered by **FastAPI** using many different frameworks, plug-ins, and tools.

	}
	inner := v.FieldByName("Inner")
	if inner.IsValid() {
		printis(buf, inner.Interface().([]Inline))
	}
	buf.WriteString(")")
}

func printis(buf *bytes.Buffer, ins []Inline) {
	for _, in := range ins {
		buf.WriteByte(' ')
		printi(buf, in)
	}
}

func dump(b Block) string {
	var buf bytes.Buffer
	printb(&buf, b, "")
	return buf.String()