dependency('org', 'optionaldep', '1.0')
            noMoreDependencies()
        }
        javaLibrary.parsedIvy.dependencies.size() == 1
        javaLibrary.parsedIvy.dependencies['org:optionaldep:1.0'].hasConf('featureRuntimeElements->default')

        and:
        resolveArtifacts(javaLibrary) { expectFiles "publishTest-1.9.jar" }
        resolveApiArtifacts(javaLibrary) { expectFiles "publishTest-1.9.jar" }

    @Override
    public void reset () {
        super.reset();
        this.isPrimary = this.hasMore = true;
    }


    protected void reset ( int key, String lastName ) {
        reset();
    }


    @Override
    public boolean hasMoreElements () {
        return this.hasMore;
    }


    @Override
    public SmbComTransaction nextElement () {

		got[strings.TrimPrefix(string(match), " can inline ")] = true
		return nil
	})
	wantInlinable := []string{
		"(*uint128).halves",
		"Addr.BitLen",
		"Addr.hasZone",
		"Addr.Is4",
		"Addr.Is4In6",
		"Addr.Is6",
		"Addr.IsInterfaceLocalMulticast",
		"Addr.IsValid",
		"Addr.IsUnspecified",
		"Addr.Less",
		"Addr.Unmap",
		"Addr.Zone",
		"Addr.v4",
		"Addr.v6",

        secondaryParameterOffset = SECONDARY_PARAMETER_OFFSET;
    }

    void reset() {
        super.reset();
        isPrimary = hasMore = true; 
    }
    void reset( int key, String lastName ) {
        reset();
    }
    public boolean hasMoreElements() {
        return hasMore;
    }
    public Object nextElement() {
        if( isPrimary ) {
            isPrimary = false;

    String org
    String module
    String revision
    String revisionConstraint
    Set<String> confs
    String transitive
    Collection<IvyDescriptorDependencyExclusion> exclusions = []

    boolean hasConf(String conf) {
        this.confs.contains(conf)
    }

    boolean transitiveEnabled() {
        transitive != 'false'
    }

    boolean hasExcludes() {
        exclusions
    }

        assert this.ext == ext
        assert this.type == type
        assert this.conf == conf
        assert this.classifier == classifier
    }

    IvyDescriptorArtifact hasConf(def conf) {
        assert this.conf == conf
        return this
    }

    IvyDescriptorArtifact hasType(def type) {
        assert this.type == type
        return this
    }

	}
	return association.Error
}

func (association *Association) Append(values ...interface{}) error {
	if association.Error == nil {
		switch association.Relationship.Type {
		case schema.HasOne, schema.BelongsTo:
			if len(values) > 0 {
				association.Error = association.Replace(values...)
			}
		default:
			association.saveAssociation( /*clear*/ false, values...)
		}
	}

	return association.Error

        class BinaryTasksPlugin extends RuleSource {
            @BinaryTasks
            void createTasks(ModelMap<Task> tasks, SampleBinary binary) {
                tasks.create("\${binary.projectScopedName}TaskOne"){
                    it.doLast{
                        println "running \${it.name}"
                    }
                }
                tasks.create("\${binary.projectScopedName}TaskTwo"){

            String key = StringUtils.substringBefore(it, "@")
            String conf = StringUtils.substringAfter(it, "@") + "->default"
            assert dependencies.containsKey(key)
            assert dependencies[key].hasConf(conf)
        }
        true
    }

    def assertConfigurationDependsOn(String configuration, String[] expected) {

				DeploymentID: globalDeploymentID(),
			},
		},
	}

	go fetchHealthInfo(healthCtx, objectAPI, &query, healthInfoCh, healthInfo)

	for {
		select {
		case hi, hasMore := <-healthInfoCh:
			if !hasMore {
				auditOptions := AuditLogOptions{Event: "callhome:diagnostics"}
				// Received all data. Send to SUBNET and return
				err := sendHealthInfo(ctx, healthInfo)
				if err != nil {