}

    @Override
    public int hashCode() {
      return value.hashCode();
    }
  }

  /**
   * LocalManualCache is a wrapper around LocalCache for a cache without loading.
   *
   * @param <K> the base key type
   * @param <V> the base value type
   */
  public static class LocalManualCache<K, V> extends AbstractCache<K, V> {
    final LocalCache<K, V> localCache;

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.lease;

/**
 * Defines directory lease state constants for SMB2/SMB3 directory leasing.
 *
 * This class provides constants and utility methods for managing directory lease states
 * in SMB2/SMB3 protocol implementations. Directory leases enable clients to cache

     *
     * @param responseData the response data containing the response body
     * @return a temporary file containing the response body
     * @throws CrawlingAccessException if an error occurs while reading the response body
     */
    public static File createResponseBodyFile(final ResponseData responseData) {
        File tempFile = null;
        FileOutputStream fos = null;

import okio.ByteString.Companion.encodeUtf8

object Http2 {
  @JvmField
  val CONNECTION_PREFACE = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".encodeUtf8()

  /** The initial max frame size, applied independently writing to, or reading from the peer. */
  const val INITIAL_MAX_FRAME_SIZE = 0x4000 // 16384

  const val TYPE_DATA = 0x0
  const val TYPE_HEADERS = 0x1
  const val TYPE_PRIORITY = 0x2
  const val TYPE_RST_STREAM = 0x3

  /**
   * Writes all the bytes from the given {@code InputStream} to this sink. Does not close {@code
   * input}.
   *
   * @return the number of bytes written
   * @throws IOException if an I/O occurs while reading from {@code input} or writing to this sink
   */
  @CanIgnoreReturnValue
  public long writeFrom(InputStream input) throws IOException {
    checkNotNull(input);

    try (OutputStream out = openStream()) {

  /**
   * Writes all the bytes from the given {@code InputStream} to this sink. Does not close {@code
   * input}.
   *
   * @return the number of bytes written
   * @throws IOException if an I/O occurs while reading from {@code input} or writing to this sink
   */
  @CanIgnoreReturnValue
  public long writeFrom(InputStream input) throws IOException {
    checkNotNull(input);

    try (OutputStream out = openStream()) {

        int n = readn(in, buffer, bufferIndex, HEADER_LENGTH);
        if (n != HEADER_LENGTH) {
            if (n == -1) {
                return -1;
            }
            throw new IOException("unexpected EOF reading netbios session header");
        }
        return buffer[bufferIndex] & 0xFF;
    }

    int type, length;

    /**
     * Writes the packet to the specified byte array in wire format.
     *

     */
    int TYPE_COMM = 0x40;

    /* open flags */

    /**
     * Open for reading only.
     */
    int O_RDONLY = 0x01;
    /**
     * Open for writing only.
     */
    int O_WRONLY = 0x02;
    /**
     * Open for reading and writing.
     */
    int O_RDWR = 0x03;
    /**
     * Open in append mode.
     */
    int O_APPEND = 0x04;

        IOException exception = assertThrows(IOException.class, () -> {
            SessionServicePacket.readPacketType(bais, buffer, 0);
        });

        assertEquals("unexpected EOF reading netbios session header", exception.getMessage());
    }

    @Test
    @DisplayName("readPacketType should throw IOException on incomplete header")
    void testReadPacketTypeIncompleteHeader() {

   */
  public static Ticker systemTicker() {
    return SYSTEM_TICKER;
  }

  private static final Ticker SYSTEM_TICKER =
      new Ticker() {
        @Override
        @SuppressWarnings("GoodTime") // reading system time without TimeSource
        public long read() {
          return System.nanoTime();
        }
      };