vfsStore.store(regularFile("${location}/some/child"))
                vfsStore.store(regularFile("${location}/other/child"))
                instant.partialSnapshotsStored
                thread.blockUntil.invalidated
                vfsStore.store(regularFile("${location}/other/child2"))
                vfsStore.store(regularFile("${location}/some/child2"))
                instant.snapshottingFinished

        resources: {}
        volumeMounts:
        - mountPath: /var/lib/data/foo.json
          name: some-injected-file
          subPath: foo.json
      volumes:
      - downwardAPI:
          items:
          - fieldRef:
              fieldPath: metadata.annotations['foo']
            path: foo.json
        name: some-injected-file
status: {}

    def "can get base directory of relative file" () {
        File file = new File("/some/relatively/long/path/to/a/file")
        RelativePath relativePath = RelativePath.parse(true, "to/a/file")
        RelativeFile relativeFile = new RelativeFile(file, relativePath)

        expect:
        relativeFile.getBaseDir() == new File("/some/relatively/long/path")
    }

            apply<GradlePluginPlugin>()

            extensions.getByType(MyExtension::class).some("api.get")
            extensions.configure<MyExtension> { some("api.configure") }
            the<MyExtension>().some("kotlin.get")
            configure<MyExtension> { some("kotlin.configure") }
        """)
        withBuildScript("""tasks.register("noop")""")

        assertThat(

  controlPlaneAuthPolicy: NONE
  proxyMetadata:
    SOME: setting
  drainDuration: 1s`
	proxyOverride := `discoveryAddress: foo:123
proxyMetadata:
  SOME: setting
drainDuration: 1s
controlPlaneAuthPolicy: NONE`
	overridesExpected := func() *meshconfig.ProxyConfig {
		m := mesh.DefaultProxyConfig()
		m.DiscoveryAddress = "foo:123"
		m.ProxyMetadata = map[string]string{"SOME": "setting"}
		m.DrainDuration = durationpb.New(time.Second)

     */
    @Nonnull
    <T> Optional<T> lookupOptional(Class<T> type, String name);

    /**
     * Performs a collection lookup for given typed components.
     *
     * @param type The component type.
     * @return The list of components. The list may be empty if no components found.
     * @param <T> The component type.

        handler.enterClassLoadingScope("some/Class")
        handler.exitClassLoadingScope()

        then:
        noExceptionThrown()
    }

    def "rethrows the #expectedExceptionClass.simpleName if the scope exits with #exception.class.simpleName"() {
        given:
        TransformErrorHandler handler = handler()

        when:
        handler.enterClassLoadingScope("some/Class")

        usesEfficientSerialization(new File("some-file"), serializer, 10) == new File("some-file")
    }

    def "uses efficient serialization for Paths"() {
        expect:
        def serializer = factory.getSerializerFor(Path)
        def encoded = toBytes(Paths.get("some-file"), serializer)
        fromBytes(encoded, serializer) == Paths.get("some-file")
        encoded.length == 10
    }

        }
    }

    def loadsFromXmlFile() {
        def inputFile = tmpDir.file('input.xml')
        inputFile.text = '<root name="some-xml"/>'

        when:
        object.load(inputFile)

        then:
        rootElement == 'some-xml'
    }

    def loadsFromDefaultResource() {
        when:
        object.loadDefaults()

        then:
        rootElement == 'default-xml'

    - name: svc2
      port: 80
  - matches:
    - path:
        type: Exact
        value: /baz
      headers:
      - name: my-header
        value: some-value
        type: Exact
      queryParams:
      - name: my-param
        value: some-value
        type: RegularExpression
    backendRefs:
    - name: svc2
      port: 80
  - matches:
    - path:
        type: PathPrefix
        value: /