if (whenExpression != null) {
                    val subject = whenExpression.subjectExpression ?: return with(analysisSession) { builtinTypes.boolean }
                    val kotlinType = analysisContext.analyze(subject).getType(subject)
                    return kotlinType?.toKtNonErrorType(analysisContext)
                }
            }

                }
            }
        }

        private ModelReference<?> mapSubject(ModelReference<?> subject, ModelPath targetPath) {
            if (subject.getPath() == null) {
                return subject.inScope(targetPath);
            } else {
                return subject.withPath(targetPath.descendant(subject.getPath()));
            }
        }

        }
    }

    @Override
    public <T> void bind(ModelReference<T> subject, ModelActionRole role, ModelAction mutator) {
        bindInternal(subject, role, mutator);
    }

    private <T> RuleBinder bindInternal(ModelReference<T> subject, ModelActionRole role, ModelAction mutator) {
        BindingPredicate mappedSubject = mapSubject(subject, role);
        List<BindingPredicate> mappedInputs = mapInputs(mutator.getInputs());

     */
    String getMailSmtpServerMainHostAndPort();

    /**
     * Get the value for the key 'mail.subject.test.prefix'. <br>
     * The value is, e.g. [Test] <br>
     * comment: The prefix of subject to show test environment or not
     * @return The value of found property. (NotNull: if not found, exception but basically no way)
     */

import org.gradle.util.ConcurrentSpecification
import spock.lang.Subject

class WorkerDaemonClientsManagerTest extends ConcurrentSpecification {
    def options = Stub(DaemonForkOptions)
    def starter = Stub(WorkerDaemonStarter)
    def listenerManager = Stub(ListenerManager)
    def loggingManager = Stub(LoggingManagerInternal)
    def memoryManager = Mock(MemoryManager)

    @Subject

}

func (e UnknownAuthorityError) Error() string {
	s := "x509: certificate signed by unknown authority"
	if e.hintErr != nil {
		certName := e.hintCert.Subject.CommonName
		if len(certName) == 0 {
			if len(e.hintCert.Subject.Organization) > 0 {
				certName = e.hintCert.Subject.Organization[0]
			} else {
				certName = "serial:" + e.hintCert.SerialNumber.String()
			}
		}

            putValue(data, "Sender", message.getSender());
            putValue(data, "Sent-Date", message.getSentDate());
            putValue(data, "Size", message.getSize());
            putValue(data, "Subject", message.getSubject());
            putValue(data, "Receipients", message.getAllRecipients());
            putValue(data, "To", message.getRecipients(Message.RecipientType.TO));

        failure.assertHasCause("Attempt to modify a read only view of model element 'people' of type 'ModelMap<Person>' given to rule RulePlugin#mutate(ModelMap<Task>, ModelMap<Person>)")
    }

    def "cannot mutate when used as subject of validate rule"() {
        when:
        buildScript '''
            @Managed
            interface Person extends Named {
              String getValue()
              void setValue(String string)

Contributor.

2. GRANT OF RIGHTS

  a) Subject to the terms of this Agreement, each Contributor hereby
  grants Recipient a non-exclusive, worldwide, royalty-free copyright
  license to reproduce, prepare Derivative Works of, publicly display,
  publicly perform, Distribute and sublicense the Contribution of such
  Contributor, if any, and such Derivative Works.

  b) Subject to the terms of this Agreement, each Contributor hereby

import spock.lang.Specification
import spock.lang.Subject

import java.util.function.Function

class DefaultUserInputHandlerTest extends Specification {

    private static final String TEXT = 'Accept license?'
    def outputEventBroadcaster = Mock(OutputEventListener)
    def userInputReader = Mock(UserInputReader)
    def clock = Mock(Clock)
    @Subject