How to use Error method of got Package

...77	if err != nil {78		t.Fatalf("expected no error, got %v", err)79	}80	if chbook.Balance().Sign() != 0 {81		t.Errorf("expected: %v, got %v", "0", chbook.Balance())82	}83	chbox, err := NewInbox(key1, addr0, addr1, &key0.PublicKey, backend)84	if err != nil {85		t.Fatalf("expected no error, got %v", err)86	}87	received, err := chbox.Receive(ch)88	if err != nil {89		t.Fatalf("expected no error, got %v", err)90	}91	if received.Cmp(big.NewInt(43)) != 0 {92		t.Errorf("expected: %v, got %v", "43", received)93	}94}95func TestCheckbookFile(t *testing.T) {96	path := filepath.Join(os.TempDir(), "chequebook-test.json")97	backend := newTestBackend()98	chbook, err := NewChequebook(path, addr0, key0, backend)99	if err != nil {100		t.Fatalf("expected no error, got %v", err)101	}102	chbook.sent[addr1] = new(big.Int).SetUint64(42)103	chbook.balance = new(big.Int).Set(common.Big1)104	chbook.Save()105	chbook, err = LoadChequebook(path, key0, backend, false)106	if err != nil {107		t.Fatalf("expected no error, got %v", err)108	}109	if chbook.Balance().Cmp(common.Big1) != 0 {110		t.Errorf("expected: %v, got %v", "0", chbook.Balance())111	}112	var ch *Cheque113	if ch, err = chbook.Issue(addr1, common.Big1); err != nil {114		t.Fatalf("expected no error, got %v", err)115	}116	if ch.Amount.Cmp(new(big.Int).SetUint64(43)) != 0 {117		t.Errorf("expected: %v, got %v", "0", ch.Amount)118	}119	err = chbook.Save()120	if err != nil {121		t.Fatalf("expected no error, got %v", err)122	}123}124func TestVerifyErrors(t *testing.T) {125	path0 := filepath.Join(os.TempDir(), "chequebook-test-0.json")126	backend := newTestBackend()127	contr0, err := deploy(key0, common.Big2, backend)128	if err != nil {129		t.Errorf("expected no error, got %v", err)130	}131	chbook0, err := NewChequebook(path0, contr0, key0, backend)132	if err != nil {133		t.Errorf("expected no error, got %v", err)134	}135	path1 := filepath.Join(os.TempDir(), "chequebook-test-1.json")136	contr1, _ := deploy(key1, common.Big2, backend)137	chbook1, err := NewChequebook(path1, contr1, key1, backend)138	if err != nil {139		t.Errorf("expected no error, got %v", err)140	}141	chbook0.sent[addr1] = new(big.Int).SetUint64(42)142	chbook0.balance = new(big.Int).Set(common.Big2)143	chbook1.balance = new(big.Int).Set(common.Big1)144	amount := common.Big1145	ch0, err := chbook0.Issue(addr1, amount)146	if err != nil {147		t.Fatalf("expected no error, got %v", err)148	}149	chbox, err := NewInbox(key1, contr0, addr1, &key0.PublicKey, backend)150	if err != nil {151		t.Fatalf("expected no error, got %v", err)152	}153	received, err := chbox.Receive(ch0)154	if err != nil {155		t.Fatalf("expected no error, got %v", err)156	}157	if received.Cmp(big.NewInt(43)) != 0 {158		t.Errorf("expected: %v, got %v", "43", received)159	}160	ch1, err := chbook0.Issue(addr2, amount)161	if err != nil {162		t.Fatalf("expected no error, got %v", err)163	}164	received, err = chbox.Receive(ch1)165	t.Logf("correct error: %v", err)166	if err == nil {167		t.Fatalf("expected receiver error, got none and value %v", received)168	}169	ch2, err := chbook1.Issue(addr1, amount)170	if err != nil {171		t.Fatalf("expected no error, got %v", err)172	}173	received, err = chbox.Receive(ch2)174	t.Logf("correct error: %v", err)175	if err == nil {176		t.Fatalf("expected sender error, got none and value %v", received)177	}178	_, err = chbook1.Issue(addr1, new(big.Int).SetInt64(-1))179	t.Logf("correct error: %v", err)180	if err == nil {181		t.Fatalf("expected incorrect amount error, got none")182	}183	received, err = chbox.Receive(ch0)184	t.Logf("correct error: %v", err)185	if err == nil {186		t.Fatalf("expected incorrect amount error, got none and value %v", received)187	}188}189func TestDeposit(t *testing.T) {190	path0 := filepath.Join(os.TempDir(), "chequebook-test-0.json")191	backend := newTestBackend()192	contr0, _ := deploy(key0, new(big.Int), backend)193	chbook, err := NewChequebook(path0, contr0, key0, backend)194	if err != nil {195		t.Errorf("expected no error, got %v", err)196	}197	balance := new(big.Int).SetUint64(42)198	chbook.Deposit(balance)199	backend.Commit()200	if chbook.Balance().Cmp(balance) != 0 {201		t.Fatalf("expected balance %v, got %v", balance, chbook.Balance())202	}203	amount := common.Big1204	_, err = chbook.Issue(addr1, amount)205	if err != nil {206		t.Fatalf("expected no error, got %v", err)207	}208	backend.Commit()209	exp := new(big.Int).SetUint64(41)210	if chbook.Balance().Cmp(exp) != 0 {211		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())212	}213	// autodeposit on each issue214	chbook.AutoDeposit(0, balance, balance)215	_, err = chbook.Issue(addr1, amount)216	if err != nil {217		t.Fatalf("expected no error, got %v", err)218	}219	backend.Commit()220	_, err = chbook.Issue(addr1, amount)221	if err != nil {222		t.Fatalf("expected no error, got %v", err)223	}224	backend.Commit()225	if chbook.Balance().Cmp(balance) != 0 {226		t.Fatalf("expected balance %v, got %v", balance, chbook.Balance())227	}228	// autodeposit off229	chbook.AutoDeposit(0, common.Big0, balance)230	_, err = chbook.Issue(addr1, amount)231	if err != nil {232		t.Fatalf("expected no error, got %v", err)233	}234	backend.Commit()235	_, err = chbook.Issue(addr1, amount)236	if err != nil {237		t.Fatalf("expected no error, got %v", err)238	}239	backend.Commit()240	exp = new(big.Int).SetUint64(40)241	if chbook.Balance().Cmp(exp) != 0 {242		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())243	}244	// autodeposit every 30ms if new cheque issued245	interval := 30 * time.Millisecond246	chbook.AutoDeposit(interval, common.Big1, balance)247	_, err = chbook.Issue(addr1, amount)248	if err != nil {249		t.Fatalf("expected no error, got %v", err)250	}251	backend.Commit()252	_, err = chbook.Issue(addr1, amount)253	if err != nil {254		t.Fatalf("expected no error, got %v", err)255	}256	backend.Commit()257	exp = new(big.Int).SetUint64(38)258	if chbook.Balance().Cmp(exp) != 0 {259		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())260	}261	time.Sleep(3 * interval)262	backend.Commit()263	if chbook.Balance().Cmp(balance) != 0 {264		t.Fatalf("expected balance %v, got %v", balance, chbook.Balance())265	}266	exp = new(big.Int).SetUint64(40)267	chbook.AutoDeposit(4*interval, exp, balance)268	_, err = chbook.Issue(addr1, amount)269	if err != nil {270		t.Fatalf("expected no error, got %v", err)271	}272	backend.Commit()273	_, err = chbook.Issue(addr1, amount)274	if err != nil {275		t.Fatalf("expected no error, got %v", err)276	}277	time.Sleep(3 * interval)278	backend.Commit()279	if chbook.Balance().Cmp(exp) != 0 {280		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())281	}282	_, err = chbook.Issue(addr1, amount)283	if err != nil {284		t.Fatalf("expected no error, got %v", err)285	}286	time.Sleep(1 * interval)287	backend.Commit()288	if chbook.Balance().Cmp(balance) != 0 {289		t.Fatalf("expected balance %v, got %v", balance, chbook.Balance())290	}291	chbook.AutoDeposit(1*interval, common.Big0, balance)292	chbook.Stop()293	_, err = chbook.Issue(addr1, common.Big1)294	if err != nil {295		t.Fatalf("expected no error, got %v", err)296	}297	backend.Commit()298	_, err = chbook.Issue(addr1, common.Big2)299	if err != nil {300		t.Fatalf("expected no error, got %v", err)301	}302	time.Sleep(1 * interval)303	backend.Commit()304	exp = new(big.Int).SetUint64(39)305	if chbook.Balance().Cmp(exp) != 0 {306		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())307	}308}309func TestCash(t *testing.T) {310	path := filepath.Join(os.TempDir(), "chequebook-test.json")311	backend := newTestBackend()312	contr0, _ := deploy(key0, common.Big2, backend)313	chbook, err := NewChequebook(path, contr0, key0, backend)314	if err != nil {315		t.Errorf("expected no error, got %v", err)316	}317	chbook.sent[addr1] = new(big.Int).SetUint64(42)318	amount := common.Big1319	chbook.balance = new(big.Int).Set(common.Big1)320	ch, err := chbook.Issue(addr1, amount)321	if err != nil {322		t.Fatalf("expected no error, got %v", err)323	}324	backend.Commit()325	chbox, err := NewInbox(key1, contr0, addr1, &key0.PublicKey, backend)326	if err != nil {327		t.Fatalf("expected no error, got %v", err)328	}329	// cashing latest cheque...

...10	tests := []struct {11		err  string12		want error13	}{14		{"", fmt.Errorf("")},15		{"foo", fmt.Errorf("foo")},16		{"foo", New("foo")},17		{"string with format specifiers: %v", errors.New("string with format specifiers: %v")},18	}19	for _, tt := range tests {20		got := New(tt.err)21		if got.Error() != tt.want.Error() {22			t.Errorf("New.Error(): got: %q, want %q", got, tt.want)23		}24	}25}26func TestWrapNil(t *testing.T) {27	got := Wrap(nil, "no error")28	if got != nil {29		t.Errorf("Wrap(nil, \"no error\"): got %#v, expected nil", got)30	}31}32func TestWrap(t *testing.T) {33	tests := []struct {34		err     error35		message string36		want    string37	}{38		{io.EOF, "read error", "read error: EOF"},39		{Wrap(io.EOF, "read error"), "client error", "client error: read error: EOF"},40	}41	for _, tt := range tests {42		got := Wrap(tt.err, tt.message).Error()43		if got != tt.want {44			t.Errorf("Wrap(%v, %q): got: %v, want %v", tt.err, tt.message, got, tt.want)45		}46	}47}48type nilError struct{}49func (nilError) Error() string { return "nil error" }50func TestCause(t *testing.T) {51	x := New("error")52	tests := []struct {53		err  error54		want error55	}{{56		// nil error is nil57		err:  nil,58		want: nil,59	}, {60		// explicit nil error is nil61		err:  (error)(nil),62		want: nil,63	}, {64		// typed nil is nil65		err:  (*nilError)(nil),66		want: (*nilError)(nil),67	}, {68		// uncaused error is unaffected69		err:  io.EOF,70		want: io.EOF,71	}, {72		// caused error returns cause73		err:  Wrap(io.EOF, "ignored"),74		want: io.EOF,75	}, {76		err:  x, // return from errors.New77		want: x,78	}, {79		WithMessage(nil, "whoops"),80		nil,81	}, {82		WithMessage(io.EOF, "whoops"),83		io.EOF,84	}, {85		WithStack(nil),86		nil,87	}, {88		WithStack(io.EOF),89		io.EOF,90	}}91	for i, tt := range tests {92		got := Cause(tt.err)93		if !reflect.DeepEqual(got, tt.want) {94			t.Errorf("test %d: got %#v, want %#v", i+1, got, tt.want)95		}96	}97}98func TestWrapfNil(t *testing.T) {99	got := Wrapf(nil, "no error")100	if got != nil {101		t.Errorf("Wrapf(nil, \"no error\"): got %#v, expected nil", got)102	}103}104func TestWrapf(t *testing.T) {105	tests := []struct {106		err     error107		message string108		want    string109	}{110		{io.EOF, "read error", "read error: EOF"},111		{Wrapf(io.EOF, "read error without format specifiers"), "client error", "client error: read error without format specifiers: EOF"},112		{Wrapf(io.EOF, "read error with %d format specifier", 1), "client error", "client error: read error with 1 format specifier: EOF"},113	}114	for _, tt := range tests {115		got := Wrapf(tt.err, tt.message).Error()116		if got != tt.want {117			t.Errorf("Wrapf(%v, %q): got: %v, want %v", tt.err, tt.message, got, tt.want)118		}119	}120}121func TestErrorf(t *testing.T) {122	tests := []struct {123		err  error124		want string125	}{126		{Errorf("read error without format specifiers"), "read error without format specifiers"},127		{Errorf("read error with %d format specifier", 1), "read error with 1 format specifier"},128	}129	for _, tt := range tests {130		got := tt.err.Error()131		if got != tt.want {132			t.Errorf("Errorf(%v): got: %q, want %q", tt.err, got, tt.want)133		}134	}135}136func TestWithStackNil(t *testing.T) {137	got := WithStack(nil)138	if got != nil {139		t.Errorf("WithStack(nil): got %#v, expected nil", got)140	}141}142func TestWithStack(t *testing.T) {143	tests := []struct {144		err  error145		want string146	}{147		{io.EOF, "EOF"},148		{WithStack(io.EOF), "EOF"},149	}150	for _, tt := range tests {151		got := WithStack(tt.err).Error()152		if got != tt.want {153			t.Errorf("WithStack(%v): got: %v, want %v", tt.err, got, tt.want)154		}155	}156}157func TestWithMessageNil(t *testing.T) {158	got := WithMessage(nil, "no error")159	if got != nil {160		t.Errorf("WithMessage(nil, \"no error\"): got %#v, expected nil", got)161	}162}163func TestWithMessage(t *testing.T) {164	tests := []struct {165		err     error166		message string167		want    string168	}{169		{io.EOF, "read error", "read error: EOF"},170		{WithMessage(io.EOF, "read error"), "client error", "client error: read error: EOF"},171	}172	for _, tt := range tests {173		got := WithMessage(tt.err, tt.message).Error()174		if got != tt.want {175			t.Errorf("WithMessage(%v, %q): got: %q, want %q", tt.err, tt.message, got, tt.want)176		}177	}178}179func TestWithMessagefNil(t *testing.T) {180	got := WithMessagef(nil, "no error")181	if got != nil {182		t.Errorf("WithMessage(nil, \"no error\"): got %#v, expected nil", got)183	}184}185func TestWithMessagef(t *testing.T) {186	tests := []struct {187		err     error188		message string189		want    string190	}{191		{io.EOF, "read error", "read error: EOF"},192		{WithMessagef(io.EOF, "read error without format specifier"), "client error", "client error: read error without format specifier: EOF"},193		{WithMessagef(io.EOF, "read error with %d format specifier", 1), "client error", "client error: read error with 1 format specifier: EOF"},194	}195	for _, tt := range tests {196		got := WithMessagef(tt.err, tt.message).Error()197		if got != tt.want {198			t.Errorf("WithMessage(%v, %q): got: %q, want %q", tt.err, tt.message, got, tt.want)199		}200	}201}202// errors.New, etc values are not expected to be compared by value203// but the change in errors#27 made them incomparable. Assert that204// various kinds of errors have a functional equality operator, even205// if the result of that equality is always false.206func TestErrorEquality(t *testing.T) {207	vals := []error{208		nil,209		io.EOF,210		errors.New("EOF"),211		New("EOF"),212		Errorf("EOF"),213		Wrap(io.EOF, "EOF"),214		Wrapf(io.EOF, "EOF%d", 2),215		WithMessage(nil, "whoops"),216		WithMessage(io.EOF, "whoops"),217		WithStack(io.EOF),218		WithStack(nil),219	}220	for i := range vals {221		for j := range vals {222			_ = vals[i] == vals[j] // mustn't panic223		}224	}225}...

1import "fmt"2type MyError struct {3}4func (e *MyError) Error() string {5    return fmt.Sprintf("%d - %s", e.arg, e.prob)6}7func errorf(arg int) (int, error) {8    if arg < 0 {9        return -1, &MyError{arg, "can't work with negetive number"}10    }11}12func main() {13    for _, i := range []int{7, -2} {14        if r, e := errorf(i); e != nil {15            fmt.Println("error", e)16        } else {17            fmt.Println("result", r)18        }19    }20}21import "fmt"22type MyError struct {23}24func (e *MyError) Error() string {25    return fmt.Sprintf("%d - %s", e.arg, e.prob)26}27func errorf(arg int) (int, error) {28    if arg < 0 {29        return -1, &MyError{arg, "can't work with negetive number"}30    }31}32func main() {33    for _, i := range []int{7, -2} {34        if r, e := errorf(i); e != nil {35            fmt.Println("error", e)36        } else {37            fmt.Println("result", r)38        }39    }40}41import "fmt"42type MyError struct {43}44func (e *MyError) Error() string {45    return fmt.Sprintf("%d - %s", e.arg, e.prob)46}47func errorf(arg int) (int, error) {48    if arg < 0 {49        return -1, fmt.Errorf("can't work with negetive number: %d", arg)50    }

1import (2func main() {3    f, err := os.Open("test.txt")4    if err != nil {5        log.Fatal(err)6    }7    fmt.Println(f.Name(), "opened successfully")8}

1import (2type got struct {3}4func (g *got) Error() error {5}6func newGot(err error) *got {7	return &got{err}8}9func main() {10	g := newGot(fmt.Errorf("Got error"))11	fmt.Println(g.Error())12}

1import (2func main() {3	fmt.Println(stringutil.Reverse("!oG ,olleH"))4}5func Reverse(s string) string {6	r := []rune(s)7	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {8	}9	return string(r)10}11import (12func Reverse(s string) string {13	r := []rune(s)14	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {15	}16	return string(r)17}18func main() {19	fmt.Println(Reverse("!oG ,olleH"))20}21import (22func Reverse(s string) string {23	r := []rune(s)24	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {25	}26	return string(r)27}28func main() {29	fmt.Println(Reverse("!oG ,olleH"))30}31import (32func main() {33	fmt.Println(stringutil.Reverse("!oG ,olleH"))34}35import (36func Reverse(s string) string {37	r := []rune(s)38	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {39	}40	return string(r)41}42func main() {43	fmt.Println(Reverse("!oG ,olleH"))44}45import (

1func main() {2    got := new(Got)3    got.Error("Error message")4}5func main() {6    got := new(Got)7    got.Error("Error message")8}9func main() {10    got := new(Got)11    got.Error("Error message")12}13func main() {14    got := new(Got)15    got.Error("Error message")16}17func main() {18    got := new(Got)19    got.Error("Error message")20}21func main() {22    got := new(Got)23    got.Error("Error message")24}25func main() {26    got := new(Got)27    got.Error("Error message")28}29func main() {30    got := new(Got)31    got.Error("Error message")32}33func main() {34    got := new(Got)35    got.Error("Error message")36}37func main() {38    got := new(Got)39    got.Error("Error message")40}41func main() {42    got := new(Got)43    got.Error("Error message")44}45func main() {46    got := new(Got)47    got.Error("Error message")48}49func main() {50    got := new(Got)51    got.Error("Error message")52}53func main() {54    got := new(Got)55    got.Error("Error message")56}

1import (2func main() {3	fmt.Println(errors.New("got error"))4}5import "fmt"6func main() {7	fmt.Println(fmt.Errorf("got error"))8}9import "log"10func main() {11	log.Println("got error")12}13import "os"14func main() {15	os.Exit(1)16}17import "strconv"18func main() {19	strconv.ParseInt("123", 10, 64)20}21import "time"22func main() {23	time.Parse("2006-01-02", "2019-12-31")24}25import "regexp"26func main() {27	regexp.MatchString("a+", "abc")28}29import "bufio"30func main() {31	r := bufio.NewReader(nil)32	r.ReadString('33}34import "bytes"35func main() {36	b := bytes.Buffer{}37	b.WriteString("abc")38}39import "encoding/json"40func main() {41	json.Unmarshal([]byte(`{"a": "b"}`), nil)42}43import "encoding/xml"44func main() {45	xml.Unmarshal([]byte(`<a>b</a>`), nil)46}47import "flag"48func main() {49	flag.StringVar(&s, "s", "", "string flag")50	flag.Parse()51}52import

1import "fmt"2type got struct {3}4func (g *got) Error() string {5}6func main() {7    g := got{}8    fmt.Println(g.Error())9}

1import (2type got struct {3}4func (g got) Error() string {5	return fmt.Sprintf("got %v is %v years old", g.name, g.age)6}7func main() {8	g := got{9	}10	log.Fatal(g)11}12import (13type got struct {14}15func (g got) Error() string {16	return fmt.Sprintf("got %v is %v years old", g.name, g.age)17}18func main() {19	g := got{20	}21	log.Fatal(g.Error())22}23import (24type got struct {25}26func (g got) Error() string {27	return fmt.Sprintf("got %v is %v years old", g.name, g.age)28}29func main() {30	g = got{31	}32	log.Fatal(g)33}34import (35type got struct {36}37func (g got) Error() string {38	return fmt.Sprintf("got %v is %v years old", g.name, g.age)39}40func main()