ListMultimap<K, V> multimap2 =
        getSubjectGenerator()
            .create(mapEntry(k0(), v1()), mapEntry(k0(), v0()), mapEntry(k0(), v0()));
    new EqualsTester().addEqualityGroup(multimap1).addEqualityGroup(multimap2).testEquals();
  }

 *     from Guava.)
 */
@Deprecated
@GwtCompatible
public class ComputationException extends RuntimeException {
  /** Creates a new instance with the given cause. */
  public ComputationException(@Nullable Throwable cause) {
    super(cause);
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

        dumpResponse(context, "", secDispatcher.validateConfiguration());
        return OK;
    }

    @Override
    protected int doExecute(EncryptContext context) throws Exception {
        throw new IllegalStateException("Cannot reach here");
    }

| <<<par>>> *           |               | <= type>   | java      |                       | <<<true>>>            |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+

     */
    public DefaultToolchainsBuildingResult(PersistedToolchains effectiveToolchains, List<Problem> problems) {
        this.effectiveToolchains = effectiveToolchains;
        this.problems = (problems != null) ? problems : new ArrayList<>();
    }

    @Override
    public PersistedToolchains getEffectiveToolchains() {
        return effectiveToolchains;
    }

    @Override
    public List<Problem> getProblems() {

import org.apache.maven.execution.ProjectExecutionListener;

@Named
@Singleton
public class DelegatingProjectExecutionListener implements ProjectExecutionListener {
    private final List<ProjectExecutionListener> listeners = new CopyOnWriteArrayList<>();

    @Override
    public void beforeProjectExecution(ProjectExecutionEvent event) throws LifecycleExecutionException {
        for (ProjectExecutionListener listener : listeners) {

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

/**
 */
class PhaseRecorderTest {
    @Test
    void testObserveExecution() throws Exception {
        PhaseRecorder phaseRecorder = new PhaseRecorder(ProjectDependencyGraphStub.A);
        MavenExecutionPlan plan = LifecycleExecutionPlanCalculatorStub.getProjectAExecutionPlan();
        final List<MojoExecution> executions = plan.getMojoExecutions();

    }

    MethodDoc forClass(ClassDoc referringClass) {
        def refererMetaData = referringClass.classMetaData
        if (refererMetaData == this.referringClass) {
            return this
        }
        return new MethodDoc(refererMetaData, metaData, comment)
    }

    String getId() {
        return id
    }

    String getName() {
        return metaData.name
    }

    MethodMetaData getMetaData() {

    //                                                                           Singleton
    //                                                                           =========
    private static final BadWordDbm _instance = new BadWordDbm();

    private BadWordDbm() {
    }

    public static BadWordDbm getInstance() {
        return _instance;
    }

    //                                                                           Singleton
    //                                                                           =========
    private static final BoostDocumentRuleDbm _instance = new BoostDocumentRuleDbm();

    private BoostDocumentRuleDbm() {
    }

    public static BoostDocumentRuleDbm getInstance() {
        return _instance;
    }