* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.http2

import assertk.fail
import okio.BufferedSource
import okio.ByteString

internal open class BaseTestHandler : Http2Reader.Handler {
  override fun data(
    inFinished: Boolean,
    streamId: Int,
    source: BufferedSource,

		return sha1.Size
	case c.Is(ChecksumSHA256):
		return sha256.Size
	case c.Is(ChecksumCRC64NVME):
		return crc64.Size
	}
	return 0
}

// IsSet returns whether the type is valid and known.
func (c ChecksumType) IsSet() bool {
	return !c.Is(ChecksumInvalid) && !c.Base().Is(ChecksumNone)
}

// ChecksumStringToType is like NewChecksumType but without the `mode`

  testImplementation(libs.conscrypt.openjdk)
  testImplementation(libs.junit)
  testImplementation(libs.kotlin.test.common)
  testImplementation(libs.kotlin.test.junit)
  testImplementation(libs.assertk)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import okhttp3.internal.http.parseChallenges
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Test

class HeadersChallengesTest {

aqute-bnd = { module = "biz.aQute.bnd:biz.aQute.bnd", version.ref = "bnd" }
aqute-resolve = { module = "biz.aQute.bnd:biz.aQute.resolve", version.ref = "bnd" }
assertk = { module = "com.willowtreeapps.assertk:assertk", version.ref = "assertk" }
bouncycastle-bcpkix = { module = "org.bouncycastle:bcpkix-jdk15to18", version.ref = "org-bouncycastle" }

    }

    val bit = 1 shl id
    set = set or bit
    values[id] = value
    return this
  }

  /** Returns true if a value has been assigned for the setting `id`. */
  fun isSet(id: Int): Boolean {
    val bit = 1 shl id
    return set and bit != 0
  }

  /** Returns the value for the setting `id`, or 0 if unset. */
  operator fun get(id: Int): Int = values[id]

    //                                                                              ======
    public void insert(BadWord entity) {
        doInsert(entity, null);
    }

    public void insert(BadWord entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
        entity.asDocMeta().indexOption(opLambda);
        doInsert(entity, null);
    }

    //                                                                              ======
    public void insert(BoostDocumentRule entity) {
        doInsert(entity, null);
    }

    public void insert(BoostDocumentRule entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
        entity.asDocMeta().indexOption(opLambda);
        doInsert(entity, null);
    }

    //                                                                              ======
    public void insert(DuplicateHost entity) {
        doInsert(entity, null);
    }

    public void insert(DuplicateHost entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
        entity.asDocMeta().indexOption(opLambda);
        doInsert(entity, null);
    }

    //                                                                              ======
    public void insert(JobLog entity) {
        doInsert(entity, null);
    }

    public void insert(JobLog entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
        entity.asDocMeta().indexOption(opLambda);
        doInsert(entity, null);
    }