Request.Builder()
        .url("https://square.com")
        .tag("a" as Any)
        .tag(null)
        .build()
    assertThat(request.tag<Any>()).isNull()
  }

  @Test
  fun removeAbsentTag() {
    val request =
      Request.Builder()
        .url("https://square.com")
        .tag(null)
        .build()
    assertThat(request.tag<String>()).isNull()
  }

  @Test

     *
     * @param node1 the first artifact declaration
     * @param node2 the second artifact declaration
     * @return the artifact declaration to use: <code>node1</code>; <code>node2</code>; or <code>null</code>if
     *         this conflict cannot be resolved
     * @since 3.0
     */
    ResolutionNode resolveConflict(ResolutionNode node1, ResolutionNode node2);

class DefaultProblemCollector implements ProblemCollector {

    private final List<Problem> problems;

    private String source;

    DefaultProblemCollector(List<Problem> problems) {
        this.problems = (problems != null) ? problems : new ArrayList<>();
    }

    @Override
    public List<Problem> getProblems() {
        return problems;
    }

    @Override
    public void setSource(String source) {

        this.packaging = requireNonNull(packaging);
    }

    @Override
    public String getClassifier() {
        return classifier;
    }

    @Override
    public String getDirectory() {
        return null;
    }

    @Override
    public String getExtension() {
        return extension;
    }

    @Override
    public String getLanguage() {
        return "none";
    }

    @Override

        final OptionalThing<FessUserBean> userBean = getUserBean();
        activityHelper.logout(userBean);
        final String redirectUrl = userBean.map(user -> ComponentUtil.getSsoManager().logout(user)).orElse(null);
        fessLoginAssist.logout();
        userInfoHelper.deleteUserCodeFromCookie(request);
        if (StringUtil.isNotBlank(redirectUrl)) {
            return HtmlResponse.fromRedirectPathAsIs(redirectUrl);
        }

        this.pattern = Pattern.compile(pattern);
    }

    public DictionaryFile<? extends DictionaryItem> create(final String path, final Date timestamp) {
        if (!isTarget(path)) {
            return null;
        }

        return newDictionaryFile(encodePath(path), path, timestamp);
    }

    protected String encodePath(final String path) {

    public void setUp() throws Exception {
        super.setUp();
        groovyEngine = new GroovyEngine();
    }

    @Override
    public void tearDown() throws Exception {
        ComponentUtil.setFessConfig(null);
        super.tearDown();
    }

    public void test_evaluate() {
        final Map<String, Object> params = new HashMap<>();
        assertNull(groovyEngine.evaluate("", params));

import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.annotation.Nonnull;
import javax.annotation.meta.TypeQualifierDefault;

/**
 * Marks all "top-level" types as non-null in a way that is recognized by Kotlin. Note that this
 * unfortunately includes type-variable usages, so we also provide {@link ParametricNullness} to
 * "undo" it as best we can.
 */
@GwtCompatible
@Retention(RUNTIME)

import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.annotation.Nonnull;
import javax.annotation.meta.TypeQualifierDefault;

/**
 * Marks all "top-level" types as non-null in a way that is recognized by Kotlin. Note that this
 * unfortunately includes type-variable usages, so we also provide {@link ParametricNullness} to
 * "undo" it as best we can.
 */
@GwtCompatible
@Retention(RUNTIME)

import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.annotation.Nonnull;
import javax.annotation.meta.TypeQualifierDefault;

/**
 * Marks all "top-level" types as non-null in a way that is recognized by Kotlin. Note that this
 * unfortunately includes type-variable usages, so we also provide {@link ParametricNullness} to
 * "undo" it as best we can.
 */
@GwtCompatible
@Retention(RUNTIME)