import org.codelibs.fess.helper.PluginHelper.ArtifactType;
import org.codelibs.fess.unit.UnitFessTestCase;
import org.lastaflute.di.exception.IORuntimeException;

public class PluginHelperTest extends UnitFessTestCase {
    private PluginHelper pluginHelper;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        pluginHelper = new PluginHelper() {

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@IgnoreJRERequirement // We opt into library desugaring for our tests.
public class MapComputeIfPresentTester<K, V> extends AbstractMapTester<K, V> {

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfPresent_supportedAbsent() {
    assertNull(
        "computeIfPresent(notPresent, function) should return null",
        getMap()

import junit.framework.TestCase;

/** Tests for {@link AbstractFuture} with the cancellation cause system property set */
@AndroidIncompatible // custom classloading

public class AbstractFutureCancellationCauseTest extends TestCase {

  private ClassLoader oldClassLoader;
  private URLClassLoader classReloader;
  private Class<?> settableFutureClass;
  private Class<?> abstractFutureClass;

  @Override

 * writeReplace} when serializing an instance of the subclass. For an example of this problem, see
 * b/310253115.
 */
public class WriteReplaceOverridesTest extends TestCase {
  private static final ImmutableSet<String> GUAVA_PACKAGES =
      FluentIterable.of(
              "base",
              "cache",
              "collect",
              "escape",
              "eventbus",

        Query parse(final String query, final FilterChain chain);
    }

    public interface FilterChain {
        Query parse(final String query);
    }

    protected static class LuceneQueryParser extends org.apache.lucene.queryparser.classic.QueryParser {

        private final String defaultField;

        /**
         * Creates a new {@link ExtendableQueryParser} instance
         *

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package gradlebuild.docs.dsl.docbook

import spock.lang.Specification

class BasicJavadocLexerTest extends Specification {
    final BasicJavadocLexer lexer = new BasicJavadocLexer(new JavadocScanner(""))
    final visitor = Mock(JavadocLexer.TokenVisitor)

    def parsesHtmlElements() {
        when:

import org.codelibs.fess.crawler.rule.Rule;
import org.codelibs.fess.crawler.rule.RuleManager;
import org.dbflute.utflute.core.PlainTestCase;

/**
 * @author shinsuke
 *
 */
public class RuleManagerImplTest extends PlainTestCase {
    public RuleManager ruleManager;

    @Override
    protected void setUp() throws Exception {
        super.setUp();

import org.codelibs.fess.helper.SystemHelper;
import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.unit.UnitFessTestCase;
import org.codelibs.fess.util.ComponentUtil;

public class LdapManagerTest extends UnitFessTestCase {

    @Override
    public void setUp() throws Exception {
        super.setUp();
        ComponentUtil.register(new SystemHelper(), "systemHelper");
    }

    @SuppressWarnings("serial")

import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;
import org.opensearch.index.query.RangeQueryBuilder;

public class TermRangeQueryCommand extends QueryCommand {
    private static final Logger logger = LogManager.getLogger(TermRangeQueryCommand.class);

    @Override
    protected String getQueryClassName() {
        return TermRangeQuery.class.getSimpleName();

import com.google.common.testing.FakeTicker;
import junit.framework.TestCase;

/**
 * Tests relating to automatic cache refreshing.
 *
 * @author Charles Fry
 */
public class CacheRefreshTest extends TestCase {
  public void testAutoRefresh() {
    FakeTicker ticker = new FakeTicker();
    IncrementingLoader loader = incrementingLoader();
    LoadingCache<Integer, Integer> cache =
        CacheBuilder.newBuilder()