} catch(RuntimeException e) {
                println("get failed with: " + e.message)
                println("get failed with cause: " + e.cause.message)
            }
            try {
                two.prop.present
            } catch(RuntimeException e) {
                println("present failed with: " + e.message)
                println("present failed with cause: " + e.cause.message)
            }

// xatexit schedules the exit-handler f to be run when the program exits.
func xatexit(f func()) {
	atexits = append(atexits, f)
}

// xprintf prints a message to standard output.
func xprintf(format string, args ...interface{}) {
	fmt.Printf(format, args...)
}

// errprintf prints a message to standard output.
func errprintf(format string, args ...interface{}) {
	fmt.Fprintf(os.Stderr, format, args...)
}

}

class MyTypeImpl(override val name: String) : MyType {
    // Implement other properties and methods...
}

// Usage
val instance = MyTypeImpl("myName")
println(instance.name) // Prints: myName
----

[[managed_types]]
== Using Gradle Managed Types

A managed type as an abstract class or interface with no fields and whose properties are all managed.

            }
        }
    }

    def "fails when negative timeout is specified"() {
        given:
        buildFile << """
            task broken() {
                doLast {
                    println "Hello"
                }
                timeout = Duration.ofMillis(-1)
            }
            """

        expect:
        2.times {
            fails "broken"

                        println "${propertyPrefix}.serviceFactoryCreate.config.buildScanRequest = \$config.buildScanRequest"
                        println "${propertyPrefix}.serviceFactoryCreate.config.autoApplied = \$config.autoApplied"
                        println "${propertyPrefix}.serviceFactoryCreate.config.taskExecutingBuild = \$config.taskExecutingBuild"

                    println "gradle.projectsLoaded(Action) from $source"
                } as Action)
                gradle.projectsLoaded {
                    println "gradle.projectsLoaded(Closure) from $source"
                }
                gradle.addListener(new BuildAdapter() {
                    void projectsLoaded(Gradle ignored) {
                        println "gradle.addListener(BuildListener) from $source"

            System.out.println();
            System.out.println("Kotlin:       " + KotlinDslVersion.current().getKotlinVersion());
            System.out.println("Groovy:       " + ReleaseInfo.getVersion());
            System.out.println("Ant:          " + Main.getAntVersion());
            System.out.println("JVM:          " + Jvm.current());

                @TaskAction
                void run() {
                    println "value = " + value
                    println "value.child = " + value.dir("child")
                    println "propValue = " + propValue.get()
                    println "propValue.child = " + propValue.get().dir("child")
                    println "propValue.child.mapped = " + propValue.dir("child").get()
                }
            }

                    add 'b'
                }
              }
              tasks {
                create("print") {
                  doLast {
                    println "mapThings: " + ($.mapThings as List)*.keySet()
                    println "setThings: " + ($.setThings as List)
                    println "setStrings: " + ($.setStrings as List)
                  }
                }
              }
            }

                    tasks.create("fromPlugin") {
                        doLast {
                            println "plugin input: $os"
                            println "plugin name: $os.name"
                        }
                    }
                }
            }

            apply type: RulePlugin

            model {