mode = msdosModeToFileMode(h.ExternalAttrs)
	}
	if len(h.Name) > 0 && h.Name[len(h.Name)-1] == '/' {
		mode |= fs.ModeDir
	}
	return mode
}

// SetMode changes the permission and mode bits for the [FileHeader].
func (h *FileHeader) SetMode(mode fs.FileMode) {
	h.CreatorVersion = h.CreatorVersion&0xff | creatorUnix<<8
	h.ExternalAttrs = fileModeToUnixMode(mode) << 16

    public void setFid(final int fid) {
        this.fid = fid;
    }

    /**
     * Sets the seek mode.
     *
     * @param mode
     *            the mode to set
     */
    public final void setMode(final int mode) {
        this.mode = mode;
    }

    /**
     * Sets the seek offset.
     *
     * @param offset
     *            the offset to set
     */

		}
	}
}

func testCreate(t *testing.T, w *Writer, wt *WriteTest) {
	header := &FileHeader{
		Name:   wt.Name,
		Method: wt.Method,
	}
	if wt.Mode != 0 {
		header.SetMode(wt.Mode)
	}
	f, err := w.CreateHeader(header)
	if err != nil {
		t.Fatal(err)
	}
	_, err = f.Write(wt.Data)
	if err != nil {
		t.Fatal(err)
	}
}

			}
		})
	}
}

func TestFSWalkBadFile(t *testing.T) {
	t.Parallel()

	var buf bytes.Buffer
	zw := NewWriter(&buf)
	hdr := &FileHeader{Name: "."}
	hdr.SetMode(fs.ModeDir | 0o755)
	w, err := zw.CreateHeader(hdr)
	if err != nil {
		t.Fatalf("create zip header: %v", err)
	}
	_, err = w.Write([]byte("some data"))
	if err != nil {

                // otherwise there are no guarantees anyway, but this stuff is legacy anyways.
                final SmbComSeek seekReq = new SmbComSeek(config, 0);
                seekReq.setMode(0x2); // from EOF
                final SmbComSeekResponse seekResp = new SmbComSeekResponse(config);
                seekReq.setFid(response.getFid());
                try {
                    h.send(seekReq, seekResp);

            when(mockReferral.getNode()).thenReturn("\\server1\\share1\\path1");
            first = DfsReferralDataImpl.fromReferral(mockReferral, "\\\\server1\\share1\\path1", System.currentTimeMillis() + 10000, 20);

            // Setup second referral
            DfsReferralDataImpl second = new DfsReferralDataImpl();
            when(mockReferral.getNode()).thenReturn("\\server2\\share2\\path2");

        assertNotNull(referral.getRpath());
        assertNotNull(referral.getAltPath());
        assertNotNull(referral.getNode());
        assertEquals("\\\\server\\\\share", referral.getRpath());
        assertEquals("\\\\alt\\\\path", referral.getAltPath());
        assertEquals("NODE01", referral.getNode());

        String result = referral.toString();

        assertTrue(result.contains("Referral["));

Eine `FastAPI`-Anwendung (-Instanz) verfügt über eine `.openapi()`-Methode, von der erwartet wird, dass sie das OpenAPI-Schema zurückgibt.

Als Teil der Erstellung des Anwendungsobjekts wird eine *Pfadoperation* für `/openapi.json` (oder welcher Wert für den Parameter `openapi_url` gesetzt wurde) registriert.

Diese gibt lediglich eine JSON-Response zurück, mit dem Ergebnis der Methode `.openapi()` der Anwendung.

`user_in` ist ein Pydantic-Modell der Klasse `UserIn`.

Pydantic-Modelle haben eine `.dict()`-Methode, die ein `dict` mit den Daten des Modells zurückgibt.

Wenn wir also ein Pydantic-Objekt `user_in` erstellen, etwa so:

```Python
user_in = UserIn(username="john", password="secret", email="******@****.***")
```

und wir rufen seine `.dict()`-Methode auf:

```Python
user_dict = user_in.dict()
```

### Pydantics `exclude_unset`-Parameter verwenden

Wenn Sie Teil-Aktualisierungen entgegennehmen, ist der `exclude_unset`-Parameter in der `.model_dump()`-Methode von Pydantic-Modellen sehr nützlich.

Wie in `item.model_dump(exclude_unset=True)`.

/// info

In Pydantic v1 hieß diese Methode `.dict()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstützt) und in `.model_dump()` umbenannt.