// as per rfc-1320; they are low-order byte first
        context[0] = 0x67452301;
        context[1] = 0xEFCDAB89;
        context[2] = 0x98BADCFE;
        context[3] = 0x10325476;
        count = 0L;
        for (int i = 0; i < BLOCK_LENGTH; i++) {
            buffer[i] = 0;
        }
    }

    /**
     * Continues an MD4 message digest using the input byte.
     */
    @Override

        SmbNegotiationResponse otherNego = mock(SmbNegotiationResponse.class);
        when(transport.getNegotiateResponse()).thenReturn(otherNego);

        assertEquals(0L, handle.getServerTimeZoneOffset());
        assertNull(handle.getOEMDomainName());
    }

    @Test
    @DisplayName("Tree properties delegate: getTreeType/getConnectedShare")
    void treePropertiesDelegate() {

            return "id-" + dataMap.get("url");
        }
    }

    private static class TestSearchLogHelper extends SearchLogHelper {
        int clickCount = 0;
        long favoriteCount = 0L;

        @Override
        public int getClickCount(String url) {
            return clickCount;
        }

        @Override
        public long getFavoriteCount(String url) {

    List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2);
    List<Integer> ints = Arrays.asList(0, 1, 2);
    List<Float> floats = Arrays.asList(0.0f, 1.0f, 2.0f);
    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Bytes.toArray(bytes)).isEqualTo(array);
    assertThat(Bytes.toArray(shorts)).isEqualTo(array);

     * everywhere.
     */
    static final class Sync<V> extends AbstractQueuedSynchronizer {

      private static final long serialVersionUID = 0L;

      /* Valid states. */
      static final int RUNNING = 0;
      static final int COMPLETING = 1;
      static final int COMPLETED = 2;
      static final int CANCELLED = 4;

        // Test reset functionality
        concreteResponse.setMid(789L);
        concreteResponse.setCommand(0x42);
        concreteResponse.setDigest(digest);
        concreteResponse.reset();
        assertEquals(0L, concreteResponse.getMid());
        assertEquals(0, concreteResponse.getCommand());
        assertNull(concreteResponse.getDigest());
        assertNull(concreteResponse.getException());

      headersOf(
        "header-name",
        "header-value",
        "Content-Type",
        "application/octet-stream",
      ),
    )
    val readBuff = Buffer()
    var byteCount = 0L
    while (true) {
      val readByteCount = onlyPart.body.read(readBuff, 1024L)
      if (readByteCount == -1L) break
      byteCount += readByteCount

        // Should throw NullPointerException when reading with null array
        assertThrows(NullPointerException.class, () -> sis.read((byte[]) null));
    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, -1L, -10L })
    @DisplayName("Skip returns 0 for zero or negative values")
    void skipReturnsZeroForNegativeOrZero(long skipBytes) throws IOException {
        // Create message with 5 bytes of data

    }

    @Test
    @DisplayName("Test writeUTime with zero time")
    void testWriteUTimeWithZeroTime() {
        byte[] dst = new byte[4];

        SMB1SigningDigest.writeUTime(mockConfig, 0L, dst, 0);

        assertEquals((byte) 0xFF, dst[0]);
        assertEquals((byte) 0xFF, dst[1]);
        assertEquals((byte) 0xFF, dst[2]);
        assertEquals((byte) 0xFF, dst[3]);
    }

    @Test

          196.0);

  private static final ImmutableList<Long> SIXTEEN_SQUARES_LONGS =
      ImmutableList.of(
          25L, 100L, 0L, 144L, 9L, 121L, 4L, 225L, 169L, 64L, 49L, 16L, 36L, 1L, 81L, 196L);
  private static final ImmutableList<Integer> SIXTEEN_SQUARES_INTEGERS =
      ImmutableList.of(25, 100, 0, 144, 9, 121, 4, 225, 169, 64, 49, 16, 36, 1, 81, 196);