hosts:
  - abc.foo.example.com
  http:
  - match:
    - uri:
        prefix: /abc-foo-example-com
    name: gateway-conformance-infra.attaches-to-abc-foo-example-com-with-hostname-intersection.0
    route:
    - destination:
        host: infra-backend-v1.gateway-conformance-infra.svc.domain.suffix
        port:
          number: 8080
---

kind: HTTPRoute
metadata:
  name: attaches-to-abc-foo-example-com-with-hostname-intersection
  namespace: gateway-conformance-infra
spec:
  parentRefs:
    - name: isolation
      namespace: gateway-conformance-infra
      sectionName: abc-foo-example-com
  hostnames:
    - "bar.com" # doesn't match abc-foo-example-com listener

        val instance = createFromPaths(listOf("abc"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(File("abc")))
        assertFalse(instance.isFileSystemCheckIgnoredFor(File("abcdef")))
        assertFalse(instance.isFileSystemCheckIgnoredFor(File("123abc")))
        assertFalse(instance.isFileSystemCheckIgnoredFor(File("abc/def")))
        assertFalse(instance.isFileSystemCheckIgnoredFor(File("xyz/abc")))
    }

    @Test

            "8.0",
            "9.0-abc"
        ]
        registry.getStringValue(WindowsRegistry.Key.HKEY_LOCAL_MACHINE, "SOFTWARE\\AdoptOpenJDK\\JDK\\8.0\\hotspot\\MSI", "Path") >> "c:\\jdk8"
        registry.getStringValue(WindowsRegistry.Key.HKEY_LOCAL_MACHINE, "SOFTWARE\\AdoptOpenJDK\\JDK\\9.0-abc\\hotspot\\MSI", "Path") >> "d:\\jdk9"

                super.connect(snk)
                write(TextUtil.toPlatformLineSeparators("abc\n123").bytes)
                close()
            }
        })

        when:
        run "echo"

        then:
        output.contains("[abc][123]")
    }

    def "task can read stdin when stdin has unbounded length"() {
        given:
        buildFile << '''
task echo {

				_ = set1000.Contains("456")
				_ = set1000.Contains("abc")
			}
		})
		b.Run("Contains/100", func(b *testing.B) {
			for range b.N {
				_ = set100.Contains("45")
				_ = set100.Contains("abc")
			}
		})
		b.Run("Contains/2", func(b *testing.B) {
			for range b.N {
				_ = set2.Contains("1")
				_ = set2.Contains("abc")
			}
		})
	})
	b.Run("SmallSet", func(b *testing.B) {

    types = listOf(Abc::class, C::class, D::class),
    externalFunctions = listOf(::newD),
    defaultImports = listOf(DefaultFqName("com.example", "newD"))
)


object SimpleAnalysisDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        printResolutionResults(
            schema.resolve(
                """
                    val myB = b()

                    a = myB

    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(

		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)

		"65xiNg"

	// oneAudString includes one `aud` claim "abc" of type string.
	oneAudString = "header.eyJhdWQiOiJhYmMiLCJleHAiOjQ3MzI5OTQ4MDEsImlhdCI6MTU3OTM5NDgwMSwiaXNzIjoidGVzdC1pc3N1ZXItMUBpc3Rpby5pbyIsInN1YiI6InN1Yi0xIn0.signature" // nolint: lll

	// twoAudList includes two `aud` claims ["abc", "xyz"] of type []string.