protected fun createStories(interopTests: Array<String>): List<Any> {
      if (interopTests.isEmpty()) return listOf<Any>(Story.MISSING)

      val result = mutableListOf<Any>()
      for (interopTestName in interopTests) {
        val stories = HpackJsonUtil.readStories(interopTestName)
        result.addAll(stories)
      }
      return result
    }

    /**

    chain: Array<out X509Certificate>,
    authType: String,
    host: String,
  ): List<Certificate> {
    if (host in insecureHosts) return listOf()
    try {
      val method =
        checkServerTrustedMethod
          ?: throw CertificateException("Failed to call checkServerTrusted")
      return method.invoke(delegate, chain, authType, host) as List<Certificate>
    } catch (e: InvocationTargetException) {
      throw e.targetException

  public static <K, V> ConcurrentMapTestSuiteBuilder<K, V> using(TestMapGenerator<K, V> generator) {
    ConcurrentMapTestSuiteBuilder<K, V> result = new ConcurrentMapTestSuiteBuilder<>();
    result.usingGenerator(generator);
    return result;
  }

  @SuppressWarnings("rawtypes") // class literals
  static final List<? extends Class<? extends AbstractTester>> TESTERS =
      asList(
          ConcurrentMapPutIfAbsentTester.class,

      Executor executor) {
    return AbstractCatchingFuture.create(input, exceptionType, fallback, executor);
  }

  public static <V extends @Nullable Object> ListenableFuture<V> catchingAsync(
      ListenableFuture<? extends V> input,
      Class<Throwable> exceptionType,
      AsyncFunction<? super Throwable, ? extends V> fallback,
      Executor executor) {

     * @throws InterruptedRuntimeException
     *             if any thread has interrupted the current thread.
     */
    public static void sleep(final long millis) {
        if (millis < 1L) {
            return;
        }
        try {
            Thread.sleep(millis);
        } catch (final InterruptedException e) {
            throw new InterruptedRuntimeException(e);
        }
    }

    /**

     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @throws SMBProtocolDecodingException if the response structure is invalid
     *

     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#readBytesWireFormat(byte[], int)
     */
    @Override

@ExtendWith(MockitoExtension.class)
public class AllocInfoTest {

    @Mock
    AllocInfo mockAllocInfo;

    /**
     * Happy path – verifies that getters return the values supplied by the
     * implementation.
     */
    @Test
    @DisplayName("verify getters return stubbed values")
    void testGettersHappyPath() {
        when(mockAllocInfo.getCapacity()).thenReturn(1000L);
        when(mockAllocInfo.getFree()).thenReturn(400L);

 */
@Deprecated(since = "4.0.0")
public interface Source {

    /**
     * Gets a byte stream to the source contents. Closing the returned stream is the responsibility of the caller.
     *
     * @return A byte stream to the source contents, never {@code null}.
     * @throws IOException in case of IO issue
     */
    InputStream getInputStream() throws IOException;

    /**

        }

        @Override
        public int getContextType() {
            return contextType;
        }

        @Override
        public int encode(byte[] dst, int dstIndex) {
            return 0;
        }

        @Override
        public int size() {
            return 0;
        }
    }

    @Nested
    @DisplayName("Interface Tests")
    class InterfaceTests {