int writtenFid = SMBUtil.readInt2(dst, 2);
        assertEquals(largeFid, writtenFid);
    }

    @Test
    @DisplayName("Test boundary condition with buffer size equal to data length minus one")
    void testBoundaryBufferSize() {
        // Arrange
        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, TEST_DATA, TEST_OFFSET, TEST_LENGTH);

  /**
   * Returns the result of subtracting this and {@code val}. If the result would have more than 64
   * bits, returns the low 64 bits of the result.
   *
   * @since 14.0
   */
  public UnsignedLong minus(UnsignedLong val) {
    return fromLongBits(this.value - checkNotNull(val).value);
  }

  /**
   * Returns the result of multiplying this and {@code val}. If the result would have more than 64

              <!-- Keep these timeouts very large because, if we hit the timeout, the tests silently pass :( -->
              <testTimeOut>86400 <!-- seconds --></testTimeOut>
              <testMethodTimeout>1440 <!-- minutes --></testMethodTimeout>
              <!-- Presumably we want watchFileChanges=false here, since we want it for compile: -->
              <extraJvmArgs>-Dgwt.watchFileChanges=false</extraJvmArgs>
            </configuration>

            byte[] outputBytes, int ioctlFlags) {
        final int headerLen = 64; // SMB2 header is 64 bytes
        final int bodyFixed = 48; // body size minus 1 for structure size field overlap
        final int payloadStart = headerLen + bodyFixed;
        final int bodyLen = bodyFixed + inputCount + outputCount;

        byte[] buf = new byte[bodyLen];
        int pos = 0;

        testBoundaryValue(1L);
        testBoundaryValue(-1L);

        // Test one second boundaries
        testBoundaryValue(1000L);
        testBoundaryValue(-1000L);

        // Test one minute boundaries
        testBoundaryValue(60000L);
        testBoundaryValue(-60000L);

        // Test one hour boundaries
        testBoundaryValue(3600000L);
        testBoundaryValue(-3600000L);

- Reduce default NodeStatusReportFrequency to 5 minutes. With this change, periodic node status updates will be send every 5m if node status doesn't change (otherwise they are still send with 10s).

  Bump NodeProblemDetector version to v0.8.0 to reduce forced NodeStatus updates frequency to 5 minutes. ([#84007](https://github.com/kubernetes/kubernetes/pull/84007), [@wojtek-t](https://github.com/wojtek-t))

     *
     * @return maximum number of retries for netbios requests
     */
    int getNetbiosRetryCount();

    /**
     *
     *
     * Property {@code jcifs.netbios.cachePolicy} in minutes (int, default 600)
     *
     * @return netbios cache timeout, in seconds, 0 - disable caching, -1 - cache forever
     */
    int getNetbiosCachePolicy();

    /**

          // The possible number of two byte characters
          TWO_BYTE_ROUNDTRIPPABLE_CHARACTERS;

  // 2048
  private static final long THREE_BYTE_SURROGATES = 2 * 1024;

  // 61,440 [chars 0x0800 to 0xFFFF, minus surrogates]
  private static final long THREE_BYTE_ROUNDTRIPPABLE_CHARACTERS =
      0xFFFF - 0x0800 + 1 - THREE_BYTE_SURROGATES;

  // 2,650,112
  private static final long EXPECTED_THREE_BYTE_ROUNDTRIPPABLE_COUNT =

        if (effect.shutdownOutput) socket.shutdownOutput()
        if (effect.closeSocket) socket.close()
      }

      Stall -> {
        // Sleep until the socket is closed.
        socket.sleepWhileOpen(TimeUnit.MINUTES.toNanos(60))
        error("expected timeout")
      }
    }

    return true
  }

  @Throws(IOException::class)
  private fun readEmptyLine(source: BufferedSource) {

    private volatile boolean skipMaskingForDebugLevel = false;

    // Rate limiting
    private final Map<String, AtomicLong> rateLimitCounters = new ConcurrentHashMap<>();
    private volatile long rateLimitWindow = 60000; // 1 minute
    private volatile int maxEventsPerWindow = 10000; // Increased for tests

    /**
     * Security event types
     */
    public enum EventType {