this.server = server
  }

  @Test
  fun suspendCall() {
    runTest {
      server.enqueue(MockResponse(body = "abc"))

      val call = client.newCall(request)

      call.executeAsync().use {
        withContext(Dispatchers.IO) {
          assertThat(it.body.string()).isEqualTo("abc")
        }
      }
    }
  }

  @Test
  fun timeoutCall() {
    runTest {
      server.enqueue(

type Foo[T any] interface {
	CreateBar() Bar[T]
}

type Bar[T any] func() Bar[T]

func (f Bar[T]) CreateBar() Bar[T] {
	return f
}

func abc[T any]() {
	var b Bar[T] = func() Bar[T] {
		var b Bar[T]
		return b
	}
	var _ Foo[T] = b()
}

func main() {
	abc[int]()

func AccessInt2(m map[int]int) bool {
	// amd64:"MOV[LQ]\t[$]5"
	_, ok := m[5]
	return ok
}

func AccessString1(m map[string]int) int {
	// amd64:`.*"abc"`
	return m["abc"]
}

func AccessString2(m map[string]int) bool {
	// amd64:`.*"abc"`
	_, ok := m["abc"]
	return ok
}

// ------------------- //
//  String Conversion  //
// ------------------- //

    }

    def "reads single line"() {
        expect:
        def reader = new PreprocessingReader(new StringReader("abc(123)"))
        def result = new StringBuilder()
        reader.readNextLine(result)
        result.toString() == "abc(123)"
        !reader.readNextLine(result)
    }

    def "reads multiple lines"() {
        expect:

        given:
        property.set(["123"] as Set)
        property.add("abc")
        property.addAll(Providers.of(["123", "abc", "123", "456"]))
        property.add("123")
        property.add("def")

        expect:
        property.get() as List == ["123", "abc", "456", "def"]
    }

}

func Seq2[T1 any, T2 any](v1 T1, v2 T2) Src[T2] {
	return nil
}

func main() {
	// Type args fully supplied
	Seq[int]()
	// Partial inference of type args
	Seq2[int](5, "abc")
	// Full inference of type args
	Seq2(5, "abc")

    def canMatchFiles() {
        given:
        FileCopyDetails details1 = details('path/abc.txt')
        FileCopyDetails details2 = details('path/bcd.txt')

        Action matchingAction = Mock()

        when:
        copySpec.filesMatching("**/a*", matchingAction)

//	<string>.findAll(<string>, <int>) <list <string>>
//
// Examples:
//
//	"abc 123".find('[0-9]*') // returns '123'
//	"abc 123".find('xyz') // returns ''
//	"123 abc 456".findAll('[0-9]*') // returns ['123', '456']
//	"123 abc 456".findAll('[0-9]*', 1) // returns ['123']
//	"123 abc 456".findAll('xyz') // returns []
func Regex() cel.EnvOption {
	return cel.Lib(regexLib)
}

var regexLib = &regex{}

		expected string
	}{
		{bytes.NewBuffer([]byte("")), 0, ""},
		{bytes.NewBuffer([]byte("")), 1, ""},
		{bytes.NewBuffer([]byte("abc")), 0, "abc"},
		{bytes.NewBuffer([]byte("abc")), 1, "bc"},
		{bytes.NewBuffer([]byte("abc")), 2, "c"},
		{bytes.NewBuffer([]byte("abc")), 3, ""},
		{bytes.NewBuffer([]byte("abc")), 4, ""},
	}
	for i, testCase := range testCases {
		r := NewSkipReader(testCase.src, testCase.skipLen)

					Annotations: map[string]string{
						autoscaling.HorizontalPodAutoscalerConditionsAnnotation: "abc",
						autoscaling.MetricSpecsAnnotation:                       "abc",
						autoscaling.BehaviorSpecsAnnotation:                     "abc",
						autoscaling.MetricStatusesAnnotation:                    "abc",
					},
				},
			},
			test: "test random value for Annotations",
		},
		{