package dsync

import (
	"math/rand"
	"sync"
)

// lockedRandSource provides protected rand source, implements rand.Source interface.
type lockedRandSource struct {
	lk  sync.Mutex
	src rand.Source
}

// Int63 returns a non-negative pseudo-random 63-bit integer as an int64.
func (r *lockedRandSource) Int63() (n int64) {
	r.lk.Lock()
	n = r.src.Int63()

        socket.sink.buffer().use { sink ->
          socket.source.buffer().use { source ->
            sink.writeUtf8("client says hello\n")
            sink.flush()

            assertThat(source.readUtf8Line()).isEqualTo("server says hello")

            sink.writeUtf8("client says goodbye\n")
            sink.flush()

            assertThat(source.readUtf8Line()).isEqualTo("server says goodbye")

  val onException: (IOException) -> Unit,
) : ForwardingSink(delegate) {
  private var hasErrors = false

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (hasErrors) {
      source.skip(byteCount)
      return
    }
    try {
      super.write(source, byteCount)
    } catch (e: IOException) {
      hasErrors = true
      onException(e)
    }
  }

  override fun flush() {

 */
class HeadersReader(
  val source: BufferedSource,
) {
  private var headerLimit = HEADER_LIMIT.toLong()

  /** Read a single line counted against the header size limit. */
  fun readLine(): String {
    val line = source.readUtf8LineStrict(headerLimit)
    headerLimit -= line.length.toLong()
    return line
  }

      )
    stream.writeHeaders(
      responseHeaders = responseHeaders,
      outFinished = false,
      flushHeaders = false,
    )
    file.source().use { source ->
      stream.sink.buffer().use { sink ->
        sink.writeAll(source)
      }
    }
  }

  private fun contentType(file: File): String =
    when {
      file.name.endsWith(".css") -> "text/css"

import java.util.Objects;

/**
 * Wraps an ordinary {@link URL} as a source.
 *
 * @deprecated since 4.0.0, use {@link org.apache.maven.api.services} instead
 */
@Deprecated(since = "4.0.0")
public class UrlSource implements Source {

    private final URL url;

    private final int hashCode;

    /**
     * Creates a new source backed by the specified URL.
     *

				if rv.Len() > 0 {
					association.Error = association.Relationship.Field.Set(association.DB.Statement.Context, source, rv.Index(0).Addr().Interface())

					if association.Relationship.Field.FieldType.Kind() == reflect.Struct {
						assignBacks = append(assignBacks, assignBack{Source: source, Dest: rv.Index(0)})
					}
				}
			case reflect.Struct:
				if !rv.CanAddr() {
					association.Error = ErrInvalidValue

        with:
          python-version: "3.10"
      - name: Install build dependencies
        run: pip install build
      - name: Build source distribution
        env:
          TIANGOLO_BUILD_PACKAGE: ${{ matrix.package }}
        run: python -m build --sdist
      - name: Decompress source distribution
        run: |
          cd dist
          tar xvf fastapi*.tar.gz
      - name: Install test dependencies
        run: |

        try {
            final RESULT result = entityType.newInstance();
            result.setCrawlingInfoId(DfTypeUtil.toString(source.get("crawlingInfoId")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setKey(DfTypeUtil.toString(source.get("key")));

        private final boolean global;
        private final Artifact source;
        private final Artifact target;

        private Relocation(boolean global, Artifact source, Artifact target) {
            this.predicate = artifactPredicate(source);
            this.global = global;
            this.source = source;
            this.target = target;
        }

        @Override