public Source(String[] some) {}
                    public String foo(String[] bar) { return "some"; }
                }
            """,
            v2 = """
                import $nullableAnnotationName;
                public class Source {
                    public Source(@Nullable String[] some) {}
                    public String foo(@Nullable String[] bar) { return "some"; }
                }
            """

                    public Source(@Nullable String some) {}
                    @Nullable public String nonFinalField = null;
                    public String foo(@Nullable String bar) { return "some"; }
                }
            """,
            v2 = """
                public class Source {
                    public Source(String some) {}
                    public String nonFinalField = "some";

While a lot of Gradle source code runs only in the Gradle daemon, not all of it does so.
When working on some source code it is important to be aware of the runtimes in which it will run, so that you don't break these constraints.
There is some assistance in the IDE for this plus a lot of validation that is applied at build time and on CI, but it is useful to keep these constraints in mind as well.

        checkNotBinaryCompatibleKotlin(
            v1 = """
                class Source(some: String?) {
                    var someVar: String? = null
                    fun foo(bar: String?) {}
                }
            """,
            v2 = """
                class Source(some: String) {
                    var someVar: String = "some"
                    fun foo(bar: String) {}
                }
            """

# Build execution model

At the highest level, Gradle's execution model is quite simple:

Below is the protocol in some more detail:

1. The client looks for a compatible idle daemon. If there isn't one, it starts a new daemon.
2. The client connects to the idle daemon and sends it a request to do some work. If the daemon is no longer running, the client starts again.

-Dorg.gradle.daemon.idletimeout=120000 -Dorg.gradle.daemon.registry.base=C:\\some\\agent\\workspace\\build\\daemon -Dorg.gradle.native.dir=C:\\some\\agent\\workspace\\intTestHomeDir\\worker-1\\native -Dorg.gradle.deprecation.trace=true -Djava.io.tmpdir=C:\\some\\agent\\workspace\\subprojects\\osgi\\build\\tmp -Dfile.encoding=windows-1252 -Dorg.gradle.classloaderscope.strict=true -ea -ea "-Dorg.gradle.appname=gradle" -classpath "C:\\some\\agent\\workspace\\subprojects\\osgi\\build\\integ test\\bin\\..\\li...

* Be careful when using features introduced in Java 9 or later. Some parts of Gradle still need to run on Java 8.
* Normalize file paths in tests. The `org.gradle.util.internal.TextUtil` class has some useful functions for this purpose.

You can consult the [Architecture documentation](architecture) to learn about some of the architecture of Gradle.

The Wrapper then downloads the Gradle distribution (if necessary), starts the Launcher and runs the build, spawning and connecting to other processes such as the Daemon as required.

Embedding a Java runtime in the distribution would provide some benefits, such as allowing the Launcher, Daemon and Workers to run on it, removing the prerequisite of an installed Java runtime.

plugins {
    `kotlin-dsl`
}

group = "gradlebuild"

description = "Provides a plugin for publishing some of Gradle's subprojects to Artifactory or the Plugin Portal"

dependencies {
    implementation(projects.basics)
    implementation(projects.moduleIdentity)

    implementation(buildLibs.publishPlugin)

    }

    @Test
    public void test_crawlingInfoPager_clear() {
        final CrawlingInfoPager pager = new CrawlingInfoPager();
        pager.id = "some-id";
        pager.sessionId = "some-session";
        pager.setCurrentPageNumber(5);

        pager.clear();

        assertNull(pager.id);
        assertNull(pager.sessionId);
    }

    @Test