*
 * @throws IOException thrown by <tt>SmbFileInputStream</tt> constructor
 */
    public InputStream getInputStream() throws IOException {
        return new SmbFileInputStream( this );
    }

/**
 * This URLConnection method just returns a new <tt>SmbFileOutputStream</tt> created with this file.
 *
 * @throws IOException thrown by <tt>SmbFileOutputStream</tt> constructor
 */

  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 {

    @Nonnull
    Collection<String> getChecksumAlgorithmNames();

    /**
     * Returns {@link ChecksumAlgorithm} for given algorithm name, or throws if algorithm not supported.
     *
     * @throws ChecksumAlgorithmServiceException if asked algorithm name is not supported.
     * @throws NullPointerException if passed in name is {@code null}.
     */
    @Nonnull
    ChecksumAlgorithm select(@Nonnull String algorithmName);

    /**

 *
 */
public class TokenizerTest {

    /**
     * @throws Exception
     */
    @Test
    public void testEOF() throws Exception {
        final Tokenizer tokenizer = new Tokenizer("");
        assertThat(tokenizer.nextToken(), is(Tokenizer.TT_EOF));
        assertThat(tokenizer.nextToken(), is(Tokenizer.TT_EOF));
    }

    /**
     * @throws Exception
     */
    @Test

     * @param writer a writer object.
     * @param settings a settings object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, Settings settings) throws IOException {
        try {
            delegate.write(writer, settings.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException(e);
        }
    }

    /**
     * Method write.
     *

    /**
     * @throws Exception
     */
    public void testIsPublic() throws Exception {
        final Field f = Hoge.class.getDeclaredField("s");
        assertTrue(ModifierUtil.isPublicStaticFinalField(f));
        final Method m = Hoge.class.getDeclaredMethod("hoge", new Class[] {});
        assertTrue(ModifierUtil.isPublic(m));
    }

    /**
     * @throws Exception
     */

    }
  }

  @Throws(IOException::class)
  fun flush() {
    this.withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

     * @throws ArtifactResolutionException in case of resolution issue
     * @throws ArtifactNotFoundException if an artifact is not found
     */
    Set<Artifact> resolve(MavenProject project, Collection<String> scopesToResolve, MavenSession session)
            throws ArtifactResolutionException, ArtifactNotFoundException;

    /**

  }

  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 {

  }

  @Throws(IOException::class)
  @JvmOverloads
  fun start(port: Int = 0) {
    started = true
    delegate.start(port)
  }

  @Throws(IOException::class)
  fun start(
    inetAddress: InetAddress,
    port: Int,
  ) {
    started = true
    delegate.start(inetAddress, port)
  }

  @Synchronized
  @Throws(IOException::class)
  fun shutdown() {