Status ConvertAttribute(const mlir::BoolAttr& attr, AttrValue* value) {
  value->set_b(attr.getValue());
  return absl::OkStatus();
}

Status ConvertAttribute(const mlir::IntegerAttr& attr, AttrValue* value) {
  value->set_i(attr.getInt());
  return absl::OkStatus();
}

Status ConvertAttribute(const mlir::FloatAttr& attr, AttrValue* value) {
  value->set_f(attr.getValueAsDouble());
  return absl::OkStatus();
}

    EXPECT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
    EXPECT_FLOAT_EQ(2.718, val);
    TF_DeleteStatus(status);
    return static_cast<void*>(s);
  };

  AttrValue v;
  v.set_f(2.718);
  CreateAndCallKernelWithAttr(my_create_func, "TestKernelAttrFloat", v);
}

TEST_F(TestKernelAttr, FloatList) {
  auto my_create_func = [](TF_OpKernelConstruction* ctx) {

        withLibraryDependencies<DependencyRemovalByNameRule>(libs.sshdScp, setOf("slf4j-simple"))
        withLibraryDependencies<DependencyRemovalByNameRule>(libs.sshdSftp, setOf("slf4j-simple"))
        withLibraryDependencies<DependencyRemovalByNameRule>(libs.gradleProfiler, setOf("slf4j-simple"))
        withLibraryDependencies<DependencyRemovalByNameRule>(libs.samplesCheck, setOf("slf4j-simple"))

  )
val expectedCompileClasspathAndroidVersion =
  expectedReducedRuntimeClasspathAndroidVersion + setOf("j2objc-annotations-3.0.0.jar")
val expectedCompileClasspathJreVersion =
  expectedReducedRuntimeClasspathJreVersion + setOf("j2objc-annotations-3.0.0.jar")

val extraLegacyDependencies = setOf("google-collections-1.0.jar")

buildscript {
  val agpVersion = if (gradle.gradleVersion.startsWith("5.")) "3.6.4" else "7.0.4"

        when:
        def aggregate = subject.aggregate()

        then:
        aggregate.exportedResourcePrefixes == setOf("META-INF/gradle-plugins")
        aggregate.exportedPackages == setOf("kotlin", "org.gradle", "groovy")
    }

    static class SpecProvider1 implements GradleApiSpecProvider {
        @Override
        GradleApiSpecProvider.Spec get() {

                    "d" to listOf("b", "e2")
                )
            ),
            equalTo(
                mapOf(
                    "a" to setOf("e1", "e2"),
                    "b" to setOf("e1"),
                    "c" to setOf("e1", "e2"),
                    "d" to setOf("e1", "e2")
                )
            )
        )
    }

func (t *Mask) Merge(other Mask) {
	*t |= other
}

// MergeMaskable will merge other into t.
func (t *Mask) MergeMaskable(other Maskable) {
	*t |= Mask(other.Mask())
}

// SetIf will add other if b is true.
func (t *Mask) SetIf(b bool, other Mask) {
	if b {
		*t |= other
	}
}

// Mask returns the mask as a uint64.
func (t Mask) Mask() uint64 {
	return uint64(t)
}

	//	print("sumpd a=", a, " len=", len(a), " cap=", cap(a), "\n");
	t := 0
	for i := 0; i < len(a); i++ {
		t += a[i]
	}
	//	print("sumpd t=", t, "\n");
	return t
}

func setpf(a *[20]int) {
	//	print("setpf a=", a, " len=", len(a), " cap=", cap(a), "\n");
	for i := 0; i < len(a); i++ {
		a[i] = i
	}
}

func sumpf(a *[20]int) int {
	//	print("sumpf a=", a, " len=", len(a), " cap=", cap(a), "\n");

                )
            )
        )

        assertEquals(
            mapOf(
                "First.class" to setOf("Second.class", "Third.class", "Forth.class"),
                "Second.class" to emptySet(),
                "Third.class" to setOf("First.class"),
                "Forth.class" to emptySet()
            ),
            result
        )
    }

eclipse {
    classpath {
        plusConfigurations += functional
    }
}

// tag::test-sources[]
eclipse {
    classpath {
        testSourceSets = testSourceSets.get() + setOf(integTest)
        testConfigurations = testConfigurations.get() + setOf(functional)
    }
}
// end::test-sources[]

// tag::test-fixtures[]
eclipse {
    classpath {
        containsTestFixtures = true
    }
}