case <-callhomeTimer.C:
			if !globalCallhomeConfig.Enabled() {
				// Stop the processing as callhome got disabled
				return false
			}

			performCallhome(ctx)

			// Reset the timer for next cycle.
			callhomeTimer.Reset(globalCallhomeConfig.FrequencyDur())
		}
	}
}

func performCallhome(ctx context.Context) {
	deadline := 10 * time.Second // Default deadline is 10secs for callhome

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeCondCheck Msgsize() is inaccurate")
	}

	vn := CondCheck{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeCondCheck(b *testing.B) {
	v := CondCheck{}
	var buf bytes.Buffer

    /**
     * Updates the context class loader such that the container will search the project realm when the model builder
     * injects the lifecycle bindings from the packaging in the next step. The context class loader is to be reset by
     * the project builder when the project is fully assembled.
     *
     * @param project The project whose class realm should be selected, must not be {@code null}.
     */

		if offset >= int64(len(block)) {
			// Decrement offset.
			offset -= int64(len(block))
			continue
		}

		// Skip until offset.
		block = block[offset:]

		// Reset the offset for next iteration to read everything
		// from subsequent blocks.
		offset = 0

		// We have written all the blocks, write the last remaining block.
		if write < int64(len(block)) {

import java.io.IOException

/** Thrown when an HTTP/2 stream is canceled without damage to the socket that carries it. */
class StreamResetException(
  @JvmField val errorCode: ErrorCode,

	h            hash.Hash
	shardSize    int64
	canClose     *sync.WaitGroup
}

func (b *streamingBitrotWriter) Write(p []byte) (int, error) {
	if len(p) == 0 {
		return 0, nil
	}
	b.h.Reset()
	b.h.Write(p)
	hashBytes := b.h.Sum(nil)
	_, err := b.iow.Write(hashBytes)
	if err != nil {
		b.closeWithErr(err)
		return 0, err
	}
	n, err := b.iow.Write(p)
	if err != nil {
		b.closeWithErr(err)

		select {
		case <-ctx.Done():
			return
		case <-lkTimer.C:
			globalLockServer.expireOldLocks(lockValidityDuration)

			// Reset the timer for next cycle.
			lkTimer.Reset(lockMaintenanceInterval)
		}
	}

	srcCtnt, srcOk := nextObject(srcCh)
	tgtCtnt, tgtOk := nextObject(tgtCh)

	var srcEOF, tgtEOF bool

	srcSha256 := sha256.New()
	tgtSha256 := sha256.New()

	for {
		srcSha256.Reset()
		tgtSha256.Reset()

		srcEOF = !srcOk
		tgtEOF = !tgtOk

		// No objects from source AND target: Finish
		if srcEOF && tgtEOF {
			break
		}

		if !srcEOF && srcCtnt.Err != nil {

  DISCONNECT_DURING_REQUEST_BODY,
  DISCONNECT_DURING_RESPONSE_BODY,
  DO_NOT_READ_REQUEST_BODY,
  FAIL_HANDSHAKE,
  SHUTDOWN_INPUT_AT_END,
  SHUTDOWN_OUTPUT_AT_END,
  STALL_SOCKET_AT_START,
  NO_RESPONSE,
  RESET_STREAM_AT_START,
  EXPECT_CONTINUE,
  CONTINUE_ALWAYS,

@app.put("/user/{user_id}")
def put_user(user_id: str, name: str = Body(), db: dict = Depends(get_database)):
    db[user_id] = name
    return {"message": "OK"}


@pytest.fixture(autouse=True)
def reset_state_and_db():
    global fake_database
    global state
    fake_database = initial_fake_database.copy()
    state = initial_state.copy()


client = TestClient(app)


def test_dependency_gets_exception():