return propertyMetadata.isAnnotationPresent(SkipWhenEmpty.class)
            ? InputBehavior.PRIMARY
            : propertyMetadata.isAnnotationPresent(Incremental.class)
            ? InputBehavior.INCREMENTAL
            : InputBehavior.NON_INCREMENTAL;
    }

    private static LineEndingSensitivity determineLineEndingSensitivity(PropertyMetadata propertyMetadata) {

        executedAndNotSkipped ":run"
    }

    def "is not incremental by default"() {
        when:
        run "run"

        then:
        executedAndNotSkipped ":run"

        when:
        run "run"

        then:
        executedAndNotSkipped ":run"
    }

    def 'arguments passed via command line take precedence and is not incremental by default'() {
        when:

│       ├── gradle-4.9-all
│       └── gradle-4.9-bin
└── gradle.properties       // <8>
----
<1> Global cache directory (for everything that is not project-specific).
<2> Version-specific caches (e.g., to support incremental builds).
<3> Shared caches (e.g., for artifacts of dependencies).
<4> Registry and logs of the <<gradle_daemon.adoc#gradle_daemon, Gradle Daemon>>.
<5> Global <<init_scripts.adoc#init_scripts, initialization scripts>>.

        when:
        def returnedResult = step.execute(work, context)
        then:
        _ * work.executionBehavior >> UnitOfWork.ExecutionBehavior.INCREMENTAL
        _ * context.changes >> optionalChanges
        1 * changes.createInputChanges() >> inputChanges
        1 * inputChanges.incremental >> true
        1 * delegate.execute(work, _ as InputChangesContext) >> { UnitOfWork work, InputChangesContext context ->

    Request createRequest(UnitOfWork work);

    interface Request {
        /**
         * Force the re-execution of the unit of work, disabling optimizations
         * like up-to-date checks, build cache and incremental execution.
         */
        void forceNonIncremental(String nonIncremental);

        /**
         * Set the validation context to use during execution.
         */

import org.gradle.internal.typeconversion.CrossBuildCachingNotationConverter;
import org.gradle.internal.typeconversion.NotationParser;
import org.gradle.internal.typeconversion.NotationParserBuilder;
import org.gradle.work.Incremental;
import org.gradle.work.NormalizeLineEndings;

class DependencyManagementGlobalScopeServices implements ServiceRegistrationProvider {
    void configure(ServiceRegistration registration) {

val spockVersion = if (isGroovy4) "2.2-groovy-4.0" else "2.2-groovy-3.0"
val asmVersion = "9.7"
// To try out better kotlin compilation avoidance and incremental compilation
// with -Pkotlin.incremental.useClasspathSnapshot=true
val kotlinVersion = providers.gradleProperty("buildKotlinVersion")
    .getOrElse(embeddedKotlinVersion)

dependencies {
    constraints {

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.compile.incremental.processing;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import org.gradle.api.internal.tasks.compile.incremental.compilerapi.deps.GeneratedResource;
import org.gradle.internal.serialize.HierarchicalNameSerializer;

		if len(extraDeletes) > 0 {
			log.Errorf("%s: TEST for node:%s unexpected deletions: %v %v", v3.GetShortType(w.TypeUrl), con.proxy.ID, details, extraDeletes)
		}
		if len(missedDeletes) > 0 && !incremental {
			// We can skip this if we are incremental; this expects us to only send a partial list. So these are not actually deletes
			log.Errorf("%s: TEST for node:%s missed deletions: %v %v", v3.GetShortType(w.TypeUrl), con.proxy.ID, details, missedDeletes)

			// push, recomputing push context. Doing that on every IP change doesn't scale, so we need these to remain
			// incremental pushes.
			// This allows waypoints only to push LDS on incremental pushes to Address type which would otherwise be skipped.
			return true
		}
		// Otherwise, only handle full pushes (skip endpoint-only updates)
		if !req.Full {
			return false
		}