file("buildSrc/src/main/java/Thing.java") << "class Thing { }"
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "includes build identifier in build operations with #display"() {
        when:
        file("buildSrc/settings.gradle") << settings << "\n"
        succeeds()

        then:
        def root = ops.root(RunBuildBuildOperationType)

        def records = all(displayName)
        if (records.isEmpty()) {
            throw new AssertionFailedError("No operations found with display name that matches $displayName")
        } else if (records.size() > 1) {
            throw new AssertionFailedError("Multiple operations found with display name that matches $displayName")
        }
        return records.first()
    }

    @Override

            }

            def key = new Param<String>(display: 'a')
            def map = [:]
            map[key] = new Param<Number>(display: 12)

            tasks.create("thing", MyTask) {
                prop = $value
            }
        """

        when:
        succeeds("thing")

        then:
        outputContains("prop = $display")

        where:

        def componentId = new DummyComponentIdentifier()

        expect:
        new ComponentFileArtifactIdentifier(componentId, "thing").toString() == "thing (example)"
    }

    def "identifiers are equal when display names are equal"() {
        def componentId = new DummyComponentIdentifier()
        def otherId = new DummyComponentIdentifier()

        def id = new ComponentFileArtifactIdentifier(componentId, "one")

		switch t := tableOptions.(type) {
		case *metav1.TableOptions:
			if t != nil {
				noHeaders = t.NoHeaders
			}
		default:
			return nil, fmt.Errorf("unrecognized type %T for table options, can't display tabular output", tableOptions)
		}
	}
	return c.TableGenerator.GenerateTable(obj, printers.GenerateOptions{Wide: true, NoHeaders: noHeaders})

import org.gradle.util.Matchers
import spock.lang.Specification

class SocketInetAddressTest extends Specification {
    def localhost = java.net.InetAddress.getByName("localhost")

    def "has useful display name"() {
        def address = new SocketInetAddress(localhost, 234)

        expect:
        address.displayName == "localhost/${localhost.hostAddress}:234"

    /**
     * Returns the display granularity of the events to be logged. For example, if set to 0, a method-level event will be displayed as "Test Run > Test Worker x > org.SomeClass > org.someMethod". If
     * set to 2, the same event will be displayed as "org.someClass &gt; org.someMethod". <p>-1 denotes the highest granularity and corresponds to an atomic test.
     *
     * @return the display granularity of the events to be logged

        def resource = Stub(TextResource)
        _ * source.className >> scriptClassName
        _ * source.fileName >> scriptFileName
        _ * source.displayName >> "script-display-name"
        _ * source.longDisplayName >> Describables.of("script-display-name")
        _ * source.resource >> resource
        _ * resource.text >> scriptText
        return source
    }

    def testCompileScriptToDir() {

 * limitations under the License.
 */

package org.gradle.api.launcher.cli;

import org.gradle.api.Incubating;

import java.io.Serializable;

/**
 * Configures when to display the welcome message on the command line.
 *
 * @since 7.5
 */
@Incubating
public class WelcomeMessageConfiguration implements Serializable {

    private WelcomeMessageDisplayMode welcomeMessageDisplayMode;

 Plugins should avoid these classes and be updated to use only Maven3 dependencies (and require Maven3): see
 {{{https://cwiki.apache.org/confluence/display/MAVEN/Plugin+migration+to+Maven3+dependencies} Plugin migration to Maven3 dependencies}}