}
            defaultTask.custom = 'another value'
            javaTask.custom = 'another value'
            groovyTask.custom = 'another value'
            assert !project.hasProperty('custom')
            assert defaultTask.hasProperty('custom')
            assert defaultTask.custom == 'another value'
            assert javaTask.custom == 'another value'
            assert groovyTask.custom == 'another value'

This is quite simple (not very useful), but will help us focus on how the sub-dependencies work.

## Second dependency, "dependable" and "dependant"

Then you can create another dependency function (a "dependable") that at the same time declares a dependency of its own (so it is a "dependant" too):

=== "Python 3.10+"

    ```Python hl_lines="13"

    Collection<? extends DependencyGraphEdge> getIncomingEdges();

    Collection<? extends DependencyGraphEdge> getOutgoingEdges();

    /**
     * The outgoing file dependencies of this node. Should be modelled edges to another node, but are treated separately for now.
     */
    Set<? extends LocalFileDependencyMetadata> getOutgoingFileEdges();

    VariantGraphResolveMetadata getMetadata();

    boolean isSelected();

    def setup() {
        buildFile.touch()
        settingsFile << """
            rootProject.name = "root"
        """
    }

    @TargetGradleVersion(">=8.8")
    def "can run a build with Java 21 followed by another build with a different version"() {
        given:
        def jdk21 = AvailableJavaHomes.getJdk21()
        def jdk17 = AvailableJavaHomes.getJdk17()

// A generic type alias may be used like any other generic type.
type A[P any] = RHS[P, int]

func _(a A[string]) {
	a.p = "foo"
	a.q = 42
}

// A generic alias may refer to another generic alias.
type B[P any] = A[P]

func _(a B[string]) {
	a.p = "foo"
	a.q = 42
	// error messages print the instantiated alias type
	a.r /* ERROR "a.r undefined (type B[string] has no field or method r)" */ = 0

/**
 * The option of a command-line tool where to place the paths to some dependencies.
 * A {@code PathType} can identify the Java class-path, the Java module-path,
 * or another kind of path for another programming language for example.
 * Path types are often exclusive. For example, a dependency should not be
 * both on the Java class-path and on the Java module-path.
 *

                                }
                            }
                            testMethodSuite("anotherTestFactory()") {
                                operationDisplayName "another test factory"
                                testDisplayName "another test factory"
                                test("anotherTestFactory()[1]") {
                                    operationDisplayName "foo"

 * that they don't leak the service: the lifetime of the property should be shorter or as long as the lifetime of the cached service.
 *
 * When caching a service inside another service, the property should also be [lazy] to avoid issues with cyclic service initialization and
 * excessive class loading on startup.
 *

					br.Close()
				}
				p.readers[i] = nil

				// Since ReadAt returned error, trigger another read.
				readTriggerCh <- true
				return
			}
			newBufLK.Lock()
			newBuf[bufIdx] = p.buf[bufIdx][:n]
			newBufLK.Unlock()
			// Since ReadAt returned success, there is no need to trigger another read.
			readTriggerCh <- false
		}(readerIndex)
		readerIndex++
	}
	wg.Wait()

	createPod("128.0.0.1", "another-pod")
	assert.Equal(t, sets.New(c.pods.getPodKeys("128.0.0.1")...), sets.New(
		types.NamespacedName{Name: "new-pod", Namespace: "ns"},
		types.NamespacedName{Name: "another-pod", Namespace: "ns"},
	))

	fetch := func() sets.Set[types.NamespacedName] { return sets.New(c.pods.getPodKeys("128.0.0.1")...) }
	pods.Delete("another-pod", "ns")