}

    def "knows when heap space is exhausted (#rateThreshold <= #rate, #usageThreshold <= #usage)"(double rateThreshold, int usageThreshold, double rate, int usage, boolean unhealthy) {
        given:
        def underTest = new HealthExpirationStrategy(
            Mock(DaemonHealthStats) {
                getHeapStats() >> stats(usage, rate, true)
                getNonHeapStats() >> stats(-1, -1, false)
            },

        classpath.extendsFrom == [runtimeElements] as Set
        def attributes = classpath.attributes.keySet()
        attributes.size() == 2
        def usage = classpath.attributes.getAttribute(Usage.USAGE_ATTRIBUTE)
        usage.name == Usage.JAVA_RUNTIME
        def format = classpath.attributes.getAttribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE)
        format.name == LibraryElements.JAR

    }

                    attribute('org.gradle.usage', 'java-runtime')
                    attribute('org.gradle.libraryelements', 'jar')
                    attribute('org.gradle.category', 'library')
                    artifact('feat1')
                }
                variant('feature2') {
                    capability('org', 'feature-2', '1.0')
                    attribute('org.gradle.usage', 'java-runtime')

    }

    @Override
    public void usage(String usage, Action<? super VariantVersionMappingStrategy> action) {
        variant(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage.class, usage), action);
    }

    @Override
    public void defaultResolutionConfiguration(String usage, String defaultConfiguration) {

        configuration.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage.class, usage));
    }

    private void configureExtension(Project project) {

		t.Fatalf("TestInfo failed: %s", err.Error())
	}
	availablebytes, capacity, usage, inodesTotal, inodesFree, inodeUsage, err = Info(tmpfile1.Name())
	validateInfo(t, availablebytes, capacity, usage, inodesTotal, inodeUsage, inodesFree)
}

func validateInfo(t *testing.T, availablebytes int64, capacity int64, usage int64, inodesTotal int64, inodeUsage int64, inodesFree int64) {

	"time"

	"cmd/go/internal/cfg"
	"cmd/go/internal/modfetch/codehost"
)

func usage() {
	fmt.Fprintf(os.Stderr, "usage: go run shell.go vcs remote\n")
	os.Exit(2)
}

func main() {
	cfg.GOMODCACHE = "/tmp/vcswork"
	log.SetFlags(0)
	log.SetPrefix("shell: ")
	flag.Usage = usage
	flag.Parse()
	if flag.NArg() != 2 {
		usage()
	}

	repo, err := codehost.NewRepo(flag.Arg(0), flag.Arg(1))
	if err != nil {

        buildFile << """
            def usage = Attribute.of('usage', String)
            def format = Attribute.of('format', String)
            allprojects {
                dependencies {
                    attributesSchema {
                        attribute(usage)
                    }
                }
                configurations { compile { attributes.attribute(usage, 'for-compile') } }
            }
        """

                for (ResolvedArtifactResult artifact : importPathConfig.getIncoming().getArtifacts()) {
                    Usage usage = artifact.getVariant().getAttributes().getAttribute(Usage.USAGE_ATTRIBUTE);
                    if (usage != null && Usage.C_PLUS_PLUS_API.equals(usage.getName())) {
                        String moduleName;

                        ComponentIdentifier id = artifact.getId().getComponentIdentifier();

    }
}
// end::artifact-transform-countloc[]

def usage = Attribute.of('usage', String)
def artifactType = Attribute.of('artifactType', String)

dependencies {
    registerTransform(CountLoc) {
        from.attribute(artifactType, 'java')
        to.attribute(artifactType, 'loc')
    }
}

dependencies {
    attributesSchema {
        attribute(usage)
    }
}
configurations.create("compile") {