@AndroidIncompatible // Reflection bug, or actual binary compatibility problem?
  public void testElementSetBridgeMethods() {
    for (Method m : TreeMultiset.class.getMethods()) {
      if (m.getName().equals("elementSet") && m.getReturnType().equals(SortedSet.class)) {
        return;
      }
    }
    fail("No bridge method found");
  }

package org.gradle.test

class GroovyClassWithConstants {
    static final int INT_CONST = 9
    public static final String STRING_CONST = 'some-string'
    static final Object OBJECT_CONST = new GroovyClassWithConstants()
    static final def BIG_DECIMAL_CONST = 1.02

    String ignored = 'ignore'
    final int ignored2 = 1001
    static def ignored3

import org.codelibs.fess.util.ComponentUtil;

/**
 * Helper class for crawler logging operations.
 * Extends LogHelperImpl to provide specialized logging functionality for crawler operations,
 * including failure URL tracking and crawler statistics integration.
 */
public class CrawlerLogHelper extends LogHelperImpl {

    /**
     * Creates a new instance of CrawlerLogHelper.
     */

/**
 * Unit tests for SMB3 Multi-Channel functionality
 *
 * These tests verify the multi-channel implementation without requiring a real SMB server.
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class MultiChannelIntegrationTest {

    @Mock
    private SmbTransportInternal mockTransport;

    @Mock
    private CIFSContext mockContext;

    @Mock

 * they are available to GWT.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public final class DerivedGoogleCollectionGenerators {
  public static class MapGenerator<K extends @Nullable Object, V extends @Nullable Object>
      implements TestMapGenerator<K, V>, DerivedGenerator {

/**
 * Unit test for {@link ComparisonChain}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked
public class ComparisonChainTest extends TestCase {
  private static final DontCompareMe DONT_COMPARE_ME = new DontCompareMe();

  private static class DontCompareMe implements Comparable<DontCompareMe> {
    @Override
    public int compareTo(DontCompareMe o) {
      throw new AssertionFailedError();

    assertThrows(IllegalArgumentException.class, () -> max());
  }

  public void testMax() {
    assertThat(max(LEAST)).isEqualTo(LEAST);
    assertThat(max(GREATEST)).isEqualTo(GREATEST);
    assertThat(max((byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1)).isEqualTo((byte) 127);
  }

  public void testMin_noArgs() {
    assertThrows(IllegalArgumentException.class, () -> min());
  }

# Without aliases


@app.get("/optional-str")
async def read_optional_str(p: Annotated[Optional[str], Cookie()] = None):
    return {"p": p}


class CookieModelOptionalStr(BaseModel):
    p: Optional[str] = None


@app.get("/model-optional-str")
async def read_model_optional_str(p: Annotated[CookieModelOptionalStr, Cookie()]):
    return {"p": p.p}

	c.infWrites.Store(t.IsZero())
	c.writeSetAt = time.Time{}
	return c.Conn.SetWriteDeadline(t)
}

// Close wraps conn.Close and stops sending deadline updates.
func (c *DeadlineConn) Close() error {
	c.abortReads.Store(true)
	c.abortWrites.Store(true)
	return c.Conn.Close()
}

// WithReadDeadline sets a new read side net.Conn deadline.

        getContainer().lookup(DelegatingMojoExecutionListener.class).addMojoExecutionListener(mojoListener);

        try {
            lifecycleExecutor.execute(session);
        } finally {
            getContainer()
                    .lookup(DelegatingProjectExecutionListener.class)