Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use Close method of executor Package

Best K6 code snippet using executor.Close

executor_test.go

Source:executor_test.go

...123	if result.Err != query.ErrQueryInterrupted {124		t.Errorf("unexpected error: %s", result.Err)125	}126}127func TestQueryExecutor_KillQuery_CloseTaskManager(t *testing.T) {128	q, err := influxql.ParseQuery(`SELECT count(value) FROM cpu`)129	if err != nil {130		t.Fatal(err)131	}132	qid := make(chan uint64)133	// Open a channel to stall the statement executor forever. This keeps the statement executor134	// running even after we kill the query which can happen with some queries. We only close it once135	// the test has finished running.136	done := make(chan struct{})137	defer close(done)138	e := NewQueryExecutor()139	e.StatementExecutor = &StatementExecutor{140		ExecuteStatementFn: func(stmt influxql.Statement, ctx *query.ExecutionContext) error {141			switch stmt.(type) {142			case *influxql.KillQueryStatement, *influxql.ShowQueriesStatement:143				return e.TaskManager.ExecuteStatement(stmt, ctx)144			}145			qid <- ctx.QueryID146			<-done147			return nil148		},149	}150	// Kill the query. This should switch it into a zombie state.151	go discardOutput(e.ExecuteQuery(q, query.ExecutionOptions{}, nil))152	q, err = influxql.ParseQuery(fmt.Sprintf("KILL QUERY %d", <-qid))153	if err != nil {154		t.Fatal(err)155	}156	discardOutput(e.ExecuteQuery(q, query.ExecutionOptions{}, nil))157	// Display the queries and ensure that the original is still in there.158	q, err = influxql.ParseQuery("SHOW QUERIES")159	if err != nil {160		t.Fatal(err)161	}162	tasks := e.ExecuteQuery(q, query.ExecutionOptions{}, nil)163	// The killed query should still be there.164	task := <-tasks165	if len(task.Series) != 1 {166		t.Errorf("expected %d series, got %d", 1, len(task.Series))167	} else if len(task.Series[0].Values) != 2 {168		t.Errorf("expected %d rows, got %d", 2, len(task.Series[0].Values))169	}170	// Close the task manager to ensure it doesn't cause a panic.171	if err := e.TaskManager.Close(); err != nil {172		t.Errorf("unexpected error: %s", err)173	}174}175func TestQueryExecutor_KillQuery_AlreadyKilled(t *testing.T) {176	q, err := influxql.ParseQuery(`SELECT count(value) FROM cpu`)177	if err != nil {178		t.Fatal(err)179	}180	qid := make(chan uint64)181	// Open a channel to stall the statement executor forever. This keeps the statement executor182	// running even after we kill the query which can happen with some queries. We only close it once183	// the test has finished running.184	done := make(chan struct{})185	defer close(done)186	e := NewQueryExecutor()187	e.StatementExecutor = &StatementExecutor{188		ExecuteStatementFn: func(stmt influxql.Statement, ctx *query.ExecutionContext) error {189			switch stmt.(type) {190			case *influxql.KillQueryStatement, *influxql.ShowQueriesStatement:191				return e.TaskManager.ExecuteStatement(stmt, ctx)192			}193			qid <- ctx.QueryID194			<-done195			return nil196		},197	}198	// Kill the query. This should switch it into a zombie state.199	go discardOutput(e.ExecuteQuery(q, query.ExecutionOptions{}, nil))200	q, err = influxql.ParseQuery(fmt.Sprintf("KILL QUERY %d", <-qid))201	if err != nil {202		t.Fatal(err)203	}204	discardOutput(e.ExecuteQuery(q, query.ExecutionOptions{}, nil))205	// Now attempt to kill it again. We should get an error.206	results := e.ExecuteQuery(q, query.ExecutionOptions{}, nil)207	result := <-results208	if got, want := result.Err, query.ErrAlreadyKilled; got != want {209		t.Errorf("unexpected error: got=%v want=%v", got, want)210	}211}212func TestQueryExecutor_Interrupt(t *testing.T) {213	q, err := influxql.ParseQuery(`SELECT count(value) FROM cpu`)214	if err != nil {215		t.Fatal(err)216	}217	e := NewQueryExecutor()218	e.StatementExecutor = &StatementExecutor{219		ExecuteStatementFn: func(stmt influxql.Statement, ctx *query.ExecutionContext) error {220			select {221			case <-ctx.Done():222				return ctx.Err()223			case <-time.After(100 * time.Millisecond):224				t.Error("killing the query did not close the channel after 100 milliseconds")225				return errUnexpected226			}227		},228	}229	closing := make(chan struct{})230	results := e.ExecuteQuery(q, query.ExecutionOptions{}, closing)231	close(closing)232	result := <-results233	if result.Err != query.ErrQueryInterrupted {234		t.Errorf("unexpected error: %s", result.Err)235	}236}237func TestQueryExecutor_Abort(t *testing.T) {238	q, err := influxql.ParseQuery(`SELECT count(value) FROM cpu`)239	if err != nil {240		t.Fatal(err)241	}242	ch1 := make(chan struct{})243	ch2 := make(chan struct{})244	e := NewQueryExecutor()245	e.StatementExecutor = &StatementExecutor{246		ExecuteStatementFn: func(stmt influxql.Statement, ctx *query.ExecutionContext) error {247			<-ch1248			if err := ctx.Send(&query.Result{Err: errUnexpected}); err != query.ErrQueryAborted {249				t.Errorf("unexpected error: %v", err)250			}251			close(ch2)252			return nil253		},254	}255	done := make(chan struct{})256	close(done)257	results := e.ExecuteQuery(q, query.ExecutionOptions{AbortCh: done}, nil)258	close(ch1)259	<-ch2260	discardOutput(results)261}262func TestQueryExecutor_ShowQueries(t *testing.T) {263	e := NewQueryExecutor()264	e.StatementExecutor = &StatementExecutor{265		ExecuteStatementFn: func(stmt influxql.Statement, ctx *query.ExecutionContext) error {266			switch stmt.(type) {267			case *influxql.ShowQueriesStatement:268				return e.TaskManager.ExecuteStatement(stmt, ctx)269			}270			t.Errorf("unexpected statement: %s", stmt)271			return errUnexpected272		},273	}274	q, err := influxql.ParseQuery(`SHOW QUERIES`)275	if err != nil {276		t.Fatal(err)277	}278	results := e.ExecuteQuery(q, query.ExecutionOptions{}, nil)279	result := <-results280	if len(result.Series) != 1 {281		t.Errorf("expected %d series, got %d", 1, len(result.Series))282	} else if len(result.Series[0].Values) != 1 {283		t.Errorf("expected %d row, got %d", 1, len(result.Series[0].Values))284	}285	if result.Err != nil {286		t.Errorf("unexpected error: %s", result.Err)287	}288}289func TestQueryExecutor_Limit_Timeout(t *testing.T) {290	q, err := influxql.ParseQuery(`SELECT count(value) FROM cpu`)291	if err != nil {292		t.Fatal(err)293	}294	e := NewQueryExecutor()295	e.StatementExecutor = &StatementExecutor{296		ExecuteStatementFn: func(stmt influxql.Statement, ctx *query.ExecutionContext) error {297			select {298			case <-ctx.Done():299				return ctx.Err()300			case <-time.After(time.Second):301				t.Errorf("timeout has not killed the query")302				return errUnexpected303			}304		},305	}306	e.TaskManager.QueryTimeout = time.Nanosecond307	results := e.ExecuteQuery(q, query.ExecutionOptions{}, nil)308	result := <-results309	if result.Err == nil || !strings.Contains(result.Err.Error(), "query-timeout") {310		t.Errorf("unexpected error: %s", result.Err)311	}312}313func TestQueryExecutor_Limit_ConcurrentQueries(t *testing.T) {314	q, err := influxql.ParseQuery(`SELECT count(value) FROM cpu`)315	if err != nil {316		t.Fatal(err)317	}318	qid := make(chan uint64)319	e := NewQueryExecutor()320	e.StatementExecutor = &StatementExecutor{321		ExecuteStatementFn: func(stmt influxql.Statement, ctx *query.ExecutionContext) error {322			qid <- ctx.QueryID323			<-ctx.Done()324			return ctx.Err()325		},326	}327	e.TaskManager.MaxConcurrentQueries = 1328	defer e.Close()329	// Start first query and wait for it to be executing.330	go discardOutput(e.ExecuteQuery(q, query.ExecutionOptions{}, nil))331	<-qid332	// Start second query and expect for it to fail.333	results := e.ExecuteQuery(q, query.ExecutionOptions{}, nil)334	select {335	case result := <-results:336		if len(result.Series) != 0 {337			t.Errorf("expected %d rows, got %d", 0, len(result.Series))338		}339		if result.Err == nil || !strings.Contains(result.Err.Error(), "max-concurrent-queries") {340			t.Errorf("unexpected error: %s", result.Err)341		}342	case <-qid:343		t.Errorf("unexpected statement execution for the second query")344	}345}346func TestQueryExecutor_Close(t *testing.T) {347	q, err := influxql.ParseQuery(`SELECT count(value) FROM cpu`)348	if err != nil {349		t.Fatal(err)350	}351	ch1 := make(chan struct{})352	ch2 := make(chan struct{})353	e := NewQueryExecutor()354	e.StatementExecutor = &StatementExecutor{355		ExecuteStatementFn: func(stmt influxql.Statement, ctx *query.ExecutionContext) error {356			close(ch1)357			<-ctx.Done()358			return ctx.Err()359		},360	}361	results := e.ExecuteQuery(q, query.ExecutionOptions{}, nil)362	go func(results <-chan *query.Result) {363		result := <-results364		if result.Err != query.ErrQueryEngineShutdown {365			t.Errorf("unexpected error: %s", result.Err)366		}367		close(ch2)368	}(results)369	// Wait for the statement to start executing.370	<-ch1371	// Close the query executor.372	e.Close()373	// Check that the statement gets interrupted and finishes.374	select {375	case <-ch2:376	case <-time.After(100 * time.Millisecond):377		t.Fatal("closing the query manager did not kill the query after 100 milliseconds")378	}379	results = e.ExecuteQuery(q, query.ExecutionOptions{}, nil)380	result := <-results381	if len(result.Series) != 0 {382		t.Errorf("expected %d rows, got %d", 0, len(result.Series))383	}384	if result.Err != query.ErrQueryEngineShutdown {385		t.Errorf("unexpected error: %s", result.Err)386	}...

executor.go

Source:executor.go

...93	if s.dbTx != nil {94		panic("dbTx isn't nil")95	}96	if s.rowsHandle != nil {97		s.rowsHandle.Close()98	}99	s.rowsHandle = nil100	if s.pool == nil {101		if s.dbHandle != nil {102			//log.Print("close database connection...")103			s.dbHandle.Close()104		}105		s.dbHandle = nil106		return107	}108	s.pool.putIn(s)109}110func (s *Executor) destroy() {111	if s.dbHandle != nil {112		s.dbHandle.Close()113	}114}115func (s *Executor) idle() bool {116	return time.Now().Sub(s.finishTime) > 10*time.Minute117}118// BeginTransaction Begin Transaction119func (s *Executor) BeginTransaction() (err error) {120	atomic.AddInt32(&s.dbTxCount, 1)121	if s.dbTx == nil && s.dbTxCount == 1 {122		if s.rowsHandle != nil {123			s.rowsHandle.Close()124		}125		s.rowsHandle = nil126		tx, txErr := s.dbHandle.Begin()127		if txErr != nil {128			err = txErr129			log.Printf("begin transaction failed, err:%s", err.Error())130			return131		}132		s.dbTx = tx133		//log.Print("BeginTransaction")134	}135	return136}137// CommitTransaction Commit Transaction138func (s *Executor) CommitTransaction() (err error) {139	atomic.AddInt32(&s.dbTxCount, -1)140	if s.dbTx != nil && s.dbTxCount == 0 {141		err = s.dbTx.Commit()142		if err != nil {143			s.dbTx = nil144			log.Printf("commit transaction failed, err:%s", err.Error())145			return146		}147		s.dbTx = nil148		//log.Print("Commit")149	}150	return151}152// RollbackTransaction Rollback Transaction153func (s *Executor) RollbackTransaction() (err error) {154	atomic.AddInt32(&s.dbTxCount, -1)155	if s.dbTx != nil && s.dbTxCount == 0 {156		err = s.dbTx.Rollback()157		if err != nil {158			s.dbTx = nil159			log.Printf("rollback transaction failed, err:%s", err.Error())160			return161		}162		s.dbTx = nil163		//log.Print("Rollback")164	}165	return166}167// Query Query168func (s *Executor) Query(sql string) (err error) {169	//log.Printf("Query, sql:%s", sql)170	if s.dbTx == nil {171		if s.dbHandle == nil {172			panic("dbHanlde is nil")173		}174		if s.rowsHandle != nil {175			s.rowsHandle.Close()176			s.rowsHandle = nil177		}178		rows, rowErr := s.dbHandle.Query(sql)179		if rowErr != nil {180			err = rowErr181			log.Printf("query failed, sql:%s, err:%s", sql, err.Error())182			return183		}184		s.rowsHandle = rows185	} else {186		if s.rowsHandle != nil {187			s.rowsHandle.Close()188			s.rowsHandle = nil189		}190		rows, rowErr := s.dbTx.Query(sql)191		if rowErr != nil {192			err = rowErr193			log.Printf("query failed, sql:%s, err:%s", sql, err.Error())194			return195		}196		s.rowsHandle = rows197	}198	return199}200// Next Next201func (s *Executor) Next() bool {202	if s.rowsHandle == nil {203		panic("rowsHandle is nil")204	}205	ret := s.rowsHandle.Next()206	if !ret {207		//log.Print("Next, close rows")208		s.rowsHandle.Close()209		s.rowsHandle = nil210	}211	return ret212}213// Finish Finish214func (s *Executor) Finish() {215	if s.rowsHandle != nil {216		s.rowsHandle.Close()217		s.rowsHandle = nil218	}219}220// GetField GetField221func (s *Executor) GetField(value ...interface{}) (err error) {222	if s.rowsHandle == nil {223		panic("rowsHandle is nil")224	}225	err = s.rowsHandle.Scan(value...)226	if err != nil {227		log.Printf("scan failed, err:%s", err.Error())228	}229	return230}231// Insert Insert232func (s *Executor) Insert(sql string) (ret int64, err error) {233	if s.rowsHandle != nil {234		s.rowsHandle.Close()235	}236	s.rowsHandle = nil237	if s.dbTx == nil {238		if s.dbHandle == nil {239			panic("dbHandle is nil")240		}241		result, resultErr := s.dbHandle.Exec(sql)242		if resultErr != nil {243			err = resultErr244			log.Printf("exec failed, sql:%s, err:%s", sql, err.Error())245			return246		}247		idNum, idErr := result.LastInsertId()248		if idErr != nil {249			err = idErr250			log.Printf("get lastInsertId failed, sql:%s, err:%s", sql, err.Error())251			return252		}253		ret = idNum254		return255	}256	result, resultErr := s.dbTx.Exec(sql)257	if resultErr != nil {258		err = resultErr259		log.Printf("exec failed, sql:%s, err:%s", sql, err.Error())260		return261	}262	idNum, idErr := result.LastInsertId()263	if idErr != nil {264		err = idErr265		log.Printf("get lastInsertId failed, sql:%s, err:%s", sql, err.Error())266		return267	}268	ret = idNum269	return270}271// Update Update272func (s *Executor) Update(sql string) (ret int64, err error) {273	if s.rowsHandle != nil {274		s.rowsHandle.Close()275	}276	s.rowsHandle = nil277	if s.dbTx == nil {278		if s.dbHandle == nil {279			panic("dbHandle is nil")280		}281		result, resultErr := s.dbHandle.Exec(sql)282		if resultErr != nil {283			err = resultErr284			log.Printf("exec failed, sql:%s, err:%s", sql, err.Error())285			return286		}287		num, numErr := result.RowsAffected()288		if numErr != nil {289			err = numErr290			log.Printf("get affected rows number failed, sql:%s, err:%s", sql, err.Error())291		}292		ret = num293		return294	}295	result, resultErr := s.dbTx.Exec(sql)296	if resultErr != nil {297		err = resultErr298		log.Printf("exec failed, sql:%s, err:%s", sql, err.Error())299		return300	}301	num, numErr := result.RowsAffected()302	if numErr != nil {303		err = numErr304		log.Printf("get affected rows number failed, sql:%s, err:%s", sql, err.Error())305		return306	}307	ret = num308	return309}310// Delete Delete311func (s *Executor) Delete(sql string) (ret int64, err error) {312	if s.rowsHandle != nil {313		s.rowsHandle.Close()314	}315	s.rowsHandle = nil316	if s.dbTx == nil {317		if s.dbHandle == nil {318			panic("dbHandle is nil")319		}320		result, resultErr := s.dbHandle.Exec(sql)321		if resultErr != nil {322			err = resultErr323			log.Printf("exec failed, sql:%s, err:%s", sql, err.Error())324			return325		}326		num, numErr := result.RowsAffected()327		if numErr != nil {328			err = numErr329			log.Printf("get affected rows number failed, sql:%s, err:%s", sql, err.Error())330			return331		}332		ret = num333		return334	}335	result, resultErr := s.dbTx.Exec(sql)336	if resultErr != nil {337		err = resultErr338		log.Printf("exec failed, sql:%s, err:%s", sql, err.Error())339		return340	}341	num, numErr := result.RowsAffected()342	if numErr != nil {343		err = numErr344		log.Printf("get affected rows number failed, sql:%s, err:%s", sql, err.Error())345		return346	}347	ret = num348	return349}350// Execute Execute351func (s *Executor) Execute(sql string) (ret int64, err error) {352	if s.rowsHandle != nil {353		s.rowsHandle.Close()354	}355	s.rowsHandle = nil356	if s.dbTx == nil {357		if s.dbHandle == nil {358			panic("dbHandle is nil")359		}360		result, resultErr := s.dbHandle.Exec(sql)361		if resultErr != nil {362			err = resultErr363			log.Printf("exec failed, sql:%s, err:%s", sql, err.Error())364			return365		}366		num, numErr := result.RowsAffected()367		if numErr != nil {...

Using AI Code Generation

1import (2func main() {3	cmd := exec.Command("ls", "-la")4	stdout, err := cmd.StdoutPipe()5	if err != nil {6		fmt.Println(err)7		os.Exit(1)8	}9	if err := cmd.Start(); err != nil {10		fmt.Println(err)11		os.Exit(1)12	}13	buf := make([]byte, 1024)14	for {15		n, err := stdout.Read(buf)16		if err != nil {17		}18		fmt.Print(string(buf[:n]))19	}20	if err := cmd.Wait(); err != nil {21		fmt.Println(err)22		os.Exit(1)23	}24}25import (26func main() {27	cmd := exec.Command("go", "build")28	stderr, err := cmd.StderrPipe()29	if err != nil {30		fmt.Println(err)31		os.Exit(1)32	}33	if err := cmd.Start(); err != nil {34		fmt.Println(err)35		os.Exit(1)36	}37	buf := make([]byte, 1024)38	for {39		n, err := stderr.Read(buf)40		if err != nil {41		}42		fmt.Print(string(buf[:n]))43	}44	if err := cmd.Wait(); err != nil {45		fmt.Println(err)46		os.Exit(1)47	}48}49	/usr/local/go/src/pkg/fmt (from $GOR

Using AI Code Generation

1import (2type User struct {3    Name string `orm:"size(100)"`4}5func init() {6    orm.RegisterDataBase("default", "mysql", "root:root@/test?charset=utf8", 30)7    orm.RegisterModel(new(User))8    orm.RunSyncdb("default", false, true)9}10func main() {11    o := orm.NewOrm()12    user := User{Name: "slene"}13    id, err := o.Insert(&user)14    fmt.Printf("ID: %d, ERR: %v15    num, err := o.Update(&user)16    fmt.Printf("NUM: %d, ERR: %v17    u := User{Id: user.Id}18    err = o.Read(&u)19    fmt.Printf("ERR: %v20    num, err = o.Delete(&u)21    fmt.Printf("NUM: %d, ERR: %v22}23import (24type User struct {25    Name string `orm:"size(100)"`26}27func init() {28    orm.RegisterDataBase("default", "mysql", "root:root@/test?charset=utf8", 30)29    orm.RegisterModel(new(User))30    orm.RunSyncdb("default", false, true)31}32func main() {33    o := orm.NewOrm()34    user := User{Name: "slene"}35    id, err := o.Insert(&user)36    fmt.Printf("ID: %d, ERR: %v37    num, err := o.Update(&user

Using AI Code Generation

1import (2func main() {3	cmd := exec.Command("ls", "-l")4	err := cmd.Start()5	if err != nil {6		fmt.Println(err)7		os.Exit(1)8	}9	fmt.Println("Waiting for command to finish...")10	err = cmd.Wait()11	fmt.Println("Command finished with error: %v", err)12}13import (14func main() {15	cmd := exec.Command("ls", "-l")16	err := cmd.Start()17	if err != nil {18		fmt.Println(err)19		os.Exit(1)20	}21	fmt.Println("Waiting for command to finish...")22	err = cmd.Wait()23	fmt.Println("Command finished with error: %v", err)24}25import (26func main() {27	cmd := exec.Command("ls", "-l")28	err := cmd.Run()29	if err != nil {30		fmt.Println(err)31		os.Exit(1)32	}33	fmt.Println("Command finished with error: %v", err)34}35import (36func main() {37	cmd := exec.Command("ls", "-l")38	output, err := cmd.Output()39	if err != nil {40		fmt.Println(err)41		os.Exit(1)42	}43	fmt.Println("Command finished with error: %v", err)44	fmt.Printf("Output: %s", output)45}46import (47func main() {48	cmd := exec.Command("ls", "-l")49	output, err := cmd.CombinedOutput()50	if err != nil {51		fmt.Println(err

Using AI Code Generation

1import "fmt"2func main() {3e := executor.New()4e.Close()5fmt.Println("Closed")6}7import "fmt"8func main() {9e := executor.New()10e.Close()11fmt.Println("Closed")12}13import "fmt"14func main() {15e := executor.New()16e.Close()17fmt.Println("Closed")18}19import "fmt"20func main() {21e := executor.New()22e.Close()23fmt.Println("Closed")24}25import "fmt"26func main() {27e := executor.New()28e.Close()29fmt.Println("Closed")30}31import "fmt"32func main() {33e := executor.New()34e.Close()35fmt.Println("Closed")36}37import "fmt"38func main() {39e := executor.New()40e.Close()41fmt.Println("Closed")42}43import "fmt"44func main() {45e := executor.New()46e.Close()47fmt.Println("Closed")48}49import "fmt"50func main() {51e := executor.New()52e.Close()53fmt.Println("Closed")54}55import "fmt"56func main() {57e := executor.New()58e.Close()59fmt.Println("Closed")60}61import "fmt"62func main() {63e := executor.New()64e.Close()65fmt.Println("Closed")66}67import "fmt"68func main() {69e := executor.New()70e.Close()71fmt.Println("Closed")72}

Using AI Code Generation

1import (2func main() {3	fmt.Println("Hello World!")4	executor := newExecutor()5	executor.Execute()6	executor.Close()7}8import (9func main() {10	fmt.Println("Hello World!")11	executor := newExecutor()12	executor.Execute()13	executor.Close()14}15main.(*executor).Close(0xc00007e5a0)16main.main()17import (18type executor struct {19}20func newExecutor() *executor {21	return &executor{}22}23func (e *executor) Execute() {24	e.wg.Add(1)25	go func() {26		defer e.wg.Done()27		fmt.Println("Executing task...")28	}()29}30func (e *executor) Close() {31	e.wg.Wait()32}33func main() {34	fmt.Println("Hello World!")35	executor := newExecutor()36	executor.Execute()37	executor.Close()38}

Using AI Code Generation

1import (2func main() {3	executor := exec.Command("ls", "-l")4	err := executor.Run()5	if err != nil {6		fmt.Println("Error occured while running the command")7		os.Exit(-1)8	}9	err = executor.Process.Kill()10	if err != nil {11		fmt.Println("Error occured while closing the command")12		os.Exit(-1)13	}14}15import (16func main() {17	executor := exec.Command("ls", "-l")18	executor.Start()19	err := executor.Process.Kill()20	if err != nil {21		fmt.Println("Error occured while closing the command")22		os.Exit(-1)23	}24}25import (26func main() {27	executor := exec.Command("tail", "-f", "/var/log/auth.log

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.