exceptions/exception_test.go at main · gomlx/exceptions · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
package exceptions

import (
	"fmt"
	"github.com/pkg/errors"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"testing"
)

func testCountExceptions(fn func()) (eInt int, eErr error, eFloat float64) {
	exception := Try(fn)
	if exception != nil {
		if e, ok := exception.(int); ok {
			eInt = e
		} else if e, ok := exception.(error); ok {
			eErr = e
		} else if e, ok := exception.(float64); ok {
			eFloat = e
		} else {
			panic(e)
		}
	}
	return
}

func TestTry(t *testing.T) {
	// No throws.
	eInt, eErr, eFloat := testCountExceptions(func() {})
	assert.Equal(t, 0, eInt)
	assert.Equal(t, nil, eErr)
	assert.Equal(t, 0.0, eFloat)

	// Panicf an int.
	eInt, eErr, eFloat = testCountExceptions(func() {
		panic(7)
	})
	assert.Equal(t, 7, eInt)
	assert.Equal(t, nil, eErr)
	assert.Equal(t, 0.0, eFloat)

	// Panicf an error.
	e := fmt.Errorf("blah")
	eInt, eErr, eFloat = testCountExceptions(func() { panic(e) })
	assert.Equal(t, 0, eInt)
	assert.Equal(t, e, eErr)
	assert.Equal(t, 0.0, eFloat)

	// Panicf something different.
	assert.Panics(t,
		func() {
			// Exception of type string is not caught.
			_, _, _ = testCountExceptions(func() { panic("some string") })
		})
}

func TestTryCatch(t *testing.T) {
	want := errors.New("test error")
	var err error
	require.NotPanics(t, func() { err = TryCatch[error](func() { panic(want) }) })
	require.EqualError(t, err, want.Error())
}

func TestThrow(t *testing.T) {
	err := TryCatch[error](func() { Panicf("2+3=%d", 2+3) })
	require.EqualError(t, err, "2+3=5")
}

func TestRuntimeErrors(t *testing.T) {
	var x any = 0.0
	err := TryCatch[error](func() { fmt.Println(x.(string)) })
	require.ErrorContains(t, err, "interface conversion")
}