@Inject abstract ProviderFactory getProviderFactory()

                @Internal abstract Property<String> getOther()

                @Internal Provider<String> getFoo() {
                    return other;
                }

                @TaskAction
                void useIt() {
                    assert foo.get() == "foobar"
                }
            }

                @Restricted
                Property<String> getId();


                Foo getFoo();

                @Configuring
                default void foo(Action<? super Foo> action) {
                    action.execute(getFoo());
                }

                public abstract static class Foo {
                    public Foo() { }

	g := Gcd(x, y)
	fmt.Println("The gcd of", x, "and", y, "is", g)

	// Manipulate the Foo global variable

	// Output its current value
	fmt.Println("Foo =", GetFoo())

	// Change its value
	SetFoo(3.1415926)

	// See if the change took effect
	fmt.Println("Foo =", GetFoo())
}
-- main.swig --
%module main

%inline %{
extern int    gcd(int x, int y);
extern double Foo;
%}
-- main_test.go --
package main

        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Internal abstract ConfigurableFileCollection getFoo()
                @Internal abstract ConfigurableFileCollection getBar()
                @Inject abstract ProjectLayout getLayout()

                @TaskAction
                void useIt() {

 * limitations under the License.
 */

package org.gradle.workers.fixtures;

import org.gradle.api.Named;

public class TestManagedTypes {
    public interface ManagedThing {
        String getFoo();
        void setFoo(String foo);
    }

    public interface ImmutableManagedThing extends Named {
    }

 * transformed to the first argument, and the callable kind becomes static). For Groovy properties,
 * the name of the callable is also transformed from "foo" to "getFoo".
 * It is possible to specify the custom name for the extension implementation, if needed.
 */
public @interface WithExtensionReferences {
    Class<?> toClass();
    String methodName() default "";

        hasField(clazz.clazz, 'bar', int).modifiers == Modifier.FINAL
        hasField(extracted, 'bar', int).modifiers == Modifier.FINAL
        hasMethod(clazz.clazz, 'getFoo').modifiers == Modifier.ABSTRACT
        hasMethod(extracted, 'getFoo').modifiers == Modifier.ABSTRACT
        hasMethod(clazz.clazz, 'doBar').modifiers == Modifier.SYNCHRONIZED
        hasMethod(extracted, 'doBar').modifiers == Modifier.SYNCHRONIZED

    }

        then:
        assert newIsolatables.every { it instanceof IsolatedManagedValue }

        and:
        newIsolatables[0].isolate().getFoo() == "bar"
        newIsolatables[1].isolate().getFoo() == "baz"
    }

    def "can serialize/deserialize generated immutable Managed values"() {
        def instantiator = TestUtil.objectInstantiator()

                    getId().convention("<no id>");
                }

                @Restricted
                public abstract Property<String> getId();

                public Foo getFoo() {
                    return foo;
                }

                @Configuring
                public void foo(Action<? super Foo> action) {
                    action.execute(foo);
                }

                DirectoryProperty getFoo() { return foo }

                void setFoo(File foo) { throw RuntimeException("") }

                @TaskAction
                void produce() { print("Producer ran") }
            }

            abstract class Consumer extends DefaultTask {
                @InputDirectory
                abstract DirectoryProperty getFoo()

                @TaskAction