org.codehaus.plexus.configuration.PlexusConfiguration failedConfiguration; public void ComponentConfigurati(String); public void ComponentConfigurati(String, Throwable); public void ComponentConfigurati(Throwable); public void ComponentConfigurati(org.codehaus.plexus.configuration.PlexusConfiguration, String); public void ComponentConfigurati(org.codehaus.plexus.configuration.PlexusConfiguration, String, Throwable); public void ComponentConfigurati(org.codehaus.plexus.configuration.PlexusConfiguration,...

            opLambda.callback(builder);
        }
    }

    public void setCreatedAt_DateRange() {
        setCreatedAt_DateRange(null);
    }

    public void setCreatedAt_DateRange(ConditionOptionCall<DateRangeAggregationBuilder> opLambda) {
        setCreatedAt_DateRange("createdAt", opLambda, null);
    }

    public void setCreatedAt_DateRange(ConditionOptionCall<DateRangeAggregationBuilder> opLambda,

@GwtCompatible
public class MathPreconditionsTest extends TestCase {

  public void testCheckPositive_zeroInt() {
    try {
      MathPreconditions.checkPositive("int", 0);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCheckPositive_maxInt() {
    MathPreconditions.checkPositive("int", Integer.MAX_VALUE);
  }

  public void testCheckPositive_minInt() {
    try {

    assertStillOpen(closeable1);
  }

  public void testFrom_failedInput() throws Exception {
    assertFinallyFailsWithException(failedClosingFuture());
  }

  public void testFrom_cancelledInput() throws Exception {
    assertBecomesCanceled(ClosingFuture.from(immediateCancelledFuture()));
  }

  public void testEventuallyClosing() throws Exception {
    ClosingFuture<String> closingFuture =

  public class MultipleCandidates {
    @Test
    public void testAllFilesPresentInMultipleCandidates() {
      KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates"), Pattern.compile("^(.+)\\.kt$"), null, true);
    }

    @Test
    @TestMetadata("ambiguous.kt")
    public void testAmbiguous() {

      return null;
    }
  }

  public void testGoodEquals() throws Exception {
    tester.testEquals(GoodEquals.class);
  }

  public void testEquals_interface() {
    tester.testEquals(AnInterface.class);
  }

  public void testEquals_abstractClass() {
    tester.testEquals(AnAbstractClass.class);
  }

  public void testEquals_enum() {
    tester.testEquals(OneConstantEnum.class);

synchronized class SystemStreamLog implements Log { public void SystemStreamLog(); public void debug(CharSequence); public void debug(CharSequence, Throwable); public void debug(Throwable); public void info(CharSequence); public void info(CharSequence, Throwable); public void info(Throwable); public void warn(CharSequence); public void warn(CharSequence, Throwable); public void warn(Throwable); public void error(CharSequence); public void error(CharSequence, Throwable); public void error(Throwable);...

      this.finalField = finalField;
    }

    @Tested
    abstract void abstractMethod();

    @Tested
    void overridableMethod() {}

    @Tested
    protected void protectedMethod() {}

    @Tested
    private void privateMethod() {}

    @Tested
    public final void publicFinalMethod() {}

    void notAnnotatedMethod() {}

    static Invokable<A, A> constructor() throws Exception {

  @Test
  public void edgesConnecting_orderMismatch() {
    addEdge(N1, N2, E12);
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class,
            () -> {
              Set<String> unused = network.edgesConnecting(EndpointPair.unordered(N1, N2));
            });
    assertThat(e).hasMessageThat().contains(ENDPOINTS_MISMATCH);
  }

  @Test

    abstract T returningT();

    abstract void acceptT(T t);

    abstract <X extends T> X returningX();

    abstract <X> void acceptX(X x);

    abstract <T2 extends Enum<T2> & CharSequence> T2 returningT2();

    abstract <T2 extends CharSequence & Iterable<T2>> void acceptT2(T2 t2);

    static void verifyConsistentRawType() {