trailer := string(b.toSTAR().trailer())
	switch {
	case magic == magicUSTAR && trailer == trailerSTAR:
		return formatSTAR
	case magic == magicUSTAR:
		return FormatUSTAR | FormatPAX
	case magic == magicGNU && version == versionGNU:
		return FormatGNU
	default:
		return formatV7
	}
}

// setFormat writes the magic values necessary for specified format
// and then updates the checksum accordingly.

        // Create inner content with OID and magic bytes but wrong tag after
        ByteArrayOutputStream innerContent = new ByteArrayOutputStream();
        ASN1ObjectIdentifier kerberosOid = new ASN1ObjectIdentifier(KerberosConstants.KERBEROS_OID);
        innerContent.write(kerberosOid.getEncoded());
        innerContent.write(0x01); // magic byte 1
        innerContent.write(0x00); // magic byte 2

Even if your **FastAPI** application uses normal `def` functions instead of `async def`, it is still an `async` application underneath.

The `TestClient` does some magic inside to call the asynchronous FastAPI application in your normal `def` test functions, using standard pytest. But that magic doesn't work anymore when we're using it inside asynchronous functions. By running our tests asynchronously, we can no longer use the `TestClient` inside our test functions.

    private static final String S2C_SEAL_CONSTANT = "session key to server-to-client sealing key magic constant";

    private static final String C2S_SIGN_CONSTANT = "session key to client-to-server signing key magic constant";
    private static final String C2S_SEAL_CONSTANT = "session key to client-to-server sealing key magic constant";

def magic_data_reader(raw_body: bytes):
    return {
        "size": len(raw_body),
        "content": {
            "name": "Maaaagic",
            "price": 42,
            "description": "Just kiddin', no magic here. ✨",
        },
    }


@app.post(
    "/items/",
    openapi_extra={
        "requestBody": {
            "content": {
                "application/json": {
                    "schema": {

  private fun readJournal() {
    fileSystem.read(journalFile) {
      val magic = readUtf8LineStrict()
      val version = readUtf8LineStrict()
      val appVersionString = readUtf8LineStrict()
      val valueCountString = readUtf8LineStrict()
      val blank = readUtf8LineStrict()

      if (MAGIC != magic ||
        VERSION_1 != version ||
        appVersion.toString() != appVersionString ||

     */
    public static void writeUTime(final long t, final byte[] dst, final int dstIndex) {
        writeInt4(t / 1000, dst, dstIndex);
    }

    /**
     * SMB1 protocol header template with magic number 0xFF 'SMB'
     */
    public static final byte[] SMB_HEADER = { (byte) 0xFF, (byte) 'S', (byte) 'M', (byte) 'B', (byte) 0x00, (byte) 0x00, (byte) 0x00,

 * limitations under the License.
 */
package okhttp3.internal.ws

import okio.Buffer
import okio.ByteString.Companion.encodeUtf8

object WebSocketProtocol {
  /** Magic value which must be appended to the key in a response header. */
  internal const val ACCEPT_MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"

  /*
  Each frame starts with two bytes of data.

    // yet known to the library, but are supported by the platform.
    ConnectionSpec
      .Builder(ConnectionSpec.MODERN_TLS)
      .cipherSuites("MAGIC-CIPHER")
      .tlsVersions("TLS9k")
      .build()
  }

  @Test
  fun tls_missingRequiredCipher() {
    platform.assumeNotConscrypt()
    platform.assumeNotBouncyCastle()
    val tlsSpec =

	"github.com/minio/highwayhash"
	"github.com/minio/minio/internal/hash/sha256"
	"golang.org/x/crypto/blake2b"

	xioutil "github.com/minio/minio/internal/ioutil"
	"github.com/minio/minio/internal/logger"
)

// magic HH-256 key as HH-256 hash of the first 100 decimals of π as utf-8 string with a zero key.