thing1.onMethodMissing = { name, args -> [].foo() }
        conf(thing1) { m1() }

        then:
        def e = thrown(MissingMethodException)
        e.method == "foo"

        when:
        thing1.onPropertyMissingGet = { new Object().bar }
        conf(thing1) { abc }

        then:
        e = thrown(MissingPropertyException)
        e.property == "bar"

        when:

import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * To be implemented by test generators of things that can contain elements. Such things include
 * both {@link Collection} and {@link Map}; since there isn't an established collective noun that
 * encompasses both of these, 'container' is used.
 *
 * @author George van den Driessche
 */

import javax.inject.Inject

allprojects {
    apply plugin: CustomPlugin
}

class CustomModel implements Serializable {
    List<CustomThing> things = new ArrayList()

    CustomModel(int heapSizeMb) {
        for(int i = 0; i < heapSizeMb; i++) {
            things.add(new CustomThing())
        }
    }
}

class CustomThing implements Serializable {
    byte[] payload = new byte[1024 * 1024]
}

        expect:
        matcher.formatErrorMessage("thing", "container") == "thing 'name' not found in container."
    }

    def "builds error message for multiple matches"() {
        setup:
        matcher.find("n", ["number", "name", "other"])

        expect:
        matcher.formatErrorMessage("thing", "container") == "thing 'n' is ambiguous in container. Candidates are: 'name', 'number'."
    }

        sourceFile << """
            ${read.requiredImports().collect { "import $it" }.join("\n")}

            println("apply = " + ${read.groovyExpression})
            tasks.register("thing") {
                doLast {
                    println("task = " + ${read.groovyExpression})
                }
            }
        """
    }

        when:
        def libDir = file('libs').createDir()
        jarWithClasses(libDir.file("somelib.jar"), Thing: 'interface Thing {}')
        def anotherJar = libDir.file("anotherlib.jar")
        jarWithClasses(anotherJar, Thing2: 'interface Thing2 {}')
        file("src/main/java/Foo.java") << "class Foo implements Thing, Thing2{}"
        buildFile << """
            dependencies {
                implementation fileTree("libs/")

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"os"

	"./b"
)

func main() {
	seed := "some things are better"
	bsl := []byte(seed)
	b.CallReadValues("/dev/null")
	vals, err := b.ReadValues(bsl)
	if vals["better"] != seed || err != nil {
		os.Exit(1)
	}

}
```

The `SelectorRegexp` specifies that this rule applies only to imports which
match that regex.

Note: an empty list (`[]`) matches nothing, and an empty string (`""`) is a
prefix of everything.

### What are InverseRules?

In contrast to rules, which are defined in terms of "things this package
depends on", inverse rules are defined in terms of "things which import this

    The new logic runs with no external dependencies, and will attempt to continue if errors are encountered (which could be caused by things like SELinux rules).

        when:
        buildScript '''
            interface Thing { }

            class Rules extends RuleSource {
              @Model
              void s(Thing s) {}
            }

            apply type: Rules
        '''

        then:
        fails "tasks"

        and:
        failure.assertHasCause("Declaration of model rule Rules#s(Thing) is invalid.")