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'
        varname << ['theBigDecimal', 'theBigInteger', 'theDouble', 'thedouble', 'thefloat', 'theFloat', 'theint',

    String getLocation() {
        return "Plugin class 'SneakyPlugin'"
    }

    @Override
    void buildLogicApplication(BuildInputRead read) {
        staticGroovyPlugin(file("buildSrc/src/main/groovy/SneakyPlugin.groovy"), read)
        buildFile << """
            apply plugin: SneakyPlugin
        """
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution

import com.google.common.collect.Maps
import groovy.transform.CompileStatic
import groovy.transform.Immutable
import org.gradle.api.internal.file.TestFiles
import org.gradle.internal.execution.history.ExecutionHistoryStore
import org.gradle.internal.execution.model.InputNormalizer

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package gradlebuild.performance

import groovy.transform.CompileStatic
import groovy.transform.MapConstructor

// Modify this class with care, see class org.gradle.performance.results.PerformanceTestExecutionResult
@MapConstructor
@CompileStatic
class ScenarioBuildResultData {

    private static void addPluginSource(TestFile pluginProjectDir, String code) {
        def packageName = "org.gradle.test"
        def sourceFilePath = "${packageName.replaceAll("\\.", "/")}/${"TestPlugin"}.groovy"
        pluginProjectDir.file("src/main/groovy/${sourceFilePath}") << """
            ${packageName ? "package $packageName" : ""}

            class TestPlugin implements $Plugin.name<$Project.name> {

    @UsesSample("modelRules/modelDsl")
    def "dsl creation example works"() {
        when:
        inDirectory(sample.dir.file('groovy'))

        then:
        succeeds "hello"
        output.contains("Hello John Smith!")

        when:
        inDirectory(sample.dir.file('groovy'))

        then:
        succeeds "listPeople"
        output.contains("configuring Person 'people.john'")

 */

package org.gradle.internal.cc.impl.inputs.process.instrument

/**
 * Test cases for single-argument {@code ProcessGroovyMethods.execute} with static import (Groovy produces a special byte code in this case):
 * <pre>
 *     import static org.codehaus.groovy.runtime.ProcessGroovyMethods.execute
 *     execute("echo 123")
 *     execute(["echo", "123"])
 * </pre>
 */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.manage.schema.extract

import groovy.transform.CompileStatic
import org.codehaus.groovy.reflection.ClassInfo

@CompileStatic
class ModelStoreTestUtils {
    private final static Object GLOBAL_CLASS_SET
    private final static Iterable<ClassInfo> GLOBAL_CLASS_SET_ITEMS

/**
 * A set of helpers to generate a Groovy plugin with provided code in buildSrc and apply it to the project under test.
 * The trait is intended to be mixed into something that extends {@link org.gradle.integtests.fixtures.AbstractIntegrationSpec}.
 */
trait DynamicGroovyPluginMixin {
    void withPluginCode(String imports, String codeUnderTest, boolean enableIndy) {
        file("buildSrc/src/main/groovy/SomePlugin.groovy") << """

import org.gradle.api.tasks.TaskAction

import javax.inject.Inject

class PropertyGroovyInterOpIntegrationTest extends AbstractPropertyGroovyInterOpIntegrationTest {
    def setup() {
        pluginDir.file("src/main/groovy/SomeTask.groovy") << """
            import ${DefaultTask.name}
            import ${Property.name}
            import ${ListProperty.name}
            import ${SetProperty.name}
            import ${MapProperty.name}