@Model
              void group(Group group) {
                group.name = "Women in computing"

                group.members.create { name = "Ada Lovelace" }
                group.members.create { name = "Grace Hooper" }

                assert group.members.is(group.members)
              }
            }

            apply type: Rules

            model {
              tasks {

internal
class Summary(
    /**
     * Total of all problems, regardless of severity.
     */
    val problemCount: Int,

    /**
     * Total number of problems that are failures.
     */
    val failureCount: Int,

    /**
     * Total number of [suppressed][ProblemSeverity.Suppressed] problems.
     */
    private
    val suppressedCount: Int,

    private

 * See https://www.jetbrains.com/help/teamcity/teamcity-data-clean-up.html#Clean-up+Rules
 *
 * @param historyDays days number of days to store build history .
 * @param artifactsDays number of days to store artifacts. In the stored history, artifacts older than this number will be cleaned up.
 * @param artifactPatterns patterns for artifacts clean-up. If not specified, all artifacts will be removed.
 */

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.fixtures.codegen;

import org.gradle.api.Incubating;

public interface IncubatingFunction {
    @Incubating
    void extendedFunction(Class<Number> type);

 * failing tasks only, to not use up unnecessary disk space on Team City. This also improves the performance of
 * artifact publishing by reducing the artifacts and packaging reports that consist of multiple files.
 *
 * Reducing the number of reports also makes it easier to find the important ones when analysing a failed build in
 * Team City.
 */

val testFilesCleanup = extensions.create<TestFileCleanUpExtension>("testFilesCleanup").apply {

    Property<String> getBaselines() {
        return baselines
    }

    @Option(option = "warmups", description = "Number of warmups before measurements")
    void setWarmups(@Nullable String warmups) {
        this.warmups = warmups
    }

    @Option(option = "runs", description = "Number of iterations of measurements")
    void setRuns(@Nullable String runs) {
        this.runs = runs
    }

        fi
        # Roll the args list around exactly as many times as the number of
        # args, so each arg winds up back in the position where it started, but
        # possibly modified.
        #
        # NB: a `for` loop captures its iteration list before it begins, so
        # changing the positional parameters here affects neither the number of
        # iterations, nor the values presented in `arg`.

        failure.assertThatCause(containsString('''The following types/formats are supported:
  - A String or CharSequence
  - Any Number'''))

        where:
        // not including char, Character, and String since Groovy auto-coerces to String,
        // or boolean/Boolean since those are special cased for 'true'

                    subject.invariantClass(type = Number::class)
                    subject.covariantClass(type = Int::class)
                    subject.contravariantClass(type = Number::class)

                    subject.varargOfClasses(Number::class, Int::class)
                    subject.arrayOfClasses(types = arrayOf(Number::class, Int::class))
                    subject.collectionOfClasses(listOf(Number::class, Int::class))

            """
            addAndConfigure("test") {
                number = 123
            }
            justAdd("test2")
            complexValueOne = one(two("three"))
            complexValueOneFromUtils = utils.oneUtil()
            complexValueTwo = two("three")
            nested {
                number = 456
                add()
            }
            """.trimIndent()
        )