// RUN: tf-opt -split-input-file -verify-diagnostics -tf-unroll-batch-matmul %s | FileCheck %s

//==== V1 tests ====

func.func @batchMatMulTwoDim(%arg0: tensor<2x3x4x5xf32>, %arg1: tensor<2x3x5x6xf32>) -> tensor<2x3x4x6xf32> {
  %0 = "tf.BatchMatMul"(%arg0, %arg1) : (tensor<2x3x4x5xf32>, tensor<2x3x5x6xf32>) -> tensor<2x3x4x6xf32>
  func.return %0 : tensor<2x3x4x6xf32>

  // CHECK-LABEL: batchMatMulTwoDim

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.integtests.resolve.AbstractModuleDependencyResolveTest
import spock.lang.Unroll

@RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value = "true")
class ComponentAttributesDynamicVersionIntegrationTest extends AbstractModuleDependencyResolveTest {

    @Unroll("#outcome if component-level attribute is #requested")
    def "component attributes are used to reject fixed version"() {

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:

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

class ErrorHandlingModuleComponentRepositoryTest extends Specification {

    private static final String REPOSITORY_ID = 'abc'
    def delegate = Mock(ModuleComponentRepositoryAccess)