*/
class HpackRoundTripTest : HpackDecodeTestBase() {
  internal class StoriesTestProvider : SimpleProvider() {
    override fun arguments(): List<Any> = createStories(RAW_DATA)
  }

  private val bytesOut = Buffer()
  private val hpackWriter = Hpack.Writer(out = bytesOut)

  @ParameterizedTest
  @ArgumentsSource(StoriesTestProvider::class)
  fun testRoundTrip(story: Story) {
    assumeFalse(
      story === Story.MISSING,

 * and we can't rely on classnames after proguard, so are probably best served by falling through
 * to a situation of trying our least likely noisiest options.
 */
class DeferredSocketAdapter(private val socketAdapterFactory: Factory) : SocketAdapter {
  private var delegate: SocketAdapter? = null

  override fun isSupported(): Boolean {
    return true
  }

    } catch (UnsupportedOperationException expected) {
    }
  }

  // Unconditional setCount no-ops.

  private void assertZeroToZero() {
    assertSetCount(e3(), 0);
  }

  private void assertOneToOne() {
    assertSetCount(e0(), 1);
  }

  private void assertThreeToThree() {
    initThreeCopies();
    assertSetCount(e0(), 3);
  }

  @CollectionFeature.Require(SUPPORTS_ADD)

  /** A cache of annotated objects (typically a Class or Method) to its set of annotations. */
  private static final Map<AnnotatedElement, List<Annotation>> annotationCache = new HashMap<>();

  private static final Map<Class<?>, TesterRequirements> classTesterRequirementsCache =
      new HashMap<>();

  private static final Map<Method, TesterRequirements> methodTesterRequirementsCache =
      new HashMap<>();

  /**

@GwtCompatible(emulated = true)
public class FloatsTest extends TestCase {
  private static final float[] EMPTY = {};
  private static final float[] ARRAY1 = {(float) 1};
  private static final float[] ARRAY234 = {(float) 2, (float) 3, (float) 4};

  private static final float LEAST = Float.NEGATIVE_INFINITY;
  private static final float GREATEST = Float.POSITIVE_INFINITY;

  private static final float[] NUMBERS =
      new float[] {
        LEAST,

@GwtCompatible(emulated = true)
public class DoublesTest extends TestCase {
  private static final double[] EMPTY = {};
  private static final double[] ARRAY1 = {(double) 1};
  private static final double[] ARRAY234 = {(double) 2, (double) 3, (double) 4};

  private static final double LEAST = Double.NEGATIVE_INFINITY;
  private static final double GREATEST = Double.POSITIVE_INFINITY;

  private static final double[] NUMBERS =
      new double[] {

@GwtCompatible(emulated = true)
public class FloatsTest extends TestCase {
  private static final float[] EMPTY = {};
  private static final float[] ARRAY1 = {(float) 1};
  private static final float[] ARRAY234 = {(float) 2, (float) 3, (float) 4};

  private static final float LEAST = Float.NEGATIVE_INFINITY;
  private static final float GREATEST = Float.POSITIVE_INFINITY;

  private static final float[] NUMBERS =
      new float[] {
        LEAST,

import jakarta.annotation.Resource;

/**
 * @author Keiichi Watanabe
 */
public class AdminSysteminfoAction extends FessAdminAction {

    public static final String ROLE = "admin-systeminfo";

    private static final String MASKED_VALUE = "XXXXXXXX";

    // ===================================================================================
    //                                                                           Attribute

          .build()
      HandshakeCertificates.Builder()
        .heldCertificate(heldCertificate)
        .addTrustedCertificate(heldCertificate.certificate)
        .build()
    }
  private var acceptedHostName: String? = null

  private lateinit var server: MockWebServer

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server

    // Test designed for Conscrypt and JSSE

@ElementTypesAreNonnullByDefault
final class RegularImmutableSet<E> extends ImmutableSet.CachingAsList<E> {
  private static final Object[] EMPTY_ARRAY = new Object[0];
  static final RegularImmutableSet<Object> EMPTY =
      new RegularImmutableSet<>(EMPTY_ARRAY, 0, EMPTY_ARRAY, 0);

  private final transient Object[] elements;
  private final transient int hashCode;
  // the same values as `elements` in hashed positions (plus nulls)