assert

README

V Assertion Library

Yet another assertion library for Golang.

Quick Start

import (
    . "v2ray.com/ext/assert"
)

func TestStringEquals(t *testing.T) {
    assert := With(t)

    str := "Hello" + " " + "World"
    assert(str, Equals, "Hello World")
}

Usage

The assert function take at least 2 parameters: assert(value, matcher, expectations...), where:

• value is the value to be asserted.
• matcher is a "function" to assert the value.
• expectations are optional parameters that will be passed into matcher for the assertion.

There are several predefined matchers:

• Equals
• LessThan
• GreaterThan
• AtLeast
• AtMost
• IsNil
• IsNotNil
• HasSubstring

Documentation

Overview

Package assert provides basic assertions for unit tests.

Example Usage

The following examples show how to use this library:

import (
  "testing"
  . "v2ray.com/ext/assert"
)

func TestSomething(t *testing.T) {
  assert := With(t)

  a := 10
  b := 1
  assert(a, Equals, b)
}

Index

• Variables
• func RegisterEqualsMatcher(f interface{})
• func RegisterGreaterThanMatcher(f interface{})
• func RegisterLessThanMatcher(f interface{})
• type Assert
  • func With(t *testing.T) Assert
• type Matcher
  • func CreateMatcher(fv interface{}, verb string) *Matcher
  • func Not(op *Matcher) *Matcher

Variables

var AtLeast = CreateMatcher(func(v interface{}, exp interface{}) bool {
	return !callInternal(less, v, exp)
}, "less than")

var AtMost = CreateMatcher(func(v interface{}, exp interface{}) bool {
	return !callInternal(greater, v, exp)
}, "less than or equals to")

var Equals = CreateMatcher(func(v interface{}, exp interface{}) bool {
	vt := reflect.TypeOf(v)
	op, found := equals[vt]
	if found {
		return op.call(v, []interface{}{exp})
	}
	return v == exp
}, "equals to")

Equals is a Matcher that expects two given values are equal to each other.

var GreaterThan = CreateMatcher(func(v interface{}, exp interface{}) bool {
	return callInternal(greater, v, exp)
}, "less than")

var HasDone = CreateMatcher(func(ctx context.Context) bool {
	select {
	case <-ctx.Done():
		return true
	default:
		return false
	}
}, "has done.")

var HasPrefix = CreateMatcher(func(a, b string) bool {
	return strings.HasPrefix(a, b)
}, "has prefix")

var HasStringElement = CreateMatcher(func(a []string, b string) bool {
	for _, v := range a {
		if v == b {
			return true
		}
	}
	return false
}, "contains string element")

var HasSubstring = CreateMatcher(func(a, b string) bool {
	return strings.Contains(a, b)
}, "contains substring")

var HasSuffix = CreateMatcher(func(a, b string) bool {
	return strings.HasSuffix(a, b)
}, "has suffix")

var Implements = CreateMatcher(func(v interface{}, exp interface{}) bool {
	return reflect.TypeOf(v).Implements(reflect.TypeOf(exp).Elem())
}, "implements")

var IsEmpty = CreateMatcher(func(v interface{}) bool {
	return reflect.ValueOf(v).Len() == 0
}, "is empty")

var IsFalse = CreateMatcher(func(v bool) bool {
	return !v
}, "is false")

var IsNegative = CreateMatcher(func(v interface{}, exp interface{}) bool {
	return callInternal(less, v, 0)
}, "is negative")

var IsNil = CreateMatcher(func(v interface{}) bool {
	return v == nil || reflect.ValueOf(v).IsNil()
}, "is nil")

var IsNotNil = CreateMatcher(func(v interface{}) bool {
	return v != nil
}, "is not nil")

var IsPositive = CreateMatcher(func(v interface{}, exp interface{}) bool {
	return callInternal(greater, v, 0)
}, "is positive")

var IsTrue = CreateMatcher(func(v bool) bool {
	return v
}, "is true")

var LessThan = CreateMatcher(func(v interface{}, exp interface{}) bool {
	return callInternal(less, v, exp)
}, "less than")

LessThan expects the given value is less than the expectation.

var NotEquals = CreateMatcher(func(v interface{}, exp interface{}) bool {
	vt := reflect.TypeOf(v)
	op, found := equals[vt]
	if found {
		return !op.call(v, []interface{}{exp})
	}
	return v != exp
}, "not equals to")

NotEquals is a Matcher that expects two given values are not equal to each other.

var Panics = CreateMatcher(func(v interface{}) (ret bool) {
	defer func() {
		if x := recover(); x != nil {
			ret = true
		}
	}()
	if vf, ok := v.(func()); ok {
		vf()
	}
	return false
}, "panics")

Functions

func RegisterEqualsMatcher

func RegisterEqualsMatcher(f interface{})

func RegisterGreaterThanMatcher

func RegisterGreaterThanMatcher(f interface{})

func RegisterLessThanMatcher

func RegisterLessThanMatcher(f interface{})

Types

type Assert

type Assert func(value interface{}, op *Matcher, expectations ...interface{})

Assert asserts the given value matches expectations.

func With

func With(t *testing.T) Assert

With creates wrap the testing object into an assertion.

type Matcher

type Matcher struct {
	// contains filtered or unexported fields
}

func CreateMatcher

func CreateMatcher(fv interface{}, verb string) *Matcher

func Not

func Not(op *Matcher) *Matcher