math_ops.matmul(x, y, name='x_y_prod')


def tfmatmulandadd(_):
  # This tests multiple outputs.
  x = array_ops.placeholder(dtypes.float32, name='x_hold')
  y = array_ops.placeholder(dtypes.float32, name='y_hold')
  math_ops.matmul(x, y, name='x_y_prod')
  math_ops.add(x, y, name='x_y_sum')


def tffunction(_):

  @function.Defun(dtypes.int32, dtypes.int32)
  def test_func(a, b):
    return a + b

!!! danger "Gefahr"
    Speichern Sie niemals das Klartext-Passwort eines Benutzers. Speichern Sie immer den „sicheren Hash“, den Sie verifizieren können.

    Falls Ihnen das nichts sagt, in den [Sicherheits-Kapiteln](security/simple-oauth2.md#passwort-hashing){.internal-link target=_blank} werden Sie lernen, was ein „Passwort-Hash“ ist.

## Mehrere Modelle

	}

	// resolve and type-check package AST
	importer := new(resolveTestImporter)
	conf := Config{Importer: importer}
	uses := make(map[*syntax.Name]Object)
	defs := make(map[*syntax.Name]Object)
	_, err := conf.Check("testResolveIdents", files, &Info{Defs: defs, Uses: uses})
	if err != nil {
		t.Fatal(err)
	}

	// check that all packages were imported
	for _, name := range pkgnames {
		if !importer.imported[name] {

	}

	// resolve and type-check package AST
	importer := new(resolveTestImporter)
	conf := Config{Importer: importer}
	uses := make(map[*ast.Ident]Object)
	defs := make(map[*ast.Ident]Object)
	_, err := conf.Check("testResolveIdents", fset, files, &Info{Defs: defs, Uses: uses})
	if err != nil {
		t.Fatal(err)
	}

	// check that all packages were imported
	for _, name := range pkgnames {
		if !importer.imported[name] {

    def create(self, arg0: str, arg1: FunctionType) -> FuncOp: ...
    def getArguments(self) -> list[BlockArgument]: ...
    def getBody(self) -> Region: ...
    def getName(self) -> str: ...
    def getType(self) -> FunctionType: ...

class FunctionType(Type):
    def __init__(self, *args, **kwargs) -> None: ...
    def getResults(self) -> list[Type]: ...

class IntegerAttr(Attribute):

        0 * _
    }

    def "file tree is live"() {
        def source1 = Mock(FileCollectionInternal)
        def source2 = Mock(FileCollectionInternal)
        def dir1 = new File("dir1")
        def dir2 = new File("dir1")
        def dir3 = new File("dir1")
        def source3 = Mock(FileCollectionInternal)
        def collection = new TestCompositeFileCollection(source1, source2)

        given:
        def message1 = unicast()
        def message2 = broadcast()
        def message3 = unicast()
        def endpoint1 = queue.newEndpoint()
        def endpoint2 = queue.newEndpoint()

        and:
        queue.dispatch(message1)
        queue.dispatch(message2)
        queue.dispatch(message3)

        when:
        queue.empty(endpoint1)

    def "closes services for home dir when another home dir is in use"() {
        def dir1 = new File("home-dir-1")
        def dir2 = new File("home-dir-2")

        given:
        def servicesHomeDir1 = homeDirServices.getServicesFor(dir1)
        def homeDir1Service = servicesHomeDir1.get(SomeHomeDirService)

        when:
        def services1 = homeDirServices.getServicesFor(dir2)

    }

    def "collects all failures from actions when running sequentially"() {
        given:
        def action1 = Mock(Supplier)
        def action2 = Mock(Supplier)
        def action3 = Mock(Supplier)
        def failure1 = new RuntimeException()
        def failure2 = new RuntimeException()

        when:
        runner.run([action1, action2, action3])

        then:

        0 * listener.onDiscovered(_)
    }

    def "notifies listener of node with matching ancestor"() {
        def a = node("a")
        def b = node("a.b")
        def c = node("a.b.c")
        def d = node("a.b.d")
        def e = node("a.b.c.e")
        def f = node("d")

        given:
        def listener = Mock(ModelListener) {
            matches(_) >> true