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();

package unix_test

import (
	"internal/goarch"
	"internal/syscall/unix"
	"runtime"
	"strings"
	"testing"
	"unsafe"
)

// TestSiginfoChildLayout validates SiginfoChild layout. Modelled after
// static assertions in linux kernel's arch/*/kernel/signal*.c.
func TestSiginfoChildLayout(t *testing.T) {
	var si unix.SiginfoChild

	const host64bit = goarch.PtrSize == 8

import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.internal.file.FileCollectionInternal;

import javax.annotation.Nullable;

/**
 * Represents a local file dependency. Should be modelled as a regular dependency, but is treated separately as a migration step.
 */
public interface LocalFileDependencyMetadata {
    /**

    return is_stateless.getValue();

  // Assume ops can be duplicated if modelled.
  return op->isRegistered();
}

// TF dialect fallback for MemoryEffectOpInterface. The filtering for returning
// the interface is done in the return below and here it is empty as it is only
// returned for known not-stateful and unmodelled ops.
struct TensorFlowRegistryEffectInterfaceFallback

     */
    @Nullable
    public IvyArtifactName getDependencyArtifact() {
        return dependencyArtifact;
    }

    /**
     * When a Maven dependency declares a classifier or type attribute, this is modelled as a 'dependency artifact'.
     * This means that instead of resolving the default artifacts for the target dependency, we'll use the one defined
     * for the dependency.
     */

        run("merge")

        then:
        result.assertTasksNotSkipped(":createDirs", ":merge")
        file("output/merged.txt").text == 'new-dir1,new-dir1'
    }

    def "can wire a set of output files modelled using a project level property as input to a task"() {
        buildFile """
            class FileOutputTask extends DefaultTask {
                @InputFile

        return style(style).a(message).resetStyle();
    }

    MessageBuilder style(String style);

    MessageBuilder resetStyle();

    //
    // message building methods modelled after Ansi methods
    //

    @Nonnull
    @Override
    MessageBuilder append(CharSequence cs);

    @Nonnull
    @Override
    MessageBuilder append(CharSequence cs, int start, int end);

         * but the usage happens during runtime and may be associated to a logical entity (e.g. task, plugin).
         *
         * The association between a usage and entity is not modelled by the usage,
         * but can be inferred from the operation stream (for deprecations, for which operation progress events are emitted).
         *

            //it's possible that we receive an output for a suite here
            //in this case we will create the test result for a suite that normally would not be created
            //feels like this scenario should modelled more explicitly
            classResult = new TestClassResult(internalIdCounter++, className, ((TestDescriptorInternal) testDescriptor).getClassDisplayName(), 0);
            results.put(className, classResult);
        }

We want to apply a set of code quality checking rules to both types of projects and configure some aspects specific to each type.


== Organizing build logic

The use case can be modelled by layering three separate plugins:

====
[.multi-language-sample]
=====
.Build logic layout
[source, kotlin]
----
├── convention-plugins
│   ├── build.gradle.kts
│   ├── settings.gradle.kts