throw new SmbException("Buffer access out of bounds");
        }
    }

    /**
     * Safely add integers checking for overflow
     *
     * @param a first value
     * @param b second value
     * @return sum
     * @throws SmbException if overflow would occur
     */
    public int safeAdd(int a, int b) throws SmbException {
        totalValidations.incrementAndGet();

        doc1.put("id", "1");
        builder1.addDocument(doc1);
        builder1.allRecordCount(1L);
        SearchResult result1 = builder1.build();

        // Create second result with two documents using a new builder
        SearchResult.SearchResultBuilder builder2 = SearchResult.create();
        Map<String, Object> doc2a = new HashMap<>();
        doc2a.put("id", "2a");

        assertNotNull(output);
        assertTrue(output.contains("00000:"));
        assertTrue(output.contains("00010:")); // Second line offset

        // Verify first line contains bytes 0-15
        assertTrue(output.contains(" 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F"));
        // Verify second line contains bytes 16-31
        assertTrue(output.contains(" 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F"));
    }

 *
 *     Runtime.getRuntime().addShutdownHook(new Thread() {
 *       public void run() {
 *         // Give the services 5 seconds to stop to ensure that we are responsive to shutdown
 *         // requests.
 *         try {
 *           manager.stopAsync().awaitStopped(5, TimeUnit.SECONDS);
 *         } catch (TimeoutException timeout) {
 *           // stopping timed out
 *         }
 *       }
 *     });

      .isCloseTo(now.toDouble(), deltaMillis)
    assertThat(certificate.notAfter.time.toDouble())
      .isCloseTo(now.toDouble() + durationMillis, deltaMillis)
  }

  @Test
  fun customInterval() {
    // 5 seconds starting on 1970-01-01.
    val heldCertificate =
      HeldCertificate
        .Builder()
        .validityInterval(5000L, 10000L)
        .build()
    val certificate = heldCertificate.certificate

	if w != nil {
		// Increment the prometheus http request response histogram with API, Bucket
		bucketHTTPRequestsDuration.With(prometheus.Labels{
			"api":    api,
			"bucket": bucket,
		}).Observe(w.TTFB().Seconds())
	}

	bh.Lock()
	defer bh.Unlock()

	hstats, ok := bh.httpStats[bucket]
	if !ok {
		hstats = bucketHTTPAPIStats{
			currentS3Requests: &HTTPAPIStats{},
			totalS3Requests:   &HTTPAPIStats{},

        assertEquals(2, bytesWritten, "Should write 2 bytes.");
        assertEquals(SmbComTransaction.TRANS2_QUERY_PATH_INFORMATION, dst[0], "The first byte should be the subCommand.");
        assertEquals((byte) 0x00, dst[1], "The second byte should be 0.");
    }

    /**
     * Tests the writeParametersWireFormat method.
     */
    @Test
    void testWriteParametersWireFormat() {
        // Given

   * {@code key} (or zero, if there is none) is passed as the first argument to {@code
   * accumulatorFunction}, and {@code x} is passed as the second argument.
   *
   * @since 21.0
   */
  @CanIgnoreReturnValue
  public long accumulateAndGet(K key, long x, LongBinaryOperator accumulatorFunction) {
    checkNotNull(accumulatorFunction);

            names.names[0].sid_type = (short) jcifs.SID.SID_TYPE_USER;
            names.names[0].name = new UnicodeString("alice", false);
            names.names[0].sid_index = 0;
            // Second is a domain group
            names.names[1] = new lsarpc.LsarTranslatedName();
            names.names[1].sid_type = (short) jcifs.SID.SID_TYPE_DOM_GRP;
            names.names[1].name = new UnicodeString("Domain Users", false);

            notification.readBytesWireFormat(buffer1, 0);

            // Second read with different values
            byte[] fileId2 = new byte[16];
            Arrays.fill(fileId2, (byte) 0x99);
            byte[] buffer2 = createValidOplockBreakBuffer((byte) 0x08, fileId2);
            notification.readBytesWireFormat(buffer2, 0);

            // Verify second read overwrote first read values