sslSocketClass: Class<in SSLSocket>,
  private val sslSocketFactoryClass: Class<in SSLSocketFactory>,
  private val paramClass: Class<*>,
) : AndroidSocketAdapter(sslSocketClass) {
  override fun matchesSocketFactory(sslSocketFactory: SSLSocketFactory): Boolean = sslSocketFactoryClass.isInstance(sslSocketFactory)

  override fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? {
    val context: Any? =
      readFieldOrNull(

// UnmarshalYAML - BatchJobKV extends default unmarshal to extract line, col information.
func (kv *BatchJobKV) UnmarshalYAML(val *yaml.Node) error {
	type jobKV BatchJobKV
	var tmp jobKV
	err := val.Decode(&tmp)
	if err != nil {
		return err
	}
	*kv = BatchJobKV(tmp)
	kv.line, kv.col = val.Line, val.Column
	return nil
}

// Validate returns an error if key is empty
func (kv BatchJobKV) Validate() error {

        ?: return arrayOf()

    val testCaseDirectory = File(resource.toURI()).toOkioPath()
    val result = mutableListOf<String>()
    for (path in fileSystem.list(testCaseDirectory)) {
      val story00 = path / "story_00.json"
      if (!fileSystem.exists(story00)) continue
      try {
        readStory(story00)
        result.add(path.name)
      } catch (ignored: IOException) {
        // Skip this path.

import okio.ForwardingSink
import okio.buffer

class UploadProgress {
  companion object {
    private const val IMGUR_CLIENT_ID = "9199fdef135c122"
    private val MEDIA_TYPE_PNG = "image/png".toMediaType()
  }

  private val client = OkHttpClient()

  @Throws(Exception::class)
  fun run() {
    val progressListener =
      object : ProgressListener {
        private var firstUpdate = true

    // TODO(lowasser): make this GWT-compatible
    return fromIntBits(value * checkNotNull(val).value);
  }

  /**
   * Returns the result of dividing this by {@code val}.
   *
   * @throws ArithmeticException if {@code val} is zero
   * @since 14.0
   */
  public UnsignedInteger dividedBy(UnsignedInteger val) {
    return fromIntBits(UnsignedInts.divide(value, checkNotNull(val).value));
  }

    companion object {
        val LOGGER: Logger = LoggerFactory.getLogger(IncubatingApiReportAggregationWorkAction::class.java.name) as Logger
        const val GITHUB_BASE_URL = "https://github.com/gradle/gradle/blob"
    }

    override fun execute() {
        val byCategory = mutableMapOf<String, ProjectNameToProblems>()

 */
class CipherSuiteSurvey(
  val clients: List<Client>,
  val ianaSuites: IanaSuites,
  val orderBy: List<SuiteId>,
) {
  fun printGoogleSheet() {
    print("name")
    for (client in clients) {
      print("\t")
      print(client.nameAndVersion)
    }
    println()
    val sortedSuites =
      ianaSuites.suites.sortedBy { ianaSuite ->
        val index = orderBy.indexOfFirst { it.matches(ianaSuite) }

    @TaskAction
    fun update() {
        val contributorsInReleaseNotes = getContributorsInReleaseNotes().associateBy { it.login }
        val contributorsFromPullRequests = getContributorsFromPullRequests().associateBy { it.login }

        val unrecognizedContributors = contributorsFromPullRequests.keys - contributorsInReleaseNotes.keys
        if (unrecognizedContributors.isNotEmpty()) {

 * of its component streams are closed. This class takes advantage of that.
 */
internal class MockWebServerSocket(
  val javaNetSocket: Socket,
) : Closeable,
  BufferedSocket {
  private val delegate = javaNetSocket.asOkioSocket()
  private val closedLatch = CountDownLatch(2)

  override val source: BufferedSource =
    object : ForwardingSource(delegate.source) {
      private var closed = false

package clause_test

import (
	"fmt"
	"testing"

	"gorm.io/gorm/clause"
)

func TestGroupBy(t *testing.T) {
	results := []struct {
		Clauses []clause.Interface
		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.GroupBy{
				Columns: []clause.Column{{Name: "role"}},
				Having:  []clause.Expression{clause.Eq{"role", "admin"}},
			}},