ss_flags int32
}

type siginfo struct {
	si_signo  int32
	si_errno  int32
	si_code   int32
	si_pid    int32
	si_uid    uint32
	si_status int32
	si_addr   uintptr
	si_value  [4]byte
	_reason   [32]byte
}

type mcontext struct {
	mc_onstack       uint32
	mc_gs            uint32
	mc_fs            uint32
	mc_es            uint32
	mc_ds            uint32
	mc_edi           uint32

	pad_cgo_0 [4]byte
}

type siginfo struct {
	si_signo  int32
	si_errno  int32
	si_code   int32
	si_pid    int32
	si_uid    uint32
	si_status int32
	si_addr   uint64
	si_value  [8]byte
	_reason   [40]byte
}

type gpregs struct {
	gp_ra      uint64
	gp_sp      uint64
	gp_gp      uint64
	gp_tp      uint64
	gp_t       [7]uint64
	gp_s       [12]uint64
	gp_a       [8]uint64

	pad_cgo_0 [4]byte
}

type siginfo struct {
	si_signo  int32
	si_errno  int32
	si_code   int32
	si_pid    int32
	si_uid    uint32
	si_status int32
	si_addr   uint64
	si_value  [8]byte
	_reason   [40]byte
}

type mcontext struct {
	mc_onstack       uint64
	mc_rdi           uint64
	mc_rsi           uint64
	mc_rdx           uint64
	mc_rcx           uint64
	mc_r8            uint64

            module("org.springframework:spring-aop:${springVersion}", springAopDeps).byReason(reason3)
            module("org.springframework:spring-beans:${springVersion}", springBeansDeps).byReason(reason3)
            module("org.springframework:spring-core:${springVersion}")
            module("org.springframework:spring-expression:${springVersion}", springExpressionDeps).byReason(reason3)
        }
        def springTestDeps = {

        constraint.force = false
        constraint.reason = 'reason1'
        DefaultProjectDependencyConstraint constraintCopy = constraint.copy()

        when:
        constraintCopy.force = true
        constraintCopy.reason = 'reason2'

        then:
        constraint.force == false
        constraint.reason == 'reason1'
    }

    def "resolution result API gives access to dependency reasons in case of conflict"() {
        given:
        mavenRepo.with {
            def leaf1 = module('org.test', 'leaf', '1.0').publish()
            def leaf2 = module('org.test', 'leaf', '1.1').publish()
            module('org.test', 'a', '1.0')
                .dependsOn(leaf1, reason: 'first reason')
                .withModuleMetadata()
                .publish()

        NodeBuilder maybeByReason(String reason) {
            ignoreReasons.add(reason)
            this
        }

        NodeBuilder byConstraint(String reason = null) {
            if (reason == null) {
                reasons << ComponentSelectionCause.CONSTRAINT.defaultReason
            } else {
                reasons << "${ComponentSelectionCause.CONSTRAINT.defaultReason}: $reason".toString()
            }

	}

	if len(condition.Reason) == 0 {
		allErrs = append(allErrs, field.Required(fldPath.Child("reason"), "must be set"))
	} else {
		for _, currErr := range isValidConditionReason(condition.Reason) {
			allErrs = append(allErrs, field.Invalid(fldPath.Child("reason"), condition.Reason, currErr))
		}
		if len(condition.Reason) > maxReasonLen {

	case 2:
		return fmt.Sprintf("%s:%d and %s:%d", reason0, reason0Cnt, reason1, reason1Cnt)
	default:
		return fmt.Sprintf("%s:%d and %d(%d) more reasons", reason0, reason0Cnt, len(req.Reason)-1,
			req.Reason.Count()-reason0Cnt)
	}
}

func doSendPushes(stopCh <-chan struct{}, semaphore chan struct{}, queue *PushQueue) {
	for {
		select {
		case <-stopCh:
			return
		default:

            reasons.add(reason);
        } else if (isNewReason(reasons, reason)) {
            reasons.add(reason);
        }
    }

    private static boolean isNewReason(List<ComponentSelectionDescriptorInternal> reasons, ComponentSelectionDescriptorInternal reason) {
        return (reasons.size() == 1 && !reason.equals(reasons.get(0)))
            || !reasons.contains(reason);
    }

    @Override