func Fail(t *testing.T, text string) {
	stackString := "Call stack:\n"
	for idx := 1; ; idx++ {
		_, file, line, ok := runtime.Caller(idx)
		if !ok {
			break
		}
		_, filename := filepath.Split(file)
		if filename == "assert.go" {
			continue
		}
		if filename == "testing.go" {
			break
		}
		stackString += fmt.Sprintf("%v:%v\n", filename, line)
	}
	if t != nil {
		t.Fatal(text, "\n", stackString)
	} else {
		fmt.Print(text, "\n", stackString)
	}
}
Fail fails immediately
package assert
import (
	"fmt"
	"path/filepath"
	"reflect"
	"regexp"
	"runtime"
	"testing"
	"time"
)
func True(t *testing.T, actual interface{}) {
	if actual != true {
		Failf(t, "Expected: true\nReceived: %v", actual)
	}
}
func Eq(t *testing.T, expected interface{}, actual interface{}) {
	if expected == nil && actual == nil {
		return
	}
	if !reflect.DeepEqual(expected, actual) {
		Failf(t, "Values are not equal\nExpected: %v\nReceived: %v", expected, actual)
	}
}
func EqItems(t *testing.T, expected interface{}, actual interface{}) {
	var exp = reflect.ValueOf(expected)
	var act = reflect.ValueOf(actual)
	if exp.Type() != act.Type() {
		Failf(t, "Types are not equal\nExpected: %v\nReceived: %v", exp.Type(), act.Type())
	}
	if exp.Len() != act.Len() {
		Failf(t, "Lengths are not equal\nExpected: %v (%d elements)\nReceived: %v (%d elements)", exp, exp.Len(), act, act.Len())
	}
	if exp.Len() == 0 {
		return
	}
	var keyType = exp.Index(0).Type()
	var valueType = reflect.TypeOf(int(0))
	var mapType = reflect.MapOf(keyType, valueType)
	merged := reflect.MakeMapWithSize(mapType, exp.Len())
	for i := 0; i < exp.Len(); i++ {
		var existing = merged.MapIndex(exp.Index(i))
		if existing.IsValid() {
			merged.SetMapIndex(exp.Index(i), reflect.ValueOf(int(existing.Int())+1))  
		} else {
			merged.SetMapIndex(exp.Index(i), reflect.ValueOf(int(1)))
		}
	}
	for i := 0; i < act.Len(); i++ {
		var existing = merged.MapIndex(act.Index(i))
		if !existing.IsValid() {
			Failf(t, "Unexpected item %d: %v found in %v, expecting %v", i, act.Index(i), act, exp)
		}
		merged.SetMapIndex(act.Index(i), reflect.ValueOf(int(existing.Int())-1))  
	}
	for _, k := range merged.MapKeys() {
		var existing = merged.MapIndex(k)
		if existing.Int() != 0 {
			Failf(t, "Expected %v more of item %v", existing.Int(), k)
		}
	}
}
func NotEq(t *testing.T, notThisValue interface{}, actual interface{}) {
	if reflect.DeepEqual(notThisValue, actual) {
		Failf(t, "Expected a value other than %v", notThisValue)
	}
}
func Err(t *testing.T, err error) {
	if err == nil {
		Failf(t, "Expected error hasn't occurred: %v", err)
	}
}
func NoErr(t *testing.T, err error) {
	if err != nil {
		Failf(t, "Unexpected error occurred: %v", err)
	}
}
func NotNil(t *testing.T, actual interface{}) {
	var act = reflect.ValueOf(actual)
	if act.IsNil() {
		Failf(t, "Unexpected nil, type %v", act.Type())
	}
}
func Failf(t *testing.T, format string, args ...interface{}) {
	Fail(t, fmt.Sprintf(format, args...))
}