scm("commons-codec:commons-codec:1.7")
    scm("some:unresolved:2.5")
}

// tag::walk-task[]
tasks.register<DependencyGraphWalk>("walkDependencyGraph") {
    dependencies = configurations["scm"].incoming
}

abstract class DependencyGraphWalk: DefaultTask() {

    @get:Input
    abstract val dependencies: Property<ResolvableDependencies>

    @TaskAction
    fun walk() {

    compile files(f)
}

task redThings {
    def files = configurations.compile.incoming.artifactView {
        attributes {
            attribute(type, "red")
        }
    }.files
    doLast {
        files*.name
    }
}

task blueThings {
    def files = configurations.compile.incoming.artifactView {
        attributes {
            attribute(type, "blue")
        }
    }.files

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Package resourcequota enforces all incoming requests against any applied quota
// in the namespace context of the request

   */
  private fun doReadTimeout() = !connection.client || sink.closed || sink.finished

  /**
   * A source that reads the incoming data frames of a stream. Although this class uses
   * synchronization to safely receive incoming data frames, it is not intended for use by multiple
   * readers.
   */
  inner class FramingSource internal constructor(

            </thead>
            <tr>
                <td>description</td>
            </tr>
            <tr>
                <td>state</td>
            </tr>
            <tr>
                <td>incoming</td>
            </tr>
            <tr>
                <td>visible</td>
            </tr>
            <tr>
                <td>transitive</td>
            </tr>
            <tr>

    }

    Set<EdgeState> getIncomingEdges() {
        Set<EdgeState> incoming = new LinkedHashSet<>();
        if (selected != null) {
            for (NodeState nodeState : selected.getNodes()) {
                incoming.addAll(nodeState.getIncomingEdges());
            }
        }
        return incoming;
    }

    VirtualPlatformState getPlatformState() {
        if (platformState == null) {

import org.gradle.api.internal.tasks.TaskDependencyResolveContext;

import javax.annotation.Nullable;
import java.util.HashSet;
import java.util.Set;

/**
 * A {@link TaskDependencyResolveContext} which visits incoming dependencies if they are {@link TaskDependencyContainer} instances.
 */
public abstract class AbstractTaskDependencyContainerVisitingContext extends AbstractTaskDependencyResolveContext {

        buildFile << """
            task check${name} {
                def files = configurations.${name}
                def incomingFiles = files.incoming.files
                def artifactFiles = files.incoming.artifactView{}.files
                def artifacts = files.incoming.artifactView{}.artifacts
                doLast {
                    assert files.collect { it.name } == [${fileNames}]

                    }
                }
                ["blue", "green"].each { type ->
                    tasks.register("resolve\${type.capitalize()}") {
                        def artifacts = configurations.compile.incoming.artifactView {
                            attributes { it.attribute(artifactType, type) }
                        }.artifacts

                        inputs.files artifacts.artifactFiles

        repo.createLightWeightTag("1.2")
        dependency(dependencyName)

        buildFile << """
            classes.doLast {
                def components = configurations.runtimeClasspath.incoming.resolutionResult.allComponents.id
                assert components.size() == 3
                assert components[0].build.buildPath == ':'
                assert components[0].build.name == ':'