import assertk.assertions.isTrue
import org.junit.jupiter.api.Test

class SettingsTest {
  @Test
  fun unsetField() {
    val settings = Settings()
    assertThat(settings.isSet(Settings.MAX_CONCURRENT_STREAMS)).isFalse()
    assertThat(settings.getMaxConcurrentStreams()).isEqualTo(Int.MAX_VALUE)
  }

  @Test
  fun setFields() {
    val settings = Settings()
    settings[Settings.HEADER_TABLE_SIZE] = 8096

    val bit = 1 shl ENABLE_PUSH
    return if (bit and set != 0) values[ENABLE_PUSH] == 1 else defaultValue
  }

  fun getMaxConcurrentStreams(): Int {
    val bit = 1 shl MAX_CONCURRENT_STREAMS
    return if (bit and set != 0) values[MAX_CONCURRENT_STREAMS] else Int.MAX_VALUE
  }

  fun getMaxFrameSize(defaultValue: Int): Int {
    val bit = 1 shl MAX_FRAME_SIZE
    return if (bit and set != 0) values[MAX_FRAME_SIZE] else defaultValue

  }

  private fun connectHttp2(
    peer: MockHttp2Peer,
    realConnection: RealConnection,
    maxConcurrentStreams: Int,
  ): Http2Connection {
    // Write the mocking script.
    val settings1 = Settings()
    settings1[Settings.MAX_CONCURRENT_STREAMS] = maxConcurrentStreams
    peer.sendFrame().settings(settings1)
    peer.acceptFrame() // ACK
    peer.sendFrame().ping(false, 2, 0)

                            }
                          }
                        ],
                        "http2_protocol_options": {
                          "max_concurrent_streams": 100,
                          "allow_connect": true
                        },
                        "server_name": "istio-envoy",
                        "use_remote_address": false,

    val settings = Settings()
    settings[Settings.MAX_CONCURRENT_STREAMS] = 10
    peer.sendFrame().settings(settings)
    peer.acceptFrame() // ACK
    peer.sendFrame().ping(false, 2, 0)
    peer.acceptFrame() // PING
    peer.play()

    // Play it back.
    val maxConcurrentStreamsUpdated = CountDownLatch(1)
    val maxConcurrentStreams = AtomicInteger()
    val listener: Http2Connection.Listener =

                            }
                          }
                        ],
                        "http2_protocol_options": {
                          "max_concurrent_streams": 100,
                          "allow_connect": true
                        },
                        "server_name": "istio-envoy",
                        "forward_client_cert_details": "APPEND_FORWARD",

  fun settingsLimitsMaxConcurrentStreams(
    protocol: Protocol,
    mockWebServer: MockWebServer,
  ) {
    setUp(protocol, mockWebServer)
    val settings = Settings()
    settings[Settings.MAX_CONCURRENT_STREAMS] = 2

    // Read & write a full request to confirm settings are accepted.
    server.enqueue(
      MockResponse.Builder()
        .settings(settings)
        .build(),
    )

               "@type": "type.googleapis.com/envoy.extensions.filters.http.router.v3.Router"
              }
             }
            ],
            "http2_protocol_options": {
             "max_concurrent_streams": 100,
             "allow_connect": true
            },
            "server_name": "waypoint-envoy",
            "use_remote_address": false,
            "forward_client_cert_details": "APPEND_FORWARD",

pkg net/http, type HTTP2Config struct #67813
pkg net/http, type HTTP2Config struct, CountError func(string) #67813
pkg net/http, type HTTP2Config struct, MaxConcurrentStreams int #67813
pkg net/http, type HTTP2Config struct, MaxDecoderHeaderTableSize int #67813
pkg net/http, type HTTP2Config struct, MaxEncoderHeaderTableSize int #67813
pkg net/http, type HTTP2Config struct, MaxReadFrameSize int #67813

                                      1ms
                                    rule: duration(self) >= duration('1ms')
                                maxConcurrentStreams:
                                  description: The maximum number of concurrent streams
                                    allowed for a peer on one HTTP/2 connection.
                                  format: int32