tc

var After Checker = &timeCompareChecker{
	CheckerInfo: &CheckerInfo{Name: "After", Params: []string{"obtained", "want"}},
	compareFunc: func(t1, t2 time.Time) bool {
		return t1.After(t2)
	},
}

After checks whether the obtained time.Time is After the want time.Time.

var Almost Checker = &timeCompareChecker{
	CheckerInfo: &CheckerInfo{Name: "Almost", Params: []string{"obtained", "want"}},
	compareFunc: func(t1, t2 time.Time) bool {
		return math.Abs(t1.Sub(t2).Seconds()) <= 1.0
	},
}

Almost checks whether the obtained time.Time is within 1s of the want time.Time.

var Before Checker = &timeCompareChecker{
	CheckerInfo: &CheckerInfo{Name: "Before", Params: []string{"obtained", "want"}},
	compareFunc: func(t1, t2 time.Time) bool {
		return t1.Before(t2)
	},
}

Before checks whether the obtained time.Time is Before the want time.Time.

var DeepEquals Checker = &deepEqualsChecker{
	&CheckerInfo{Name: "DeepEquals", Params: []string{"obtained", "expected"}},
}

The DeepEquals checker verifies that the obtained value is deep-equal to the expected value. The check will work correctly even when facing slices, interfaces, and values of different types (which always fail the test).

For example:

c.Assert(value, DeepEquals, 42)
c.Assert(array, DeepEquals, []string{"hi", "there"})

This checker differs from gocheck.DeepEquals in that it will compare a nil slice equal to an empty slice, and a nil map equal to an empty map.

var Equals Checker = &equalsChecker{
	&CheckerInfo{Name: "Equals", Params: []string{"obtained", "expected"}},
}

The Equals checker verifies that the obtained value is equal to the expected value, according to usual Go semantics for ==.

For example:

c.Assert(value, Equals, 42)

var ErrorIs Checker = &errorIsChecker{
	CheckerInfo: &CheckerInfo{
		Name:   "ErrorIs",
		Params: []string{"obtained", "error"},
	},
}

ErrorIs checks whether a value is an error that matches the other argument.

var ErrorIsNil Checker = &errorIsNilChecker{
	&CheckerInfo{Name: "ErrorIsNil", Params: []string{"value"}},
}

The ErrorIsNil checker tests whether the obtained value is nil. Explicitly tests against only `nil`.

For example:

c.Assert(err, ErrorIsNil)

var ErrorMatches Checker = errorMatchesChecker{
	&CheckerInfo{Name: "ErrorMatches", Params: []string{"value", "regex"}},
}

The ErrorMatches checker verifies that the error value is non nil and matches the regular expression provided.

For example:

c.Assert(err, ErrorMatches, "perm.*denied")

var FitsTypeOf Checker = &fitsTypeChecker{
	&CheckerInfo{Name: "FitsTypeOf", Params: []string{"obtained", "sample"}},
}

The FitsTypeOf checker verifies that the obtained value is assignable to a variable with the same type as the provided sample value.

For example:

c.Assert(value, FitsTypeOf, int64(0))
c.Assert(value, FitsTypeOf, os.Error(nil))

var HasLen Checker = &hasLenChecker{
	&CheckerInfo{Name: "HasLen", Params: []string{"obtained", "n"}},
}

The HasLen checker verifies that the obtained value has the provided length. In many cases this is superior to using Equals in conjunction with the len function because in case the check fails the value itself will be printed, instead of its length, providing more details for figuring the problem.

For example:

c.Assert(list, HasLen, 5)

var Ignore Checker = &ignoreChecker{
	&CheckerInfo{Name: "Ignore", Params: []string{"obtained"}},
}

Ignore always succeeds.

var Implements Checker = &implementsChecker{
	&CheckerInfo{Name: "Implements", Params: []string{"obtained", "ifaceptr"}},
}

The Implements checker verifies that the obtained value implements the interface specified via a pointer to an interface variable.

For example:

var e os.Error
c.Assert(err, Implements, &e)

var IsFalse Checker = Not(IsTrue)

IsTrue checks whether a value has an underlying boolean type and is false.

var IsNil Checker = &isNilChecker{
	&CheckerInfo{Name: "IsNil", Params: []string{"value"}},
}

The IsNil checker tests whether the obtained value is nil.

For example:

c.Assert(err, IsNil)

var IsTrue Checker = &isTrueChecker{
	&CheckerInfo{Name: "IsTrue", Params: []string{"obtained"}},
}

IsTrue checks whether a value has an underlying boolean type and is true.

var IsZero Checker = &zeroChecker{
	&CheckerInfo{Name: "IsZero", Params: []string{"obtained"}},
}

IsZero is a Checker that ensures the obtained value is the zero value for the obtained type.

var Matches Checker = &matchesChecker{
	&CheckerInfo{Name: "Matches", Params: []string{"value", "regex"}},
}

The Matches checker verifies that the string provided as the obtained value (or the string resulting from obtained.String()) matches the regular expression provided.

For example:

c.Assert(err, Matches, "perm.*denied")

var NotNil Checker = &notNilChecker{
	&CheckerInfo{Name: "NotNil", Params: []string{"value"}},
}

The NotNil checker verifies that the obtained value is not nil.

For example:

c.Assert(iface, NotNil)

This is an alias for Not(IsNil), made available since it's a fairly common check.

var NotZero Checker = Not(IsZero)

NotZero is a Checker that ensures the obtained value is not the zero value for the obtained type.

var PanicMatches Checker = &panicMatchesChecker{
	&CheckerInfo{Name: "PanicMatches", Params: []string{"function", "expected"}},
}

The PanicMatches checker verifies that calling the provided zero-argument function will cause a panic with an error value matching the regular expression provided.

For example:

c.Assert(func() { f(1, 2) }, PanicMatches, `open.*: no such file or directory`).

var Panics Checker = &panicsChecker{
	&CheckerInfo{Name: "Panics", Params: []string{"function", "expected"}},
}

The Panics checker verifies that calling the provided zero-argument function will cause a panic which is deep-equal to the provided value.

For example:

c.Assert(func() { f(1, 2) }, Panics, &SomeErrorType{"BOOM"}).

var SameContents Checker = &sameContents{
	&CheckerInfo{Name: "SameContents", Params: []string{"obtained", "expected"}},
}

SameContents checks that the obtained slice contains all the values (and same number of values) of the expected slice and vice versa, without respect to order or duplicates. Uses DeepEquals on contents to compare. Content types do not need to be hashable, but must satisfy reflect.DeepEquals.

var SamePath Checker = &samePathChecker{
	&CheckerInfo{Name: "SamePath", Params: []string{"obtained", "expected"}},
}

SamePath checks paths to see whether they're the same, can follow symlinks and is OS independent

var Satisfies Checker = &satisfiesChecker{
	&CheckerInfo{
		Name:   "Satisfies",
		Params: []string{"obtained", "func(T) bool"},
	},
}

Satisfies checks whether a value causes the argument function to return true. The function must be of type func(T) bool where the value being checked is assignable to T.