import gradlebuild.basics.releasedVersionsFile
import gradlebuild.basics.repoRoot
import gradlebuild.identity.extension.GradleModuleExtension
import gradlebuild.identity.extension.ReleasedVersionsDetails
import gradlebuild.identity.provider.BuildTimestampFromBuildReceiptValueSource
import gradlebuild.identity.provider.BuildTimestampValueSource
import gradlebuild.identity.tasks.BuildReceipt
import java.util.Optional

plugins {
    `java-base`
}

    new EqualsTester()
        .addEqualityGroup(
            Equivalence.identity().onResultOf(Functions.toStringFunction()),
            Equivalence.identity().onResultOf(Functions.toStringFunction()))
        .addEqualityGroup(Equivalence.equals().onResultOf(Functions.toStringFunction()))
        .addEqualityGroup(Equivalence.identity().onResultOf(Functions.identity()))
        .testEquals();
  }

  public void testEquivalentTo() {

  public void testIdentity_same() {
    Function<@Nullable String, @Nullable String> identity = Functions.identity();
    assertThat(identity.apply(null)).isNull();
    assertThat(identity.apply("foo")).isSameInstanceAs("foo");
  }

  public void testIdentity_notSame() {
    Function<Long, Long> identity = Functions.identity();
    assertThat(identity.apply(new Long(135135L))).isNotSameInstanceAs(new Long(135135L));
  }

        assertFalse(isNotNull.apply(null));
    }

    @Test
    public void test_apply_boolean() {
        BooleanFunction<Boolean> identity = b -> b != null && b;

        assertTrue(identity.apply(true));
        assertFalse(identity.apply(false));
        assertFalse(identity.apply(null));
    }

    @Test
    public void test_lambda_expression() {

    assertThat(stringIdentityConverter.reverse().convert(STR_VAL)).isSameInstanceAs(STR_VAL);

    assertThat(stringIdentityConverter.toString()).isEqualTo("Converter.identity()");

    assertThat(Converter.identity()).isSameInstanceAs(Converter.identity());
  }

  public void testFrom() {
    Function<String, Integer> forward = Integer::parseInt;
    Function<Object, String> backward = toStringFunction();

    companion object {
        const val NAME: String = "gradleModule"
    }

    @get:Nested
    abstract val identity: ModuleIdentity

    fun identity(action: ModuleIdentity.() -> Unit) {
        action(identity)
    }

    /**
     * Describes the target processes that the code in this module must be able

includeBuild("../build-logic-settings")

// Shared basics for all
include("basics")

// Platform: defines shared dependency versions
include("build-platform")

// Compute the identity/version we are building and related details (like current git commit)
include("module-identity")

// Code quality rules common to :build-logic and the root build
include("code-quality-rules")

// Plugins to build :build-logic plugins
include("gradle-plugin")

  public void testIdentity_same() {
    Function<@Nullable String, @Nullable String> identity = Functions.identity();
    assertThat(identity.apply(null)).isNull();
    assertThat(identity.apply("foo")).isSameInstanceAs("foo");
  }

  public void testIdentity_notSame() {
    Function<Long, Long> identity = Functions.identity();
    assertThat(identity.apply(new Long(135135L))).isNotSameInstanceAs(new Long(135135L));
  }

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

import gradlebuild.basics.gradleProperty
import gradlebuild.identity.extension.GradleModuleExtension

plugins {
    id("publishing")
}

val artifactoryUrl
    get() = System.getenv("GRADLE_INTERNAL_REPO_URL") ?: ""

val artifactoryUserName

import gradlebuild.buildutils.tasks.UpdateKotlinVersions
import gradlebuild.buildutils.tasks.UpdateReleasedVersions
import gradlebuild.buildutils.tasks.UpdateSmokeTestedPluginsVersions

plugins {
    id("gradlebuild.module-identity")
}

tasks.named<UpdateDaemonJvm>("updateDaemonJvm") {
    languageVersion = JavaLanguageVersion.of(17)
}

tasks.withType<UpdateReleasedVersions>().configureEach {