func (w *Wrapper) Truthy(expr data.Value) {
	w.Helper()
	w.Assertions.True(data.Truthy(expr))
}
Truthy tests a Value for system-specific Truthy
package assert
import (
	"errors"
	"fmt"
	"strings"
	"testing"
	"github.com/kode4food/ale/data"
	"github.com/stretchr/testify/assert"
)
type (
	Any interface{}
	Wrapper struct {
		*testing.T
		*assert.Assertions
	}
)
const (
	ErrInvalidTestExpression = "invalid test expression: %v"
	ErrProperErrorNotRaised  = "proper error not raised"
	ErrValueNotFound         = "value not found in object: %s"
)
func New(t *testing.T) *Wrapper {
	return &Wrapper{
		T:          t,
		Assertions: assert.New(t),
	}
}
func (w *Wrapper) String(expect string, expr Any) {
	w.Helper()
	switch s := expr.(type) {
	case string:
		w.Assertions.Equal(expect, s)
	case data.Value:
		w.Assertions.Equal(expect, s.String())
	default:
		panic(fmt.Errorf(ErrInvalidTestExpression, expr))
	}
}
func (w *Wrapper) Number(expect float64, expr Any) {
	w.Helper()
	switch n := expr.(type) {
	case float64:
		w.Assertions.Equal(expect, n)
	case int:
		w.Assertions.Equal(int64(expect), int64(n))
	case data.Number:
		w.Assertions.Equal(data.EqualTo, data.Float(expect).Cmp(n))
	default:
		panic(fmt.Errorf(ErrInvalidTestExpression, expr))
	}
}
func (w *Wrapper) Equal(expect Any, expr Any) {
	w.Helper()
	switch expect := expect.(type) {
	case data.String:
		w.String(string(expect), expr)
	case data.Number:
		num := expr.(data.Number)
		w.Assertions.Equal(data.EqualTo, expect.Cmp(num))
	case data.Value:
		if expr, ok := expr.(data.Value); ok {
			w.True(expect.Equal(expr))
		} else {
			w.String(expect.String(), expr)
		}
	default:
		w.Assertions.Equal(expect, expr)
	}
}
func (w *Wrapper) True(expr Any) {
	w.Helper()
	if b, ok := expr.(data.Bool); ok {
		w.Assertions.True(bool(b))
		return
	}
	w.Assertions.True(expr.(bool))
}