doLast {
                    val zero = ${ZeroThought::class.qualifiedName}()
                    val light = ${LightThought::class.qualifiedName}()
                    val deep = ${DeepThought::class.qualifiedName}()
                    println("*" + zero.compute() + "*")
                    println("*" + light.compute() + "*")
                    println("*" + deep.compute() + "*")
                }
            }

 * Green background — you can declare dependencies against the configuration.
 * Blue-gray background — the configuration is for consumption by tasks, not for you to declare dependencies.
 * Light blue background with monospace text — a task.

.Java plugin - _main_ source set dependency configurations
image::java-main-configurations.png[]

.Java plugin - _test_ source set dependency configurations

                    // this block and discard the left sibling. Might also need to merge the parent
                    left.mergeFrom(this);
                    parent.maybeMerge();
                    return;
                }
            }

            // Attempt to merge with the right sibling
            IndexBlock right = parent.getNext(this);
            if (right != null) {

        task.nested = new Tree(value: "root", right: new Tree(value: "right", right: new Tree(value: "right")))

        when:
        visitProperties(task)

        then:
        _ * visitor.visitNested() >> true
        noExceptionThrown()
        task.nested.right == task.nested.right.right
    }

    def "nested beans can be re-used"() {

    margin-left: 0;
    padding-left: 0;
}

.last {
    margin-right: 0;
    padding-right: 0;
}

.top {
    margin-top: 0;
    padding-top: 0;
}

.bottom {
    margin-bottom: 0;
    padding-bottom: 0;
}

.citetitle {
    font-style: normal;
}

table th.border-right {
    border-right: solid #d0d0d0 1px;
}

table th.no-border-bottom {

        return simplify(ExcludeAllOf.class, one, two, (left, right) -> doUnion(ImmutableSet.of(left, right)));
    }

    @Override
    public ExcludeSpec allOf(ExcludeSpec one, ExcludeSpec two) {
        return simplify(ExcludeAnyOf.class, one, two, (left, right) -> doIntersect(ImmutableSet.of(left, right)));
    }

    // Simplifies (A ∪ ...) ∩ A = A
    // and  (A ∩ ...) ∪ A = A

 * </p>
 *
 * <ul>
 *     <li>"any state". The provider will return the value and make no guarantees about the content. This might be used, for example, when generating IDE configuration files or models.
 *     The task that generates the configuration file might only care where some output file will end up and not care whether or not that file has been built yet.

Some projects might need to divert from the default behavior and enforce an earlier version of a dependency e.g. if the source code of the project depends on an older API of a dependency than some of the external libraries.

[WARNING]
====
Forcing a version of a dependency requires a conscious decision.

        private final ValueProducer left;
        private final ValueProducer right;

        public PlusProducer(ValueProducer left, ValueProducer right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public boolean isKnown() {
            return left.isKnown() || right.isKnown();
        }

        @Override

        buffer.consumeWhitespace();
        while (buffer.consume("##")) {
            buffer.consumeWhitespace();
            right = buffer.readIdentifier();
            if (right == null) {
                // Need another identifier
                buffer.pos = pos;