reason: String,
    )
  }

  /**
   * Process the next protocol frame.
   *
   *  * If it is a control frame this will result in a single call to [FrameCallback].
   *  * If it is a message frame this will result in a single call to [FrameCallback.onReadMessage].
   *    If the message spans multiple frames, each interleaved control frame will result in a
   *    corresponding call to [FrameCallback].
   */

		// second return value is "more", not "ok"
		frame, _ := frames.Next()
		if (!strings.HasPrefix(frame.File, gormSourceDir) ||
			strings.HasSuffix(frame.File, "_test.go")) && !strings.HasSuffix(frame.File, ".gen.go") {
			return frame
		}
	}

	return runtime.Frame{}
}

// FileWithLineNum return the file name and line number of the current file
func FileWithLineNum() string {
	frame := CallerFrame()
	if frame.PC != 0 {

The frame size <code>$24-8</code> states that the function has a 24-byte frame
and is called with 8 bytes of argument, which live on the caller's frame.
If <code>NOSPLIT</code> is not specified for the <code>TEXT</code>,
the argument size must be provided.
For assembly functions with Go prototypes, <code>go</code> <code>vet</code> will check that the
argument size is correct.
</p>

<p>

		return "select count(*) from users", 0
	}, nil)

	if strings.Contains(buf.String(), "gorm/logger/slog.go") {
		t.Error("Found internal slog.go reference in caller frame. Expected only test file references.")
	}

	if !strings.Contains(buf.String(), "gorm/logger/slog_test.go") {
		t.Error("Missing expected test file reference. 'gorm/logger/slog_test.go' should appear in caller frames.")
	}

    )
    assertThat(webSocket.close(1000, null)).isFalse()
  }

  /**
   * There's no read timeout when reading the first byte of a new frame. But as soon as we start
   * reading a frame we enable the read timeout. In this test we have the server returning the first
   * byte of a frame but no more frames.
   */
  @Test
  fun readTimeoutAppliesWithinFrames() {
    webServer.dispatcher =
      object : Dispatcher() {

code {
  direction: ltr;
  display: inline-block;
}

.illustration {
  margin-top: 2em;
  margin-bottom: 2em;
}

/* Screenshots */
/*
Simulate a browser window frame.
Inspired by Termynal's CSS tricks with modifications
*/

.screenshot {
  display: block;
  background-color: #d3e0de;
  border-radius: 4px;
  padding: 45px 5px 5px;
  position: relative;

    data.write("8a7e007e".decodeHex())
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Control frame must be less than 125B.")
    }
  }

  @Test fun clientSimpleHello() {
    data.write("810548656c6c6f".decodeHex()) // Hello
    clientReader.processNextFrame()
    callback.assertTextMessage("Hello")
  }

    tag: String,
  ) {
    val logger = Logger.getLogger(logger)
    if (configuredLoggers.add(logger)) {
      logger.useParentHandlers = false
      // log based on levels at startup to avoid logging each frame
      logger.level =
        when {
          Log.isLoggable(tag, Log.DEBUG) -> Level.FINE
          Log.isLoggable(tag, Log.INFO) -> Level.INFO
          else -> Level.WARNING
        }

    assertThat(firstFrame(logs, "HEADERS")!!, "header logged")
      .contains("HEADERS       END_HEADERS")
    // While MockWebServer waits to read the client's HEADERS frame before sending the response, it
    // doesn't wait to read the client's DATA frame and may send a DATA frame before the client
    // does. So we can't assume the client's empty DATA will be logged first.

	op := operands[next]
	if len(op) < 2 || op[0].ScanToken != '$' {
		p.errorf("TEXT %s: frame size must be an immediate constant", name)
		return
	}
	op = op[1:]
	negative := false
	if op[0].ScanToken == '-' {
		negative = true
		op = op[1:]
	}
	if len(op) == 0 || op[0].ScanToken != scanner.Int {
		p.errorf("TEXT %s: frame size must be an immediate constant", name)
		return
	}