}, {
		base:   "/foo/bar",
		pfx:    "",
		expect: true,
	}, {
		base:   "",
		pfx:    "/foo",
		expect: false,
	}, {
		base:   "/foo",
		pfx:    "/foo",
		expect: true,
	}, {
		base:   "/foo/bar",
		pfx:    "/foo",
		expect: true,
	}, {
		base:   "/foobar/qux",
		pfx:    "/foo",
		expect: false,
	}, {
		base:   "/foo/bar/bat/qux/zrb",
		pfx:    "/foo/bar/bat",
		expect: true,

        configurationCacheRun "myTask"

        then:
        outputContains("bar")
        outputContains("Calculating task graph as configuration cache cannot be reused due to ${commandLineArgs.first()}")
        configurationCache.assertStateStored()

        when:
        configurationCacheRun "myTask"

        then:
        outputContains("bar")
        configurationCache.assertStateLoaded()

        where:

        val result = pluginsSchema.runChecks(
            """
            foo()
            bar()
            baz()
            pluginManagement { }
            plugins {
                id("foo")
            }
            baq()
            """.trimIndent()
        )

        assertEquals(listOf("foo()", "bar()", "baz()"), result.map { it.location.sourceData.text() })

  namespace: gateway-conformance-infra
spec:
  parentRefs:
    - name: isolation
      namespace: gateway-conformance-infra
      sectionName: empty-hostname
  hostnames:
    - "bar.com"
    - "*.example.com" # request matching is prevented by the isolation wildcard-example-com listener
    - "*.foo.example.com" # request matching is prevented by the isolation wildcard-foo-example-com listener

    @ExampleAnnotation
    FOO,
    BAR
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testGetField() {
    Field foo = Enums.getField(AnEnum.FOO);
    assertEquals("FOO", foo.getName());
    assertTrue(foo.isAnnotationPresent(ExampleAnnotation.class));

    Field bar = Enums.getField(AnEnum.BAR);
    assertEquals("BAR", bar.getName());

                        attributes {
                            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, "bar"))
                        }
                    }
                }
                assert configurations.foo.attributes.getAttribute(Category.CATEGORY_ATTRIBUTE).name == "bar"
            }

            assert configurations.empty
        """

        expect:
        succeeds "help"

  ],
  "ports": [
    {
      "containerPort": 8001
    }
  ],
  "env": [
    {
      "name": "ENV_FOO",
      "value": "bar"
    },
    {
      "name": "ENV_BAR",
      "valueFrom": {
        "secretKeyRef": {
          "name": "foo",
          "key": "bar",
          "optional": true
        }
      }
    }
  ],
  "resources": {
    "limits": {
      "foo": "1G"
    },

kind: Gateway
metadata:
  annotations:
    gateway.istio.io/controller-version: "5"
---
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    fizz: buzz
  labels:
    foo: bar
    gateway.istio.io/managed: istio.io-gateway-controller
    gateway.networking.k8s.io/gateway-name: default
    istio.io/dataplane-mode: none
    istio.io/gateway-name: default
  name: default-istio
  namespace: default

        then:
        project.modelRegistry.realize("foo", String) == "bar"
    }

    def "can apply a rule source by type"() {
        when:
        def project = buildProject()
        project.apply type: CustomRuleSource

        then:
        project.modelRegistry.realize("foo", String) == "bar"
    }

    def "cannot apply a type that is neither a plugin nor a rule source"() {
        when:

    pthread_create(&th, &attr, thr, 0);
    pthread_join(th, 0);
}

static void bar() {
    go_callback2();
}
*/
import "C"

import (
	"log"
	"os"
	"runtime"
	"runtime/trace"
)

//export go_callback
func go_callback() {
	// Do another call into C, just to test that path too.
	C.bar()
}

//export go_callback2
func go_callback2() {
	runtime.GC()
}

func main() {