bv, _ := strconv.ParseBool(defVal)
	AssertEqual(t, bv, false)
	AssertEqual(t, ok, true)

	// default 'null' -> 'null'
	session := DB.Session(&gorm.Session{Logger: Tracer{
		Logger: DB.Config.Logger,
		Test: func(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error) {
			sql, _ := fc()
			if strings.HasPrefix(sql, "ALTER TABLE") {

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.smb;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSException;
import jcifs.CloseableIterator;
import jcifs.ResourceNameFilter;
import jcifs.SmbConstants;
import jcifs.SmbResource;
import jcifs.SmbResourceLocator;

package logger

import (
	"database/sql/driver"
	"fmt"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"time"
	"unicode"

	"gorm.io/gorm/utils"
)

const (
	tmFmtWithMS = "2006-01-02 15:04:05.999"
	tmFmtZero   = "0000-00-00 00:00:00"
	nullStr     = "NULL"
)

func isPrintable(s string) bool {
	for _, r := range s {
		if !unicode.IsPrint(r) {
			return false
		}
	}
	return true
}

        </rule-config>
        <rule-config name='FieldName'>
            <property name='finalRegex' value='^[a-z][a-zA-Z0-9]*$'/>
            <property name='staticFinalRegex' value='^logger$|^[A-Z][A-Z_0-9]*$|^serialVersionUID$'/>
        </rule-config>
        <rule-config name='MethodName'>
            <property name='regex' value='^[a-z][\$_a-zA-Z0-9]*$|^.*\s.*$'/>
        </rule-config>

    }

    /** The role name for general settings administration. */
    public static final String ROLE = "admin-general";

    private static final String DUMMY_PASSWORD = "**********";

    private static final Logger logger = LogManager.getLogger(AdminGeneralAction.class);

    // ===================================================================================

import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.util.concurrent.locks.ReentrantLock;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.internal.CommonServerMessageBlock;
import jcifs.internal.SMBSigningDigest;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Crypto;

/**

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.SmbTransport;
import jcifs.internal.CommonServerMessageBlock;

/**
 * Handles failover and recovery for multi-channel connections
 */
public class ChannelFailover {

    private static final Logger log = LoggerFactory.getLogger(ChannelFailover.class);

// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package logger

import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"regexp"
	"runtime"

	"github.com/minio/minio/internal/color"
)

var ansiRE = regexp.MustCompile("(\x1b[^m]*m)")

	}
	return rows, tx.Error
}

// Scan scans selected value to the struct dest
func (db *DB) Scan(dest interface{}) (tx *DB) {
	config := *db.Config
	currentLogger, newLogger := config.Logger, logger.Recorder.New()
	config.Logger = newLogger

	tx = db.getInstance()
	tx.Config = &config

	if rows, err := tx.Rows(); err == nil {
		if rows.Next() {
			tx.ScanRows(rows, dest)
		} else {
			tx.RowsAffected = 0

        </rule-config>
        <rule-config name='FieldName'>
            <property name='finalRegex' value='^[a-z][a-zA-Z0-9]*$'/>
            <property name='staticFinalRegex' value='^logger$|^[A-Z][A-Z_0-9]*$|^serialVersionUID$'/>
        </rule-config>
        <rule-config name='MethodName'>
            <property name='regex' value='^[a-z][\$_a-zA-Z0-9]*$|^.*\s.*$'/>
        </rule-config>