def "formats progress"() {
        def f = new SimpleProgressFormatter(10, "things")

        expect:
        f.progress == "0/10 things"
        f.incrementAndGetProgress() == "1/10 things"
        f.incrementAndGetProgress() == "2/10 things"
        f.progress == "2/10 things"
    }

    def "does not allow overflow"() {
        def f = new SimpleProgressFormatter(2, "cats");

        def visitor = new FormattingDiagnosticsVisitor()

        given:
        visitor.candidate("thing 1")
        visitor.candidate("thing 2").example("a")
        visitor.candidate("thing 3").example("a").example("b")

        expect:
        visitor.candidates == ["thing 1", "thing 2, for example a.", "thing 3, for example a, b."]
    }

    def "merges duplicate candidates"() {

        def step = new HasSuffixPatternStep(".java", true)

        expect:
        step.matches("thing.java")
        step.matches(".java")
        !step.matches("thing.JAVA")
        !step.matches("thing.Java")
        !step.matches("thing.jav")
        !step.matches("thing.c")
        !step.matches("")
        !step.matches("something else")
    }

    def "matches name case insensitive"() {

        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(WithConstructor))
        collector.add(SuperClass.class.getMethod("thing"), "rule", "is not annotated with anything.")

        expect:
        collector.format() == """Type ${fullyQualifiedNameOf(WithConstructor)} is not a valid <thing>:
- Method FormattingValidationProblemCollectorTest.SuperClass.thing() is not a valid rule method: is not annotated with anything."""
    }

        given:
        buildFile << '''
class Thing { }

class Rules extends RuleSource {
    @Model
    Thing thing() {
        return new Thing()
    }

    @Mutate
    void tasks(ModelMap<Task> tasks, @Path("thing") ModelElement thing) {
        tasks.create("show") {
            doLast {
                println "thing: $thing"
                println "name: $thing.name"

package main

import (
	"fmt"
	"os"
)

type big struct {
	pile [768]int8
}

type thing struct {
	name  string
	next  *thing
	self  *thing
	stuff []big
}

func test(t *thing, u *thing) {
	if t.next != nil {
		return
	}
	fmt.Fprintf(os.Stderr, "%s\n", t.name)
	u.self = u
	t.self = t
	t.next = u
	for _, p := range t.stuff {
		if isFoo(t, p) {
			return
		}
	}
}

	stop         <-chan struct{}
}

// dependency is a specific thing that can be depended on
type dependency struct {
	id             collectionUID
	collectionName string
	// Filter over the collection
	filter *filter
}

type erasedEventHandler = func(o []Event[any], initialSync bool)

// registerDependency is an internal interface for things that can register dependencies.

        settingsFile << "includeBuild 'plugin'"
        file("buildSrc/src/main/java/Thing.java") << "class Thing {}"
        createDir("plugin") {
            file("settings.gradle") << ""
            file("build.gradle") << "plugins { id 'java' }"
            file("buildSrc/src/main/java/Thing.java") << "class Thing {}"
            file("src/main/java/Thing.java") << "class Thing {}"
        }
        file("build.gradle") << "task t"

        when:

                mavenRepo.module("thing", "lib1", "2.0-SNAPSHOT").dependsOn(dep).publish()
            }
        }

        @Override
        void publishNewSnapshot(AbstractIntegrationSpec owner) {
            owner.with {
                def dep = mavenRepo.module("thing", "lib2", "4.1").publish()
                def module = mavenRepo.module("thing", "lib1", "2.0-SNAPSHOT").dependsOn(dep)

    def "detects change in classpath order"() {
        jarWithClasses(file("lib1.jar"), Thing: "class Thing {public void foo() {} }")
        jarWithClasses(file("lib2.jar"), Thing: "class Thing { public void bar() {} }")
        file("src/main/java/Foo.java") << "public class Foo extends Thing {}"

        buildFile << buildScriptWithClasspath("lib1.jar", "lib2.jar")

        when:
        run "compile"