SVI Исправление ссылки на себя

pkg/components/kernel/keeper/keeper.go

@@ -27,30 +27,30 @@ func NewKeeper(kernel types.IKernel) *Keeper {
 		panic("GetKeeper(): IKernel is nil")
 	}
 
-	sf := &Keeper{
+	сам := &Keeper{
 		kernel: kernel,
 		slog:   kernel.Slog(),
 		chSys:  make(chan os.Signal, 3),
 	}
-	sf.kernel.Wg().Add("keeper")
-	signal.Notify(sf.chSys, os.Interrupt, syscall.SIGTERM)
-	go sf.run()
-	sf.slog.Debugf("NewKeeper()\n")
-	return sf
+	сам.kernel.Wg().Add("keeper")
+	signal.Notify(сам.chSys, os.Interrupt, syscall.SIGTERM)
+	go сам.run()
+	сам.slog.Debugf("NewKeeper()\n")
+	return сам
 }
 
 // Слушает сигналы завершения изнутри и снаружи
-func (sf *Keeper) run() {
-	sf.slog.Infof("Keeper.run()\n")
+func (сам *Keeper) run() {
+	сам.slog.Infof("Keeper.run()\n")
 	defer func() {
-		sf.slog.Infof("Keeper.run(): end\n")
-		sf.kernel.Wg().Done("keeper")
+		сам.slog.Infof("Keeper.run(): end\n")
+		сам.kernel.Wg().Done("keeper")
 	}()
 	select {
-	case sig := <-sf.kernel.Done(): // глобальная отмена контекста
-		sf.slog.Infof("Keeper.run(): intern_sig=%q\n", sig)
-	case sig := <-sf.chSys: // Системный сигнал закрытия
-		sf.kernel.CancelApp()
-		sf.slog.Infof("Keeper.run(): sys_sig=%v\n", sig)
+	case sig := <-сам.kernel.Done(): // глобальная отмена контекста
+		сам.slog.Infof("Keeper.run(): intern_sig=%q\n", sig)
+	case sig := <-сам.chSys: // Системный сигнал закрытия
+		сам.kernel.CancelApp()
+		сам.slog.Infof("Keeper.run(): sys_sig=%v\n", sig)
 	}
 }

pkg/components/kernel/keeper/keeper_test.go

@@ -35,51 +35,51 @@ func TestKeeper(t *testing.T) {
 }
 
 // Отмена глобального контекста приложения
-func (sf *tester) cancel() {
-	sf.kp.chSys <- syscall.SIGTERM
+func (сам *tester) cancel() {
+	сам.kp.chSys <- syscall.SIGTERM
 	time.Sleep(time.Microsecond * 150)
-	sf.createGood1()
-	sf.kern.CancelApp()
+	сам.createGood1()
+	сам.kern.CancelApp()
 	time.Sleep(time.Microsecond * 150)
 }
 
 // Создание сторожа
-func (sf *tester) create() {
-	sf.createBad1()
-	sf.createGood1()
+func (сам *tester) create() {
+	сам.createBad1()
+	сам.createGood1()
 }
 
-func (sf *tester) createGood1() {
+func (сам *tester) createGood1() {
 	defer func() {
 		if _panic := recover(); _panic != nil {
-			sf.t.Errorf("createGood1(: panic=\n\t%v\n", _panic)
+			сам.t.Errorf("createGood1(: panic=\n\t%v\n", _panic)
 		}
 	}()
-	sf.me.Unset()
-	if err := sf.me.InitLocal(); err != nil {
-		sf.t.Errorf("createGood1(): не локальное окружение, err=\n\t%v\n", err)
+	сам.me.Unset()
+	if err := сам.me.InitLocal(); err != nil {
+		сам.t.Errorf("createGood1(): не локальное окружение, err=\n\t%v\n", err)
 		return
 	}
-	sf.kern = mockkernel.NewMockKernel()
-	sf.kern.Slog_, sf.err = slog.NewSlog(sf.kern)
-	if sf.err != nil {
-		sf.t.Errorf("createGood1(): in create ISlog, err=\n\t%v", sf.err)
+	сам.kern = mockkernel.NewMockKernel()
+	сам.kern.Slog_, сам.err = slog.NewSlog(сам.kern)
+	if сам.err != nil {
+		сам.t.Errorf("createGood1(): in create ISlog, err=\n\t%v", сам.err)
 	}
-	sf.kp = NewKeeper(sf.kern)
-	if sf.kp == nil {
-		sf.t.Errorf("createGood1(): keep==nil")
+	сам.kp = NewKeeper(сам.kern)
+	if сам.kp == nil {
+		сам.t.Errorf("createGood1(): keep==nil")
 	}
 }
 
 // Нет объекта приложения
-func (sf *tester) createBad1() {
+func (сам *tester) createBad1() {
 	defer func() {
 		if _panic := recover(); _panic == nil {
-			sf.t.Errorf("createBad1(: panic==nil\n")
+			сам.t.Errorf("createBad1(: panic==nil\n")
 		}
-		if sf.kp != nil {
-			sf.t.Errorf("createBad1(): keep!=nil")
+		if сам.kp != nil {
+			сам.t.Errorf("createBad1(): keep!=nil")
 		}
 	}()
-	sf.kp = NewKeeper(nil)
+	сам.kp = NewKeeper(nil)
 }

pkg/components/kernel/kernel.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 	"sync"
+
 	// "time"
 
 	"wartank/pkg/components/kernel/keeper"
@@ -31,49 +32,49 @@ type Kernel struct {
 }
 
 // NewKernel -- возвращает новый *Kernel
-func NewKernel() (sf *Kernel, err error) {
+func NewKernel() (сам *Kernel, err error) {
 	// timeStart := time.Now().UTC().Format("2006-10-02 15:04:05.000")
 	// fmt._rintf("%v\t%v\tCI/CD test\n", cons.SelfName, timeStart)
-	sf = &Kernel{
+	сам = &Kernel{
 		ctxBg: context.Background(),
 		wg:    wgname.NewWgName(),
 	}
-	sf.ctxApp, sf.fnCancel = context.WithCancel(sf.ctxBg)
-	sf.block.Lock()
-	sf.slog, err = slog.NewSlog(sf)
-	sf.block.Unlock()
+	сам.ctxApp, сам.fnCancel = context.WithCancel(сам.ctxBg)
+	сам.block.Lock()
+	сам.slog, err = slog.NewSlog(сам)
+	сам.block.Unlock()
 	if err != nil {
 		return nil, fmt.Errorf("NewKernel(): in creste ISlog, err=%w", err)
 	}
-	sf.slog.Debugf("NewKernel()")
-	sf.keeper = keeper.NewKeeper(sf)
-	return sf, nil
+	сам.slog.Debugf("NewKernel()")
+	сам.keeper = keeper.NewKeeper(сам)
+	return сам, nil
 }
 
 // Wg -- возвращает объект групповой сихнронизации
-func (sf *Kernel) Wg() types.IWgName {
-	return sf.wg
+func (сам *Kernel) Wg() types.IWgName {
+	return сам.wg
 }
 
 // CtxApp -- возвращает глобальный контекст приложения
-func (sf *Kernel) CtxApp() context.Context {
-	return sf.ctxApp
+func (сам *Kernel) CtxApp() context.Context {
+	return сам.ctxApp
 }
 
 // Done -- возвращает канал отмены контекста приложения
-func (sf *Kernel) Done() <-chan struct{} {
-	return sf.ctxApp.Done()
+func (сам *Kernel) Done() <-chan struct{} {
+	return сам.ctxApp.Done()
 }
 
 // CancelApp -- отменяет глобальный контекст приложения
-func (sf *Kernel) CancelApp() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.slog.Infof("Kernel.CancelApp()\n")
-	sf.fnCancel()
+func (сам *Kernel) CancelApp() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.slog.Infof("Kernel.CancelApp()\n")
+	сам.fnCancel()
 }
 
 // Slog -- возвращает глобальный лог приложения
-func (sf *Kernel) Slog() types.ISlog {
-	return sf.slog
+func (сам *Kernel) Slog() types.ISlog {
+	return сам.slog
 }

pkg/components/kernel/kernel_test.go

@@ -21,23 +21,23 @@ func TestKernel(t *testing.T) {
 }
 
 // Создание базового объекта
-func (sf *tester) create() {
-	sf.t.Logf("create\n")
-	sf.kern, sf.err = NewKernel()
-	if sf.err != nil {
-		sf.t.Errorf("create(): err=\n\t%v", sf.err)
+func (сам *tester) create() {
+	сам.t.Logf("create\n")
+	сам.kern, сам.err = NewKernel()
+	if сам.err != nil {
+		сам.t.Errorf("create(): err=\n\t%v", сам.err)
 	}
-	if sf.kern == nil {
-		sf.t.Errorf("create(): kernel==nil\n")
+	if сам.kern == nil {
+		сам.t.Errorf("create(): kernel==nil\n")
 	}
-	if wg := sf.kern.Wg(); wg == nil {
-		sf.t.Errorf("create(): wg==nil\n")
+	if wg := сам.kern.Wg(); wg == nil {
+		сам.t.Errorf("create(): wg==nil\n")
 	}
-	if ctx := sf.kern.CtxApp(); ctx == nil {
-		sf.t.Errorf("create(): ctx==nil\n")
+	if ctx := сам.kern.CtxApp(); ctx == nil {
+		сам.t.Errorf("create(): ctx==nil\n")
 	}
-	if slog := sf.kern.Slog(); slog == nil {
-		sf.t.Errorf("create(): slog==nil\n")
+	if slog := сам.kern.Slog(); slog == nil {
+		сам.t.Errorf("create(): slog==nil\n")
 	}
-	sf.kern.CancelApp()
+	сам.kern.CancelApp()
 }

pkg/components/kernel/slog/slog.go

@@ -41,7 +41,7 @@ func NewSlog(kern types.IKernel) (*Slog, error) {
 	if kern == nil {
 		return nil, fmt.Errorf("NewSlog(): IKernel is nil")
 	}
-	sf := &Slog{
+	сам := &Slog{
 		kern:   kern,
 		buf:    strings.Builder{},
 		lt:     slog_term.NewSlogTerm(),
@@ -52,57 +52,57 @@ func NewSlog(kern types.IKernel) (*Slog, error) {
 	if err != nil {
 		return nil, fmt.Errorf("NewSlog(): in create SlogFile, err=\n\t%w", err)
 	}
-	sf.lf = lf
+	сам.lf = lf
 
-	go sf.close()
-	sf.isWork.Уст()
-	sf.kern.Wg().Add(strSlog)
-	sf.Infof("NewSlog()\n")
-	return sf, nil
+	go сам.close()
+	сам.isWork.Уст()
+	сам.kern.Wg().Add(strSlog)
+	сам.Infof("NewSlog()\n")
+	return сам, nil
 }
 
 // Debugf -- выводит в лог отладочную инфу
-func (sf *Slog) Debugf(str string, lstVal ...interface{}) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if !sf.isWork.Получ() {
+func (сам *Slog) Debugf(str string, lstVal ...interface{}) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	if !сам.isWork.Получ() {
 		return
 	}
-	sf.printf("DEBUG", str, lstVal...)
+	сам.printf("DEBUG", str, lstVal...)
 }
 
 // Infof -- выводит в лог дежурную инфу
-func (sf *Slog) Infof(str string, lstVal ...interface{}) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if !sf.isWork.Получ() {
+func (сам *Slog) Infof(str string, lstVal ...interface{}) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	if !сам.isWork.Получ() {
 		return
 	}
-	sf.printf("INFO", str, lstVal...)
+	сам.printf("INFO", str, lstVal...)
 }
 
 // Warnf -- выводит в лог предупредительную инфу
-func (sf *Slog) Warnf(str string, lstVal ...interface{}) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if !sf.isWork.Получ() {
+func (сам *Slog) Warnf(str string, lstVal ...interface{}) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	if !сам.isWork.Получ() {
 		return
 	}
-	sf.printf("WARN", str, lstVal...)
+	сам.printf("WARN", str, lstVal...)
 }
 
 // Errorf -- выводит в лог инфу об ошибках
-func (sf *Slog) Errorf(str string, lstVal ...interface{}) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if !sf.isWork.Получ() {
+func (сам *Slog) Errorf(str string, lstVal ...interface{}) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	if !сам.isWork.Получ() {
 		return
 	}
-	sf.printf("ERROR", str, lstVal...)
+	сам.printf("ERROR", str, lstVal...)
 }
 
 // Внутренний вызов без блокировки
-func (sf *Slog) printf(pref, str string, lstVal ...interface{}) {
+func (сам *Slog) printf(pref, str string, lstVal ...interface{}) {
 	style := ""
 	switch pref {
 	case "DEBUG": // Режим отладки
@@ -117,23 +117,23 @@ func (sf *Slog) printf(pref, str string, lstVal ...interface{}) {
 		style = "\033[1;37;41m"
 	}
 	strTime := time.Now().Local().Format("2006-01-02 15:04:05.000\t")
-	sf.buf.WriteString(strTime + "\t")
-	sf.buf.WriteString(pref + "\t")
-	sf.buf.WriteString(cons.СамИмя + "\n\t")
-	sf.buf.WriteString(fmt.Sprintf(str, lstVal...))
-	sf.lf.Write(sf.buf.String())
-	sf.lt.Write(style + sf.buf.String() + "\033[00m")
-	sf.buf.Reset()
+	сам.buf.WriteString(strTime + "\t")
+	сам.buf.WriteString(pref + "\t")
+	сам.buf.WriteString(cons.СамИмя + "\n\t")
+	сам.buf.WriteString(fmt.Sprintf(str, lstVal...))
+	сам.lf.Write(сам.buf.String())
+	сам.lt.Write(style + сам.buf.String() + "\033[00m")
+	сам.buf.Reset()
 }
 
 // Ожидает закрытия приложения
-func (sf *Slog) close() {
-	<-sf.kern.Done()
-	sf.block.Lock()
-	if !sf.isWork.Получ() {
+func (сам *Slog) close() {
+	<-сам.kern.Done()
+	сам.block.Lock()
+	if !сам.isWork.Получ() {
 		return
 	}
-	sf.isWork.Сброс()
-	sf.kern.Wg().Done(strSlog)
-	sf.block.Unlock()
+	сам.isWork.Сброс()
+	сам.kern.Wg().Done(strSlog)
+	сам.block.Unlock()
 }

pkg/components/kernel/slog/slog_file/slog_file.go

@@ -37,53 +37,53 @@ func NewSlogFile(kern types.IKernel, build string) (*SlogFile, error) {
 			return nil, fmt.Errorf("NewSlogFile(): strBuild is empty")
 		}
 	}
-	sf := &SlogFile{
+	сам := &SlogFile{
 		kern:     kern,
 		fileName: cons.СамИмя + "_" + build + time.Now().UTC().Format("_2006-01-02 15:04:05.000") + ".log",
 		isWork:   safe_bool.НовБезопБул(),
 		chMsg:    make(chan []byte, 10),
 	}
-	sf.isWork.Уст()
+	сам.isWork.Уст()
 	_ = os.MkdirAll("./log", 0700)
-	sf.fileName = "./log/" + sf.fileName
-	if err := sf.open(); err != nil {
+	сам.fileName = "./log/" + сам.fileName
+	if err := сам.open(); err != nil {
 		return nil, fmt.Errorf("NewSlogFile(): in open log-file, err=%w", err)
 	}
-	sf.kern.Wg().Add(threadName)
-	go sf.run()
-	return sf, nil
+	сам.kern.Wg().Add(threadName)
+	go сам.run()
+	return сам, nil
 }
 
 // Открывает файл на запись
-func (sf *SlogFile) open() error {
-	file, err := os.OpenFile(sf.fileName, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0600)
+func (сам *SlogFile) open() error {
+	file, err := os.OpenFile(сам.fileName, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0600)
 	if err != nil {
-		sf.kern.CancelApp()
-		return fmt.Errorf("NewSlogFile.open(): in open %q, err=%w", sf.fileName, err)
+		сам.kern.CancelApp()
+		return fmt.Errorf("NewSlogFile.open(): in open %q, err=%w", сам.fileName, err)
 	}
-	sf.file = file
+	сам.file = file
 	return nil
 }
 
 // Запускает работу в отдельном потоке
-func (sf *SlogFile) run() {
+func (сам *SlogFile) run() {
 	defer func() {
-		sf.isWork.Сброс()
-		sf.block.Lock()
-		defer sf.block.Unlock()
-		_ = sf.file.Close()
-		close(sf.chMsg)
-		sf.kern.Wg().Done(threadName)
+		сам.isWork.Сброс()
+		сам.block.Lock()
+		defer сам.block.Unlock()
+		_ = сам.file.Close()
+		close(сам.chMsg)
+		сам.kern.Wg().Done(threadName)
 		// log._rintf("SlogFile.run(): end work\n")
-		sf.kern.CancelApp()
+		сам.kern.CancelApp()
 	}()
 	for {
 		select {
-		case <-sf.kern.Done(): // Ожидание отмены контекста приложения
+		case <-сам.kern.Done(): // Ожидание отмены контекста приложения
 			return
-		case msg := <-sf.chMsg:
-			if err := sf.write(msg); err != nil {
-				sf.kern.Slog().Errorf("SlogFile.run(): in write msg, err=\n\t%v", err)
+		case msg := <-сам.chMsg:
+			if err := сам.write(msg); err != nil {
+				сам.kern.Slog().Errorf("SlogFile.run(): in write msg, err=\n\t%v", err)
 				return
 			}
 		}
@@ -91,20 +91,20 @@ func (sf *SlogFile) run() {
 }
 
 // Внцтренни вызов записи
-func (sf *SlogFile) write(msg []byte) error {
-	_, err := sf.file.Write(msg)
+func (сам *SlogFile) write(msg []byte) error {
+	_, err := сам.file.Write(msg)
 	if err != nil {
-		return fmt.Errorf("SlogFile.run(): in write file %q, err=\n\t%w", sf.fileName, err)
+		return fmt.Errorf("SlogFile.run(): in write file %q, err=\n\t%w", сам.fileName, err)
 	}
 	return nil
 }
 
 // Write -- записывает данные в файл
-func (sf *SlogFile) Write(msg string) {
-	if !sf.isWork.Получ() {
+func (сам *SlogFile) Write(msg string) {
+	if !сам.isWork.Получ() {
 		return
 	}
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.chMsg <- []byte(msg)
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.chMsg <- []byte(msg)
 }

pkg/components/kernel/slog/slog_file/slog_file_test.go

@@ -18,7 +18,7 @@ type tester struct {
 	err  error
 	me   *mockenv.MockEnv
 	kern *mockkernel.MockKernel
-	sf   *SlogFile
+	сам  *SlogFile
 }
 
 func TestSlogFile(t *testing.T) {
@@ -36,75 +36,75 @@ func TestSlogFile(t *testing.T) {
 }
 
 // файл уже закрыт
-func (sf *tester) writeBad1() {
-	if err := sf.sf.write([]byte{}); err == nil {
-		sf.t.Errorf("write(): err==nil")
+func (сам *tester) writeBad1() {
+	if err := сам.сам.write([]byte{}); err == nil {
+		сам.t.Errorf("write(): err==nil")
 	}
 }
 
 // закрытие логгера
-func (sf *tester) close() {
-	sf.t.Logf("=close=")
-	sf.kern.CancelApp()
-	sf.kern.Wg().Wait()
-	sf.sf.Write("")
+func (сам *tester) close() {
+	сам.t.Logf("=close=")
+	сам.kern.CancelApp()
+	сам.kern.Wg().Wait()
+	сам.сам.Write("")
 }
 
 // отмена работы
-func (sf *tester) cancel() {
-	sf.t.Logf("=cancal=")
-	sf.createGood1()
-	sf.kern.CancelApp()
-	sf.kern.Wg().Wait()
+func (сам *tester) cancel() {
+	сам.t.Logf("=cancal=")
+	сам.createGood1()
+	сам.kern.CancelApp()
+	сам.kern.Wg().Wait()
 }
 
 // запись сообщения
-func (sf *tester) write() {
-	sf.t.Logf("=write=")
-	sf.sf.Write("test msg")
+func (сам *tester) write() {
+	сам.t.Logf("=write=")
+	сам.сам.Write("test msg")
 	time.Sleep(time.Millisecond * 150)
 }
 
 // Создание файлового логгера
-func (sf *tester) create() {
-	sf.t.Logf("=create=")
-	sf.createBad1()
-	sf.createBad2()
-	sf.createGood1()
+func (сам *tester) create() {
+	сам.t.Logf("=create=")
+	сам.createBad1()
+	сам.createBad2()
+	сам.createGood1()
 }
 
-func (sf *tester) createGood1() {
-	sf.t.Logf("=createGood1=")
-	sf.sf, sf.err = NewSlogFile(sf.kern, "test")
-	if sf.err != nil {
-		sf.t.Errorf("createGood1(): err=%v", sf.err)
+func (сам *tester) createGood1() {
+	сам.t.Logf("=createGood1=")
+	сам.сам, сам.err = NewSlogFile(сам.kern, "test")
+	if сам.err != nil {
+		сам.t.Errorf("createGood1(): err=%v", сам.err)
 	}
-	if sf.sf == nil {
-		sf.t.Errorf("createGood1(): SlogFile == nil")
+	if сам.сам == nil {
+		сам.t.Errorf("createGood1(): SlogFile == nil")
 	}
 }
 
 // Нет верси сборки
-func (sf *tester) createBad2() {
-	sf.t.Logf("=createBad2=")
-	sf.kern = mockkernel.NewMockKernel()
-	sf.sf, sf.err = NewSlogFile(sf.kern, "")
-	if sf.err == nil {
-		sf.t.Errorf("createBad2(): err == nil")
+func (сам *tester) createBad2() {
+	сам.t.Logf("=createBad2=")
+	сам.kern = mockkernel.NewMockKernel()
+	сам.сам, сам.err = NewSlogFile(сам.kern, "")
+	if сам.err == nil {
+		сам.t.Errorf("createBad2(): err == nil")
 	}
-	if sf.sf != nil {
-		sf.t.Errorf("createBad2(): SlogFile != nil")
+	if сам.сам != nil {
+		сам.t.Errorf("createBad2(): SlogFile != nil")
 	}
 }
 
 // Нет объекта ядра
-func (sf *tester) createBad1() {
-	sf.t.Logf("=createBad1=")
-	sf.sf, sf.err = NewSlogFile(nil, "test")
-	if sf.err == nil {
-		sf.t.Errorf("createBad1(): err == nil")
+func (сам *tester) createBad1() {
+	сам.t.Logf("=createBad1=")
+	сам.сам, сам.err = NewSlogFile(nil, "test")
+	if сам.err == nil {
+		сам.t.Errorf("createBad1(): err == nil")
 	}
-	if sf.sf != nil {
-		sf.t.Errorf("createBad1(): SlogFile != nil")
+	if сам.сам != nil {
+		сам.t.Errorf("createBad1(): SlogFile != nil")
 	}
 }

pkg/components/kernel/slog/slog_term/slog_term.go

@@ -8,21 +8,21 @@ type SlogTerm struct {
 
 // NewSlogTerm -- возвращает новый терминальный логгер
 func NewSlogTerm() *SlogTerm {
-	sf := &SlogTerm{
+	сам := &SlogTerm{
 		chMsg: make(chan string, 10),
 	}
-	go sf.run()
-	return sf
+	go сам.run()
+	return сам
 }
 
 // Write -- пишет запись в консоль
-func (sf *SlogTerm) Write(msg string) {
-	sf.chMsg <- msg
+func (сам *SlogTerm) Write(msg string) {
+	сам.chMsg <- msg
 }
 
 // Главный цикл, работает в отдельном потоке
-func (sf *SlogTerm) run() {
-	// for msg := range sf.chMsg {
+func (сам *SlogTerm) run() {
+	// for msg := range сам.chMsg {
 	// 	// fmt._rintln(msg)
 	// }
 }

pkg/components/kernel/slog/slog_test.go

@@ -31,40 +31,40 @@ func TestSlog(t *testing.T) {
 }
 
 // Создание логера
-func (sf *tester) create() {
-	sf.t.Logf("=create=\n")
-	sf.createBad2()
-	sf.createGood1()
+func (сам *tester) create() {
+	сам.t.Logf("=create=\n")
+	сам.createBad2()
+	сам.createGood1()
 }
 
-func (sf *tester) createGood1() {
-	sf.t.Logf("=createGood1=\n")
-	sf.slog, sf.err = NewSlog(sf.kern)
-	if sf.err != nil {
-		sf.t.Errorf("createGood1(): in create ISlog, err=\n\t%v", sf.err)
+func (сам *tester) createGood1() {
+	сам.t.Logf("=createGood1=\n")
+	сам.slog, сам.err = NewSlog(сам.kern)
+	if сам.err != nil {
+		сам.t.Errorf("createGood1(): in create ISlog, err=\n\t%v", сам.err)
 	}
-	sf.kern.Slog_ = sf.slog
-	sf.slog.Debugf("Проверка good1: %v\n", "test_123")
-	sf.slog.Infof("Проверка good1: %v\n", "test_123")
-	sf.slog.Warnf("Проверка good1: %v\n", "test_123")
-	sf.slog.Errorf("Проверка good1: %v\n", fmt.Errorf("test_123").Error())
-	sf.kern.CancelApp()
+	сам.kern.Slog_ = сам.slog
+	сам.slog.Debugf("Проверка good1: %v\n", "test_123")
+	сам.slog.Infof("Проверка good1: %v\n", "test_123")
+	сам.slog.Warnf("Проверка good1: %v\n", "test_123")
+	сам.slog.Errorf("Проверка good1: %v\n", fmt.Errorf("test_123").Error())
+	сам.kern.CancelApp()
 	time.Sleep(time.Millisecond * 150)
-	sf.slog.Debugf("Проверка good1: %v\n", "test_123 bad")
-	sf.slog.Infof("")
-	sf.slog.Warnf("")
-	sf.slog.Errorf("")
-	sf.slog.close()
+	сам.slog.Debugf("Проверка good1: %v\n", "test_123 bad")
+	сам.slog.Infof("")
+	сам.slog.Warnf("")
+	сам.slog.Errorf("")
+	сам.slog.close()
 }
 
 // Нет объекта ядра
-func (sf *tester) createBad2() {
-	sf.t.Logf("=createBad2=\n")
+func (сам *tester) createBad2() {
+	сам.t.Logf("=createBad2=\n")
 	slog, err := NewSlog(nil)
 	if err == nil {
-		sf.t.Errorf("createBad2(): in create ISlog, err==nil")
+		сам.t.Errorf("createBad2(): in create ISlog, err==nil")
 	}
 	if slog != nil {
-		sf.t.Errorf("createBad2): slog!=nil")
+		сам.t.Errorf("createBad2): slog!=nil")
 	}
 }

pkg/components/kernel/wgname/wgname.go

@@ -18,47 +18,47 @@ type WgName struct {
 
 // NewWgName -- возвращает новый ожидатель группы
 func NewWgName() *WgName {
-	sf := &WgName{
+	сам := &WgName{
 		dictName: make(map[string]bool),
 		chEnd:    make(chan int, 1),
 		isWork:   safe_bool.НовБезопБул(),
 	}
-	sf.isWork.Уст()
-	return sf
+	сам.isWork.Уст()
+	return сам
 }
 
 // Add -- добавляет имя в группу ожидания
-func (sf *WgName) Add(name string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	_, isOk := sf.dictName[name]
+func (сам *WgName) Add(name string) error {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	_, isOk := сам.dictName[name]
 	if isOk {
 		return fmt.Errorf("WgName.Add(): name %q already exists", name)
 	}
-	sf.dictName[name] = true
+	сам.dictName[name] = true
 	return nil
 }
 
 // Done -- отмечает словарь ожидания готовности потока
-func (sf *WgName) Done(name string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	_, isOk := sf.dictName[name]
+func (сам *WgName) Done(name string) error {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	_, isOk := сам.dictName[name]
 	if !isOk {
 		return fmt.Errorf("WgName.Done(): name %q not exists", name)
 	}
-	delete(sf.dictName, name)
-	if !sf.isWork.Получ() {
+	delete(сам.dictName, name)
+	if !сам.isWork.Получ() {
 		return nil
 	}
-	if len(sf.dictName) == 0 {
-		sf.isWork.Сброс()
-		close(sf.chEnd)
+	if len(сам.dictName) == 0 {
+		сам.isWork.Сброс()
+		close(сам.chEnd)
 	}
 	return nil
 }
 
 // Wait -- ожидание закрытия группы
-func (sf *WgName) Wait() {
-	<-sf.chEnd
+func (сам *WgName) Wait() {
+	<-сам.chEnd
 }

pkg/components/kernel/wgname/wgname_test.go

@@ -22,67 +22,67 @@ func TestWgName(t *testing.T) {
 }
 
 // Отпскание имени
-func (sf *tester) done() {
-	sf.t.Logf("=done=")
-	sf.doneGood1()
-	sf.doneBad1()
-	sf.doneBad1()
+func (сам *tester) done() {
+	сам.t.Logf("=done=")
+	сам.doneGood1()
+	сам.doneBad1()
+	сам.doneBad1()
 }
 
 // Повторное удаление
-func (sf *tester) doneBad1() {
-	sf.t.Logf("=doneBad1=")
-	if err := sf.wn.Done("test"); err == nil {
-		sf.t.Errorf("doneBad1(): err==nil")
+func (сам *tester) doneBad1() {
+	сам.t.Logf("=doneBad1=")
+	if err := сам.wn.Done("test"); err == nil {
+		сам.t.Errorf("doneBad1(): err==nil")
 	}
 }
 
-func (sf *tester) doneGood1() {
-	sf.t.Logf("=doneGood1=")
-	if err := sf.wn.Done("test"); err != nil {
-		sf.t.Errorf("doneGood1(): err=%v", err)
+func (сам *tester) doneGood1() {
+	сам.t.Logf("=doneGood1=")
+	if err := сам.wn.Done("test"); err != nil {
+		сам.t.Errorf("doneGood1(): err=%v", err)
 	}
 }
 
 // Добавление имени в группу
-func (sf *tester) add() {
-	sf.t.Logf("=add=")
-	sf.addGood1()
-	sf.addBad1()
+func (сам *tester) add() {
+	сам.t.Logf("=add=")
+	сам.addGood1()
+	сам.addBad1()
 }
 
 // Уже есть такое имя
-func (sf *tester) addBad1() {
-	sf.t.Logf("=addBad1=")
-	if err := sf.wn.Add("test"); err == nil {
-		sf.t.Errorf("addBad1(): err==nil")
+func (сам *tester) addBad1() {
+	сам.t.Logf("=addBad1=")
+	if err := сам.wn.Add("test"); err == nil {
+		сам.t.Errorf("addBad1(): err==nil")
 	}
-	if len(sf.wn.dictName) != 1 {
-		sf.t.Errorf("addBad1(): len dictName != 1")
+	if len(сам.wn.dictName) != 1 {
+		сам.t.Errorf("addBad1(): len dictName != 1")
 	}
 }
 
-func (sf *tester) addGood1() {
-	sf.t.Logf("=addGood1=")
-	if err := sf.wn.Add("test"); err != nil {
-		sf.t.Errorf("addGood1(): err=%v", err)
+func (сам *tester) addGood1() {
+	сам.t.Logf("=addGood1=")
+	if err := сам.wn.Add("test"); err != nil {
+		сам.t.Errorf("addGood1(): err=%v", err)
 	}
-	if len(sf.wn.dictName) != 1 {
-		sf.t.Errorf("addGood1(): len dictName != 1")
+	if len(сам.wn.dictName) != 1 {
+		сам.t.Errorf("addGood1(): len dictName != 1")
 	}
 }
 
 // Создание группы ожидания
-func (sf *tester) create() {
-	sf.t.Logf("=create=")
-	sf.wn = NewWgName()
-	if sf.wn.dictName == nil {
-		sf.t.Errorf("create(): dictName == nil")
+func (сам *tester) create() {
+	сам.t.Logf("=create=")
+	сам.wn = NewWgName()
+	if сам.wn.dictName == nil {
+		сам.t.Errorf("create(): dictName == nil")
 	}
-	if len(sf.wn.dictName) != 0 {
-		sf.t.Errorf("create(): dictName not empty")
+	if len(сам.wn.dictName) != 0 {
+		сам.t.Errorf("create(): dictName not empty")
 	}
-	if len(sf.wn.chEnd) != 0 {
-		sf.t.Errorf("create(): chEnd not empty")
+	if len(сам.wn.chEnd) != 0 {
+		сам.t.Errorf("create(): chEnd not empty")
 	}
 }

pkg/components/lst_string/lst_string.go

@@ -19,36 +19,36 @@ func NewLstString(strControl string) (*LstString, error) {
 	if strControl == "" {
 		return nil, fmt.Errorf("NewLstString(): strControl is empty")
 	}
-	sf := &LstString{
+	сам := &LstString{
 		val:        make([]string, 0),
 		strControl: strControl,
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Get -- возвращает список строк для анализа
-func (sf *LstString) Get() []string {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *LstString) Get() []string {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Set -- устанавливает список строк для анализа
-func (sf *LstString) Set(lstString []string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (сам *LstString) Set(lstString []string) error {
+	сам.block.Lock()
+	defer сам.block.Unlock()
 	if lstString == nil {
 		return fmt.Errorf("LstString.Set(): lstString is nil")
 	}
 	isOk := false
 	for _, strControl := range lstString {
-		if strings.Contains(strControl, sf.strControl) {
+		if strings.Contains(strControl, сам.strControl) {
 			isOk = true
 			break
 		}
 	}
 	if isOk {
-		sf.val = lstString
+		сам.val = lstString
 		return nil
 	}
 	// Найти заголовок
@@ -58,5 +58,5 @@ func (sf *LstString) Set(lstString []string) error {
 			break
 		}
 	}
-	return fmt.Errorf("LstString.Set(): lstString не имеет правильный title(%q), фактически(%q)", sf.strControl, strOut)
+	return fmt.Errorf("LstString.Set(): lstString не имеет правильный title(%q), фактически(%q)", сам.strControl, strOut)
 }

pkg/components/parser_time/parse_hour/parse_hour.go

@@ -55,9 +55,9 @@ func (сам *ПарсерЧас) Сброс() {
 // Уст -- устанавливает значение часов
 //
 //	Значение часов может быть больше 24
-func (sf *ПарсерЧас) Уст(часы alias.Время) error {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
+func (сам *ПарсерЧас) Уст(часы alias.Время) error {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
 	цЧасы, err := strconv.Atoi(string(часы))
 	if err != nil {
 		return fmt.Errorf("ПарсерЧас.Уст(): часы(%q) не число, err=\n\t%w", часы, err)
@@ -65,24 +65,24 @@ func (sf *ПарсерЧас) Уст(часы alias.Время) error {
 	if цЧасы < 0 {
 		return fmt.Errorf("ПарсерЧас.Уст(): часы(%q) меньше нуля, err=\n\t%w", часы, err)
 	}
-	if err := sf.уст(alias.Час(цЧасы)); err != nil {
+	if err := сам.уст(alias.Час(цЧасы)); err != nil {
 		return fmt.Errorf("ПарсерЧас.Уст(): in internal set hour(%q), err=\n\t%w", часы, err)
 	}
 	return nil
 }
 
 // УстЧас -- устанавливает числовое значение часов
-func (sf *ПарсерЧас) УстЧас(часы alias.Час) error {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
-	if err := sf.уст(часы); err != nil {
+func (сам *ПарсерЧас) УстЧас(часы alias.Час) error {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	if err := сам.уст(часы); err != nil {
 		return fmt.Errorf("ПарсерЧас.УстЧас(): in internal set hour(%v), err=\n\t%w", часы, err)
 	}
 	return nil
 }
 
 // Внутренняя процедура для числовой установки часов без блокировки
-func (sf *ПарсерЧас) уст(часы alias.Час) error {
-	sf.знач = часы
+func (сам *ПарсерЧас) уст(часы alias.Час) error {
+	сам.знач = часы
 	return nil
 }

pkg/components/parser_time/parse_hour/parse_hour_test.go

@@ -25,93 +25,93 @@ func TestParseHour(t *testing.T) {
 }
 
 // Сброс часов в ноль
-func (sf *tester) reset() {
-	sf.t.Logf("=reset=\n")
-	sf.ph.Сброс()
-	if strHour := sf.ph.String(); strHour != "00" {
-		sf.t.Errorf("setGood2(): strHour(%q)!='00'\n", strHour)
+func (сам *tester) reset() {
+	сам.t.Logf("=reset=\n")
+	сам.ph.Сброс()
+	if strHour := сам.ph.String(); strHour != "00" {
+		сам.t.Errorf("setGood2(): strHour(%q)!='00'\n", strHour)
 	}
 }
 
 // Устанавливает целочисленное значение часов
-func (sf *tester) set() {
-	sf.t.Logf("=set=\n")
-	sf.setBad1()
-	sf.setGood1()
+func (сам *tester) set() {
+	сам.t.Logf("=set=\n")
+	сам.setBad1()
+	сам.setGood1()
 }
-func (sf *tester) setGood1() {
-	sf.t.Logf("=setGood1=\n")
-	if err := sf.ph.Уст("8"); err != nil {
-		sf.t.Errorf("setGood1(): err=\n\t%v\n", err)
+func (сам *tester) setGood1() {
+	сам.t.Logf("=setGood1=\n")
+	if err := сам.ph.Уст("8"); err != nil {
+		сам.t.Errorf("setGood1(): err=\n\t%v\n", err)
 	}
 }
 
 // Отрицательное значение часа
-func (sf *tester) setBad1() {
-	sf.t.Logf("=setBad1=\n")
-	if err := sf.ph.Уст("-1"); err == nil {
-		sf.t.Errorf("setBad1(): err==nil\n")
+func (сам *tester) setBad1() {
+	сам.t.Logf("=setBad1=\n")
+	if err := сам.ph.Уст("-1"); err == nil {
+		сам.t.Errorf("setBad1(): err==nil\n")
 	}
 }
 
 // Устанавливает значение часов
-func (sf *tester) parse() {
-	sf.t.Logf("=parse=\n")
-	sf.parseBad1()
-	sf.parseBad2()
-	sf.parseGood1()
-	sf.parseGood2()
+func (сам *tester) parse() {
+	сам.t.Logf("=parse=\n")
+	сам.parseBad1()
+	сам.parseBad2()
+	сам.parseGood1()
+	сам.parseGood2()
 }
 
 // Установка правильных большихчасов
-func (sf *tester) parseGood2() {
-	sf.t.Logf("=parseGood2=\n")
-	if err := sf.ph.Уст("867"); err != nil {
-		sf.t.Errorf("parseGood2(): err=\n\t%v\n", err)
+func (сам *tester) parseGood2() {
+	сам.t.Logf("=parseGood2=\n")
+	if err := сам.ph.Уст("867"); err != nil {
+		сам.t.Errorf("parseGood2(): err=\n\t%v\n", err)
 	}
-	if strHour := sf.ph.String(); strHour != "867" {
-		sf.t.Errorf("parseGood2(): strHour(%q)!='867'\n", strHour)
+	if strHour := сам.ph.String(); strHour != "867" {
+		сам.t.Errorf("parseGood2(): strHour(%q)!='867'\n", strHour)
 	}
 }
 
 // Установка правильных часов
-func (sf *tester) parseGood1() {
-	sf.t.Logf("=parseGood1=\n")
-	if err := sf.ph.Уст("8"); err != nil {
-		sf.t.Errorf("parseGood1(): err=\n\t%v\n", err)
+func (сам *tester) parseGood1() {
+	сам.t.Logf("=parseGood1=\n")
+	if err := сам.ph.Уст("8"); err != nil {
+		сам.t.Errorf("parseGood1(): err=\n\t%v\n", err)
 	}
-	if strHour := sf.ph.String(); strHour != "08" {
-		sf.t.Errorf("parseGood1(): strHour(%q)!='08'\n", strHour)
+	if strHour := сам.ph.String(); strHour != "08" {
+		сам.t.Errorf("parseGood1(): strHour(%q)!='08'\n", strHour)
 	}
 }
 
 // Установка отрицательных часов
-func (sf *tester) parseBad2() {
-	sf.t.Logf("=parseBad2=\n")
-	if err := sf.ph.Уст("-1"); err == nil {
-		sf.t.Errorf("parseBad2(): err==nil\n")
+func (сам *tester) parseBad2() {
+	сам.t.Logf("=parseBad2=\n")
+	if err := сам.ph.Уст("-1"); err == nil {
+		сам.t.Errorf("parseBad2(): err==nil\n")
 	}
 }
 
 // Установка не часов
-func (sf *tester) parseBad1() {
-	sf.t.Logf("=parseBad1=\n")
-	if err := sf.ph.Уст("abc"); err == nil {
-		sf.t.Errorf("parseBad1(): err==nil\n")
+func (сам *tester) parseBad1() {
+	сам.t.Logf("=parseBad1=\n")
+	if err := сам.ph.Уст("abc"); err == nil {
+		сам.t.Errorf("parseBad1(): err==nil\n")
 	}
 }
 
 // Создание парсера часов
-func (sf *tester) create() {
-	sf.t.Logf("=create=\n")
-	sf.ph = НовПарсерЧас()
-	if sf.ph == nil {
-		sf.t.Errorf("create(): parseHour==nil\n")
+func (сам *tester) create() {
+	сам.t.Logf("=create=\n")
+	сам.ph = НовПарсерЧас()
+	if сам.ph == nil {
+		сам.t.Errorf("create(): parseHour==nil\n")
 	}
-	if hour := sf.ph.Получ(); hour != 0 {
-		sf.t.Errorf("create(): hour(%v)!=0\n", hour)
+	if hour := сам.ph.Получ(); hour != 0 {
+		сам.t.Errorf("create(): hour(%v)!=0\n", hour)
 	}
-	if strHour := sf.ph.String(); strHour != "00" {
-		sf.t.Errorf("create(): strHour(%q)!='00'\n", strHour)
+	if strHour := сам.ph.String(); strHour != "00" {
+		сам.t.Errorf("create(): strHour(%q)!='00'\n", strHour)
 	}
 }

pkg/components/parser_time/parse_min/parse_min_test.go

@@ -25,88 +25,88 @@ func TestParseMin(t *testing.T) {
 }
 
 // Устанавливает целочисленное значение
-func (sf *tester) set() {
-	sf.t.Logf("=set=\n")
-	sf.setGood1()
-	sf.setBad1()
+func (сам *tester) set() {
+	сам.t.Logf("=set=\n")
+	сам.setGood1()
+	сам.setBad1()
 }
 
 // Кривое число минут
-func (sf *tester) setBad1() {
-	sf.t.Logf("=setBad1=\n")
-	if err := sf.ph.УстМин(60); err == nil {
-		sf.t.Errorf("setBad1(): err==nil\n")
+func (сам *tester) setBad1() {
+	сам.t.Logf("=setBad1=\n")
+	if err := сам.ph.УстМин(60); err == nil {
+		сам.t.Errorf("setBad1(): err==nil\n")
 	}
-	if strHour := sf.ph.String(); strHour != "08" {
-		sf.t.Errorf("setBad1(): strHour(%q)!='08'\n", strHour)
+	if strHour := сам.ph.String(); strHour != "08" {
+		сам.t.Errorf("setBad1(): strHour(%q)!='08'\n", strHour)
 	}
 }
 
-func (sf *tester) setGood1() {
-	sf.t.Logf("=setGood1=\n")
-	if err := sf.ph.УстМин(8); err != nil {
-		sf.t.Errorf("setGood1(): err=\n\t%v\n", err)
+func (сам *tester) setGood1() {
+	сам.t.Logf("=setGood1=\n")
+	if err := сам.ph.УстМин(8); err != nil {
+		сам.t.Errorf("setGood1(): err=\n\t%v\n", err)
 	}
-	if strHour := sf.ph.String(); strHour != "08" {
-		sf.t.Errorf("setGood1(): strHour(%q)!='08'\n", strHour)
+	if strHour := сам.ph.String(); strHour != "08" {
+		сам.t.Errorf("setGood1(): strHour(%q)!='08'\n", strHour)
 	}
 }
 
 // Сброс часов в ноль
-func (sf *tester) reset() {
-	sf.t.Logf("=reset=\n")
-	sf.ph.Сброс()
-	if strHour := sf.ph.String(); strHour != "00" {
-		sf.t.Errorf("reset(): strHour(%q)!='00'\n", strHour)
+func (сам *tester) reset() {
+	сам.t.Logf("=reset=\n")
+	сам.ph.Сброс()
+	if strHour := сам.ph.String(); strHour != "00" {
+		сам.t.Errorf("reset(): strHour(%q)!='00'\n", strHour)
 	}
 }
 
 // Устанавливает значение минут
-func (sf *tester) parse() {
-	sf.t.Logf("=parse=\n")
-	sf.parseBad1()
-	sf.parseBad2()
-	sf.parseGood1()
+func (сам *tester) parse() {
+	сам.t.Logf("=parse=\n")
+	сам.parseBad1()
+	сам.parseBad2()
+	сам.parseGood1()
 }
 
 // Установка правильных минут
-func (sf *tester) parseGood1() {
-	sf.t.Logf("=parseGood1=\n")
-	if err := sf.ph.Уст("8"); err != nil {
-		sf.t.Errorf("parseGood1(): err=\n\t%v\n", err)
+func (сам *tester) parseGood1() {
+	сам.t.Logf("=parseGood1=\n")
+	if err := сам.ph.Уст("8"); err != nil {
+		сам.t.Errorf("parseGood1(): err=\n\t%v\n", err)
 	}
-	if strHour := sf.ph.String(); strHour != "08" {
-		sf.t.Errorf("parseGood1(): strHour(%q)!='08'\n", strHour)
+	if strHour := сам.ph.String(); strHour != "08" {
+		сам.t.Errorf("parseGood1(): strHour(%q)!='08'\n", strHour)
 	}
 }
 
 // Установка отрицательных минут
-func (sf *tester) parseBad2() {
-	sf.t.Logf("=parseBad2=\n")
-	if err := sf.ph.Уст("-1"); err == nil {
-		sf.t.Errorf("parseBad2(): err==nil\n")
+func (сам *tester) parseBad2() {
+	сам.t.Logf("=parseBad2=\n")
+	if err := сам.ph.Уст("-1"); err == nil {
+		сам.t.Errorf("parseBad2(): err==nil\n")
 	}
 }
 
 // Установка не минут
-func (sf *tester) parseBad1() {
-	sf.t.Logf("=parseBad1=\n")
-	if err := sf.ph.Уст("abc"); err == nil {
-		sf.t.Errorf("parseBad1(): err==nil\n")
+func (сам *tester) parseBad1() {
+	сам.t.Logf("=parseBad1=\n")
+	if err := сам.ph.Уст("abc"); err == nil {
+		сам.t.Errorf("parseBad1(): err==nil\n")
 	}
 }
 
 // Создание парсера минут
-func (sf *tester) create() {
-	sf.t.Logf("=create=\n")
-	sf.ph = НовПарсерМинут()
-	if sf.ph == nil {
-		sf.t.Errorf("create(): parseHour==nil\n")
+func (сам *tester) create() {
+	сам.t.Logf("=create=\n")
+	сам.ph = НовПарсерМинут()
+	if сам.ph == nil {
+		сам.t.Errorf("create(): parseHour==nil\n")
 	}
-	if мин := sf.ph.Получ(); мин != 0 {
-		sf.t.Errorf("create(): мин(%v)!=0\n", мин)
+	if мин := сам.ph.Получ(); мин != 0 {
+		сам.t.Errorf("create(): мин(%v)!=0\n", мин)
 	}
-	if стрМин := sf.ph.String(); стрМин != "00" {
-		sf.t.Errorf("create(): стрМин(%q)!='00'\n", стрМин)
+	if стрМин := сам.ph.String(); стрМин != "00" {
+		сам.t.Errorf("create(): стрМин(%q)!='00'\n", стрМин)
 	}
 }

pkg/components/parser_time/parse_sec/parse_sec.go

@@ -78,10 +78,10 @@ func (сам *ПарсерСекунд) УстСек(цСек alias.Сек) erro
 }
 
 // Внутренняя установка значения секунд
-func (sf *ПарсерСекунд) уст(цСек alias.Сек) error {
+func (сам *ПарсерСекунд) уст(цСек alias.Сек) error {
 	if !(0 <= цСек && цСек < 60) {
 		return fmt.Errorf("ПарсерСекунд.уст(): секунды(%v) не в диапазоне 0..60", цСек)
 	}
-	sf.знач = цСек
+	сам.знач = цСек
 	return nil
 }

pkg/components/parser_time/parse_sec/parse_sec_test.go

@@ -25,103 +25,103 @@ func TestParsesec(t *testing.T) {
 }
 
 // Целочисленная установка секунд
-func (sf *tester) set() {
-	sf.t.Logf("=set=\n")
-	sf.setGood1()
+func (сам *tester) set() {
+	сам.t.Logf("=set=\n")
+	сам.setGood1()
 }
 
-func (sf *tester) setGood1() {
-	sf.t.Logf("=setGood1=\n")
-	if err := sf.ph.УстСек(26); err != nil {
-		sf.t.Errorf("setGood1(): err=\n\t%v\n", err)
+func (сам *tester) setGood1() {
+	сам.t.Logf("=setGood1=\n")
+	if err := сам.ph.УстСек(26); err != nil {
+		сам.t.Errorf("setGood1(): err=\n\t%v\n", err)
 	}
-	if strHour := sf.ph.String(); strHour != "26" {
-		sf.t.Errorf("setGood1(): strHour(%q)!='26'\n", strHour)
+	if strHour := сам.ph.String(); strHour != "26" {
+		сам.t.Errorf("setGood1(): strHour(%q)!='26'\n", strHour)
 	}
 }
 
 // Сброс секунд в ноль
-func (sf *tester) reset() {
-	sf.t.Logf("=reset=\n")
-	sf.ph.Сброс()
-	if strSec := sf.ph.String(); strSec != "00" {
-		sf.t.Errorf("setGood2(): strSec(%q)!='00'\n", strSec)
+func (сам *tester) reset() {
+	сам.t.Logf("=reset=\n")
+	сам.ph.Сброс()
+	if strSec := сам.ph.String(); strSec != "00" {
+		сам.t.Errorf("setGood2(): strSec(%q)!='00'\n", strSec)
 	}
 }
 
 // Устанавливает значение секунд
-func (sf *tester) parse() {
-	sf.t.Logf("=parse=\n")
-	sf.parseBad1()
-	sf.parseBad2()
-	sf.parseBad3()
-	sf.parseGood1()
-	sf.parseGood2()
+func (сам *tester) parse() {
+	сам.t.Logf("=parse=\n")
+	сам.parseBad1()
+	сам.parseBad2()
+	сам.parseBad3()
+	сам.parseGood1()
+	сам.parseGood2()
 }
 
 // Установка правильных секунд
-func (sf *tester) parseGood2() {
-	sf.t.Logf("=parseGood2=\n")
+func (сам *tester) parseGood2() {
+	сам.t.Logf("=parseGood2=\n")
 	defer func() {
 		if _panic := recover(); _panic != nil {
-			sf.t.Errorf("parseGood2(): panic=\n\t%v\n", _panic)
+			сам.t.Errorf("parseGood2(): panic=\n\t%v\n", _panic)
 		}
 	}()
-	sf.ph.Уст("59")
-	if strHour := sf.ph.String(); strHour != "59" {
-		sf.t.Errorf("parseGood2(): strHour(%q)!='867'\n", strHour)
+	сам.ph.Уст("59")
+	if strHour := сам.ph.String(); strHour != "59" {
+		сам.t.Errorf("parseGood2(): strHour(%q)!='867'\n", strHour)
 	}
 }
 
 // Установка правильных часов
-func (sf *tester) parseGood1() {
-	sf.t.Logf("=parseGood1=\n")
+func (сам *tester) parseGood1() {
+	сам.t.Logf("=parseGood1=\n")
 	defer func() {
 		if _panic := recover(); _panic != nil {
-			sf.t.Errorf("parseGood1(): panic=\n\t%v\n", _panic)
+			сам.t.Errorf("parseGood1(): panic=\n\t%v\n", _panic)
 		}
 	}()
-	sf.ph.Уст("8")
-	if strHour := sf.ph.String(); strHour != "08" {
-		sf.t.Errorf("parseGood1(): strHour(%q)!='08'\n", strHour)
+	сам.ph.Уст("8")
+	if strHour := сам.ph.String(); strHour != "08" {
+		сам.t.Errorf("parseGood1(): strHour(%q)!='08'\n", strHour)
 	}
 }
 
 // Установка больших часов
-func (sf *tester) parseBad3() {
-	sf.t.Logf("=parseBad3=\n")
-	if err := sf.ph.Уст("61"); err == nil {
-		sf.t.Errorf("parseBad3(): err==nil\n")
+func (сам *tester) parseBad3() {
+	сам.t.Logf("=parseBad3=\n")
+	if err := сам.ph.Уст("61"); err == nil {
+		сам.t.Errorf("parseBad3(): err==nil\n")
 	}
 }
 
 // Установка отрицательных часов
-func (sf *tester) parseBad2() {
-	sf.t.Logf("=parseBad2=\n")
-	if err := sf.ph.Уст("-1"); err == nil {
-		sf.t.Errorf("parseBad2(): err==nil\n")
+func (сам *tester) parseBad2() {
+	сам.t.Logf("=parseBad2=\n")
+	if err := сам.ph.Уст("-1"); err == nil {
+		сам.t.Errorf("parseBad2(): err==nil\n")
 	}
 }
 
 // Установка не часов
-func (sf *tester) parseBad1() {
-	sf.t.Logf("=parseBad1=\n")
-	if err := sf.ph.Уст("abc"); err == nil {
-		sf.t.Errorf("parseBad1(): err==nil\n")
+func (сам *tester) parseBad1() {
+	сам.t.Logf("=parseBad1=\n")
+	if err := сам.ph.Уст("abc"); err == nil {
+		сам.t.Errorf("parseBad1(): err==nil\n")
 	}
 }
 
 // Создание парсера часов
-func (sf *tester) create() {
-	sf.t.Logf("=create=\n")
-	sf.ph = НовПарсерСекунд()
-	if sf.ph == nil {
-		sf.t.Errorf("create(): parseHour==nil\n")
+func (сам *tester) create() {
+	сам.t.Logf("=create=\n")
+	сам.ph = НовПарсерСекунд()
+	if сам.ph == nil {
+		сам.t.Errorf("create(): parseHour==nil\n")
 	}
-	if hour := sf.ph.Получ(); hour != 0 {
-		sf.t.Errorf("create(): hour(%v)!=0\n", hour)
+	if hour := сам.ph.Получ(); hour != 0 {
+		сам.t.Errorf("create(): hour(%v)!=0\n", hour)
 	}
-	if strHour := sf.ph.String(); strHour != "00" {
-		sf.t.Errorf("create(): strHour(%q)!='00'\n", strHour)
+	if strHour := сам.ph.String(); strHour != "00" {
+		сам.t.Errorf("create(): strHour(%q)!='00'\n", strHour)
 	}
 }

pkg/components/parser_time/parser_time.go

@@ -132,7 +132,7 @@ func (сам *ПарсерВремя) Сек() types.ИПарсерСек {
 }
 
 // String -- возвращает хранимое время
-func (sf *ПарсерВремя) String() string {
-	res := sf.час.String() + ":" + sf.мин.String() + ":" + sf.сек.String()
+func (сам *ПарсерВремя) String() string {
+	res := сам.час.String() + ":" + сам.мин.String() + ":" + сам.сек.String()
 	return res
 }

pkg/components/parser_time/parser_time_test.go

@@ -23,143 +23,143 @@ func TestParseTime(t *testing.T) {
 }
 
 // Создание парсера
-func (sf *tester) create() {
-	sf.t.Logf("=create=\n")
-	sf.pars = НовПарсерВремя()
-	if sf.pars.час == nil {
-		sf.t.Errorf("create(): hour==nil\n")
+func (сам *tester) create() {
+	сам.t.Logf("=create=\n")
+	сам.pars = НовПарсерВремя()
+	if сам.pars.час == nil {
+		сам.t.Errorf("create(): hour==nil\n")
 	}
-	if sf.pars.мин == nil {
-		sf.t.Errorf("create(): min==nil\n")
+	if сам.pars.мин == nil {
+		сам.t.Errorf("create(): min==nil\n")
 	}
-	if sf.pars.сек == nil {
-		sf.t.Errorf("create(): sec==nil\n")
+	if сам.pars.сек == nil {
+		сам.t.Errorf("create(): sec==nil\n")
 	}
-	if val := sf.pars.ПолучМилСек(); val != 0 {
-		sf.t.Errorf("create(): valInt(%d)!=0\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 0 {
+		сам.t.Errorf("create(): valInt(%d)!=0\n", val)
 	}
-	_ = sf.pars.String()
+	_ = сам.pars.String()
 }
 
 // Парсинг строки времени
-func (sf *tester) parse() {
-	sf.t.Logf("=parse=\n")
-	sf.parseBad1()
-	sf.parseSec()
-	sf.parseSecBad1()
-	sf.parseMin()
-	sf.parseMinSecBad1()
-	sf.parseMinMinBad1()
-	sf.parseHour()
-	sf.parseHourSecBad1()
-	sf.parseHourMinBad1()
-	sf.parseHourHourBad1()
+func (сам *tester) parse() {
+	сам.t.Logf("=parse=\n")
+	сам.parseBad1()
+	сам.parseSec()
+	сам.parseSecBad1()
+	сам.parseMin()
+	сам.parseMinSecBad1()
+	сам.parseMinMinBad1()
+	сам.parseHour()
+	сам.parseHourSecBad1()
+	сам.parseHourMinBad1()
+	сам.parseHourHourBad1()
 }
 
-func (sf *tester) parseHourHourBad1() {
-	sf.t.Logf("=parseHourHourBad1=\n")
-	if err := sf.pars.Уст("-11:14:54"); err == nil {
-		sf.t.Errorf("parseHourHourBad1(): err==nil\n")
+func (сам *tester) parseHourHourBad1() {
+	сам.t.Logf("=parseHourHourBad1=\n")
+	if err := сам.pars.Уст("-11:14:54"); err == nil {
+		сам.t.Errorf("parseHourHourBad1(): err==nil\n")
 	}
-	if val := sf.pars.ПолучМилСек(); val != 5820 {
-		sf.t.Errorf("parseHourHourBad1(): valInt(%d)!=5820\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 5820 {
+		сам.t.Errorf("parseHourHourBad1(): valInt(%d)!=5820\n", val)
 	}
-	if hour := sf.pars.Час().Получ(); hour != 1 {
-		sf.t.Errorf("parseHourHourBad1(): hour(%d)!=1\n", hour)
+	if hour := сам.pars.Час().Получ(); hour != 1 {
+		сам.t.Errorf("parseHourHourBad1(): hour(%d)!=1\n", hour)
 	}
-	if min := sf.pars.Мин().Получ(); min != 14 {
-		sf.t.Errorf("parseHourHourBad1(): min(%d)!=14\n", min)
+	if min := сам.pars.Мин().Получ(); min != 14 {
+		сам.t.Errorf("parseHourHourBad1(): min(%d)!=14\n", min)
 	}
-	if sec := sf.pars.Сек().Получ(); sec != 54 {
-		sf.t.Errorf("parseHourHourBad1(): sec(%d)!=54\n", sec)
+	if sec := сам.pars.Сек().Получ(); sec != 54 {
+		сам.t.Errorf("parseHourHourBad1(): sec(%d)!=54\n", sec)
 	}
 }
 
-func (sf *tester) parseHourMinBad1() {
-	sf.t.Logf("=parseHourMinBad1=\n")
-	if err := sf.pars.Уст("01:-4:01"); err == nil {
-		sf.t.Errorf("parseHourMinBad1(): err==nil\n")
+func (сам *tester) parseHourMinBad1() {
+	сам.t.Logf("=parseHourMinBad1=\n")
+	if err := сам.pars.Уст("01:-4:01"); err == nil {
+		сам.t.Errorf("parseHourMinBad1(): err==nil\n")
 	}
-	if val := sf.pars.ПолучМилСек(); val != 5820 {
-		sf.t.Errorf("parseHourMinBad1(): valInt(%d)!=5820\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 5820 {
+		сам.t.Errorf("parseHourMinBad1(): valInt(%d)!=5820\n", val)
 	}
 }
 
-func (sf *tester) parseHourSecBad1() {
-	sf.t.Logf("=parseHourSecBad1=\n")
-	if err := sf.pars.Уст("01:37:a"); err == nil {
-		sf.t.Errorf("parseHourSecBad1(): err==nil\n")
+func (сам *tester) parseHourSecBad1() {
+	сам.t.Logf("=parseHourSecBad1=\n")
+	if err := сам.pars.Уст("01:37:a"); err == nil {
+		сам.t.Errorf("parseHourSecBad1(): err==nil\n")
 	}
-	if val := sf.pars.ПолучМилСек(); val != 5820 {
-		sf.t.Errorf("parseHourSecBad1(): valInt(%d)!=5820\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 5820 {
+		сам.t.Errorf("parseHourSecBad1(): valInt(%d)!=5820\n", val)
 	}
 }
 
-func (sf *tester) parseHour() {
-	sf.t.Logf("=parseHour=\n")
-	if err := sf.pars.Уст("01:37:00"); err != nil {
-		sf.t.Errorf("parseHour(): err=\n\t%v\n", err)
+func (сам *tester) parseHour() {
+	сам.t.Logf("=parseHour=\n")
+	if err := сам.pars.Уст("01:37:00"); err != nil {
+		сам.t.Errorf("parseHour(): err=\n\t%v\n", err)
 	}
-	if val := sf.pars.ПолучМилСек(); val != 5820 {
-		sf.t.Errorf("parseHour(): valInt(%d)!=5820\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 5820 {
+		сам.t.Errorf("parseHour(): valInt(%d)!=5820\n", val)
 	}
 }
 
-func (sf *tester) parseMinMinBad1() {
-	sf.t.Logf("=parseMinMinBad1=\n")
-	if err := sf.pars.Уст("60:25"); err == nil {
-		sf.t.Errorf("parseMinMinBad1(): err==nil\n")
+func (сам *tester) parseMinMinBad1() {
+	сам.t.Logf("=parseMinMinBad1=\n")
+	if err := сам.pars.Уст("60:25"); err == nil {
+		сам.t.Errorf("parseMinMinBad1(): err==nil\n")
 	}
-	if val := sf.pars.ПолучМилСек(); val != 444 {
-		sf.t.Errorf("parseMinMinBad1(): valInt(%d)!=444\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 444 {
+		сам.t.Errorf("parseMinMinBad1(): valInt(%d)!=444\n", val)
 	}
 }
 
-func (sf *tester) parseMinSecBad1() {
-	sf.t.Logf("=parseMinSecBad1=\n")
-	if err := sf.pars.Уст("07:-1"); err == nil {
-		sf.t.Errorf("parseMinSecBad1(): err==nil\n")
+func (сам *tester) parseMinSecBad1() {
+	сам.t.Logf("=parseMinSecBad1=\n")
+	if err := сам.pars.Уст("07:-1"); err == nil {
+		сам.t.Errorf("parseMinSecBad1(): err==nil\n")
 	}
-	if val := sf.pars.ПолучМилСек(); val != 7*60+24 {
-		sf.t.Errorf("parseMinSecBad1(): valInt(%d)!=7*60+24\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 7*60+24 {
+		сам.t.Errorf("parseMinSecBad1(): valInt(%d)!=7*60+24\n", val)
 	}
 }
 
-func (sf *tester) parseMin() {
-	sf.t.Logf("=parseMin=\n")
-	if err := sf.pars.Уст("07:24"); err != nil {
-		sf.t.Errorf("parseMin(): err=\n\t%v\n", err)
+func (сам *tester) parseMin() {
+	сам.t.Logf("=parseMin=\n")
+	if err := сам.pars.Уст("07:24"); err != nil {
+		сам.t.Errorf("parseMin(): err=\n\t%v\n", err)
 	}
-	if val := sf.pars.ПолучМилСек(); val != 7*60+24 {
-		sf.t.Errorf("parseMin(): valInt(%d)!=7*60+24\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 7*60+24 {
+		сам.t.Errorf("parseMin(): valInt(%d)!=7*60+24\n", val)
 	}
 }
 
 // Слишком большие секунды
-func (sf *tester) parseSecBad1() {
-	sf.t.Logf("=parseSecBad1=\n")
-	if err := sf.pars.Уст("60"); err == nil {
-		sf.t.Errorf("parseSecBad1(): err==nil\n")
+func (сам *tester) parseSecBad1() {
+	сам.t.Logf("=parseSecBad1=\n")
+	if err := сам.pars.Уст("60"); err == nil {
+		сам.t.Errorf("parseSecBad1(): err==nil\n")
 	}
-	if val := sf.pars.ПолучМилСек(); val != 28 {
-		sf.t.Errorf("parseSecBad1(): valInt(%d)!=28\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 28 {
+		сам.t.Errorf("parseSecBad1(): valInt(%d)!=28\n", val)
 	}
 }
 
-func (sf *tester) parseSec() {
-	sf.t.Logf("=parseSec=\n")
-	if err := sf.pars.Уст("28"); err != nil {
-		sf.t.Errorf("parseSec(): err=\n\t%v\n", err)
+func (сам *tester) parseSec() {
+	сам.t.Logf("=parseSec=\n")
+	if err := сам.pars.Уст("28"); err != nil {
+		сам.t.Errorf("parseSec(): err=\n\t%v\n", err)
 	}
-	if val := sf.pars.ПолучМилСек(); val != 28 {
-		sf.t.Errorf("parseSec(): valInt(%d)!=28\n", val)
+	if val := сам.pars.ПолучМилСек(); val != 28 {
+		сам.t.Errorf("parseSec(): valInt(%d)!=28\n", val)
 	}
 }
 
 // Нет строки для парсинга
-func (sf *tester) parseBad1() {
-	sf.t.Logf("=parseBad1=\n")
-	if err := sf.pars.Уст(""); err == nil {
-		sf.t.Errorf("parseBad1(): err==nil\n")
+func (сам *tester) parseBad1() {
+	сам.t.Logf("=parseBad1=\n")
+	if err := сам.pars.Уст(""); err == nil {
+		сам.t.Errorf("parseBad1(): err==nil\n")
 	}
 }

pkg/components/safe_bool/safe_bool.go

@@ -18,22 +18,22 @@ func НовБезопБул() *БезопБул {
 }
 
 // Получ -- возвращает хранимое значение булевого признака
-func (sf *БезопБул) Получ() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *БезопБул) Получ() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Уст -- устанавливает хранимое значение булевого признака
-func (sf *БезопБул) Уст() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = true
+func (сам *БезопБул) Уст() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = true
 }
 
 // Сброс -- сбарсывает хранимое значение булевого признака
-func (sf *БезопБул) Сброс() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = false
+func (сам *БезопБул) Сброс() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = false
 }

pkg/components/safe_bool/safe_bool_test.go

@@ -21,26 +21,26 @@ func TestSafeBool(t *testing.T) {
 }
 
 // Присовение и сброс признака
-func (sf *tester) set() {
-	sf.t.Logf("=set=\n")
-	sf.sb.Уст()
-	if isReset := sf.sb.Получ(); !isReset {
-		sf.t.Errorf("create(): isReset==true\n")
+func (сам *tester) set() {
+	сам.t.Logf("=set=\n")
+	сам.sb.Уст()
+	if isReset := сам.sb.Получ(); !isReset {
+		сам.t.Errorf("create(): isReset==true\n")
 	}
-	sf.sb.Сброс()
-	if isSet := sf.sb.Получ(); isSet {
-		sf.t.Errorf("create(): isSet==true\n")
+	сам.sb.Сброс()
+	if isSet := сам.sb.Получ(); isSet {
+		сам.t.Errorf("create(): isSet==true\n")
 	}
 }
 
 // Создание признака
-func (sf *tester) create() {
-	sf.t.Logf("=create=\n")
-	sf.sb = НовБезопБул()
-	if sf.sb == nil {
-		sf.t.Errorf("create(): safeBool==nil\n")
+func (сам *tester) create() {
+	сам.t.Logf("=create=\n")
+	сам.sb = НовБезопБул()
+	if сам.sb == nil {
+		сам.t.Errorf("create(): safeBool==nil\n")
 	}
-	if isSet := sf.sb.Получ(); isSet {
-		sf.t.Errorf("create(): isSet==true\n")
+	if isSet := сам.sb.Получ(); isSet {
+		сам.t.Errorf("create(): isSet==true\n")
 	}
 }

pkg/components/safe_int/safe_int_test.go

@@ -23,22 +23,22 @@ func TestSafeInt(t *testing.T) {
 }
 
 // Установка значения
-func (sf *tester) set() {
-	sf.t.Logf("=set=\n")
-	sf.si.Уст(-8)
-	if val := sf.si.Получ(); val != -8 {
-		sf.t.Errorf("create(): val(%d)!=-8\n", val)
+func (сам *tester) set() {
+	сам.t.Logf("=set=\n")
+	сам.si.Уст(-8)
+	if val := сам.si.Получ(); val != -8 {
+		сам.t.Errorf("create(): val(%d)!=-8\n", val)
 	}
 }
 
 // Создание целого
-func (sf *tester) create() {
-	sf.t.Logf("=create=\n")
-	sf.si = НовБезопЦелое()
-	if sf.si == nil {
-		sf.t.Errorf("create(): safeInt==nil\n")
+func (сам *tester) create() {
+	сам.t.Logf("=create=\n")
+	сам.si = НовБезопЦелое()
+	if сам.si == nil {
+		сам.t.Errorf("create(): safeInt==nil\n")
 	}
-	if val := sf.si.Получ(); val != 0 {
-		sf.t.Errorf("create(): val(%d)!=0\n", val)
+	if val := сам.si.Получ(); val != 0 {
+		сам.t.Errorf("create(): val(%d)!=0\n", val)
 	}
 }

pkg/components/safe_string/safe_string.go

@@ -18,15 +18,15 @@ func НовБезопСтрока() *БезопСтрока {
 }
 
 // Получ -- возвращает хранимое значение
-func (sf *БезопСтрока) Получ() string {
-	sf.блок.RLock()
-	defer sf.блок.RUnlock()
-	return sf.знач
+func (сам *БезопСтрока) Получ() string {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
+	return сам.знач
 }
 
 // Уст -- устанавливает хранимое значение
-func (sf *БезопСтрока) Уст(знач string) {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
-	sf.знач = знач
+func (сам *БезопСтрока) Уст(знач string) {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	сам.знач = знач
 }

pkg/components/safe_string/safe_string_test.go

@@ -23,22 +23,22 @@ func TestSafeString(t *testing.T) {
 }
 
 // Установка значения
-func (sf *tester) set() {
-	sf.t.Logf("=set=\n")
-	sf.si.Уст("test_str")
-	if val := sf.si.Получ(); val != "test_str" {
-		sf.t.Errorf("create(): val(%s)!='test_str'\n", val)
+func (сам *tester) set() {
+	сам.t.Logf("=set=\n")
+	сам.si.Уст("test_str")
+	if val := сам.si.Получ(); val != "test_str" {
+		сам.t.Errorf("create(): val(%s)!='test_str'\n", val)
 	}
 }
 
 // Создание целого
-func (sf *tester) create() {
-	sf.t.Logf("=create=\n")
-	sf.si = НовБезопСтрока()
-	if sf.si == nil {
-		sf.t.Errorf("create(): safeString==nil\n")
+func (сам *tester) create() {
+	сам.t.Logf("=create=\n")
+	сам.si = НовБезопСтрока()
+	if сам.si == nil {
+		сам.t.Errorf("create(): safeString==nil\n")
 	}
-	if val := sf.si.Получ(); val != "" {
-		sf.t.Errorf("create(): val(%s)!=``\n", val)
+	if val := сам.si.Получ(); val != "" {
+		сам.t.Errorf("create(): val(%s)!=``\n", val)
 	}
 }

pkg/components/scene_net/netclient/netclient.go

@@ -34,20 +34,20 @@ type NetClient struct {
 
 // NewNetClient -- возвращает сетевого клиента
 func NewNetClient(botNet types.ИБотСеть) *NetClient {
-	sf := &NetClient{
+	сам := &NetClient{
 		botNet: botNet,
 		conn:   botNet.Коннект(),
 		stat:   netstat.NewNetStat(botNet),
 		chRes:  make(chan *response, 2),
 	}
-	return sf
+	return сам
 }
 
 // Get -- выполняет безопасный GET-запрос в сеть
-func (sf *NetClient) Get(strLink string) (lstString []string, err error) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	ctxCancel, fnCancel := context.WithTimeout(sf.botNet.Кнт(), time.Second*7)
+func (сам *NetClient) Get(strLink string) (lstString []string, err error) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	ctxCancel, fnCancel := context.WithTimeout(сам.botNet.Кнт(), time.Second*7)
 	defer fnCancel()
 	defer func() { // Возможный перехват паники
 		if _panic := recover(); _panic != nil {
@@ -56,13 +56,13 @@ func (sf *NetClient) Get(strLink string) (lstString []string, err error) {
 			time.Sleep(time.Millisecond * 250) // Чтобы не насиловать не работающую сеть
 		}
 	}()
-	go sf.get(strLink)
+	go сам.get(strLink)
 	select {
 	case <-ctxCancel.Done(): // Таймаут по ожиданию
 		err = fmt.Errorf("NetClient.get(): таймаут ожидания ответа")
-		sf.botNet.Отмена()
+		сам.botNet.Отмена()
 		return nil, err
-	case resp := <-sf.chRes: // Получен ответ
+	case resp := <-сам.chRes: // Получен ответ
 		if resp.err != nil {
 			return nil, resp.err
 		}
@@ -71,11 +71,11 @@ func (sf *NetClient) Get(strLink string) (lstString []string, err error) {
 }
 
 // Внутренний вызов для сокрытия под общей блокировкой
-func (sf *NetClient) get(strLink string) {
+func (сам *NetClient) get(strLink string) {
 	resp := &response{}
 	defer func() {
 		if resp.err != nil {
-			sf.stat.IncErr()
+			сам.stat.IncErr()
 		}
 	}()
 	req, err := http.NewRequest("GET", strLink, nil)
@@ -84,12 +84,12 @@ func (sf *NetClient) get(strLink string) {
 		return
 	}
 	req.Header.Set("User-Agent", "Mozilla Firefox 94.1")
-	httpResp, err := sf.conn.Do(req)
+	httpResp, err := сам.conn.Do(req)
 	if err != nil {
 		resp.err = fmt.Errorf("NetClient.get(): при выполнении GET-запроса, err=\n\t%w", err)
 		return
 	}
-	defer sf.closeGetBody(strLink, httpResp, resp)
+	defer сам.closeGetBody(strLink, httpResp, resp)
 
 	if httpResp.StatusCode != http.StatusOK {
 		resp.err = fmt.Errorf("NetClient.get(): code=%v, status=%v", httpResp.StatusCode, httpResp.Status)
@@ -105,7 +105,7 @@ func (sf *NetClient) get(strLink string) {
 		return
 	}
 	lenData := len(binData) + len(strLink)
-	sf.stat.AddByte(lenData)
+	сам.stat.AddByte(lenData)
 
 	lstString := strings.Split(string(binData), "\n")
 	if len(lstString) == 0 {
@@ -116,11 +116,11 @@ func (sf *NetClient) get(strLink string) {
 }
 
 // Вызывается по завершению вызова, закрывает тело запроса
-func (sf *NetClient) closeGetBody(strLink string, httpResp *http.Response, resp *response) {
+func (сам *NetClient) closeGetBody(strLink string, httpResp *http.Response, resp *response) {
 	defer func() {
 		if _panic := recover(); _panic != nil {
 			// log._rintf("NetClient.closeGetBody(): strLink='%v', panic=%v\n", strLink, _panic)
-			sf.botNet.Отмена()
+			сам.botNet.Отмена()
 		}
 	}()
 	err := httpResp.Body.Close()
@@ -130,7 +130,7 @@ func (sf *NetClient) closeGetBody(strLink string, httpResp *http.Response, resp
 			resp.err = fmt.Errorf("NetClient.closeGetBody(): двойная ошибка при закрытии запроса URL(%q), err=\n\t%w\n\tinternal err=\n\t%w", strLink, _err, resp.err)
 		}
 		resp.lstString = nil
-		sf.stat.IncErr()
+		сам.stat.IncErr()
 	}
-	sf.chRes <- resp
+	сам.chRes <- resp
 }

pkg/components/scene_net/netstat/netstat.go

@@ -26,66 +26,66 @@ type NetStat struct {
 
 // NewNetStat -- возвращает новый *NetStat
 func NewNetStat(botNet types.ИБотСеть) *NetStat {
-	sf := &NetStat{
+	сам := &NetStat{
 		botNet: botNet,
 		chTick: make(chan int, 2),
 	}
-	go sf.run()
-	go sf.makeTick()
-	return sf
+	go сам.run()
+	go сам.makeTick()
+	return сам
 }
 
 // Тикер меток времени 1 раз в 5 минут
-func (sf *NetStat) makeTick() {
-	defer close(sf.chTick)
+func (сам *NetStat) makeTick() {
+	defer close(сам.chTick)
 	for {
 		select {
-		case <-sf.botNet.Кнт().Done():
+		case <-сам.botNet.Кнт().Done():
 			return
 		default:
 			time.Sleep(time.Second * 5 * 60)
-			sf.chTick <- 1
+			сам.chTick <- 1
 		}
 	}
 }
 
 // Главный цикл работы статистики
-func (sf *NetStat) run() {
+func (сам *NetStat) run() {
 	fnCalc := func() {
-		sf.block.Lock()
-		defer sf.block.Unlock()
-		sf.totalMinut += 5
-		mbyte := float32(sf.totalByte) / float32(sf.totalMinut*60) * (3600 * 24 * 30.5) / (1024 * 1024)
+		сам.block.Lock()
+		defer сам.block.Unlock()
+		сам.totalMinut += 5
+		mbyte := float32(сам.totalByte) / float32(сам.totalMinut*60) * (3600 * 24 * 30.5) / (1024 * 1024)
 		log.Printf("INFO NetStat.run().fnCalc(): запросы=%0.2f/сек\tтраф0=%0.2f бит/сек\tтраф1=%0.2f МБ/мес\tошибки=%v\n",
-			float32(sf.countRequestInterval)/300,
-			float32(sf.countByteInterval*8)/300,
+			float32(сам.countRequestInterval)/300,
+			float32(сам.countByteInterval*8)/300,
 			mbyte,
-			sf.countErr)
-		sf.countByteInterval = 0
-		sf.countRequestInterval = 0
+			сам.countErr)
+		сам.countByteInterval = 0
+		сам.countRequestInterval = 0
 	}
-	for range sf.chTick {
+	for range сам.chTick {
 		select {
-		case <-sf.botNet.Кнт().Done():
+		case <-сам.botNet.Кнт().Done():
 			return
-		case <-sf.chTick:
+		case <-сам.chTick:
 			fnCalc()
 		}
 	}
 }
 
 // IncErr -- добавляет ошибку в статистику
-func (sf *NetStat) IncErr() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.countErr++
+func (сам *NetStat) IncErr() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.countErr++
 }
 
 // AddByte -- увеличивает счётчик запросов и байтов на передачу/приём
-func (sf *NetStat) AddByte(val int) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.countByteInterval += val
-	sf.totalByte += val
-	sf.countRequestInterval++
+func (сам *NetStat) AddByte(val int) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.countByteInterval += val
+	сам.totalByte += val
+	сам.countRequestInterval++
 }

pkg/components/scene_net/section_net.go

@@ -63,14 +63,14 @@ func (сам *СценаСеть) Обновить() error {
 }
 
 // Get -- выполняет GET-запрос по указанному URL
-func (sf *СценаСеть) Get(strLink string) (lstString []string, err error) {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
-	// log._rintf("INFO СценаСеть.Get(): link=%v\n", sf.strUrl)
-	if !strings.Contains(strLink, sf.стрУрл) {
-		return nil, fmt.Errorf("СценаСеть.Get(): strLink(%v) не содержит strUrl(%v)", strLink, sf.стрУрл)
+func (сам *СценаСеть) Get(strLink string) (lstString []string, err error) {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	// log._rintf("INFO СценаСеть.Get(): link=%v\n", сам.strUrl)
+	if !strings.Contains(strLink, сам.стрУрл) {
+		return nil, fmt.Errorf("СценаСеть.Get(): strLink(%v) не содержит strUrl(%v)", strLink, сам.стрУрл)
 	}
-	lstString, err = sf.клиент.Get(strLink)
+	lstString, err = сам.клиент.Get(strLink)
 	if err != nil {
 		return nil, fmt.Errorf("СценаСеть.Get(): err=\n\t%v", err)
 	}

pkg/components/wrag/wrag.go

@@ -20,20 +20,20 @@ type Wrag struct {
 
 // NewWrag -- возвращает новый объект врага
 func NewWrag(app types.ИСервер, lstBattle []string) *Wrag {
-	sf := &Wrag{
+	сам := &Wrag{
 		app: app,
 	}
-	sf.update(lstBattle)
-	return sf
+	сам.update(lstBattle)
+	return сам
 }
 
 // Обновляет вражину
-func (sf *Wrag) update(lstBattleOn []string) {
+func (сам *Wrag) update(lstBattleOn []string) {
 	// <img class="tank-img" src="/tankimg?c=2&amp;k=1&amp;m=0-2,1-2,2-0,3-2,5-2,6-0&amp;t=png" alt="Тень Брата">
 	var (
-		ind    int
-		strOut string
-		isFind bool
+		ind     int
+		strOut  string
+		iсамind bool
 	)
 	for ind, strOut = range lstBattleOn {
 		if strings.Contains(strOut, `<img class="tank-img" src="/`) {
@@ -41,13 +41,13 @@ func (sf *Wrag) update(lstBattleOn []string) {
 			if strings.Contains(strOut, "prospero tank") {
 				continue
 			}
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Не нашёл метку врага
+	if !iсамind { // Не нашёл метку врага
 		logrus.Errorf("Wrag.update(): не нашёл имя врага")
-		sf.health = 800
+		сам.health = 800
 		return
 	}
 	// Вражина найдена, ищем настоящее здоровье
@@ -60,8 +60,8 @@ func (sf *Wrag) update(lstBattleOn []string) {
 	iHealth, err := strconv.Atoi(strHealth)
 	if err != nil {
 		logrus.WithError(err).Errorf("Wrag.update(): здоровье(%v) не число", strHealth)
-		sf.health = 800
+		сам.health = 800
 		return
 	}
-	sf.health = iHealth
+	сам.health = iHealth
 }

pkg/mock/mockapp/mockapp.go

@@ -19,55 +19,55 @@ type MockApp struct {
 func NewMockApp() *MockApp {
 	ctxBg := context.Background()
 	ctx, fnCancel := context.WithCancel(ctxBg)
-	sf := &MockApp{
+	сам := &MockApp{
 		MockKernel: mockkernel.NewMockKernel(),
 		ctx:        ctx,
 		fnCancel:   fnCancel,
 		block:      &sync.RWMutex{},
 	}
-	return sf
+	return сам
 }
 
-func (sf *MockApp) Store() types.IStore {
-	return sf.store
+func (сам *MockApp) Store() types.IStore {
+	return сам.store
 }
 
-func (sf *MockApp) Bot() types.ИБот {
-	return sf.bot
+func (сам *MockApp) Bot() types.ИБот {
+	return сам.bot
 }
 
-func (sf *MockApp) Angar() types.ИАнгар {
+func (сам *MockApp) Angar() types.ИАнгар {
 	return nil
 }
 
-func (sf *MockApp) CtxApp() context.Context {
-	return sf.ctx
+func (сам *MockApp) CtxApp() context.Context {
+	return сам.ctx
 }
 
-func (sf *MockApp) Tank() types.ИТанк {
+func (сам *MockApp) Tank() types.ИТанк {
 	return nil
 }
 
-func (sf *MockApp) Run() error {
+func (сам *MockApp) Run() error {
 	return nil
 }
 
-func (sf *MockApp) CancelApp() {
-	go sf.fnCancel()
+func (сам *MockApp) CancelApp() {
+	go сам.fnCancel()
 }
 
-func (sf *MockApp) Block() *sync.RWMutex {
-	return sf.block
+func (сам *MockApp) Block() *sync.RWMutex {
+	return сам.block
 }
 
-func (sf *MockApp) NetClient() types.ИБотСеть {
+func (сам *MockApp) NetClient() types.ИБотСеть {
 	return nil
 }
 
-func (sf *MockApp) ServBots() types.ИБотоФерма {
+func (сам *MockApp) ServBots() types.ИБотоФерма {
 	return nil
 }
 
-func (sf *MockApp) Gui() types.ИГуи {
+func (сам *MockApp) Gui() types.ИГуи {
 	return nil
 }

pkg/mock/mockenv/mockenv.go

@@ -27,15 +27,15 @@ type MockEnv struct {
 
 // NewMockEnv -- возвращает новый *MockEnv
 func NewMockEnv() *MockEnv {
-	sf := &MockEnv{
+	сам := &MockEnv{
 		dict: make(map[string]string),
 	}
-	return sf
+	return сам
 }
 
 // InitFake -- инициализация фейковыми данными
-func (sf *MockEnv) InitFake() {
-	sf.dict = make(map[string]string)
+func (сам *MockEnv) InitFake() {
+	сам.dict = make(map[string]string)
 	i := 0
 	for _, var_ := range vars {
 		os.Unsetenv(var_)
@@ -45,30 +45,30 @@ func (sf *MockEnv) InitFake() {
 			os.Unsetenv(var_)
 			os.Setenv(var_, "local")
 		}
-		sf.dict[var_] = strVal
+		сам.dict[var_] = strVal
 		i++
 	}
 }
 
 // InitLocal -- читает из локального окружения файл, заполняет переменные
-func (sf *MockEnv) InitLocal() error {
-	strData, err := sf.readFile()
+func (сам *MockEnv) InitLocal() error {
+	strData, err := сам.readFile()
 	if err != nil {
 		return fmt.Errorf("MockEnv.InitLocal(): при чтении файла, err=\n\t%w", err)
 	}
-	dict, err := sf.getPairs(strData)
+	dict, err := сам.getPairs(strData)
 	if err != nil {
 		return fmt.Errorf("MockEnv.InitLocal(): при получении пар ключ:значение, err=\n\t%w", err)
 	}
-	sf.initEnv(dict)
-	sf.dict = dict
-	sf.checkStage()
+	сам.initEnv(dict)
+	сам.dict = dict
+	сам.checkStage()
 	return nil
 }
 
 // Проверяет наличие поля STAGE
-func (sf *MockEnv) checkStage() {
-	stage, ok := sf.dict["STAGE"]
+func (сам *MockEnv) checkStage() {
+	stage, ok := сам.dict["STAGE"]
 	if !ok {
 		panic(fmt.Errorf("MockEnv.checkStage(): не установлена переменная STAGE"))
 	}
@@ -78,7 +78,7 @@ func (sf *MockEnv) checkStage() {
 }
 
 // Инициализирует все заданные переменные окружения
-func (sf *MockEnv) initEnv(mapEnv map[string]string) {
+func (сам *MockEnv) initEnv(mapEnv map[string]string) {
 	// Здесь не должен быть nil НИКОГДА
 	for key, value := range mapEnv {
 		os.Unsetenv(key)
@@ -87,7 +87,7 @@ func (sf *MockEnv) initEnv(mapEnv map[string]string) {
 }
 
 // Готовит словарь значений
-func (sf *MockEnv) getPairs(strData string) (map[string]string, error) {
+func (сам *MockEnv) getPairs(strData string) (map[string]string, error) {
 	lstData := strings.Split(strData, "\n")
 	mapEnv := make(map[string]string)
 	for _, line := range lstData {
@@ -116,7 +116,7 @@ func (sf *MockEnv) getPairs(strData string) (map[string]string, error) {
 }
 
 // Читает файл окружения
-func (sf *MockEnv) readFile() (string, error) {
+func (сам *MockEnv) readFile() (string, error) {
 	if !strings.Contains(path, selfPath) {
 		return "", fmt.Errorf("MockEnv.readFile(): неправильный путь проекта")
 	}
@@ -135,8 +135,8 @@ func (sf *MockEnv) readFile() (string, error) {
 }
 
 // Unset -- удаляет все переменные окружения сервиса
-func (sf *MockEnv) Unset() {
-	for key := range sf.dict {
+func (сам *MockEnv) Unset() {
+	for key := range сам.dict {
 		os.Unsetenv(key)
 	}
 }

pkg/mock/mockenv/mockenv_test.go

@@ -27,230 +27,230 @@ func TestMockEnv(t *testing.T) {
 }
 
 // Плохой STAGE
-func (sf *tester) stage() {
-	sf.t.Logf("stage()\n")
-	sf.badStage1()
-	sf.badStage2()
+func (сам *tester) stage() {
+	сам.t.Logf("stage()\n")
+	сам.badStage1()
+	сам.badStage2()
 }
 
 // STAGE имеет неизвестное значение
-func (sf *tester) badStage2() {
-	sf.t.Logf("badStage2()\n")
+func (сам *tester) badStage2() {
+	сам.t.Logf("badStage2()\n")
 	defer func() {
 		if _panic := recover(); _panic == nil {
-			sf.t.Errorf("badStage2(): panic==nil\n")
+			сам.t.Errorf("badStage2(): panic==nil\n")
 		}
 	}()
-	sf.me.dict["STAGE"] = "bad_local"
-	sf.me.checkStage()
+	сам.me.dict["STAGE"] = "bad_local"
+	сам.me.checkStage()
 }
 
 // Нет STAGE
-func (sf *tester) badStage1() {
-	sf.t.Logf("badStage1()\n")
+func (сам *tester) badStage1() {
+	сам.t.Logf("badStage1()\n")
 	defer func() {
 		if _panic := recover(); _panic == nil {
-			sf.t.Errorf("badStage1(): panic==nil\n")
+			сам.t.Errorf("badStage1(): panic==nil\n")
 		}
 	}()
-	delete(sf.me.dict, "STAGE")
-	sf.me.checkStage()
+	delete(сам.me.dict, "STAGE")
+	сам.me.checkStage()
 }
 
 // Локальная инициализация
-func (sf *tester) initLocal() {
-	sf.initLocalBad1()
-	sf.initLocalBad2()
-	sf.initLocalBad3()
-	sf.initLocalBad4()
-	sf.initLocalGood1()
-	sf.me.Unset()
+func (сам *tester) initLocal() {
+	сам.initLocalBad1()
+	сам.initLocalBad2()
+	сам.initLocalBad3()
+	сам.initLocalBad4()
+	сам.initLocalGood1()
+	сам.me.Unset()
 }
 
-func (sf *tester) initLocalGood1() {
-	if err := sf.me.InitLocal(); err != nil {
-		sf.t.Errorf("initLocalGood1(): err=\n\t%v\n", err)
+func (сам *tester) initLocalGood1() {
+	if err := сам.me.InitLocal(); err != nil {
+		сам.t.Errorf("initLocalGood1(): err=\n\t%v\n", err)
 	}
 }
 
 // Вообще нет STAGE
-func (sf *tester) initLocalBad4() {
+func (сам *tester) initLocalBad4() {
 	_fileEnv := fileEnv
 	fileEnv = "./test_data/env_bad2"
-	if err := sf.me.InitLocal(); err == nil {
-		sf.t.Errorf("initLocalBad4(): err==nil\n")
+	if err := сам.me.InitLocal(); err == nil {
+		сам.t.Errorf("initLocalBad4(): err==nil\n")
 	}
 	fileEnv = _fileEnv
 }
 
 // Кривое значение STAGE
-func (sf *tester) initLocalBad3() {
+func (сам *tester) initLocalBad3() {
 	_fileEnv := fileEnv
 	fileEnv = "./test_data/env_bad1"
-	if err := sf.me.InitLocal(); err == nil {
-		sf.t.Errorf("initLocalBad3(): err==nil\n")
+	if err := сам.me.InitLocal(); err == nil {
+		сам.t.Errorf("initLocalBad3(): err==nil\n")
 	}
 	fileEnv = _fileEnv
 }
 
 // Кривое содержимое файла
-func (sf *tester) initLocalBad2() {
+func (сам *tester) initLocalBad2() {
 	_fileEnv := fileEnv
 	fileEnv = "./test_data/env_bad"
-	if err := sf.me.InitLocal(); err == nil {
-		sf.t.Errorf("initLocalBad2(): err==nil\n")
+	if err := сам.me.InitLocal(); err == nil {
+		сам.t.Errorf("initLocalBad2(): err==nil\n")
 	}
 	fileEnv = _fileEnv
 }
 
 // Кривое имя файла
-func (sf *tester) initLocalBad1() {
+func (сам *tester) initLocalBad1() {
 	_fileEnv := fileEnv
 	fileEnv = "4"
-	if err := sf.me.InitLocal(); err == nil {
-		sf.t.Errorf("initLocalBad1(): err==nil\n")
+	if err := сам.me.InitLocal(); err == nil {
+		сам.t.Errorf("initLocalBad1(): err==nil\n")
 	}
 	fileEnv = _fileEnv
 }
 
 // Получение пар значений
-func (sf *tester) getPairs() {
-	sf.getPairsBad1()
-	sf.getPairsBad2()
-	sf.getPairsBad3()
-	sf.getPairsBad4()
-	sf.getPairsGood1()
+func (сам *tester) getPairs() {
+	сам.getPairsBad1()
+	сам.getPairsBad2()
+	сам.getPairsBad3()
+	сам.getPairsBad4()
+	сам.getPairsGood1()
 }
 
-func (sf *tester) getPairsGood1() {
-	dict, err := sf.me.getPairs("\nPARAM=\"123\"\nPARAM2=\"param2\"\n")
+func (сам *tester) getPairsGood1() {
+	dict, err := сам.me.getPairs("\nPARAM=\"123\"\nPARAM2=\"param2\"\n")
 	if err != nil {
-		sf.t.Errorf("getPairsGood1(): err=\n\t%v\n", err)
+		сам.t.Errorf("getPairsGood1(): err=\n\t%v\n", err)
 	}
 	if dict == nil {
-		sf.t.Errorf("getPairsGood1(): dict == nil\n")
+		сам.t.Errorf("getPairsGood1(): dict == nil\n")
 	}
 }
 
 // Кривая пара
-func (sf *tester) getPairsBad4() {
-	dict, err := sf.me.getPairs("\nPARAM=\"=\"=\"\"\nPARAM2=\"param2\"\n")
+func (сам *tester) getPairsBad4() {
+	dict, err := сам.me.getPairs("\nPARAM=\"=\"=\"\"\nPARAM2=\"param2\"\n")
 	if err == nil {
-		sf.t.Errorf("getPairsBad4(): err==nil\n")
+		сам.t.Errorf("getPairsBad4(): err==nil\n")
 	}
 	if dict != nil {
-		sf.t.Errorf("getPairsBad4(): dict != nil\n")
+		сам.t.Errorf("getPairsBad4(): dict != nil\n")
 	}
 }
 
 // Кривое значение
-func (sf *tester) getPairsBad3() {
-	dict, err := sf.me.getPairs("\nPARAM=\"\"\nPARAM2=\"param2\"\n")
+func (сам *tester) getPairsBad3() {
+	dict, err := сам.me.getPairs("\nPARAM=\"\"\nPARAM2=\"param2\"\n")
 	if err == nil {
-		sf.t.Errorf("getPairsBad3(): err==nil\n")
+		сам.t.Errorf("getPairsBad3(): err==nil\n")
 	}
 	if dict != nil {
-		sf.t.Errorf("getPairsBad3(): dict != nil\n")
+		сам.t.Errorf("getPairsBad3(): dict != nil\n")
 	}
 }
 
 // Кривой ключ
-func (sf *tester) getPairsBad2() {
-	dict, err := sf.me.getPairs("\n=\"param\"\nPARAM2=\"param2\"\n")
+func (сам *tester) getPairsBad2() {
+	dict, err := сам.me.getPairs("\n=\"param\"\nPARAM2=\"param2\"\n")
 	if err == nil {
-		sf.t.Errorf("getPairsBad2(): err==nil\n")
+		сам.t.Errorf("getPairsBad2(): err==nil\n")
 	}
 	if dict != nil {
-		sf.t.Errorf("getPairsBad2(): dict != nil\n")
+		сам.t.Errorf("getPairsBad2(): dict != nil\n")
 	}
 }
 
 // Пустой текст
-func (sf *tester) getPairsBad1() {
-	dict, err := sf.me.getPairs("\n\n\n")
+func (сам *tester) getPairsBad1() {
+	dict, err := сам.me.getPairs("\n\n\n")
 	if err == nil {
-		sf.t.Errorf("getPairsBad1(): err==nil\n")
+		сам.t.Errorf("getPairsBad1(): err==nil\n")
 	}
 	if dict != nil {
-		sf.t.Errorf("getPairsBad1(): dict != nil\n")
+		сам.t.Errorf("getPairsBad1(): dict != nil\n")
 	}
 }
 
 // Чтение файла переменных окружения
-func (sf *tester) readFile() {
-	sf.readFileBad1()
-	sf.readFileBad2()
-	sf.readFileBad3()
-	sf.readFileGood1()
+func (сам *tester) readFile() {
+	сам.readFileBad1()
+	сам.readFileBad2()
+	сам.readFileBad3()
+	сам.readFileGood1()
 }
 
-func (sf *tester) readFileGood1() {
-	strData, err := sf.me.readFile()
+func (сам *tester) readFileGood1() {
+	strData, err := сам.me.readFile()
 	if err != nil {
-		sf.t.Errorf("readFileGood1(): err=\n\t%v\n", err)
+		сам.t.Errorf("readFileGood1(): err=\n\t%v\n", err)
 	}
 	if strData == "" {
-		sf.t.Errorf("readFileGood1(): strData is empty\n")
+		сам.t.Errorf("readFileGood1(): strData is empty\n")
 	}
 }
 
 // Кривой путь-2
-func (sf *tester) readFileBad3() {
+func (сам *tester) readFileBad3() {
 	_selfPath := selfPath
 	selfPath = "me/"
-	strData, err := sf.me.readFile()
+	strData, err := сам.me.readFile()
 	if err == nil {
-		sf.t.Errorf("readFileBad3(): err==nil\n")
+		сам.t.Errorf("readFileBad3(): err==nil\n")
 	}
 	if strData != "" {
-		sf.t.Errorf("readFileBad3(): strData not empty\n")
+		сам.t.Errorf("readFileBad3(): strData not empty\n")
 	}
 	selfPath = _selfPath
 }
 
 // Неправильное имя файла
-func (sf *tester) readFileBad2() {
+func (сам *tester) readFileBad2() {
 	_fileEnv := fileEnv
 	fileEnv = ""
-	strData, err := sf.me.readFile()
+	strData, err := сам.me.readFile()
 	if err == nil {
-		sf.t.Errorf("readFileBad2(): err==nil\n")
+		сам.t.Errorf("readFileBad2(): err==nil\n")
 	}
 	if strData != "" {
-		sf.t.Errorf("readFileBad2(): strData not empty\n")
+		сам.t.Errorf("readFileBad2(): strData not empty\n")
 	}
 	fileEnv = _fileEnv
 }
 
 // Кривой путь
-func (sf *tester) readFileBad1() {
+func (сам *tester) readFileBad1() {
 	_selfPath := selfPath
 	selfPath = "#"
-	strData, err := sf.me.readFile()
+	strData, err := сам.me.readFile()
 	if err == nil {
-		sf.t.Errorf("readFileBad1(): err==nil\n")
+		сам.t.Errorf("readFileBad1(): err==nil\n")
 	}
 	if strData != "" {
-		sf.t.Errorf("readFileBad1(): strData not empty\n")
+		сам.t.Errorf("readFileBad1(): strData not empty\n")
 	}
 	selfPath = _selfPath
 }
 
 // Иницилизация фейковыми данными
-func (sf *tester) initFake() {
-	sf.me.InitFake()
+func (сам *tester) initFake() {
+	сам.me.InitFake()
 }
 
 // Создание объекта переменных окружения
-func (sf *tester) create() {
-	sf.me = NewMockEnv()
-	if sf.me == nil {
-		sf.t.Errorf("create(): mockEnv is nil\n")
+func (сам *tester) create() {
+	сам.me = NewMockEnv()
+	if сам.me == nil {
+		сам.t.Errorf("create(): mockEnv is nil\n")
 	}
-	if sf.me.dict == nil {
-		sf.t.Errorf("create(): dict env is nil")
+	if сам.me.dict == nil {
+		сам.t.Errorf("create(): dict env is nil")
 	}
-	if len_ := len(sf.me.dict); len_ != 0 {
-		sf.t.Errorf("create(): len dict(%v)!=0\n", len_)
+	if len_ := len(сам.me.dict); len_ != 0 {
+		сам.t.Errorf("create(): len dict(%v)!=0\n", len_)
 	}
 }

pkg/mock/mockkernel/mockkernel.go

@@ -27,36 +27,36 @@ type MockKernel struct {
 
 // NewMockKernel -- возвращает новый *MockKernel
 func NewMockKernel() *MockKernel {
-	sf := &MockKernel{
+	сам := &MockKernel{
 		ctxBg: context.Background(),
 		wg:    wgname.NewWgName(),
 	}
-	sf.ctxApp, sf.fnCancel = context.WithCancel(sf.ctxBg)
-	return sf
+	сам.ctxApp, сам.fnCancel = context.WithCancel(сам.ctxBg)
+	return сам
 }
 
 // Wg -- возвращает объект групповой сихнронизации
-func (sf *MockKernel) Wg() types.IWgName {
-	return sf.wg
+func (сам *MockKernel) Wg() types.IWgName {
+	return сам.wg
 }
 
 // CtxApp -- возвращает глобальный контекст приложения
-func (sf *MockKernel) CtxApp() context.Context {
-	return sf.ctxApp
+func (сам *MockKernel) CtxApp() context.Context {
+	return сам.ctxApp
 }
 
 // Done -- возвращает канал отмены контекста приложения
-func (sf *MockKernel) Done() <-chan struct{} {
-	return sf.ctxApp.Done()
+func (сам *MockKernel) Done() <-chan struct{} {
+	return сам.ctxApp.Done()
 }
 
 // CancelApp -- отменяет глобальный контекст приложения
-func (sf *MockKernel) CancelApp() {
+func (сам *MockKernel) CancelApp() {
 	// fmt._rintf("MockKernel.CancelApp()\n")
-	sf.fnCancel()
+	сам.fnCancel()
 }
 
 // Slog -- возвращает хранимый логгер
-func (sf *MockKernel) Slog() types.ISlog {
-	return sf.Slog_
+func (сам *MockKernel) Slog() types.ISlog {
+	return сам.Slog_
 }

pkg/mock/mockkernel/mockkernel_test.go

@@ -28,24 +28,24 @@ func TestMockKernel(t *testing.T) {
 }
 
 // Создание мок-объекта ядра приложения
-func (sf *tester) create() {
-	sf.t.Logf("create()\n")
-	sf.kern = NewMockKernel()
-	if sf.kern == nil {
-		sf.t.Errorf("create(): app==nil\n")
+func (сам *tester) create() {
+	сам.t.Logf("create()\n")
+	сам.kern = NewMockKernel()
+	if сам.kern == nil {
+		сам.t.Errorf("create(): app==nil\n")
 	}
-	if wg := sf.kern.Wg(); wg == nil {
-		sf.t.Errorf("create(): wg==nil\n")
+	if wg := сам.kern.Wg(); wg == nil {
+		сам.t.Errorf("create(): wg==nil\n")
 	}
-	if ctx := sf.kern.CtxApp(); ctx == nil {
-		sf.t.Errorf("create(): ctx==nil\n")
+	if ctx := сам.kern.CtxApp(); ctx == nil {
+		сам.t.Errorf("create(): ctx==nil\n")
 	}
-	sf.kern.Slog_, sf.err = slog.NewSlog(sf.kern)
-	if sf.err != nil {
-		sf.t.Errorf("create(): in create ISlog, err=\n\t%v", sf.err)
+	сам.kern.Slog_, сам.err = slog.NewSlog(сам.kern)
+	if сам.err != nil {
+		сам.t.Errorf("create(): in create ISlog, err=\n\t%v", сам.err)
 	}
-	if slog := sf.kern.Slog(); slog == nil {
-		sf.t.Errorf("create(): slog==nil")
+	if slog := сам.kern.Slog(); slog == nil {
+		сам.t.Errorf("create(): slog==nil")
 	}
-	sf.kern.CancelApp()
+	сам.kern.CancelApp()
 }

pkg/section/down_time/down_time_test.go

@@ -5,7 +5,8 @@ import (
 	"time"
 	"wartank/pkg/alias"
 	"wartank/pkg/components/safe_bool"
-	"wartank/pkg/mock/mock_zone"
+
+	// "wartank/pkg/mock/mock_zone"
 	"wartank/pkg/mock/mockapp"
 	"wartank/pkg/types"
 )
@@ -25,12 +26,12 @@ type tester struct {
 }
 
 // Обратный вызов для счётчика времени
-func (sf *tester) call() {
-	if sf.ct == nil {
+func (сам *tester) call() {
+	if сам.ct == nil {
 		return
 	}
-	if sf.ct.канВызов != nil {
-		<-sf.ct.канВызов
+	if сам.ct.канВызов != nil {
+		<-сам.ct.канВызов
 	}
 }
 
@@ -49,206 +50,206 @@ func TestCountTime(t *testing.T) {
 }
 
 // Оменяет работу таймера
-func (sf *tester) cancel() {
-	sf.t.Logf("=cancel=\n")
-	_ = НовВремОбрат(sf.zone, 0)
-	sf.app.CancelApp()
+func (сам *tester) cancel() {
+	сам.t.Logf("=cancel=\n")
+	_ = НовВремОбрат(сам.zone, 0)
+	сам.app.CancelApp()
 	time.Sleep(time.Millisecond * 150)
 }
 
 // Проверяет обработчик тика
-func (sf *tester) checkTick() {
-	времОбрат := НовВремОбрат(sf.zone, 0)
+func (сам *tester) checkTick() {
+	времОбрат := НовВремОбрат(сам.zone, 0)
 	{ // Секундный тик
 		времОбрат.Уст("00:00:08")
 		time.Sleep(time.Second * 1)
 		if val := времОбрат.String(); val != "00:00:08" {
-			sf.t.Errorf("checkTick(): счётчик(%v)!='00:00:08'", val)
+			сам.t.Errorf("checkTick(): счётчик(%v)!='00:00:08'", val)
 		}
 	}
 	{ // Проверка времени прямо сейчас
 		time.Sleep(time.Millisecond * 100)
 		if val := времОбрат.String(); val != "00:00:08" {
-			sf.t.Errorf("checkTick(): счётчик(%v)!='00:00:08'", val)
+			сам.t.Errorf("checkTick(): счётчик(%v)!='00:00:08'", val)
 		}
 	}
 	{ // Проверка обратного вызова прямо сейчас
 		strTime := alias.Время(time.Now().UTC().Format("15:04:05"))
 		времОбрат.Уст(strTime)
 		if val := времОбрат.String(); val != string(strTime) {
-			sf.t.Errorf("checkTick(): счётчик(%v)!=%s", val, strTime)
+			сам.t.Errorf("checkTick(): счётчик(%v)!=%s", val, strTime)
 		}
 		// Выход из функции -- и есть факт обратного вызова
-		sf.call()
+		сам.call()
 		{ // Проверка отсутствия обратного вызова прямо сейчас
 			времОбрат.Уст("00:00:00")
 			// Выход из функции -- и есть факт обратного вызова
-			sf.call()
+			сам.call()
 			if val := времОбрат.ПолучМилСек(); val != 0 {
-				sf.t.Errorf("checkTick(): счётчик(%v)!=0", val)
+				сам.t.Errorf("checkTick(): счётчик(%v)!=0", val)
 			}
 			времОбрат.Стоп()
-			sf.app.CancelApp()
+			сам.app.CancelApp()
 			time.Sleep(time.Millisecond * 50)
 		}
 	}
 }
 
-func (sf *tester) setStrBad1(strBad alias.Время) {
+func (сам *tester) setStrBad1(strBad alias.Время) {
 	defer func() {
 		if _panic := recover(); _panic == nil {
-			sf.t.Errorf("setStrBad1(): panic==nil\n")
+			сам.t.Errorf("setStrBad1(): panic==nil\n")
 		}
 	}()
-	if sf.err = sf.ct.Уст(strBad); sf.err == nil {
-		sf.t.Errorf("setStrBad1(): BAD-2 err==nil")
+	if сам.err = сам.ct.Уст(strBad); сам.err == nil {
+		сам.t.Errorf("setStrBad1(): BAD-2 err==nil")
 	}
 }
 
 // Устанавливает строковое значение времени
-func (sf *tester) setStr() {
-	go sf.call()
-	ct := НовВремОбрат(sf.zone, 0)
+func (сам *tester) setStr() {
+	go сам.call()
+	ct := НовВремОбрат(сам.zone, 0)
 	{ // BAD-1 пустая строка
-		if sf.err = ct.Уст(""); sf.err == nil {
-			sf.t.Errorf("setStr(): BAD-1 err==nil")
+		if сам.err = ct.Уст(""); сам.err == nil {
+			сам.t.Errorf("setStr(): BAD-1 err==nil")
 		}
 	}
 	// BAD-2 неформатная строка
-	sf.setStrBad1(":::")
+	сам.setStrBad1(":::")
 	// BAD-3 кривые часы
-	sf.setStrBad1("a1:02:03")
+	сам.setStrBad1("a1:02:03")
 	// BAD-4 кривые минуты
-	sf.setStrBad1("01:a2:03")
+	сам.setStrBad1("01:a2:03")
 	// BAD-5 кривые секунды
-	sf.setStrBad1("01:02:a3")
+	сам.setStrBad1("01:02:a3")
 	// BAD-6 кривые только секунды
-	sf.setStrBad1("a3")
+	сам.setStrBad1("a3")
 	// BAD-7 кривые минуты +секунды
-	sf.setStrBad1("a2:03")
+	сам.setStrBad1("a2:03")
 	// BAD-8 кривые часы +минуты +секунды
-	sf.setStrBad1("a1:02:03")
+	сам.setStrBad1("a1:02:03")
 	// BAD-9 минуты +кривые секунды
-	sf.setStrBad1("02:a3")
+	сам.setStrBad1("02:a3")
 	// BAD-10 кривые минуты +секунды
-	sf.setStrBad1("60:03")
+	сам.setStrBad1("60:03")
 	// BAD-11 кривые минуты +секунды
-	sf.setStrBad1("-1:03")
+	сам.setStrBad1("-1:03")
 	// BAD-12 минуты +кривые секунды
-	sf.setStrBad1("01:60")
+	сам.setStrBad1("01:60")
 	// BAD-13 минуты +кривые секунды
-	sf.setStrBad1("01:-1")
+	сам.setStrBad1("01:-1")
 	// BAD-14 кривые часы +минуты + секунды
-	sf.setStrBad1("-1:02:03")
+	сам.setStrBad1("-1:02:03")
 	// BAD-15 кривые часы +минуты + секунды
-	//sf.setStrBad1("24:02:03")
+	//сам.setStrBad1("24:02:03")
 	{ // GOOD-1 секунды
-		if sf.err = ct.Уст("03"); sf.err != nil {
-			sf.t.Errorf("setStr(): GOOD-1 err=%v", sf.err)
+		if сам.err = ct.Уст("03"); сам.err != nil {
+			сам.t.Errorf("setStr(): GOOD-1 err=%v", сам.err)
 		}
 	}
 	{ // GOOD-2 минуты секунды
-		if sf.err = ct.Уст("02:03"); sf.err != nil {
-			sf.t.Errorf("setStr(): GOOD-2 err=%v", sf.err)
+		if сам.err = ct.Уст("02:03"); сам.err != nil {
+			сам.t.Errorf("setStr(): GOOD-2 err=%v", сам.err)
 		}
 	}
 	{ // GOOD-3 часы минуты секунды
-		if sf.err = ct.Уст("01:02:03"); sf.err != nil {
-			sf.t.Errorf("setStr(): GOOD-3 err=%v", sf.err)
+		if сам.err = ct.Уст("01:02:03"); сам.err != nil {
+			сам.t.Errorf("setStr(): GOOD-3 err=%v", сам.err)
 		}
 	}
 }
 
 // Устанавливает число секунд для отсчёта
-func (sf *tester) setInt() {
-	go sf.call()
-	sf.zone = mock_zone.НовМокСцена()
-	ct := НовВремОбрат(sf.zone, 0)
+func (сам *tester) setInt() {
+	go сам.call()
+	// сам.zone = mock_zone.НовМокСцена()
+	ct := НовВремОбрат(сам.zone, 0)
 	{ // GOOD-1
-		if sf.err = ct.Уст("8"); sf.err != nil {
-			sf.t.Errorf("setInt(): GOOD-1 err=%v", sf.err)
+		if сам.err = ct.Уст("8"); сам.err != nil {
+			сам.t.Errorf("setInt(): GOOD-1 err=%v", сам.err)
 		}
 		if ct.остатПарсер.Час().Получ() != 0 {
-			sf.t.Errorf("setInt(): GOOD-1 hour(%v)!=0", sf.ct.остатПарсер.Час().Получ())
+			сам.t.Errorf("setInt(): GOOD-1 hour(%v)!=0", сам.ct.остатПарсер.Час().Получ())
 		}
 		if ct.остатПарсер.Мин().Получ() != 0 {
-			sf.t.Errorf("setInt(): GOOD-1 min(%v)!=0", sf.ct.остатПарсер.Мин().Получ())
+			сам.t.Errorf("setInt(): GOOD-1 min(%v)!=0", сам.ct.остатПарсер.Мин().Получ())
 		}
 		if ct.остатПарсер.Сек().Получ() != 8 {
-			sf.t.Errorf("setInt(): GOOD-1 sec(%v)!=8", sf.ct.остатПарсер.Сек().Получ())
+			сам.t.Errorf("setInt(): GOOD-1 sec(%v)!=8", сам.ct.остатПарсер.Сек().Получ())
 		}
 		if strVal := ct.String(); strVal != "00:00:08" {
-			sf.t.Errorf("setInt(): GOOD-1 strVal(%v)!='00:00:08'", strVal)
+			сам.t.Errorf("setInt(): GOOD-1 strVal(%v)!='00:00:08'", strVal)
 		}
 	}
 	{ // GOOD-2
-		if sf.err = ct.Уст("121"); sf.err != nil {
-			sf.t.Errorf("setInt(): GOOD-2 err=%v", sf.err)
+		if сам.err = ct.Уст("121"); сам.err != nil {
+			сам.t.Errorf("setInt(): GOOD-2 err=%v", сам.err)
 		}
 		if ct.остатПарсер.Час().Получ() != 0 {
-			sf.t.Errorf("setInt(): GOOD-2 hour(%v)!=0", sf.ct.остатПарсер.Час().Получ())
+			сам.t.Errorf("setInt(): GOOD-2 hour(%v)!=0", сам.ct.остатПарсер.Час().Получ())
 		}
 		if ct.остатПарсер.Мин().Получ() != 2 {
-			sf.t.Errorf("setInt(): GOOD-2 min(%v)!=2", sf.ct.остатПарсер.Мин().Получ())
+			сам.t.Errorf("setInt(): GOOD-2 min(%v)!=2", сам.ct.остатПарсер.Мин().Получ())
 		}
 		if ct.остатПарсер.Сек().Получ() != 1 {
-			sf.t.Errorf("setInt(): GOOD-2 sec(%v)!=1", sf.ct.остатПарсер.Сек().Получ())
+			сам.t.Errorf("setInt(): GOOD-2 sec(%v)!=1", сам.ct.остатПарсер.Сек().Получ())
 		}
 		if strVal := ct.String(); strVal != "00:02:01" {
-			sf.t.Errorf("setInt(): GOOD-2 strVal(%v)!='00:02:01'", strVal)
+			сам.t.Errorf("setInt(): GOOD-2 strVal(%v)!='00:02:01'", strVal)
 		}
 	}
 	{ // GOOD-3
-		if sf.err = ct.Уст("7203"); sf.err != nil {
-			sf.t.Errorf("setInt(): GOOD-3 err=%v", sf.err)
+		if сам.err = ct.Уст("7203"); сам.err != nil {
+			сам.t.Errorf("setInt(): GOOD-3 err=%v", сам.err)
 		}
 		if ct.остатПарсер.Час().Получ() != 2 {
-			sf.t.Errorf("setInt(): GOOD-3 hour(%v)!=2", sf.ct.остатПарсер.Час().Получ())
+			сам.t.Errorf("setInt(): GOOD-3 hour(%v)!=2", сам.ct.остатПарсер.Час().Получ())
 		}
 		if ct.остатПарсер.Мин().Получ() != 0 {
-			sf.t.Errorf("setInt(): GOOD-3 min(%v)!=0", sf.ct.остатПарсер.Мин().Получ())
+			сам.t.Errorf("setInt(): GOOD-3 min(%v)!=0", сам.ct.остатПарсер.Мин().Получ())
 		}
 		if ct.остатПарсер.Сек().Получ() != 3 {
-			sf.t.Errorf("setInt(): GOOD-3 sec(%v)!=3", sf.ct.остатПарсер.Сек().Получ())
+			сам.t.Errorf("setInt(): GOOD-3 sec(%v)!=3", сам.ct.остатПарсер.Сек().Получ())
 		}
 		if strVal := ct.String(); strVal != "02:00:03" {
-			sf.t.Errorf("setInt(): GOOD-3 strVal(%v)!='02:00:03'", strVal)
+			сам.t.Errorf("setInt(): GOOD-3 strVal(%v)!='02:00:03'", strVal)
 		}
 	}
 }
 
 // Нет обратного канала
-func (sf *tester) createBad1() {
+func (сам *tester) createBad1() {
 	defer func() {
 		if _panic := recover(); _panic == nil {
-			sf.t.Errorf("createBad1(): panic==nil")
+			сам.t.Errorf("createBad1(): panic==nil")
 		}
 	}()
-	sf.ct = НовВремОбрат(nil, 0)
-	if sf.ct != nil {
-		sf.t.Errorf("createBad1(): countTime!=nil")
+	сам.ct = НовВремОбрат(nil, 0)
+	if сам.ct != nil {
+		сам.t.Errorf("createBad1(): countTime!=nil")
 	}
 }
 
 // Правильное создание
-func (sf *tester) createGood1() {
+func (сам *tester) createGood1() {
 	defer func() {
 		if _panic := recover(); _panic != nil {
-			sf.t.Errorf("createGood1(): panic=\n\t%v", _panic)
+			сам.t.Errorf("createGood1(): panic=\n\t%v", _panic)
 		}
 	}()
-	sf.zone = mock_zone.НовМокСцена()
-	ct := НовВремОбрат(sf.zone, 1)
+	// сам.zone = mock_zone.НовМокСцена()
+	ct := НовВремОбрат(сам.zone, 1)
 	if ct == nil {
-		sf.t.Errorf("createGood1(): countTime==nil")
+		сам.t.Errorf("createGood1(): countTime==nil")
 	}
 	if val := ct.ПолучМилСек(); val != 0 {
-		sf.t.Errorf("createGood1(): val(%v)!=0", val)
+		сам.t.Errorf("createGood1(): val(%v)!=0", val)
 	}
 }
 
 // Создание счётчика обратного времени
-func (sf *tester) create() {
-	sf.createBad1()
-	sf.createGood1()
+func (сам *tester) create() {
+	сам.createBad1()
+	сам.createGood1()
 }

pkg/section/section.go

@@ -28,28 +28,28 @@ func НовСекция(бот types.ИБот, сценаИмя alias.Сцена
 	if ош != nil {
 		return nil, fmt.Errorf("НовСекция(): при создании ИСцена, ош=\n\t%w", ош)
 	}
-	sf := &Секция{
+	сам := &Секция{
 		Сцена:      сцена,
 		времяОстат: down_time.НовВремОбрат(сцена, 5),
 	}
-	sf.списСтр, ош = lst_string.NewLstString(стрКонтроль)
+	сам.списСтр, ош = lst_string.NewLstString(стрКонтроль)
 	if ош != nil {
 		return nil, fmt.Errorf("НовСекция(): in create *LstString, err=\n\t%w", ош)
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // СтрОбновить -- обновляет список строк секции по требованию
-func (sf *Секция) СтрОбновить(lstString []string) error {
-	if err := sf.списСтр.Set(lstString); err != nil {
+func (сам *Секция) СтрОбновить(lstString []string) error {
+	if err := сам.списСтр.Set(lstString); err != nil {
 		return fmt.Errorf("Section.СтрОбновить(): при установке lstString, err=\n\t%w", err)
 	}
 	return nil
 }
 
 // СписПолучить -- возвращает список строк секции
-func (sf *Секция) СписПолучить() []string {
-	return sf.списСтр.Get()
+func (сам *Секция) СписПолучить() []string {
+	return сам.списСтр.Get()
 }
 
 // ОбратВремяУст -- устанавливает новое значение обратного счётчика времени
@@ -66,7 +66,7 @@ func (сам *Секция) Уст(времяСек alias.Время) error {
 	if ош := сам.времяОстат.Уст(времяСек); ош != nil {
 		return fmt.Errorf("Секция.ParseCountDown(): err=\n\t%w", ош)
 	}
-	// if err := sf.countDown.Set(sec); err != nil {
+	// if err := сам.countDown.Set(sec); err != nil {
 	//
 	// }
 	return nil

pkg/store/store.go

@@ -27,36 +27,36 @@ func NewStore(app types.ИСервер) (*Store, error) {
 	if app == nil {
 		return nil, fmt.Errorf("NewStore(): IApp is nil")
 	}
-	sf := &Store{
+	сам := &Store{
 		app:    app,
 		isWork: safe_bool.НовБезопБул(),
 	}
-	if err := sf.open(); err != nil {
+	if err := сам.open(); err != nil {
 		return nil, fmt.Errorf("NewStore(): in open store, err=%w", err)
 	}
-	sf.isWork.Уст()
-	go sf.close()
-	sf.app.Wg().Add(strStore)
-	sf.app.Slog().Infof("NewStore(): run")
-	return sf, nil
+	сам.isWork.Уст()
+	go сам.close()
+	сам.app.Wg().Add(strStore)
+	сам.app.Slog().Infof("NewStore(): run")
+	return сам, nil
 }
 
 // Открытие хранилища
-func (sf *Store) open() error {
+func (сам *Store) open() error {
 	db, err := leveldb.OpenFile("store", nil)
 	if err != nil {
 		return fmt.Errorf("open(): in open store, err=%w", err)
 	}
-	sf.db = db
+	сам.db = db
 	return nil
 }
 
 // Get -- возвращает запись по ключу
-func (sf *Store) Get(key string) (string, error) {
-	if !sf.isWork.Получ() {
+func (сам *Store) Get(key string) (string, error) {
+	if !сам.isWork.Получ() {
 		return "", fmt.Errorf("Store.Get():  store is close")
 	}
-	binData, err := sf.db.Get([]byte(key), nil)
+	binData, err := сам.db.Get([]byte(key), nil)
 	if err != nil {
 		return "", fmt.Errorf("Store.Get(): in get by key(%q), err=%w", key, err)
 	}
@@ -64,19 +64,19 @@ func (sf *Store) Get(key string) (string, error) {
 }
 
 // Put -- помещает запись по ключу
-func (sf *Store) Put(key string, val string) error {
-	if !sf.isWork.Получ() {
+func (сам *Store) Put(key string, val string) error {
+	if !сам.isWork.Получ() {
 		return fmt.Errorf("Store.Put():  store is close")
 	}
-	if err := sf.db.Put([]byte(key), []byte(val), nil); err != nil {
+	if err := сам.db.Put([]byte(key), []byte(val), nil); err != nil {
 		return fmt.Errorf("Store.Put():  in put key(%q), err=\n\t%w", key, err)
 	}
 	return nil
 }
 
-func (sf *Store) Find(prefix string) (map[string]string, error) {
+func (сам *Store) Find(prefix string) (map[string]string, error) {
 	dictOut := make(map[string]string)
-	iter := sf.db.NewIterator(&util.Range{Start: []byte(prefix)}, nil)
+	iter := сам.db.NewIterator(&util.Range{Start: []byte(prefix)}, nil)
 	for iter.Next() {
 		key := iter.Key()
 		val := iter.Value()
@@ -90,12 +90,12 @@ func (sf *Store) Find(prefix string) (map[string]string, error) {
 	return dictOut, nil
 }
 
-func (sf *Store) close() {
-	<-sf.app.Done()
-	if !sf.isWork.Получ() {
+func (сам *Store) close() {
+	<-сам.app.Done()
+	if !сам.isWork.Получ() {
 		return
 	}
-	sf.app.Wg().Done(strStore)
-	sf.isWork.Сброс()
-	sf.app.Slog().Infof("NewStore(): close")
+	сам.app.Wg().Done(strStore)
+	сам.isWork.Сброс()
+	сам.app.Slog().Infof("NewStore(): close")
 }

pkg/types/iweb_server.go

@@ -0,0 +1,13 @@
+package types
+
+import (
+	"github.com/gofiber/fiber/v2"
+)
+
+// ИВебСервер -- интерфейс к веб-серверу
+type ИВебСервер interface {
+	// Файбер -- возвращает файбер-приложение
+	Файбер() *fiber.App
+	// Сервер -- вохвращает сервер
+	Сервер() ИСервер
+}