testify: github.com/stretchr/testify/require Index | Files

package require

import "github.com/stretchr/testify/require"

Package require implements the same assertions as the `assert` package but stops test execution when a test fails.

Example Usage

The following is a complete example using require in a standard test function:

import (
  "testing"
  "github.com/stretchr/testify/require"
)

func TestSomething(t *testing.T) {

  var a string = "Hello"
  var b string = "Hello"

  require.Equal(t, a, b, "The two words should be the same.")

}

Assertions

The `require` package have same global functions as in the `assert` package, but instead of returning a boolean result they call `t.FailNow()`.

Every assertion function also takes an optional string message as the final argument, allowing custom error messages to be appended to the message the assertion method outputs.

Index

Package Files

doc.go forward_requirements.go require.go require_forward.go requirements.go

func Condition Uses

func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{})

Condition uses a Comparison to assert a complex condition.

func Contains Uses

func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{})

Contains asserts that the specified string, list(array, slice...) or map contains the specified substring or element.

assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")
assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
assert.Contains(t, {"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")

Returns whether the assertion was successful (true) or not (false).

func Empty Uses

func Empty(t TestingT, object interface{}, msgAndArgs ...interface{})

Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either a slice or a channel with len == 0.

assert.Empty(t, obj)

Returns whether the assertion was successful (true) or not (false).

func Equal Uses

func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{})

Equal asserts that two objects are equal.

assert.Equal(t, 123, 123, "123 and 123 should be equal")

Returns whether the assertion was successful (true) or not (false).

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

func EqualError Uses

func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{})

EqualError asserts that a function returned an error (i.e. not `nil`) and that it is equal to the provided error.

actualObj, err := SomeFunction()
assert.EqualError(t, err,  expectedErrorString, "An error was expected")

Returns whether the assertion was successful (true) or not (false).

func EqualValues Uses

func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{})

EqualValues asserts that two objects are equal or convertable to the same types and equal.

assert.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal")

Returns whether the assertion was successful (true) or not (false).

func Error Uses

func Error(t TestingT, err error, msgAndArgs ...interface{})

Error asserts that a function returned an error (i.e. not `nil`).

  actualObj, err := SomeFunction()
  if assert.Error(t, err, "An error was expected") {
	   assert.Equal(t, err, expectedError)
  }

Returns whether the assertion was successful (true) or not (false).

func Exactly Uses

func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{})

Exactly asserts that two objects are equal is value and type.

assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal")

Returns whether the assertion was successful (true) or not (false).

func Fail Uses

func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{})

Fail reports a failure through

func FailNow Uses

func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{})

FailNow fails test

func False Uses

func False(t TestingT, value bool, msgAndArgs ...interface{})

False asserts that the specified value is false.

assert.False(t, myBool, "myBool should be false")

Returns whether the assertion was successful (true) or not (false).

func HTTPBodyContains Uses

func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{})

HTTPBodyContains asserts that a specified handler returns a body that contains a string.

assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")

Returns whether the assertion was successful (true) or not (false).

func HTTPBodyNotContains Uses

func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{})

HTTPBodyNotContains asserts that a specified handler returns a body that does not contain a string.

assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")

Returns whether the assertion was successful (true) or not (false).

func HTTPError Uses

func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values)

HTTPError asserts that a specified handler returns an error status code.

assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Returns whether the assertion was successful (true) or not (false).

func HTTPRedirect Uses

func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values)

HTTPRedirect asserts that a specified handler returns a redirect status code.

assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Returns whether the assertion was successful (true) or not (false).

func HTTPSuccess Uses

func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values)

HTTPSuccess asserts that a specified handler returns a success status code.

assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)

Returns whether the assertion was successful (true) or not (false).

func Implements Uses

func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{})

Implements asserts that an object is implemented by the specified interface.

assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject")

func InDelta Uses

func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

InDelta asserts that the two numerals are within delta of each other.

assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)

Returns whether the assertion was successful (true) or not (false).

func InDeltaSlice Uses

func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

InDeltaSlice is the same as InDelta, except it compares two slices.

func InEpsilon Uses

func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{})

InEpsilon asserts that expected and actual have a relative error less than epsilon

Returns whether the assertion was successful (true) or not (false).

func InEpsilonSlice Uses

func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{})

InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.

func IsType Uses

func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{})

IsType asserts that the specified objects are of the same type.

func JSONEq Uses

func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{})

JSONEq asserts that two JSON strings are equivalent.

assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

Returns whether the assertion was successful (true) or not (false).

func Len Uses

func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{})

Len asserts that the specified object has specific length. Len also fails if the object has a type that len() not accept.

assert.Len(t, mySlice, 3, "The size of slice is not 3")

Returns whether the assertion was successful (true) or not (false).

func Nil Uses

func Nil(t TestingT, object interface{}, msgAndArgs ...interface{})

Nil asserts that the specified object is nil.

assert.Nil(t, err, "err should be nothing")

Returns whether the assertion was successful (true) or not (false).

func NoError Uses

func NoError(t TestingT, err error, msgAndArgs ...interface{})

NoError asserts that a function returned no error (i.e. `nil`).

  actualObj, err := SomeFunction()
  if assert.NoError(t, err) {
	   assert.Equal(t, actualObj, expectedObj)
  }

Returns whether the assertion was successful (true) or not (false).

func NotContains Uses

func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{})

NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the specified substring or element.

assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
assert.NotContains(t, {"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")

Returns whether the assertion was successful (true) or not (false).

func NotEmpty Uses

func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{})

NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either a slice or a channel with len == 0.

if assert.NotEmpty(t, obj) {
  assert.Equal(t, "two", obj[1])
}

Returns whether the assertion was successful (true) or not (false).

func NotEqual Uses

func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{})

NotEqual asserts that the specified values are NOT equal.

assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")

Returns whether the assertion was successful (true) or not (false).

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

func NotNil Uses

func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{})

NotNil asserts that the specified object is not nil.

assert.NotNil(t, err, "err should be something")

Returns whether the assertion was successful (true) or not (false).

func NotPanics Uses

func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{})

NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.

assert.NotPanics(t, func(){
  RemainCalm()
}, "Calling RemainCalm() should NOT panic")

Returns whether the assertion was successful (true) or not (false).

func NotRegexp Uses

func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{})

NotRegexp asserts that a specified regexp does not match a string.

assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
assert.NotRegexp(t, "^start", "it's not starting")

Returns whether the assertion was successful (true) or not (false).

func NotZero Uses

func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{})

NotZero asserts that i is not the zero value for its type and returns the truth.

func Panics Uses

func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{})

Panics asserts that the code inside the specified PanicTestFunc panics.

assert.Panics(t, func(){
  GoCrazy()
}, "Calling GoCrazy() should panic")

Returns whether the assertion was successful (true) or not (false).

func Regexp Uses

func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{})

Regexp asserts that a specified regexp matches a string.

assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
assert.Regexp(t, "start...$", "it's not starting")

Returns whether the assertion was successful (true) or not (false).

func True Uses

func True(t TestingT, value bool, msgAndArgs ...interface{})

True asserts that the specified value is true.

assert.True(t, myBool, "myBool should be true")

Returns whether the assertion was successful (true) or not (false).

func WithinDuration Uses

func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{})

WithinDuration asserts that the two times are within duration delta of each other.

assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")

Returns whether the assertion was successful (true) or not (false).

func Zero Uses

func Zero(t TestingT, i interface{}, msgAndArgs ...interface{})

Zero asserts that i is the zero value for its type and returns the truth.

type Assertions Uses

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

Assertions provides assertion methods around the TestingT interface.

func New Uses

func New(t TestingT) *Assertions

New makes a new Assertions object for the specified TestingT.

func (*Assertions) Condition Uses

func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{})

Condition uses a Comparison to assert a complex condition.

func (*Assertions) Contains Uses

func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{})

Contains asserts that the specified string, list(array, slice...) or map contains the specified substring or element.

a.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
a.Contains(["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
a.Contains({"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Empty Uses

func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{})

Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either a slice or a channel with len == 0.

a.Empty(obj)

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Equal Uses

func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{})

Equal asserts that two objects are equal.

a.Equal(123, 123, "123 and 123 should be equal")

Returns whether the assertion was successful (true) or not (false).

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

func (*Assertions) EqualError Uses

func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{})

EqualError asserts that a function returned an error (i.e. not `nil`) and that it is equal to the provided error.

actualObj, err := SomeFunction()
a.EqualError(err,  expectedErrorString, "An error was expected")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) EqualValues Uses

func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{})

EqualValues asserts that two objects are equal or convertable to the same types and equal.

a.EqualValues(uint32(123), int32(123), "123 and 123 should be equal")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Error Uses

func (a *Assertions) Error(err error, msgAndArgs ...interface{})

Error asserts that a function returned an error (i.e. not `nil`).

  actualObj, err := SomeFunction()
  if a.Error(err, "An error was expected") {
	   assert.Equal(t, err, expectedError)
  }

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Exactly Uses

func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{})

Exactly asserts that two objects are equal is value and type.

a.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Fail Uses

func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{})

Fail reports a failure through

func (*Assertions) FailNow Uses

func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{})

FailNow fails test

func (*Assertions) False Uses

func (a *Assertions) False(value bool, msgAndArgs ...interface{})

False asserts that the specified value is false.

a.False(myBool, "myBool should be false")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPBodyContains Uses

func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{})

HTTPBodyContains asserts that a specified handler returns a body that contains a string.

a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPBodyNotContains Uses

func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{})

HTTPBodyNotContains asserts that a specified handler returns a body that does not contain a string.

a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPError Uses

func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values)

HTTPError asserts that a specified handler returns an error status code.

a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPRedirect Uses

func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values)

HTTPRedirect asserts that a specified handler returns a redirect status code.

a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPSuccess Uses

func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values)

HTTPSuccess asserts that a specified handler returns a success status code.

a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Implements Uses

func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{})

Implements asserts that an object is implemented by the specified interface.

a.Implements((*MyInterface)(nil), new(MyObject), "MyObject")

func (*Assertions) InDelta Uses

func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

InDelta asserts that the two numerals are within delta of each other.

a.InDelta(math.Pi, (22 / 7.0), 0.01)

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) InDeltaSlice Uses

func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

InDeltaSlice is the same as InDelta, except it compares two slices.

func (*Assertions) InEpsilon Uses

func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{})

InEpsilon asserts that expected and actual have a relative error less than epsilon

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) InEpsilonSlice Uses

func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{})

InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.

func (*Assertions) IsType Uses

func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{})

IsType asserts that the specified objects are of the same type.

func (*Assertions) JSONEq Uses

func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{})

JSONEq asserts that two JSON strings are equivalent.

a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Len Uses

func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{})

Len asserts that the specified object has specific length. Len also fails if the object has a type that len() not accept.

a.Len(mySlice, 3, "The size of slice is not 3")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Nil Uses

func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{})

Nil asserts that the specified object is nil.

a.Nil(err, "err should be nothing")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) NoError Uses

func (a *Assertions) NoError(err error, msgAndArgs ...interface{})

NoError asserts that a function returned no error (i.e. `nil`).

  actualObj, err := SomeFunction()
  if a.NoError(err) {
	   assert.Equal(t, actualObj, expectedObj)
  }

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) NotContains Uses

func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{})

NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the specified substring or element.

a.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
a.NotContains(["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
a.NotContains({"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) NotEmpty Uses

func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{})

NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either a slice or a channel with len == 0.

if a.NotEmpty(obj) {
  assert.Equal(t, "two", obj[1])
}

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) NotEqual Uses

func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{})

NotEqual asserts that the specified values are NOT equal.

a.NotEqual(obj1, obj2, "two objects shouldn't be equal")

Returns whether the assertion was successful (true) or not (false).

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

func (*Assertions) NotNil Uses

func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{})

NotNil asserts that the specified object is not nil.

a.NotNil(err, "err should be something")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) NotPanics Uses

func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{})

NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.

a.NotPanics(func(){
  RemainCalm()
}, "Calling RemainCalm() should NOT panic")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) NotRegexp Uses

func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{})

NotRegexp asserts that a specified regexp does not match a string.

a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
a.NotRegexp("^start", "it's not starting")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) NotZero Uses

func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{})

NotZero asserts that i is not the zero value for its type and returns the truth.

func (*Assertions) Panics Uses

func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{})

Panics asserts that the code inside the specified PanicTestFunc panics.

a.Panics(func(){
  GoCrazy()
}, "Calling GoCrazy() should panic")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Regexp Uses

func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{})

Regexp asserts that a specified regexp matches a string.

a.Regexp(regexp.MustCompile("start"), "it's starting")
a.Regexp("start...$", "it's not starting")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) True Uses

func (a *Assertions) True(value bool, msgAndArgs ...interface{})

True asserts that the specified value is true.

a.True(myBool, "myBool should be true")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) WithinDuration Uses

func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{})

WithinDuration asserts that the two times are within duration delta of each other.

a.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Zero Uses

func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{})

Zero asserts that i is the zero value for its type and returns the truth.

type TestingT Uses

type TestingT interface {
    Errorf(format string, args ...interface{})
    FailNow()
}

TestingT is an interface wrapper around *testing.T

Package require imports 4 packages (graph) and is imported by 191 packages. Updated 2017-02-05. Refresh now. Tools for package owners.