private int inLen;

    /**
     * Creates a new MimeMap instance by loading MIME type mappings from the resource file.
     *
     * @throws IOException if there is an error reading the mime.map resource file
     */
    public MimeMap() throws IOException {
        int n;

        in = new byte[IN_SIZE];
        final InputStream is = getClass().getClassLoader().getResourceAsStream("jcifs/smb1/util/mime.map");

         * @throws IllegalArgumentException If the arguments are invalid
         * @throws InsufficientDataException If insufficient data is available
         * @throws InternalException If an internal error occurs
         * @throws InvalidResponseException If the response is invalid
         * @throws NoSuchAlgorithmException If the algorithm is not available
         * @throws XmlParserException If XML parsing fails

    }

    @Test
    void testConstructor() throws SmbException {
        assertNotNull(smbRandomAccessFile);
        assertEquals(0, smbRandomAccessFile.getFilePointer());
    }

    @Test
    void testGetFilePointer() throws SmbException {
        assertEquals(0, smbRandomAccessFile.getFilePointer());
    }

    @Test
    void testSeek() throws SmbException {
        long newPosition = 100L;

        verifyNoMoreInteractions(smbFile);
    }

    @Test
    @DisplayName("accept: propagates SmbException thrown by dependency")
    void accept_propagatesSmbException() throws Exception {
        // Arrange: filter delegates to isDirectory which may throw SmbException
        SmbFileFilter filter = f -> f.isDirectory();
        SmbException boom = new SmbException("io error");

     *
     * @throws IOException if an I/O error occurs (not thrown in this implementation)
     */
    @Override
    public void close() throws IOException {
        // inputStream.close();
    }

    /**
     * Returns the number of bytes that can be read from this input stream without blocking.
     *
     * @return the number of bytes available
     * @throws IOException if an I/O error occurs
     */

     */
    @Override
    public int read() throws IOException {
        return fileInputStream.read();
    }

    @Override
    public int available() throws IOException {
        return fileInputStream.available();
    }

    /**
     * Closes this input stream and releases any system resources associated with the stream.
     * @throws IOException if an I/O error occurs.
     */
    @Override

  public void testScanFromFile_notJarFile() throws IOException {
    ClassLoader classLoader = ClassPathTest.class.getClassLoader();
    File notJar = File.createTempFile("not_a_jar", "txt");
    try {
      assertThat(new ClassPath.LocationInfo(notJar, classLoader).scanResources()).isEmpty();
    } finally {
      notJar.delete();
    }
  }

  public void testGetClassPathEntry() throws MalformedURLException, URISyntaxException {

   *
   * <p>This implementation is guaranteed to throw an {@link UnsupportedOperationException}.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final @Nullable Entry<E> pollFirstEntry() {
    throw new UnsupportedOperationException();
  }

  /**

  final ImmutableSet<V> createValues() {
    throw new AssertionError("should never be called");
  }

  /**
   * Guaranteed to throw an exception and leave the bimap unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")

  }

  public void testSuccessful() throws Exception {
    assertThat(future.set(1)).isTrue();
    assertSuccessful(future, 1);
  }

  public void testFailed() throws Exception {
    Exception cause = new Exception();
    assertThat(future.setException(cause)).isTrue();
    assertFailed(future, cause);
  }

  public void testCanceled() throws Exception {