if !regexp.MustCompile("SELECT \\* FROM `user`").MatchString(r.Statement.SQL.String()) {
		t.Errorf("Table with escape character, got %v", r.Statement.SQL.String())
	}

	r = dryDB.Table("user as u").Select("name").Find(&User{}).Statement
	if !regexp.MustCompile("SELECT .name. FROM user as u WHERE .u.\\..deleted_at. IS NULL").MatchString(r.Statement.SQL.String()) {

	sql := DB.Dialector.Explain(stmt.SQL.String(), stmt.Vars...)
	if !regexp.MustCompile(`.*age.*=8,`).MatchString(sql) {
		t.Errorf("Failed to generate sql, got %v", sql)
	}

	stmt = dryRunDB.Model(&user).Where("id = ?", 1).Updates(map[string]interface{}{"age": ageUint64(10241024)}).Statement
	sql = DB.Dialector.Explain(stmt.SQL.String(), stmt.Vars...)
	if !regexp.MustCompile(`.*age.*=10241024,`).MatchString(sql) {

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

    public static final String REGEXP = "regexp:";

    public static final String REGEXP_CASE = "regexpCase:";

    public static final String REGEXP_IGNORE_CASE = "regexpIgnoreCase:";

    public static final String CONTAINS = "contains:";

    protected static final String COLLECTIONS = "collections";

		os.RemoveAll(tempDirJSON)
		os.RemoveAll(validTempDirJSON)
	})

	cases := []struct {
		name           string
		args           []string
		wantError      bool
		expectedRegexp *regexp.Regexp // Expected regexp output
	}{
		{
			name:      "valid port naming service",
			args:      []string{"--filename", validPortNamingSvcFile},
			wantError: false,
		},
		{

        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setDocId_Regexp(String docId) {
        setDocId_Regexp(docId, null);
    }

    public void setDocId_Regexp(String docId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
        RegexpQueryBuilder builder = regRegexpQ("docId", docId);
        if (opLambda != null) {

package tests_test

import (
	"context"
	"database/sql"
	"database/sql/driver"
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"regexp"
	"strconv"
	"testing"
	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	. "gorm.io/gorm/utils/tests"
)

func TestScannerValuer(t *testing.T) {
	DB.Migrator().DropTable(&ScannerValuerStruct{})
	if err := DB.Migrator().AutoMigrate(&ScannerValuerStruct{}); err != nil {

// the regexes must include two named groups "poduid" and "containerid"
// if the regex needs to exclude certain substrings, the "mustnotmatch" group can be used
// nolint: lll
var cgroupREs = []*regexp.Regexp{
	// the regex used to parse out the pod UID and container ID from a
	// cgroup name. It assumes that any ".scope" suffix has been trimmed off
	// beforehand.  CAUTION: we used to verify that the pod and container id were

        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setElevateWordId_Regexp(String elevateWordId) {
        setElevateWordId_Regexp(elevateWordId, null);
    }

    public void setElevateWordId_Regexp(String elevateWordId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
        RegexpQueryBuilder builder = regRegexpQ("elevateWordId", elevateWordId);

        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setCrawlingInfoId_Regexp(String crawlingInfoId) {
        setCrawlingInfoId_Regexp(crawlingInfoId, null);
    }

    public void setCrawlingInfoId_Regexp(String crawlingInfoId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
        RegexpQueryBuilder builder = regRegexpQ("crawlingInfoId", crawlingInfoId);

        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setName_Regexp(String name) {
        setName_Regexp(name, null);
    }

    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
        RegexpQueryBuilder builder = regRegexpQ("name", name);
        if (opLambda != null) {