* @see VersionRange
 */
@Experimental
public interface Version extends Comparable<Version> {
    /**
     * {@return the string representation of this version}
     */
    @Nonnull
    @Override
    String toString();

 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public interface TestSortedSetGenerator<E extends @Nullable Object> extends TestSetGenerator<E> {
  @Override
  SortedSet<E> create(Object... elements);

  /**
   * Returns an element less than the {@link #samples()} and less than {@link
   * #belowSamplesGreater()}.
   */
  E belowSamplesLesser();

  /**

import org.jspecify.annotations.NullUnmarked;

/** Unit tests for {@link LongAdder}. */
@NullUnmarked
public class LongAdderTest extends TestCase {

  /**
   * No-op null-pointer test for {@link LongAdder} to override the {@link PackageSanityTests}
   * version, which checks package-private methods that we don't want to have to annotate as {@code
   * Nullable} because we don't want diffs from jsr166e.
   */
  public void testNulls() {}

     */
    void fire(ModelBuildingListener listener, ModelBuildingEvent event);

    ModelBuildingEventCatapult BUILD_EXTENSIONS_ASSEMBLED = new ModelBuildingEventCatapult() {
        @Override
        public void fire(ModelBuildingListener listener, ModelBuildingEvent event) {
            listener.buildExtensionsAssembled(event);
        }
    };

      Suppliers.ofInstance(
          new StatsCounter() {
            @Override
            public void recordHits(int count) {}

            @Override
            public void recordMisses(int count) {}

            @SuppressWarnings("GoodTime") // b/122668874
            @Override
            public void recordLoadSuccess(long loadTime) {}

     * @return tree instance with the given type
     */
    <T extends SmbTree> T unwrap(Class<T> type);

    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close();

    }

  @Test fun uncaughtException() {
    val testRule = OkHttpClientTestRule()
    testRule.beforeEach(extensionContext)

    val thread =
      object : Thread() {
        override fun run(): Unit = throw RuntimeException("boom!")
      }
    thread.start()
    thread.join()

    assertFailsWith<AssertionError> {
      testRule.afterEach(extensionContext)
    }.also { expected ->

        super(parent, delegate, filter);
    }

    /**
     * @param fe
     * @return
     * @throws MalformedURLException
     */
    @Override
    protected SmbResource adapt(final FileEntry e) throws MalformedURLException {
        return new SmbFile(getParent(), e.getName(), false, e.getType(), SmbConstants.ATTR_READONLY | SmbConstants.ATTR_DIRECTORY, 0L, 0L,

@AndroidIncompatible // test-suite builders
public class MinimalCollectionTest extends TestCase {
  public static Test suite() {
    return CollectionTestSuiteBuilder.using(
            new TestStringCollectionGenerator() {
              @Override
              public Collection<String> create(String[] elements) {
                // TODO: MinimalCollection should perhaps throw
                for (Object element : elements) {
                  if (element == null) {

    public String getRole() {
        return role;
    }

    public String getRoleHint() {
        return roleHint;
    }

    /**
     * Creates a shallow copy of this requirement.
     */
    @Override
    public Requirement clone() {
        try {
            return (Requirement) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new UnsupportedOperationException(e);
        }
    }