assert

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Dec 1, 2021 License: MIT Imports: 18 Imported by: 6

README

Go assertion library (fork of stretchr/testify/require)

This is a fork of stretchr's assertion library that does two things:

  1. It makes spotting differences in equality much easier. It uses repr and diffmatchpatch to display structural differences in colour.
  2. Aborts tests on first assertion failure (the same behaviour as stretchr/testify/require).

Example

Given the following test:

type Person struct {
  Name string
  Age  int
}

// Use github.com/alecthomas/assert
func TestDiff(t *testing.T) {
  expected := []*Person{{"Alec", 20}, {"Bob", 21}, {"Sally", 22}}
  actual := []*Person{{"Alex", 20}, {"Bob", 22}, {"Sally", 22}}
  assert.Equal(t, expected, actual)
}

// Use github.com/stretchr/testify/require
func TestTestifyDiff(t *testing.T) {
  expected := []*Person{{"Alec", 20}, {"Bob", 21}, {"Sally", 22}}
  actual := []*Person{{"Alex", 20}, {"Bob", 22}, {"Sally", 22}}
  require.Equal(t, expected, actual)
}

The following output illustrates the problems this solves. Firstly, it shows nested structures correctly, and secondly it highlights the differences between actual and expected text.

Documentation

Overview

Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.

Example Usage

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

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

func TestSomething(t *testing.T) {

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

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

}

if you assert many times, use the format below: 

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

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

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

  assert.Equal(a, b, "The two words should be the same.")
}

Assertions

Assertions allow you to easily write test code, and are global funcs in the `assert` package. All assertion functions take, as the first argument, the `*testing.T` object provided by the testing framework. This allows the assertion funcs to write the failings and other details to the correct place.

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

Constants

This section is empty.

Variables

View Source 
var AnError = errors.New("assert.AnError general error for testing")

AnError is an error instance useful for testing. If the code does not care about error specifics, and only needs to return the error for example, this error should be used to make the test code more readable.

Functions

func CallerInfo 

func CallerInfo() []string

CallerInfo returns an array of strings containing the file and line number of each stack frame leading from the current test to the assert call that failed.

func Condition 

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

Condition uses a Comparison to assert a complex condition.

func Contains 

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

Contains asserts that the specified string or list(array, slice...) 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'")

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

func DiffValues 

func DiffValues(a, b interface{}) string

func DiffValuesDefault 

func DiffValuesDefault(a, b interface{}) string

func Empty 

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 

func Equal(t TestingT, expected, 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).

func EqualError 

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.Error(t, err, "An error was expected")
assert.Equal(t, err, expectedError)

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

func EqualValues 

func EqualValues(t TestingT, expected, 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 

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

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

actualObj, err := SomeFunction()
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 

func Exactly(t TestingT, expected, 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 

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

Fail reports a failure through

func False 

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

False asserts that the specified value is true. 

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

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

func HTTPBody 

func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string

HTTPBody is a helper that returns HTTP body of the response. It returns empty string if building a new request fails.

func HTTPBodyContains 

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

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 

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

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 

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

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 

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

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 

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

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 

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 

func InDelta(t TestingT, expected, 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 

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

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

func InEpsilon 

func InEpsilon(t TestingT, expected, 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 

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

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

func IsType 

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

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

func Len 

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 

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 

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

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

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

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

func NotContains 

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

NotContains asserts that the specified string or list(array, slice...) 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'")

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

func NotEmpty 

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.

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

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

func NotEqual 

func NotEqual(t TestingT, expected, 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).

func NotNil 

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 

func NotPanics(t TestingT, f 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 

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 

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 ObjectsAreEqual 

func ObjectsAreEqual(expected, actual interface{}) bool

ObjectsAreEqual determines if two objects are considered equal.

This function does no assertion of any kind.

func ObjectsAreEqualValues 

func ObjectsAreEqualValues(expected, actual interface{}) bool

ObjectsAreEqualValues gets whether two objects are equal, or if their values are equal.

func Panics 

func Panics(t TestingT, f 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 

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 

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 

func WithinDuration(t TestingT, expected, 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 

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

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

Types

type Assertions 

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

Assertions provides assertion methods around the TestingT interface.

func New 

func New(t TestingT) *Assertions

New makes a new Assertions object for the specified TestingT.

func (*Assertions) Condition 

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

Condition uses a Comparison to assert a complex condition.

func (*Assertions) Contains 

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

Contains asserts that the specified string contains the specified substring. 

assert.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")

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

func (*Assertions) Empty 

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

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

assert.Empty(obj)

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

func (*Assertions) Equal 

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

Equal asserts that two objects are equal. 

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

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

func (*Assertions) EqualError 

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()
  if assert.Error(err, "An error was expected") {
	   assert.Equal(err, expectedError)
  }

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

func (*Assertions) EqualValues 

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

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

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

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

func (*Assertions) Error 

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

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

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

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

func (*Assertions) Exactly 

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

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

assert.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 

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

Fail reports a failure through

func (*Assertions) False 

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

False asserts that the specified value is true. 

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

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

func (*Assertions) HTTPBodyContains 

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

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 (*Assertions) HTTPBodyNotContains 

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

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 (*Assertions) HTTPError 

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

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

assert.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 

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

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

assert.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 

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

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

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

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

func (*Assertions) Implements 

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

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

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

func (*Assertions) InDelta 

func (a *Assertions) InDelta(expected, 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 (*Assertions) InEpsilon 

func (a *Assertions) InEpsilon(expected, 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) IsType 

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

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

func (*Assertions) Len 

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. 

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

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

func (*Assertions) Nil 

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

Nil asserts that the specified object is nil. 

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

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

func (*Assertions) NoError 

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

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

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

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

func (*Assertions) NotContains 

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

NotContains asserts that the specified string does NOT contain the specified substring. 

assert.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")

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

func (*Assertions) NotEmpty 

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

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

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

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

func (*Assertions) NotEqual 

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

NotEqual asserts that the specified values are NOT equal. 

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

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

func (*Assertions) NotNil 

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

NotNil asserts that the specified object is not nil. 

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

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

func (*Assertions) NotPanics 

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

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

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

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

func (*Assertions) NotRegexp 

func (a *Assertions) NotRegexp(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 (*Assertions) NotZero 

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 

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

Panics asserts that the code inside the specified PanicTestFunc panics. 

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

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

func (*Assertions) Regexp 

func (a *Assertions) Regexp(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 (*Assertions) True 

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

True asserts that the specified value is true. 

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

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

func (*Assertions) WithinDuration 

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

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

assert.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 

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

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

type Comparison 

type Comparison func() (success bool)

Comparison a custom function that returns true on success and false on failure

type PanicTestFunc 

type PanicTestFunc func()

PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics methods, and represents a simple func that takes no arguments, and returns nothing.

type TestingT 

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

TestingT is an interface wrapper around *testing.T

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.