Documentation
¶
Overview ¶
Package assert includes runtime assertion helpers. They follow common practise in C/C++ development where you can see lines like:
assert(ptr != NULL)
or
assert(!"not implemented")
With the help of the assert package we can write the same preconditions in Go:
assert.NotNil(ptr)
or
assert.NoImplementation()
The package offers a convenient way to set preconditions to code which allow us detect programming errors and API usage violations faster. Still allowing proper path to production-time error handling if needed. When used with the err2 package panics can be turned to normal Go's error values by using proper Asserter like P:
assert.P.True(s != "", "sub command cannot be empty")
Please see the code examples for more information.
Note! Format string functions need to be own instances because of Go's vet and test tool integration.
Index ¶
- type Asserter
- func (asserter Asserter) Empty(obj interface{}, msg ...interface{})
- func (asserter Asserter) EqualInt(val, want int, a ...interface{})
- func (asserter Asserter) HasStackTrace() bool
- func (asserter Asserter) HasToError() bool
- func (asserter Asserter) Len(obj interface{}, length int, a ...interface{})
- func (asserter Asserter) Lenf(obj interface{}, length int, format string, a ...interface{})
- func (asserter Asserter) NoImplementation(a ...interface{})
- func (asserter Asserter) NotEmpty(obj interface{}, msg ...interface{})
- func (asserter Asserter) NotEmptyf(obj interface{}, format string, msg ...interface{})
- func (asserter Asserter) True(term bool, a ...interface{})
- func (asserter Asserter) Truef(term bool, format string, a ...interface{})
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Asserter ¶
type Asserter uint32
Asserter is type for asserter object guided by its flags.
var ( // P is a production Asserter that types panic objects to errors which // allows err2 handlers to catch them. P = AsserterToError // D is a development Asserter that types panic objects to strings that // doesn't by caught by err2 handlers. D Asserter = 0 )
func (Asserter) Empty ¶
func (asserter Asserter) Empty(obj interface{}, msg ...interface{})
Empty asserts that length of the object is zero. If not it panics with the given formatting string. Note! This is slow.
Example ¶
package main
import (
"fmt"
"github.com/lainio/err2"
"github.com/lainio/err2/assert"
)
func main() {
sample := func(b []byte) (err error) {
defer err2.Annotate("sample", &err)
assert.P.Empty(b)
return err
}
err := sample([]byte{1, 2})
fmt.Printf("%v", err)
}
Output: sample: got 2, want == 0
func (Asserter) EqualInt ¶
EqualInt asserts that integers are equal. If not it panics/errors (current Asserter) with the given msg.
Example ¶
package main
import (
"fmt"
"github.com/lainio/err2"
"github.com/lainio/err2/assert"
)
func main() {
sample := func(b []byte) (err error) {
defer err2.Annotate("sample", &err)
assert.P.EqualInt(len(b), 3)
return err
}
err := sample([]byte{1, 2})
fmt.Printf("%v", err)
}
Output: sample: got 2, want 3
func (Asserter) HasStackTrace ¶
func (Asserter) HasToError ¶
func (Asserter) Len ¶
Len asserts that length of the object is equal to given. If not it panics/errors (current Asserter) with the given msg. Note! This is very slow (before we have generics). If you need performance use EqualInt. It's not so convenient, though.
Example ¶
package main
import (
"fmt"
"github.com/lainio/err2"
"github.com/lainio/err2/assert"
)
func main() {
sample := func(b []byte) (err error) {
defer err2.Annotate("sample", &err)
assert.P.Len(b, 3)
return err
}
err := sample([]byte{1, 2})
fmt.Printf("%v", err)
}
Output: sample: got 2, want 3
func (Asserter) Lenf ¶
Lenf asserts that length of the object is equal to given. If not it panics/errors (current Asserter) with the given msg. Note! This is very slow (before we have generics). If you need performance use EqualInt. It's not so convenient, though.
Example ¶
package main
import (
"fmt"
"github.com/lainio/err2"
"github.com/lainio/err2/assert"
)
func main() {
sample := func(b []byte) (err error) {
defer err2.Annotate("sample", &err)
assert.P.Lenf(b, 3, "actual len = %d", len(b))
return err
}
err := sample([]byte{1, 2})
fmt.Printf("%v", err)
}
Output: sample: actual len = 2
func (Asserter) NoImplementation ¶
func (asserter Asserter) NoImplementation(a ...interface{})
NoImplementation always fails with no implementation.
Example ¶
package main
import (
"fmt"
"github.com/lainio/err2"
"github.com/lainio/err2/assert"
)
func main() {
sample := func(m int) (err error) {
defer err2.Annotate("sample", &err)
switch m {
case 1:
return nil
default:
assert.P.NoImplementation()
}
return err
}
err := sample(0)
fmt.Printf("%v", err)
}
Output: sample: not implemented
func (Asserter) NotEmpty ¶
func (asserter Asserter) NotEmpty(obj interface{}, msg ...interface{})
NotEmpty asserts that length of the object greater than zero. If not it panics with the given formatting string. Note! This is slow.
func (Asserter) NotEmptyf ¶
NotEmptyf asserts that length of the object greater than zero. If not it panics with the given formatting string. Note! This is slow.
func (Asserter) True ¶
True asserts that term is true. If not it panics with the given formatting string. Note! This and Truef are the most performant of all the assertion functions.
Example ¶
package main
import (
"fmt"
"github.com/lainio/err2"
"github.com/lainio/err2/assert"
)
func main() {
sample := func() (err error) {
defer err2.Annotate("sample", &err)
assert.P.True(false, "assertion test")
return err
}
err := sample()
fmt.Printf("%v", err)
}
Output: sample: assertion test
func (Asserter) Truef ¶
Truef asserts that term is true. If not it panics with the given formatting string.
Example ¶
package main
import (
"fmt"
"github.com/lainio/err2"
"github.com/lainio/err2/assert"
)
func main() {
sample := func() (err error) {
defer err2.Annotate("sample", &err)
assert.P.Truef(false, "assertion test %d", 2)
return err
}
err := sample()
fmt.Printf("%v", err)
}
Output: sample: assertion test 2
Source Files