import spock.lang.Specification
import spock.lang.Subject
import spock.lang.Unroll

class ComponentIdentifierParserTest extends Specification {

    @Subject
    NotationParser<Object, ComponentIdentifier> parser = new ComponentIdentifierParserFactory().create()

    @Unroll("Parses #notation")
    def "can parse a module component identifier"() {
        when:

        expect:
        succeeds("test")
    }

    def 'can run spock with @Unroll'() {
        given:
        writeSpockDependencies()
        file('src/test/groovy/UnrollTest.groovy') << '''
            import spock.lang.Specification
            import spock.lang.Unroll

            class UnrollTest extends Specification {
                @Unroll
                def "can test #type"() {
                    expect: type

import org.gradle.api.internal.attributes.MultipleCandidatesResult
import org.gradle.util.SnapshotTestUtil
import org.gradle.util.TestUtil
import spock.lang.Specification
import spock.lang.Unroll

class TargetJvmVersionRulesTest extends Specification {
    private CompatibilityRule<Object> compatibilityRules
    private DisambiguationRule<Object> disambiguationRules

    def setup() {

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

package org.gradle.buildinit.plugins.internal

import spock.lang.Specification
import spock.lang.Unroll

class VersionCatalogDependencyRegistryTest extends Specification {

    def "tracks library versions"() {
        setup:
        def registry = new VersionCatalogDependencyRegistry(true)

        when:

 */

package org.gradle.plugins.ide.internal.tooling

import org.gradle.plugins.ide.internal.tooling.model.TaskNameComparator
import spock.lang.Specification
import spock.lang.Unroll

class TaskNameComparatorTest extends Specification {
    @Unroll('compares task names #first and #second')
    def compare() {
        def comparator = new TaskNameComparator()

        expect:
        comparator.compare(first, second) < 0

import org.gradle.test.preconditions.IntegTestPreconditions
import spock.lang.Issue
import spock.lang.Unroll

import java.nio.charset.Charset

@DoesNotSupportNonAsciiPaths(reason = "Some tests need to run with ASCII encoding")
class BuildEnvironmentIntegrationTest extends AbstractIntegrationSpec {

    @Unroll("default locale for gradle build switched to #locale")
    def "builds can be executed with different default locales"() {

import org.gradle.internal.resource.transport.http.HttpErrorStatusCodeException
import spock.lang.Specification
import spock.lang.Subject
import spock.lang.Unroll

@Subject(NetworkingIssueVerifier)
class NetworkingIssueVerifierTest extends Specification {

    @Unroll("'#description' is likely transient network issue")
    def "verifies if an exception is a related to transient network issue"() {
        expect:

 */

package org.gradle.internal.reflect

import spock.lang.Shared
import spock.lang.Specification
import spock.lang.Unroll

class DirectInstantiatorCacheTest extends Specification {

    @Shared
    def cache = new DirectInstantiator.ConstructorCache()

    @Unroll("constructor cache returns the same constructors as 'getConstructors' for #clazz")

import org.gradle.api.component.SoftwareComponentVariant
import org.gradle.api.internal.component.SoftwareComponentInternal
import org.gradle.test.fixtures.AbstractProjectBuilderSpec
import spock.lang.Unroll

class JavaPlatformPluginTest extends AbstractProjectBuilderSpec {
    def "applies base plugin"() {
        when:
        project.pluginManager.apply(JavaPlatformPlugin)

        then:

import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache
import spock.lang.Issue
import spock.lang.Unroll

class ConcurrentDerivationStrategyIntegTest extends AbstractIntegrationSpec {

    @ToBeFixedForConfigurationCache
    @Issue("https://github.com/gradle/gradle/issues/13555")
    @Unroll("consistent resolution using rules=#displayName")