@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListMultimapEqualsTester<K, V> extends AbstractListMultimapTester<K, V> {
  @CollectionSize.Require(SEVERAL)
  public void testOrderingAffectsEqualsComparisons() {
    ListMultimap<K, V> multimap1 =
        getSubjectGenerator()
            .create(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k0(), v0()));
    ListMultimap<K, V> multimap2 =

import java.io.OutputStream;

class SocketOutputStream extends FilterOutputStream {

    SocketOutputStream(final OutputStream out) {
        super(out);
    }

    @Override
    public synchronized void write(final byte[] b, int off, final int len) throws IOException {
        if (len > 0xFFFF) {
            throw new IOException("write too large: " + len);
        }
        if (off < 4) {

 */
public class AccumulatingLogger implements Logger {
    private final AtomicReference<List<Entry>> entries = new AtomicReference<>(new CopyOnWriteArrayList<>());

    @Override
    public void log(Level level, String message, Throwable error) {
        requireNonNull(level, "level");
        requireNonNull(message, "message");
        entries.get().add(new Entry(level, message, error));
    }

    @Override

     * @return the encoding
     */
    public String getEncoding() {
        return encoding;
    }

    /**
     * Sets the encoding.
     * @param encoding The encoding to set.
     */
    public void setEncoding(final String encoding) {
        this.encoding = encoding;
    }

    private SSLSocketFactory sslSocketFactory;

    private NodeManager nodeManager;

    /**
     * Initializes the CurlHelper with SSL configuration and node manager.
     */
    @PostConstruct
    public void init() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final String authorities = fessConfig.getFesenHttpSslCertificateAuthorities();
        if (StringUtil.isNotBlank(authorities)) {

    public KatakanaConverter(final TokenizerFactory tokenizerFactory) {
        if (isEnableTokenizer(tokenizerFactory)) {
            this.tokenizerFactory = tokenizerFactory;
        }
    }

    @Override
    public void init() throws IOException {
        /*
         * TODO if (initialized) { return; }
         *
         * if (tokenizerFactory == null) { final String path = System.getProperty(SuggestConstants.USER_DICT_PATH);

        if (lastModified != time) {
            return true;
        }

        return false;
    }

    public SynonymMap getSynonymMap() {
        return synonymMap;
    }

    protected void createSynonymMap(final boolean reload) {
        try (Reader rulesReader = getReader(reload)) {
            if (rulesReader instanceof StringReader && ((StringReader) rulesReader).toString().length() == 0) {

    return backingIterator.hasNext();
  }

  @Override
  @ParametricNullness
  public final T next() {
    return transform(backingIterator.next());
  }

  @Override
  public final void remove() {
    backingIterator.remove();
  }

import java.util.Arrays;
import java.util.List;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 */
class FilterHashEqualsTest {

    @Test
    void testIncludesExcludesArtifactFilter() {
        List<String> patterns = Arrays.asList("c", "d", "e");

        IncludesArtifactFilter f1 = new IncludesArtifactFilter(patterns);

/**
 * Tests {@link OrArtifactFilter}.
 *
 */
@Deprecated
class OrArtifactFilterTest {

    private ArtifactFilter newSubFilter() {
        return artifact -> false;
    }

    @Test
    void testEquals() {
        OrArtifactFilter filter1 = new OrArtifactFilter();

        OrArtifactFilter filter2 = new OrArtifactFilter(Arrays.asList(newSubFilter()));

        assertFalse(filter1.equals(null));