* </pre>
     * and check if the {@code -T 3} option can be overwritten via command line
     * argument.
     *
     * @throws Exception in case of failure.
     */
    @Test
    void testMVNConfigurationThreadCanBeOverwrittenViaCommandLine() throws Exception {
        System.setProperty(
                MavenCli.MULTIMODULE_PROJECT_DIRECTORY,

  }

  public void testOpenBufferedStream() throws IOException {
    Writer writer = sink.openBufferedStream();
    assertTrue(sink.wasStreamOpened());
    assertFalse(sink.wasStreamClosed());

    writer.write(STRING);
    writer.close();

    assertTrue(sink.wasStreamClosed());
    assertThat(sink.getString()).isEqualTo(STRING);
  }

  public void testWrite_string() throws IOException {

        @Override
        public HashMap getTrustedDomains(NtlmPasswordAuthentication auth) throws SmbAuthException {
            if (disabled || auth.domain == "?")
                return null;
            return super.getTrustedDomains(auth);
        }

        @Override
        public SmbTransport getDc(String domain, NtlmPasswordAuthentication auth) throws SmbAuthException {
            if (disabled)
                return null;

     *
     * @param data the data to compress
     * @param algorithm the compression algorithm to use
     * @return the compressed data
     * @throws CIFSException if compression fails
     */
    byte[] compress(byte[] data, int algorithm) throws CIFSException;

    /**
     * Compresses data using the specified algorithm with offset and length.
     *
     * @param data the data buffer

     * @param url the URL to process
     * @param client the crawler client to use for the request
     * @return the redirect URL if a redirect occurred, null otherwise
     * @throws ChildUrlsException if child URLs are discovered during processing
     * @throws DataStoreCrawlingException if an error occurs during crawling
     */
    protected String processRequest(final DataStoreParams paramMap, final Map<String, Object> dataMap, final String url,

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    counter = new CountingInputStream(new ByteArrayInputStream(new byte[20]));
  }

  public void testReadSingleByte() throws IOException {
    assertEquals(0, counter.getCount());
    assertEquals(0, counter.read());
    assertEquals(1, counter.getCount());
  }

  public void testReadArray() throws IOException {

  }

  @Override
  protected void setUp() throws Exception {
    this.sink = factory.createSink();
  }

  public void testOpenStream() throws IOException {
    Writer writer = sink.openStream();
    try {
      writer.write(data);
    } finally {
      writer.close();
    }

    assertContainsExpectedString();
  }

  public void testOpenBufferedStream() throws IOException {

    private MimeMap mimeMap;

    @BeforeEach
    void setUp() throws IOException {
        mimeMap = new MimeMap();
    }

    @Nested
    @DisplayName("getMimeType with extension only")
    class GetMimeTypeWithExtension {

        @Test
        @DisplayName("Should return correct mime type for known extensions")
        void testKnownExtensions() throws IOException {

 *
 */
public class ShortConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToShort() throws Exception {
        assertEquals(Short.valueOf("1000"), ShortConversionUtil.toShort("1,000"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveShort() throws Exception {
        assertEquals(1000, ShortConversionUtil.toPrimitiveShort("1,000"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetFirstEntry() throws Exception {
        assertThat(list.getFirstEntry(), is(nullValue()));
        list.addFirst("1");
        assertThat(list.getFirstEntry().getElement(), is("1"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetFirst() throws Exception {
        try {