import org.jspecify.annotations.NullUnmarked;
import org.junit.Test;

/** Functional tests of {@link ClassPath}. */
@NullUnmarked
public class ClassPathTest extends TestCase {
  private static final Logger log = Logger.getLogger(ClassPathTest.class.getName());
  private static final File FILE = new File(".");

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(classInfo(ClassPathTest.class), classInfo(ClassPathTest.class))

     * @param <T2>
     *
     */
    public interface Foo<T1, T2> {

        /**
         * @param foo
         * @return T2
         */
        T2 foo(T1 foo);
    }

    /**
     *
     */
    public interface Bar extends Foo<Integer, Long> {
    }

    /**
     * @param <T1>
     * @param <T2>
     *
     */
    public interface Baz<T1, T2> {

        /**

 *
 * @author Kevin Bourrillion
 */
@NullUnmarked
public class InternersTest extends TestCase {

  public void testStrong_simplistic() {
    String canonical = "a";
    String not = new String("a");

    Interner<String> pool = Interners.newStrongInterner();
    assertSame(canonical, pool.intern(canonical));
    assertSame(canonical, pool.intern(not));
  }

  public void testStrong_null() {

      this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
      countDownLatch.countDown();
    }
  }

  public void testExceptionsCaught() {
    list.add(THROWING_RUNNABLE, directExecutor());
    list.execute();
    list.add(THROWING_RUNNABLE, directExecutor());
  }

  public void testNulls() {

import jcifs.SmbConstants;
import jcifs.smb.SID;

public class PacDataInputStreamTest {

    // Helper to create PacDataInputStream from a byte array
    private PacDataInputStream createInputStream(byte[] data) throws IOException {
        return new PacDataInputStream(new ByteArrayInputStream(data));
    }

    @Test
    public void testAlign() throws IOException {
        // Test alignment from position 1 to 4

    }

    @Override
    public boolean isShutdown() {
      lastMethodCalled = "isShutdown";
      return false;
    }

    @Override
    public boolean isTerminated() {
      lastMethodCalled = "isTerminated";
      return false;
    }

    @Override
    public void shutdown() {
      lastMethodCalled = "shutdown";
    }

    @Override

  // We use ::iterator so that we test passing a plain Iterable, not a Collection.
  "UnnecessaryMethodReference",
})
public class MultimapPutIterableTester<K, V> extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllNonEmptyIterableOnPresentKey() {
    assertTrue(multimap().putAll(k0(), newArrayList(v3(), v4())::iterator));

/**
 * SPNEGO response token (NegTokenTarg) used in SPNEGO authentication exchanges
 */
public class NegTokenTarg extends SpnegoToken {

    /**
     * Result code indicating unspecified result
     */
    public static final int UNSPECIFIED_RESULT = -1;
    /**
     * Result code indicating authentication completed successfully
     */
    public static final int ACCEPT_COMPLETED = 0;
    /**

     */
    @Test
    public void testGetPipe() {
        assertEquals(mockPipeResource, smbPipeHandle.getPipe(), "getPipe() should return the underlying pipe resource.");
    }

    /**
     * Tests that the getter for the input stream returns the correct stream.
     * @throws CIFSException if an error occurs while getting the stream.
     */
    @Test
    public void testGetInputStream() throws CIFSException {

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MultisetRemoveTester<E> extends AbstractMultisetTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveNegative() {
    assertThrows(IllegalArgumentException.class, () -> getMultiset().remove(e0(), -1));
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemoveUnsupported() {