// Then
        assertEquals(6, bytesWritten);
        assertEquals(fid, SMBUtil.readInt2(dst, 0));
        // lastWriteTime is not written if digest is null, so the remaining bytes should be zero
        assertEquals(0, SMBUtil.readInt4(dst, 2));
    }

    /**
     * Test method for {@link jcifs.internal.smb1.com.SmbComClose#writeParameterWordsWireFormat(byte[], int)} with a signing digest.
     */
    @Test

        int actual = findNtStatusOrMinusOne(dosCode);

        // Assert
        assertEquals(expectedNtStatus, actual, "Mapping must match table entry");
    }

    @Test
    @DisplayName("Edge: zero DOS code maps to zero NTSTATUS")
    void zeroCodeMapsToZero() {
        // Act
        int actual = findNtStatusOrMinusOne(0x00000000);

        // Assert
        assertEquals(0x00000000, actual);
    }

      sink.flush()
    }
  }

  /**
   * Tell the peer to stop creating streams and that we last processed `lastGoodStreamId`, or zero
   * if no streams were processed.
   *
   * @param lastGoodStreamId the last stream ID processed, or zero if no streams were processed.
   * @param errorCode reason for closing the connection.
   * @param debugData only valid for HTTP/2; opaque debug data to send.
   */

        assertFalse(boolQueryBuilder.mustNot().isEmpty());
    }

    public void test_execute_withZeroBoost() {
        // Test executing BoostQuery with zero boost value
        Term term = new Term("field", "zero");
        TermQuery termQuery = new TermQuery(term);
        BoostQuery boostQuery = new BoostQuery(termQuery, 0.0f);

        QueryContext context = new QueryContext("test", false);

            // Expected if constructor validates input
            assertTrue(true);
        }
    }

    // Test with different time adjustments
    public void test_withDifferentTimeAdjustments() {
        // Test zero adjustment
        FessConfig zeroConfig = new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override
            public String getTimeAdjustTimeMillis() {

                    @Override
                    public int getStatus() {
                        // RED status should return non-zero status
                        return 2;
                    }
                };
                return response;
            }
        };

        SystemHelper systemHelper = new SystemHelper() {

        System.arraycopy(buffer, 14, encodedName, 0, nameBytes.length);
        assertArrayEquals(nameBytes, encodedName);
    }

    @Test
    @DisplayName("Test zero timeout with timeout specified constructor")
    void testZeroTimeoutWithTimeoutSpecified() {
        // Setup
        String pipeName = "TestPipe";
        long timeout = 0L;

		readsKBPerSec:     "Kilobytes read per second on a drive",
		writesKBPerSec:    "Kilobytes written per second on a drive",
		readsAwait:        "Average time for read requests to be served on a drive",
		writesAwait:       "Average time for write requests to be served on a drive",
		percUtil:          "Percentage of time the disk was busy",
		usedBytes:         "Used bytes on a drive",
		totalBytes:        "Total bytes on a drive",

            synchronized (this) {
                log.debug("Usage dropped to zero, release session");
                if (this.sessionAcquired.compareAndSet(true, false)) {
                    this.session.release();
                }
            }
        } else if (usage < 0) {
            log.error("Usage count dropped below zero " + this);
            dumpResource();

| `minio_node_drive_reads_await`       | Average time for read requests to be served on a drive.  |
| `minio_node_drive_writes_per_sec`    | Writes per second on a drive.                            |
| `minio_node_drive_writes_kb_per_sec` | Kilobytes written per second on a drive.                 |
| `minio_node_drive_writes_await`      | Average time for write requests to be served on a drive. |