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"

                    "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")
                )
            )
        )
    }

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
    }
}

            (*node_def.mutable_attr())["shared_name"].set_s(node_def.name());
          } else {
            // Use the concat of function name and node name for such ops in a
            // function as the shared_name. "@" is used as the separator because
            // it is not allowed in the function name or the node name.
            (*node_def.mutable_attr())["shared_name"].set_s(
                absl::StrCat(node_def.name(), "@", func_name));

  }

  kotlinOptions {
    jvmTarget = JavaVersion.VERSION_11.toString()
  }

  // issue merging due to conflict with httpclient and something else
  packagingOptions.resources.excludes += setOf(
    "META-INF/DEPENDENCIES"
  )
}


dependencies {
  val okhttpLegacyVersion = "3.12.12"

  implementation(libs.kotlin.reflect)
  implementation(libs.playservices.safetynet)

// tag::declare_capability[]
dependencies {
    // Activate the "LoggingCapability" rule
    components.all(LoggingCapability::class.java)
}

class LoggingCapability : ComponentMetadataRule {
    val loggingModules = setOf("log4j", "log4j-over-slf4j")

    override
    fun execute(context: ComponentMetadataContext) = context.details.run {
        if (loggingModules.contains(id.name)) {
            allVariants {

 * configured in the Settings DSL.
 */
internal
fun projectInterpretationSequenceStep(softwareTypeRegistry: SoftwareTypeRegistry) = SimpleInterpretationSequenceStepWithConversion(
    "project",
    features = setOf(ConventionApplication()),
) {
    projectEvaluationSchema(softwareTypeRegistry)