}

    void restart() {
        stop(true)
        before()
    }

    void clearSessions() {
        sshd.activeSessions.each { session ->
            session.close(true)
        }
    }

    @Override
    protected void after() {
        super.after()
        passwordAuthenticationEnabled = true
    }

    private SshServer setupConfiguredTestSshd(int sshPort) {

	}
}

func TestGORMValuer(t *testing.T) {
	type UserWithPoint struct {
		Name  string
		Point Point
	}

	dryRunDB := DB.Session(&gorm.Session{DryRun: true})

	stmt := dryRunDB.Create(&UserWithPoint{
		Name:  "jinzhu",
		Point: Point{X: 100, Y: 100},
	}).Statement

	if stmt.SQL.String() == "" || len(stmt.Vars) != 2 {

		}
	}

	associationDB := association.DB.Session(&Session{}).Model(nil)
	if !association.DB.FullSaveAssociations {
		associationDB.Select(selectedSaveColumns)
	}
	if len(omitColumns) > 0 {
		associationDB.Omit(omitColumns...)
	}
	associationDB = associationDB.Session(&Session{})

	switch reflectValue.Kind() {
	case reflect.Slice, reflect.Array:

#if ( $minimalVersion )
    #set ( $minimal = $Version.getConstructor( $String ).newInstance( $minimalVersion ) )
    #set ( $versions = $versions.headSet( $minimal, false ) )
#else
    #set ( $dummy = $versions.remove( $Version.getConstructor( $String ).newInstance( "0.0.0" ) ) )
#end
#set ( $dummy = $versions.remove( $Version.getConstructor( $String ).newInstance( "32767.32767.32767" ) ) )
#foreach ( $version in $versions )

        .build()
    val session = session(heldCertificate.certificatePem())
    assertThat(verifier.verify("foo.com", session)).isFalse()
    assertThat(verifier.verify("bar.com", session)).isFalse()
    assertThat(verifier.verify("k.com", session)).isTrue()
    assertThat(verifier.verify("K.com", session)).isTrue()
    assertThat(verifier.verify("\u2121.com", session)).isFalse()

            }
        }
    }

    private fun checkUntouchedSessionValidity(
        sessions: Set<SESSION>,
        testServices: TestServices,
    ) {
        sessions.forEach { session ->
            testServices.assertions.assertTrue(isSessionValid(session)) {

    }

    @NotThreadSafe
    class SettingsBuilderRequestBuilder {
        Session session;
        Source globalSettingsSource;
        Source projectSettingsSource;
        Source userSettingsSource;

        public SettingsBuilderRequestBuilder session(Session session) {
            this.session = session;
            return this;
        }

    /**
     * Flattens a list of nodes.
     *
     * @param session
     * @param node
     * @param scope
     * @return
     * @throws DependencyResolverException
     */
    List<Node> flatten(Session session, Node node, PathScope scope) throws DependencyResolverException;

    @Nonnull
    default DependencyResolverResult flatten(@Nonnull Session session, @Nonnull Project project) {
        return flatten(

[libraries]
alias1 = { module = "g:a" }
alias2 = { group = "g", name = "a", version = "" }

    }

    @NotThreadSafe
    class ToolchainsBuilderRequestBuilder {
        Session session;
        Source globalToolchainsSource;
        Source userToolchainsSource;

        public ToolchainsBuilderRequestBuilder session(Session session) {
            this.session = session;
            return this;
        }