ConcurrentModificationException.class,
        () -> {
          Iterator<E> iterator = collection.iterator();
          assertTrue(collection.add(e3()));
          iterator.next();
        });
  }

  /**
   * Returns the {@link Method} instance for {@link #testAdd_nullSupported()} so that tests of
   * {@link java.util.Collections#checkedCollection(java.util.Collection, Class)} can suppress it

    assertThrows(IllegalStateException.class, () -> setToTest.equals(wrappedSet));
    assertThrows(IllegalStateException.class, () -> setToTest.equals(copyOfWrappedSet));
    assertThrows(IllegalStateException.class, () -> setToTest.equals(copyOfModifiedSet));
    assertThrows(IllegalStateException.class, () -> wrappedSet.equals(setToTest));
    assertThrows(IllegalStateException.class, () -> copyOfWrappedSet.equals(setToTest));

      super(urls);
    }

    @Override
    protected synchronized Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
      // Force Finalizer to load from this class loader, not its parent.
      if (name.equals(Finalizer.class.getName())) {
        Class<?> clazz = findClass(name);
        if (resolve) {
          resolveClass(clazz);
        }
        return clazz;
      }

    assertThrows(IllegalArgumentException.class, () -> Quantiles.scale(0));
  }

  public void testScale_negative() {
    assertThrows(IllegalArgumentException.class, () -> Quantiles.scale(-4));
  }

  public void testScale_index_negative() {
    Quantiles.Scale intermediate = Quantiles.scale(10);
    assertThrows(IllegalArgumentException.class, () -> intermediate.index(-1));
  }

    assertThrows(IllegalArgumentException.class, () -> Quantiles.scale(0));
  }

  public void testScale_negative() {
    assertThrows(IllegalArgumentException.class, () -> Quantiles.scale(-4));
  }

  public void testScale_index_negative() {
    Quantiles.Scale intermediate = Quantiles.scale(10);
    assertThrows(IllegalArgumentException.class, () -> intermediate.index(-1));
  }

      assertThrows(IllegalArgumentException.class, () -> Resources.getResource("no such resource"));
    } finally {
      Thread.currentThread().setContextClassLoader(oldContextLoader);
    }
  }

  @AndroidIncompatible // .class files aren't available
  public void testNulls() {
    new NullPointerTester()
        .setDefault(URL.class, classfile(ResourcesTest.class))
        .testAllPublicStaticMethods(Resources.class);

            }
        }
    }

    @Test
    public void test_utilityClass_pattern() {
        // Verify utility class design pattern compliance

        // 1. Class should be final (or have private constructor)
        Constructor<?>[] constructors = SystemUtil.class.getDeclaredConstructors();
        assertEquals("Should have exactly one constructor", 1, constructors.length);

import jcifs.internal.util.SMBUtil;

/**
 * Test class for Smb2TreeDisconnectResponse functionality
 */
@DisplayName("Smb2TreeDisconnectResponse Tests")
class Smb2TreeDisconnectResponseTest extends BaseTest {

    private Configuration mockConfig;
    private Smb2TreeDisconnectResponse response;

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);

import org.dbflute.dbway.DBDef;
import org.dbflute.util.DfTypeUtil;

/**
 * @author ESFlute (using FreeGen)
 */
public class DataConfigDbm extends AbstractDBMeta {

    protected static final Class<?> suppressUnusedImportLocalDateTime = LocalDateTime.class;

    // ===================================================================================

            public <T extends SmbPipeHandle> T unwrap(Class<T> type) {
                return null;
            }
        }
        assertThrows(ClassCastException.class, () -> {
            OtherPipeHandle result = target.unwrap(OtherPipeHandle.class);
        });

        // Null input: document current behavior (NPE from isAssignableFrom)
        assertThrows(NullPointerException.class, () -> target.unwrap(null));
    }