[(IsNotInLiftedFunc $res),
     (IsEinsumSupportedByXlaDotV2 $equation)],
    [], (addBenefit 10)>;

}
defm : LiftCompositeOpsWithActivation<TF_ReluOp, "relu">;
defm : LiftCompositeOpsWithActivation<TF_Relu6Op, "relu6">;

def LiftGather : Pat<
  (TF_GatherV2Op:$res $params, $indices, $axis, $batch_dims),
  (LiftAsTFPartitionedCall<"composite_gather_fn">

//go:build ignore

/*
 * Input to cgo -cdefs

GOARCH=386 go tool cgo -cdefs defs2_linux.go >defs_linux_386.h

The asm header tricks we have to use for Linux on amd64
(see defs.c and defs1.c) don't work here, so this is yet another
file.  Sigh.
*/

package runtime

/*
#cgo CFLAGS: -I/tmp/linux/arch/x86/include -I/tmp/linux/include -D_LOOSE_KERNEL_NAMES -D__ARCH_SI_UID_T=__kernel_uid32_t

    }

    def "library added to binary is ordered before library for source set"() {
        def binary = testBinary(component)
        def lib1 = new Object()
        def dep1 = Stub(NativeDependencySet)
        def lib2 = new Object()
        def dep2 = Stub(NativeDependencySet)
        def sourceLib = new Object()
        def sourceDep = Stub(NativeDependencySet)

        when:

	FDIVD F2, F0                            // d8f2
	FDIVD F3, F0                            // d8f3
	FDIVD F0, F2                            // dcfa or dcf2
	FDIVD F0, F3                            // dcfb or dcf3
	FDIVD (BX), F0                          // d833 or dc33
	FDIVD (R11), F0                         // 41d833 or 41dc33
	//TODO: FDIVRP F0, F2                   // defa
	//TODO: FDIVRP F0, F3                   // defb

    void "transitive resolution resolves all dependencies"() {
        def context = Mock(org.gradle.api.internal.artifacts.CachingDependencyResolveContext)

        def superConf = project.configurations.create("superConf")
        def conf = project.configurations.create("conf")
        conf.extendsFrom(superConf)

        def dep1 = Mock(ProjectDependency)
        def dep2 = Mock(ExternalDependency)
        conf.dependencies.add(dep1)

	namer := openapi.NewDefinitionNamer(schemes...)
	defs := getDefinitions(func(path string) spec.Ref {
		return spec.MustCreateRef(path)
	})
	for name := range defs {
		_, e := namer.GetDefinitionName(name)
		gvks := extensionsToGVKs(e)
		for _, gvk := range gvks {
			gvkToRef[gvk] = name
		}
	}
	return &DefinitionsSchemaResolver{
		gvkToRef: gvkToRef,
		defs:     defs,
	}
}

	}

	// Through reader. Used to fail.
	r := NewDecoder(RawURLEncoding, bytes.NewReader([]byte(source)))
	dec2, err := io.ReadAll(io.LimitReader(r, 100))
	if err != nil || !bytes.Equal(dec2, want) {
		t.Errorf("reading NewDecoder(RawURLEncoding, %q) = %x, %v, want %x, nil", source, dec2, err, want)
	}

	// Should work with padding.
	r = NewDecoder(URLEncoding, bytes.NewReader([]byte(source+"==")))

    void "knows if is equal to"() {
        when:
        def dep1 = createDependency("group1", "name1", "version1")
        def dep2 = createDependency("group1", "name1", "version1")
        def attr1 = Attribute.of("attr1", String)
        def attr2 = Attribute.of("attr2", Integer)
        dep1.attributes {
            it.attribute(attr1, 'foo')
        }
        dep2.attributes {
            it.attribute(attr2, 123)
        }

            if "dependencies" in branch:
                for dep2 in branch["dependencies"]:
                    processed_deps.append(dep2["repository"])
                    if dep2["branch"] != "master":
                        raise Exception("Looking for master branch and found : %s for destination", dep2,
                                        rule["destination"])
                    if dep2["repository"] == dep:
                        found = True

    }

    def "Check packaging for set packaging"() {
        when:
        String packaging = mavenLocalModule.hasPackaging('war').packaging

        then:
        packaging != null
        packaging == 'war'
    }

    def "Check packaging for no set packaging"() {
        when:
        String packaging = mavenLocalModule.packaging

        then:
        packaging == null
    }