assert

package
v0.0.0-...-15b4445 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 6, 2022 License: Apache-2.0 Imports: 13 Imported by: 0

Documentation

Index

Examples

Constants

View Source
const (
	// Log is the informational level.
	Log = level(iota)
	// Error is used for things that cause test failures but do not abort.
	Error
	// Fatal is used for failures that cause the running test to immediately stop.
	Fatal
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Assertion

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

Assertion is the type for the start of an assertion line. You construct an assertion from an Output using assert.For.

func For

func For(t interface{}, msg string, args ...interface{}) *Assertion

For is shorthand for assert.To(t).For(msg, args...).

func (*Assertion) Add

func (a *Assertion) Add(key string, values ...interface{}) *Assertion

Add appends a key value pair to the output buffer.

func (Assertion) Commit

func (a Assertion) Commit()

Commit writes the output lines to the main output object.

func (*Assertion) Compare

func (a *Assertion) Compare(value interface{}, op string, expect ...interface{}) *Assertion

Compare adds both the "Got" and "Expect" entries to the output buffer, with the operator being prepended to the expect list.

func (*Assertion) CompareRaw

func (a *Assertion) CompareRaw(value interface{}, op string, expect ...interface{}) *Assertion

CompareRaw is like Compare except it does not push the values through the pretty printer.

func (*Assertion) Critical

func (a *Assertion) Critical() *Assertion

Critical switches this assertion from Error to Fatal.

func (*Assertion) Error

func (a *Assertion) Error(args ...interface{})

Error appends the supplied message to the cached output, and then flushes to the underlying output at Error level.

func (*Assertion) Expect

func (a *Assertion) Expect(op string, values ...interface{}) *Assertion

Expect adds the standard "Expect" entry to the output buffer.

func (*Assertion) ExpectRaw

func (a *Assertion) ExpectRaw(op string, values ...interface{}) *Assertion

ExpectRaw adds the standard "Expect" entry to the output buffer, without pretty printing.

func (*Assertion) Fatal

func (a *Assertion) Fatal(args ...interface{})

Fatal appends the supplied message to the cached output, and then flushes to the underlying output at Fatal level.

func (*Assertion) Got

func (a *Assertion) Got(values ...interface{}) *Assertion

Got adds the standard "Got" entry to the output buffer.

func (*Assertion) Log

func (a *Assertion) Log(args ...interface{})

Log appends the supplied message to the cached output, and then flushes to the underlying output at Log level.

func (*Assertion) Print

func (a *Assertion) Print(args ...interface{}) *Assertion

Print writes a set of values to the output buffer, joined by tabs. The values will be printed with PrintValue.

func (Assertion) PrintPretty

func (a Assertion) PrintPretty(value interface{})

PrintPretty writes a value to the output buffer. It performs standardised transformations (mostly quoting)

func (*Assertion) Printf

func (a *Assertion) Printf(format string, args ...interface{}) *Assertion

Printf writes a formatted unquoted string to the output buffer.

func (*Assertion) Println

func (a *Assertion) Println(args ...interface{}) *Assertion

Println prints the values using Print and then starts a new indented line.

func (*Assertion) Raw

func (a *Assertion) Raw(args ...interface{}) *Assertion

Raw writes a set of values to the output buffer, joined by tabs. It does not use the pretty printer.

func (*Assertion) Rawln

func (a *Assertion) Rawln(args ...interface{}) *Assertion

Println prints the values using Print and then starts a new indented line.

func (*Assertion) Test

func (a *Assertion) Test(condition bool) bool

Test commits the pending output if the condition is not true.

func (*Assertion) TestCustomDeepDiff

func (a *Assertion) TestCustomDeepDiff(value, expect interface{}, c compare.Custom) bool

TestCustomDeepDiff is equivalent to TestCustomDeepEqual except it also prints

a diff.

func (*Assertion) TestCustomDeepEqual

func (a *Assertion) TestCustomDeepEqual(value, expect interface{}, c compare.Custom) bool

TestCustomDeepEqual adds the entries for Got and Expect, then tests if they are the same using c.DeepEqual, commiting if they are not.

func (*Assertion) TestCustomDeepNotEqual

func (a *Assertion) TestCustomDeepNotEqual(value, expect interface{}, c compare.Custom) bool

TestCustomDeepNotEqual adds the entries for Got and Expect, then tests if they are the same using c.DeepEqual, commiting if they are.

func (*Assertion) TestDeepDiff

func (a *Assertion) TestDeepDiff(value, expect interface{}) bool

TestDeepDiff is equivalent to TestDeepEqual except it also prints a diff.

func (*Assertion) TestDeepEqual

func (a *Assertion) TestDeepEqual(value, expect interface{}) bool

TestDeepEqual adds the entries for Got and Expect, then tests if they are the same using compare.DeepEqual, commiting if they are not.

func (*Assertion) TestDeepNotEqual

func (a *Assertion) TestDeepNotEqual(value, expect interface{}) bool

TestDeepNotEqual adds the entries for Got and Expect, then tests if they are the same using compare.DeepEqual, commiting if they are.

func (Assertion) That

func (a Assertion) That(value interface{}) OnValue

That returns an OnValue for the specified untyped value.

func (Assertion) ThatBoolean

func (a Assertion) ThatBoolean(value bool) OnBoolean

ThatBoolean returns an OnBoolean for boolean based assertions.

func (Assertion) ThatDuration

func (a Assertion) ThatDuration(value time.Duration) OnDuration

ThatDuration returns an OnDuration for time duration based assertions.

func (Assertion) ThatEnum

func (a Assertion) ThatEnum(enum Enum) OnEnum

ThatEnum returns an OnEnum for assertions on enumeration objects.

func (Assertion) ThatError

func (a Assertion) ThatError(err error) OnError

ThatError returns an OnError for error type assertions.

func (Assertion) ThatFloat

func (a Assertion) ThatFloat(value float64) OnFloat

ThatFloat returns an OnFloat for floating point based assertions.

func (Assertion) ThatInteger

func (a Assertion) ThatInteger(value int) OnInteger

ThatInteger returns an OnInteger for integer based assertions.

func (Assertion) ThatMap

func (a Assertion) ThatMap(mp interface{}) OnMap

ThatMap returns an OnMap for assertions on map type objects. Calling this with a non map type will result in panics.

func (Assertion) ThatSlice

func (a Assertion) ThatSlice(slice interface{}) OnSlice

ThatSlice returns an OnSlice for assertions on slice type objects. Calling this with a non slice type will result in panics.

func (Assertion) ThatString

func (a Assertion) ThatString(value interface{}) OnString

ThatString returns an OnString for string based assertions. The untyped argument is converted to a string using fmt.Sprint, and the result supports string specific tests.

type Enum

type Enum interface {
	// String matches the Stringer interface, and returns the name of the value.
	String() string
	// Parse takes a name and sets the value to match the name.
	Parse(value string) error
}

Enum is the interface for something that acts like an enumeration value.

Example

An example of testing enum values

package main

import (
	"encoding/json"
	"fmt"
	"strconv"
	"strings"

	"github.com/google/gapid/core/assert"
)

type testEnum int

type enumEntry struct {
	value testEnum
	name  string
}

var (
	enums = []enumEntry{
		{0, "UNKNOWN"},
		{1, "A"},
		{2, "B"},
		{3, "BadParse"},
		{4, "FailedParse"},
		{5, "BadJsonMarshal"},
		{6, "FailedJsonMarshal"},
		{7, "BadJsonUnmarshal"},
		{8, "FailedJsonUnmarshal"},
	}
	enumTests = append(enums, []enumEntry{
		{testEnum(-1), "testEnum(-1)"},
		{1, "B"},
	}...)
)

func (v testEnum) String() string {
	for _, e := range enums {
		if e.value == v {
			return e.name
		}
	}
	return fmt.Sprintf("testEnum(%d)", v)
}

func (v *testEnum) Parse(s string) error {
	if s == "BadParse" {
		*v = 0
		return nil
	}
	if s == "FailedParse" {
		s = "badparse"
	}
	for _, e := range enums {
		if e.name == s {
			*v = e.value
			return nil
		}
	}
	trimmed := strings.TrimSuffix(strings.TrimPrefix(s, "testEnum("), ")")
	if i, err := strconv.Atoi(trimmed); err == nil {
		*v = testEnum(i)
		return nil
	}
	return fmt.Errorf("%s not in testEnum", s)
}

func (v testEnum) MarshalJSON() ([]byte, error) {
	if v.String() == "FailedJsonMarshal" {
		return nil, fmt.Errorf("FailedJsonMarshal")
	}
	if v.String() == "BadJsonMarshal" {
		return json.Marshal("badjson")
	}
	return json.Marshal(v.String())
}

func (v *testEnum) UnmarshalJSON(bytes []byte) error {
	var str string
	if err := json.Unmarshal(bytes, &str); err != nil {
		return err
	}
	if str == "FailedJsonUnmarshal" {
		return fmt.Errorf("FailedJsonUnmarshal")
	}
	if str == "BadJsonUnmarshal" {
		*v = 0
		return nil
	}
	return v.Parse(str)
}

// An example of testing enum values
func main() {
	assert := assert.To(nil)
	for _, test := range enumTests {
		assert.For(test.name).ThatEnum(&test.value).HasName(test.name)
	}
	var enum testEnum
	assert.For(`"A"`).ThatEnum(&enum).CannotUnmarshal(`"A"`)
	assert.For("0").ThatEnum(&enum).CannotUnmarshal(`0`)

}
Output:

Error:BadParse
    For enum   BadParse
    Bad Parse  UNKNOWN
Error:FailedParse
    For enum                FailedParse
    Unexpected parse error  `badparse not in testEnum`
Error:BadJsonMarshal
    For enum  BadJsonMarshal
    Bad JSON  "badjson"
    Expect    "BadJsonMarshal"
Error:FailedJsonMarshal
    For enum            FailedJsonMarshal
    JSON marshal error  `json: error calling MarshalJSON for type *assert_test.testEnum: FailedJsonMarshal`
Error:BadJsonUnmarshal
    For enum            BadJsonUnmarshal
    Bad JSON Unmarshal  UNKNOWN
Error:FailedJsonUnmarshal
    For enum              FailedJsonUnmarshal
    JSON unmarshal error  `FailedJsonUnmarshal`
Error:B
    For enum       A
    Expected name  `B`
Error:"A"
    For     "A"
    Got     A
    Expect  Unmarshal to fail

type Manager

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

Manager is the root of the fluent interface. It wraps an assertion output target in something that can construct assertion objects. The output object is normally a testing.T

func To

func To(t interface{}) Manager

To creates an assertion manager using the target t for logging. t can be a context.Context, Output or nil to log to stdout.

func (Manager) For

func (ctx Manager) For(msg string, args ...interface{}) *Assertion

For starts a new assertion with the supplied title.

type OnBoolean

type OnBoolean struct {
	Assertion
	// contains filtered or unexported fields
}

OnBoolean is the result of calling ThatBoolean on an Assertion. It provides boolean assertion tests.

func (OnBoolean) Equals

func (o OnBoolean) Equals(expect bool) bool

Equals asserts that the supplied boolean is equal to the expected boolean.

func (OnBoolean) IsFalse

func (o OnBoolean) IsFalse() bool

IsFalse asserts that the supplied boolean is false

func (OnBoolean) IsTrue

func (o OnBoolean) IsTrue() bool

IsTrue asserts that the supplied boolean is true

func (OnBoolean) NotEquals

func (o OnBoolean) NotEquals(test bool) bool

NotEquals asserts that the supplied boolean is not equal to the test boolean.

type OnDuration

type OnDuration struct {
	Assertion
	// contains filtered or unexported fields
}

OnDuration is the result of calling ThatDuration on an Assertion. It provides assertion tests that are specific to the time duration.

func (OnDuration) IsAtLeast

func (o OnDuration) IsAtLeast(min time.Duration) bool

IsAtLeast asserts that the time duration is at least than the supplied minimum.

func (OnDuration) IsAtMost

func (o OnDuration) IsAtMost(max time.Duration) bool

IsAtMost asserts that the time duration is at most than the supplied maximum.

type OnEnum

type OnEnum struct {
	Assertion
	// contains filtered or unexported fields
}

OnEnum is the result of calling ThatEnum on an Assertion. It provides enumeration assertion tests.

func (OnEnum) CannotUnmarshal

func (o OnEnum) CannotUnmarshal(data string) bool

CannotUnmarshal asserts that the enum type cannot unmarshal the supplied string without error.

func (OnEnum) HasName

func (o OnEnum) HasName(name string) bool

HasName asserts that the enum value has the supplied name. It verifies both the String/Parse and JSON marshalling.

type OnError

type OnError struct {
	Assertion
	// contains filtered or unexported fields
}

OnError is the result of calling ThatError on an Assertion. It provides assertion tests that are specific to error types.

func (OnError) DeepEquals

func (o OnError) DeepEquals(expect error) bool

DeepEquals asserts that the error value matches the expected error using compare.DeepEqual.

func (OnError) Equals

func (o OnError) Equals(expect error) bool

Equals asserts that the error value matches the expected error.

func (OnError) Failed

func (o OnError) Failed() bool

Failed asserts that the error value was not nil.

func (OnError) HasCause

func (o OnError) HasCause(expect error) bool

HasCause asserts that the error cause matches expected error.

func (OnError) HasMessage

func (o OnError) HasMessage(expect string) bool

HasMessage asserts that the error string matches the expected message.

func (OnError) Succeeded

func (o OnError) Succeeded() bool

Succeeded asserts that the error value was nil.

type OnFloat

type OnFloat struct {
	Assertion
	// contains filtered or unexported fields
}

OnFloat is the result of calling ThatFloat on an Assertion. It provides numeric assertion tests.

func (OnFloat) Equals

func (o OnFloat) Equals(v, tolerance float64) bool

Equals asserts that the float equals v with ± tolerance.

func (OnFloat) IsAtLeast

func (o OnFloat) IsAtLeast(min float64) bool

IsAtLeast asserts that the float is at least the supplied minimum.

func (OnFloat) IsAtMost

func (o OnFloat) IsAtMost(max float64) bool

IsAtMost asserts that the float is at most the supplied maximum.

type OnInteger

type OnInteger struct {
	Assertion
	// contains filtered or unexported fields
}

OnInteger is the result of calling ThatInt on an Assertion. It provides numeric assertion tests.

func (OnInteger) Equals

func (o OnInteger) Equals(expect int) bool

Equals asserts that the supplied integer is equal to the expected integer.

func (OnInteger) IsAtLeast

func (o OnInteger) IsAtLeast(min int) bool

IsAtLeast asserts that the integer is at least the supplied minimum.

func (OnInteger) IsAtMost

func (o OnInteger) IsAtMost(max int) bool

IsAtMost asserts that the integer is at most the supplied maximum.

func (OnInteger) IsBetween

func (o OnInteger) IsBetween(min, max int) bool

IsBetween asserts that the integer lies within the given range (inclusive).

func (OnInteger) NotEquals

func (o OnInteger) NotEquals(test int) bool

NotEquals asserts that the supplied integer is not equal to the test integer.

type OnMap

type OnMap struct {
	Assertion
	// contains filtered or unexported fields
}

OnMap is the result of calling ThatMap on an Assertion. It provides assertion tests that are specific to map types.

func (OnMap) DeepEquals

func (o OnMap) DeepEquals(expected interface{}) bool

DeepEquals asserts the array or map matches expected using a deep-equal comparison.

func (OnMap) Equals

func (o OnMap) Equals(expected interface{}) bool

Equals asserts the array or map matches expected.

func (OnMap) EqualsWithComparator

func (o OnMap) EqualsWithComparator(expected interface{}, same func(a, b interface{}) bool) bool

EqualsWithComparator asserts the array or map matches expected using a comparator function

func (OnMap) IsEmpty

func (o OnMap) IsEmpty() bool

IsEmpty asserts that the map was of length 0

func (OnMap) IsLength

func (o OnMap) IsLength(length int) bool

IsLength asserts that the map has exactly the specified number of elements

func (OnMap) IsNotEmpty

func (o OnMap) IsNotEmpty() bool

IsNotEmpty asserts that the map has elements

type OnSlice

type OnSlice struct {
	Assertion
	// contains filtered or unexported fields
}

OnSlice is the result of calling ThatSlice on an Assertion. It provides assertion tests that are specific to slice types.

func (OnSlice) DeepEquals

func (o OnSlice) DeepEquals(expected interface{}) bool

DeepEquals asserts the array or slice matches expected using a deep-equal comparison.

func (OnSlice) Equals

func (o OnSlice) Equals(expected interface{}) bool

Equals asserts the array or slice matches expected.

func (OnSlice) EqualsOneOf

func (o OnSlice) EqualsOneOf(expecteds interface{}) bool

Equals asserts the array or slice matches one of the expected array or slice

func (OnSlice) EqualsWithComparator

func (o OnSlice) EqualsWithComparator(expected interface{}, same func(a, b interface{}) bool) bool

EqualsWithComparator asserts the array or slice matches expected using a comparator function

func (OnSlice) IsEmpty

func (o OnSlice) IsEmpty() bool

IsEmpty asserts that the slice was of length 0

func (OnSlice) IsLength

func (o OnSlice) IsLength(length int) bool

IsLength asserts that the slice has exactly the specified number of elements

func (OnSlice) IsNotEmpty

func (o OnSlice) IsNotEmpty() bool

IsNotEmpty asserts that the slice has elements

type OnString

type OnString struct {
	Assertion
	// contains filtered or unexported fields
}

OnString is the result of calling ThatString on an Assertion. It provides assertion tests that are specific to strings.

func (OnString) Contains

func (o OnString) Contains(substr string) bool

Contains asserts that the supplied string contains substr.

func (OnString) DoesNotContain

func (o OnString) DoesNotContain(substr string) bool

DoesNotContain asserts that the supplied string does not contain substr.

func (OnString) Equals

func (o OnString) Equals(expect string) bool

Equals asserts that the supplied string is equal to the expected string.

func (OnString) HasPrefix

func (o OnString) HasPrefix(substr string) bool

HasPrefix asserts that the supplied string start with substr.

func (OnString) HasSuffix

func (o OnString) HasSuffix(substr string) bool

HasSuffix asserts that the supplied string ends with with substr.

func (OnString) NotEquals

func (o OnString) NotEquals(test string) bool

NotEquals asserts that the supplied string is not equal to the test string.

type OnValue

type OnValue struct {
	Assertion
	// contains filtered or unexported fields
}

OnValue is the result of calling That on an Assertion. It provides generice assertion tests that work for any type.

func (OnValue) CustomDeepEquals

func (o OnValue) CustomDeepEquals(expect interface{}, c compare.Custom) bool

CustomDeepEquals asserts that the supplied value is equal to the expected value using compare.Diff and the custom comparators.

func (OnValue) DeepEquals

func (o OnValue) DeepEquals(expect interface{}) bool

DeepEquals asserts that the supplied value is equal to the expected value using compare.Diff.

func (OnValue) DeepNotEquals

func (o OnValue) DeepNotEquals(test interface{}) bool

DeepNotEquals asserts that the supplied value is not equal to the test value using a deep comparison.

func (OnValue) Equals

func (o OnValue) Equals(expect interface{}) bool

Equals asserts that the supplied value is equal to the expected value.

func (OnValue) Implements

func (o OnValue) Implements(iface reflect.Type) bool

Implements asserts that the supplied value implements the specified interface.

func (OnValue) IsNil

func (o OnValue) IsNil() bool

IsNil asserts that the supplied value was a nil. Typed nils are also be allowed.

func (OnValue) IsNotNil

func (o OnValue) IsNotNil() bool

IsNotNil asserts that the supplied value was not a nil. Typed nils will also fail.

func (OnValue) NotEquals

func (o OnValue) NotEquals(test interface{}) bool

NotEquals asserts that the supplied value is not equal to the test value.

type Output

type Output interface {
	Fatal(...interface{})
	Error(...interface{})
	Log(...interface{})
}

Output matches the logging methods of the test host types.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL