}

    public void test_builder() {
        assertEquals("test", extractorFactory.builder(new ByteArrayInputStream("test".getBytes()), null).extract().getContent());
        assertEquals("test",
                extractorFactory.builder(new ByteArrayInputStream("test".getBytes()), null).filename("test.txt").extract().getContent());
    }

    public void test_addExtractor_weight() {
        final String key = "application/test";

        return false;
    }

    private TokenStream createTokenStream(final Reader rd) {
        return null;
        /*
         * TODO if (tokenizerFactory instanceof JapaneseTokenizerFactory) { return tokenizerFactory.create(); } else {
         * return null; }
         */
    }

    /**
     * Gets the reading from the attribute.
     * @param stream The token stream.

        final SmbTree tree = SmbTransport.getSmbTransport(dc, port).getSmbSession(auth).getSmbTree(LOGON_SHARE, null);
        if (LOGON_SHARE == null) {
            tree.treeConnect(null, null);
        } else {
            final Trans2FindFirst2 req = new Trans2FindFirst2("\\", "*", SmbFile.ATTR_DIRECTORY);

                artifacts, projectArtifact.artifact, null, null, null, source, filter, Collections.emptyList(), null);
    }

    private ArtifactResolutionResult collect(ArtifactSpec a) throws ArtifactResolutionException {
        return artifactCollector.collect(
                Collections.singleton(a.artifact),
                projectArtifact.artifact,
                null,
                null,
                null,

class ProblemCollectorFactoryTest {

    @Test
    void testNewInstance() {
        ProblemCollector collector1 = ProblemCollectorFactory.newInstance(null);

        Problem problem = new DefaultProblem("MESSAGE1", null, null, -1, -1, null);
        ProblemCollector collector2 = ProblemCollectorFactory.newInstance(Collections.singletonList(problem));

        assertNotSame(collector1, collector2);

      newDelegate.add(element(i));
    }
    this.table = newDelegate;
    this.entries = null;
    this.elements = null;
    incrementModCount();
    return newDelegate;
  }

  @VisibleForTesting
  boolean isUsingHashFloodingResistance() {
    return delegateOrNull() != null;
  }

  /** Stores the hash table mask as the number of bits needed to represent an index. */

   *
   * @return {@code first} if it is non-null; otherwise {@code second} if it is non-null
   * @throws NullPointerException if both {@code first} and {@code second} are null
   * @since 18.0 (since 3.0 as {@code Objects.firstNonNull()}).
   */
  public static <T> T firstNonNull(@Nullable T first, @Nullable T second) {
    if (first != null) {
      return first;
    }
    if (second != null) {
      return second;
    }

                    isInit.set(true);
                }
            }
        }

        // start
        AccessTimeoutTarget accessTimeoutTarget = null;
        TimeoutTask accessTimeoutTask = null;
        if (accessTimeout != null) {
            accessTimeoutTarget = new AccessTimeoutTarget(Thread.currentThread());

            final String filename = getDecodeText(bodyPart.getFileName());
            final String mimeType = mimeTypeHelper.getContentType(null, filename);
            if (mimeType != null) {
                final Extractor extractor = extractorFactory.getExtractor(mimeType);
                if (extractor != null) {
                    try (final InputStream in = bodyPart.getInputStream()) {

  /**
   * Creates a new instance with {@code null} as its detail message and no cause.
   *
   * @deprecated Prefer {@linkplain UncheckedExecutionException(Throwable)} a constructor that
   *     accepts a cause: Users of this class typically expect for instances to have a non-null
   *     cause. At the moment, you can <i>usually</i> still preserve behavior by passing an explicit