version = parent.getVersion();
            modVersion = replaceCiFriendlyVersion(context, version);
            parent.setVersion(modVersion);
        }
    }

    //
    // Infer inner reactor dependencies version
    //
    void handleReactorDependencies(TransformerContext context, Model model) {
        for (Dependency dep : model.getDependencies()) {
            if (dep.getVersion() == null) {

        sourceFile.text = """
            package my.org;

            public class Foo {
                public native void foo();

                public static class Inner {
                    public native void anotherNative();
                }
            }
        """
        def generatedHeaderFile = file("build/generated/sources/headers/java/main/my_org_Foo.h")

        String version = model.getVersion();
        String modVersion = replaceCiFriendlyVersion(context, version);
        builder.version(modVersion);
    }

    //
    // Infer inner reactor dependencies version
    //
    void handleReactorDependencies(ModelTransformerContext context, Model model, Path pomFile, Model.Builder builder) {
        List<Dependency> newDeps = new ArrayList<>();

import java.io.IOException;

/**
 * Efficiently serializes hierarchical names, like Java class names or relative paths of resources.
 * Splits names into prefixes and suffixes along package separators, inner class separators, file separators and camel case borders.
 * Reuses these prefixes and suffixes to efficiently store names or parts of names it has seen before.
 *

#   $2: The full path of the output binary.
#   $3: Non-versioned name to use
function download_ztunnel_if_necessary () {
  if [[ -f "$2" ]]; then
    return
  fi
  # Enter the output directory.
  mkdir -p "$(dirname "$2")"
  pushd "$(dirname "$2")"

  # Download and make the binary executable
  echo "Downloading ztunnel: $1 to $2"

class Outer {
    @get:Restricted
    val inner: Inner = Inner()

    @Configuring(propertyName = "inner")
    fun configureInner(fn: Functional) {
        fn.configure(inner)
    }

    @Configuring(propertyName = "inner")
    fun configureInnerWithGeneric(fn: GenericFunctional<Inner>) {
        fn.configure(inner)
    }
}


interface Functional {
    fun configure(inner: Inner)
}

    SettableFuture<Object> async = SettableFuture.create();
    SettableFuture<Object> inner = SettableFuture.create();
    async.setFuture(inner);
    async.cancel(true);
    assertTrue(inner.isCancelled());
    assertTrue(inner.wasInterrupted());
    assertThrows(CancellationException.class, () -> inner.get());
  }

  public void testCancel_resultCancelsInner() throws Exception {

			name: "empty map at depth = 1",
			given: func() Mapper {
				// root (dest port)
				//   15001:
				//     inner (dest ip):
				//       <no matches>
				//       fallback: chain
				inner := NewDestinationIP()
				inner.OnNoMatch = ToChain("chain")

				root := NewDestinationPort()
				root.Map["15001"] = ToMatcher(inner.Matcher)
				return root
			},
			want: func() *matcher.Matcher {
				// dest port
				// 15001: chain

    def "should not remove #modifier inner class if no API is declared"() {
        given:
        def api = toApi 'A': """
            public class A {
               $modifier class Inner {
                  public void foo() {}
               }
            }
        """

        when:
        def outer = api.classes.A
        def inner = api.classes['A$Inner']

    // source: 'fragment.kt'
    enclosing method CodeFragment.run()V
    inner (local) class CodeFragment$run$Bar Bar
    inner (local) class CodeFragment$run$Foo Foo
    public method <init>(): void
}

public class CodeFragment$run$Foo {
    // source: 'fragment.kt'
    enclosing method CodeFragment.run()V
    inner (local) class CodeFragment$run$Foo Foo
    public method <init>(): void
    public method call(): void