import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 */
@Deprecated
class DefaultModelBuilderFactoryTest {

    private static final String BASE_DIR =
            Paths.get("src", "test", "resources", "poms", "factory").toString();

    private File getPom(String name) {
        return new File(Paths.get(BASE_DIR, name + ".xml").toString()).getAbsoluteFile();
    }

    @Test

import org.slf4j.LoggerFactory;

/**
 * Dispatches callbacks to all registered EventSpies.
 * @since 3.0.2
 */
@Named
@Singleton
public class EventSpyDispatcher {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    private final List<EventSpy> eventSpies;

    @Inject
    public EventSpyDispatcher(List<EventSpy> eventSpies) {
        // make copy to get rid of needless overhead for dynamic lookups

 * </ul>
 *
 */
public class Hc4ConnectionMonitorTarget implements TimeoutTarget {
    private static final Logger logger = LogManager.getLogger(Hc4ConnectionMonitorTarget.class);

    private final HttpClientConnectionManager clientConnectionManager;

    /**
     * The timeout duration (in milliseconds) for idle connections.
     */
    private final long idleConnectionTimeout;

    /**

public class IntsTest extends TestCase {
  private static final int[] EMPTY = {};
  private static final int[] ARRAY1 = {(int) 1};
  private static final int[] ARRAY234 = {(int) 2, (int) 3, (int) 4};

  private static final int LEAST = Integer.MIN_VALUE;
  private static final int GREATEST = Integer.MAX_VALUE;

  private static final int[] VALUES = {LEAST, (int) -1, (int) 0, (int) 1, GREATEST};

    }

    ImmutableMap<K, V> buildJdkBacked() {
      return build();
    }
  }

  private static <K, V> ImmutableMap<K, V> fromEntryList(
      Collection<? extends Entry<? extends K, ? extends V>> entries) {
    return fromEntryList(/* throwIfDuplicateKeys= */ true, entries);
  }

  private static <K, V> ImmutableMap<K, V> fromEntryList(

@DisplayName("SmbTransportPoolImpl Tests")
class SmbTransportPoolImplTest {

    private SmbTransportPoolImpl pool;

    @Mock
    private CIFSContext ctx;
    @Mock
    private Configuration config;
    @Mock
    private NameServiceClient nameSvc;
    @Mock
    private Credentials creds;
    @Mock
    private Address address;
    @Mock
    private SmbNegotiationResponse negotiationResponse;

    @BeforeEach

@Tag("Slowish")
class EventSourceHttpTest {
  @RegisterExtension
  val platform = PlatformRule()

  @StartStop
  private val server = MockWebServer()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  private val eventRecorder = EventRecorder()
  private val listener = EventSourceRecorder()
  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(eventRecorder))

 * @param <N> Node parameter type
 * @param <E> Edge parameter type
 */
class StandardNetwork<N, E> extends AbstractNetwork<N, E> {
  private final boolean isDirected;
  private final boolean allowsParallelEdges;
  private final boolean allowsSelfLoops;
  private final ElementOrder<N> nodeOrder;
  private final ElementOrder<E> edgeOrder;

  final MapIteratorCache<N, NetworkConnections<N, E>> nodeConnections;

    /**
     *
     */
    private static final long serialVersionUID = 484863569441792249L;

    // to replace a bunch of one-off binary searches
    private static final Map<Integer, String> errorCodeMessages;
    private static final Map<Integer, String> winErrorCodeMessages;
    private static final Map<Integer, Integer> dosErrorCodeStatuses;

    static {

        }
    }

    @Test
    public void test_constructor_isPrivate() {
        // Verify that SystemUtil has a private constructor (utility class pattern)
        try {
            Constructor<SystemUtil> constructor = SystemUtil.class.getDeclaredConstructor();
            assertTrue("Constructor should be private", java.lang.reflect.Modifier.isPrivate(constructor.getModifiers()));