if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER &&
      (entry == null || entry.sequenceNumber != expectedSequenceNumber)
    ) {
      return null // Snapshot is stale.
    }

    if (entry?.currentEditor != null) {
      return null // Another edit is in progress.
    }

    if (entry != null && entry.lockingSourceCount != 0) {
      return null // We can't write this file because a reader is still reading it.
    }

                .let(providers::fileContents)
                .asText
        }
    }


fun isRunningInstallTask() =
    listOf("install", "installAll")
        .flatMap { listOf(":distributions-full:$it", "distributions-full:$it", it) }
        .any(gradle.startParameter.taskNames::contains)

fun isRunningDocsTestTask() =
    setOf(":docs:docsTest", "docs:docsTest")
        .any(gradle.startParameter.taskNames::contains)

   * find it when available. When this is null, use the slow way.
   */
  @J2ktIncompatible @GwtIncompatible // java.lang.reflect
  private static final @Nullable Method getStackTraceElementMethod =
      (jla == null) ? null : getGetMethod();

  /**
   * The "getStackTraceDepth" method, only available on some JDKs so we use reflection to find it
   * when available. When this is null, use the slow way.
   */

  private var constructed = false

  private var peekedHeader: DerHeader? = null

  private val bytesLeft: Long
    get() = if (limit == -1L) -1L else (limit - byteCount)

  fun hasNext(): Boolean = peekHeader() != null

  /**
   * Returns the next header to process unless this scope is exhausted.
   *
   * This returns null if:
   *
   *  * The stream is exhausted.

  /** The low-level TCP socket. */
  private var rawSocket: JavaNetSocket? = null

  /**
   * The application layer socket. Either an [SSLSocket] layered over [rawSocket], or [rawSocket]
   * itself if this connection does not use SSL.
   */
  internal var javaNetSocket: JavaNetSocket? = null
  private var handshake: Handshake? = null
  private var protocol: Protocol? = null
  private lateinit var socket: BufferedSocket

            user = userInfo.substring(u, i);
        }

        this.domain = dom != null ? dom : defDomain != null ? defDomain : "";
        this.username = user != null ? user : defUser != null ? defUser : "";
        this.password = pass != null ? pass.toCharArray() : defPassword != null ? defPassword.toCharArray() : new char[0];

        if (type == null) {
            this.type = guessAuthenticationType();
        } else {

    @DisplayName("Should handle context with null values")
    void testNullContext() {
        // When
        exception = new SmbOperationException(SmbOperationException.ErrorCode.UNKNOWN_ERROR, "Something went wrong", null, null, null);

        // Then
        assertNotNull(exception.getContext());
        assertTrue(exception.getContext().isEmpty());

        // Adding null context should be safe

    internal var request: Request? = null
    internal var protocol: Protocol? = null
    internal var code = -1
    internal var message: String? = null
    internal var handshake: Handshake? = null
    internal var headers: Headers.Builder
    internal var body: ResponseBody = ResponseBody.EMPTY
    internal var socket: Socket? = null
    internal var networkResponse: Response? = null

        });
    }

    @Test
    public void testValidString() throws Exception {
        validator.validateString("normal string", 100, "test");
        validator.validateString(null, 100, "test"); // Null should be allowed
        // Should pass without exception
    }

    @Test
    public void testStringTooLong() throws Exception {
        String longString = "a".repeat(300);

        if (protocol == null || address == null) {
            return null;
        }
        final String host = getUrlHost(address);
        final StringBuilder url = new StringBuilder();
        url.append(protocol).append("://").append(host);
        if (port > 0) {
            url.append(":").append(port);
        }
        if (path != null && !path.isEmpty()) {