kern/v4/lev0/result/result_test.go

package result

import (
	"runtime"
	"testing"

	mKs "gitp78su.ipnodns.ru/svi/kern/v4/lev0/core_spec"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev0/defs"
)

type tester struct {
	t *testing.T
}

func TestResult(t *testing.T) {
	sf := &tester{
		t: t,
	}
	sf.create()
	sf.notCheck()

}

const (
	str1 = defs.ATxt("test result")
)

// Создаёт новый результат и не проверяет его.
func (sf *tester) notCheck() {
	sf.t.Log("notCheck")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("notCheck(): panic==nil")
		}
	}()
	res := NewOk(str1)
	{
		val := res.Ok()
		if val != str1 {
			sf.t.Fatalf("notCheck() test!=test")
		}
	}
	runtime.Gosched()
	runtime.GC()
	_res := res.(*Result[defs.ATxt])
	_res.destroy(_res)
}

// Создаёт новый Result.
func (sf *tester) create() {
	sf.t.Log("create")
	sf.createOkBad1()
	sf.createOkGood1()
	sf.createOkGood2()
	sf.createErrBad1()
	sf.createErrGood1()
}

func (sf *tester) createErrGood1() {
	sf.t.Log("createErrGood1")
	defer func() {
		if _panic := recover(); _panic != nil {
			sf.t.Fatalf("createErrGood1(): panic=%v", _panic)
		}
	}()
	err := defs.Err("test err")
	res := NewErr[defs.IErr](err)
	if res.IsOk() {
		sf.t.Fatalf("createErrGood1(): is ok")
	}
	if !res.IsErr() {
		sf.t.Fatalf("createErrGood1(): not err")
	}
	if val := res.OkOr(defs.Err("test2")); val.Get() != "test2" {
		sf.t.Fatalf("createErrGood1(): val bad")
	}
	if val := res.OkOr(defs.Err("test1")); val.Get() != "test1" {
		sf.t.Fatalf("createErrGood1(): val bad")
	}
	if val := res.OkOrFn(sf.fnWrap2); val.Get() != "test5" {
		sf.t.Fatalf("createErrGood1(): val bad")
	}
	if err := res.Err(); err == nil {
		sf.t.Fatalf("createErrGood1(): err == nil")
	}
	{
		res0 := WrapErr(res, err)
		if res0.IsOk() {
			sf.t.Fatalf("createErrGood1(): err == nil")
		}
		_ = res0.Error()
	}
	{
		res := NewOk("test_ok")
		if val := res.OkOr("test_ok1"); val != "test_ok" {
			sf.t.Fatalf("createErrGood1(): val(%v) != 'test_ok'", val)
		}
	}
	sf.unwrapErr(res)
	sf.hassert(res)
	sf.hassert2(res)
	sf.assert2()
}

var (
	str2 = defs.Txt("test assert2")
)

func (sf *tester) assert2() {
	sf.t.Log("assert2")
	err := defs.Err("test_error")
	res := NewErr[mKs.EBool](err)
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("assert2(): panic==nil")
		}
	}()
	res.Assert(str2)
}

var (
	str3 = defs.Txt("test hassert2")
)

func (sf *tester) hassert2(res mKs.IResult[defs.IErr]) {
	sf.t.Log("hassert2")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("assert(): panic==nil")
		}
	}()
	_ = res.Hassert(str3)
}

var (
	str4 = defs.Txt("test assert")
)

func (sf *tester) hassert(res mKs.IResult[defs.IErr]) {
	sf.t.Log("hassert")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("hassert(): panic==nil")
		}
	}()
	_ = res.Hassert(str4)
}

func (sf *tester) unwrapErr(res mKs.IResult[defs.IErr]) {
	sf.t.Log("unwrapErr")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("unwrapErr(): panic==nil")
		}
	}()
	_ = res.Ok()
}

// Нет ошибки.
func (sf *tester) createErrBad1() {
	sf.t.Log("createErrBad1")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("createErrBad1(): panic==nil")
		}
	}()
	var err defs.IErr
	_ = NewErr[mKs.EBool](err)
}

var (
	str = defs.Txt("test val")
)

func (sf *tester) createOkGood2() {
	sf.t.Log("createOkGood2")
	defer func() {
		if _panic := recover(); _panic != nil {
			sf.t.Fatalf("createOkGood2(): panic=%v", _panic)
		}
	}()
	res := NewOk(str)
	if !res.IsOk() {
		sf.t.Fatalf("createOkGood1(): not ok")
	}
	if res.IsErr() {
		sf.t.Fatalf("createOkGood1(): is err")
	}
	if val := res.Ok(); val != str {
		sf.t.Fatalf("createOkGood1(): val bad")
	}
	txt1 := defs.Txt("test1")
	if val := res.OkOr(txt1); val != str {
		sf.t.Fatalf("createOkGood1(): val bad")
	}
	if val := res.OkOr(txt1); val != str {
		sf.t.Fatalf("createOkGood1(): val bad")
	}
	if val := res.OkOrFn(sf.fnWrap); val != str {
		sf.t.Fatalf("createOkGood1(): val bad")
	}
	res0 := NewErr[any](defs.Err("test_error"))
	if err := res0.Err(); err == nil {
		sf.t.Fatalf("createOkGood1(): err==nil")
	}
	str1 := defs.Txt("test assert")
	res.Hassert(str1)
	res.Assert(str1)
}

// Функция высшего порядка для замещения ошибки.
func (sf *tester) fnWrap2() defs.IErr {
	return defs.Err("test5")
}

// Функция высшего порядка для замещения ошибки.
func (sf *tester) fnWrap() *defs.KTxt {
	return defs.Txt("test1")
}

func (sf *tester) createOkGood1() {
	sf.t.Log("createOkGood1")
	defer func() {
		if _panic := recover(); _panic != nil {
			sf.t.Fatalf("createOkGood1(): panic=%v", _panic)
		}
	}()
	str := "test val"
	_ = NewOk(&str)
}

// Нет результата.
func (sf *tester) createOkBad1() {
	sf.t.Log("createOkBad1")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("createOkBad1(): panic==nil")
		}
	}()
	var str defs.ITxtFix
	_ = NewOk(str)
}