sampleProperty.set("original value")

            configurations {
                sample {
                    visible = false
                    canBeResolved = false
                    assert canBeConsumed

                    attributes {
                        attributeProvider(Usage.USAGE_ATTRIBUTE, sampleProperty.map(value -> objects.named(Usage, value)))

    AtomicInteger existingCounter = Maps.safeGet(countMap, element);
    if (existingCounter == null) {
      return false;
    }
    while (true) {
      int oldValue = existingCounter.get();
      if (oldValue < occurrences) {
        return false;
      }
      int newValue = oldValue - occurrences;
      if (existingCounter.compareAndSet(oldValue, newValue)) {
        if (newValue == 0) {

        "deferred -> completed"  | Deferrable.deferred { 5 } | { input -> Deferrable.completed(input + 25) }   | false           | false
        "completed -> deferred"  | Deferrable.completed(5)   | { input -> Deferrable.deferred { input + 25 } } | false           | true

        succeeds("help")
    }

    def "attempting to configure a unknown remote build cache fails with a reasonable error"() {
        settingsFile << """
            buildCache {
                remote {
                    assert false : "should not happen"
                }
            }
        """
        when:
        fails("help")
        then:

        file("src/input-change.txt") << "input"
        fails "incrementalTask", "-PexpectIncremental=true", "-PmodifyOutputs=$modifyOutputs", "-Pfail"

        expect:
        succeeds "incrementalTask", "-PexpectIncremental=$incremental"

        where:
        modifyOutputs | incremental | description
        "add"         | false       | "with additional outputs is fully rebuilt"

// A path will be restricted if:
//   - it falls under the base import path
//   - it does not fall under any of the ignored sub-trees
func (i *ImportRestriction) isRestrictedDir(dir string) (bool, error) {
	if under, err := isPathUnder(i.BaseDir, dir); err != nil {
		return false, err
	} else if !under {
		return false, nil
	}

	for _, ignored := range i.IgnoredSubTrees {

    }

    def "compileBadCode"() {
        expect:
        fails("compileGroovy")
        failure.assertHasErrorOutput 'unable to resolve class Unknown1'
        failure.assertHasErrorOutput 'unable to resolve class Unknown2'
        failure.assertHasCause(compilationFailureMessage)
    }

    def "compileBadJavaCode"() {
        expect:
        fails("compileGroovy")

        1 * variant1.addDependency("g1", "m1", requires("v1"), [], null, ImmutableAttributes.EMPTY, [], false, null)
        1 * variant1.addDependency("g2", "m2", prefers("v2"), [], null, ImmutableAttributes.EMPTY, [], false, null)
        1 * variant1.addDependency("g3", "m3", requires("v3"), excludes("gx:mx", "*:*"), null, ImmutableAttributes.EMPTY, [], false, null)

        delegate.resolveArtifact(artifact, moduleSources, result) >> { throw exception }
        repositoryBlacklister.isDisabled(REPOSITORY_ID) >> false

        when: 'repo is not disabled'
        access.resolveArtifact(artifact, moduleSources, result)

        then: 'resolution fails and repo is disabled'
        1 * repositoryBlacklister.tryDisableRepository(REPOSITORY_ID, { hasCause(it, exception) })

            'org:test:1.0' {
                expectGetMetadata()
            }
        }
        fails ':checkDeps'

        then:
        failure.assertHasCause("Could not resolve org:test:1.0: Resolution strategy disallows usage of changing versions")
    }

    def "fails to resolve a transitive changing dependency"() {
        buildFile << """
            dependencies {