fcee603081
Previously if the only names defined by _test packages were examples,
the gotest script would emit an incorrect _testmain.go file.
I worked around that by marking the example_test.go files +build ignored.
This CL changes the gotest script to handle this case correctly,
and removes the now-unnecessary build tags.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/214039
From-SVN: r280085
366 lines
12 KiB
Go
366 lines
12 KiB
Go
// Copyright 2017 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package fmt_test
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"math"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// The Errorf function lets us use formatting features
|
|
// to create descriptive error messages.
|
|
func ExampleErrorf() {
|
|
const name, id = "bueller", 17
|
|
err := fmt.Errorf("user %q (id %d) not found", name, id)
|
|
fmt.Println(err.Error())
|
|
|
|
// Output: user "bueller" (id 17) not found
|
|
}
|
|
|
|
func ExampleFscanf() {
|
|
var (
|
|
i int
|
|
b bool
|
|
s string
|
|
)
|
|
r := strings.NewReader("5 true gophers")
|
|
n, err := fmt.Fscanf(r, "%d %t %s", &i, &b, &s)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Fscanf: %v\n", err)
|
|
}
|
|
fmt.Println(i, b, s)
|
|
fmt.Println(n)
|
|
// Output:
|
|
// 5 true gophers
|
|
// 3
|
|
}
|
|
|
|
func ExampleFscanln() {
|
|
s := `dmr 1771 1.61803398875
|
|
ken 271828 3.14159`
|
|
r := strings.NewReader(s)
|
|
var a string
|
|
var b int
|
|
var c float64
|
|
for {
|
|
n, err := fmt.Fscanln(r, &a, &b, &c)
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
fmt.Printf("%d: %s, %d, %f\n", n, a, b, c)
|
|
}
|
|
// Output:
|
|
// 3: dmr, 1771, 1.618034
|
|
// 3: ken, 271828, 3.141590
|
|
}
|
|
|
|
func ExampleSscanf() {
|
|
var name string
|
|
var age int
|
|
n, err := fmt.Sscanf("Kim is 22 years old", "%s is %d years old", &name, &age)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
fmt.Printf("%d: %s, %d\n", n, name, age)
|
|
|
|
// Output:
|
|
// 2: Kim, 22
|
|
}
|
|
|
|
func ExamplePrint() {
|
|
const name, age = "Kim", 22
|
|
fmt.Print(name, " is ", age, " years old.\n")
|
|
|
|
// It is conventional not to worry about any
|
|
// error returned by Print.
|
|
|
|
// Output:
|
|
// Kim is 22 years old.
|
|
}
|
|
|
|
func ExamplePrintln() {
|
|
const name, age = "Kim", 22
|
|
fmt.Println(name, "is", age, "years old.")
|
|
|
|
// It is conventional not to worry about any
|
|
// error returned by Println.
|
|
|
|
// Output:
|
|
// Kim is 22 years old.
|
|
}
|
|
|
|
func ExamplePrintf() {
|
|
const name, age = "Kim", 22
|
|
fmt.Printf("%s is %d years old.\n", name, age)
|
|
|
|
// It is conventional not to worry about any
|
|
// error returned by Printf.
|
|
|
|
// Output:
|
|
// Kim is 22 years old.
|
|
}
|
|
|
|
func ExampleSprint() {
|
|
const name, age = "Kim", 22
|
|
s := fmt.Sprint(name, " is ", age, " years old.\n")
|
|
|
|
io.WriteString(os.Stdout, s) // Ignoring error for simplicity.
|
|
|
|
// Output:
|
|
// Kim is 22 years old.
|
|
}
|
|
|
|
func ExampleSprintln() {
|
|
const name, age = "Kim", 22
|
|
s := fmt.Sprintln(name, "is", age, "years old.")
|
|
|
|
io.WriteString(os.Stdout, s) // Ignoring error for simplicity.
|
|
|
|
// Output:
|
|
// Kim is 22 years old.
|
|
}
|
|
|
|
func ExampleSprintf() {
|
|
const name, age = "Kim", 22
|
|
s := fmt.Sprintf("%s is %d years old.\n", name, age)
|
|
|
|
io.WriteString(os.Stdout, s) // Ignoring error for simplicity.
|
|
|
|
// Output:
|
|
// Kim is 22 years old.
|
|
}
|
|
|
|
func ExampleFprint() {
|
|
const name, age = "Kim", 22
|
|
n, err := fmt.Fprint(os.Stdout, name, " is ", age, " years old.\n")
|
|
|
|
// The n and err return values from Fprint are
|
|
// those returned by the underlying io.Writer.
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Fprint: %v\n", err)
|
|
}
|
|
fmt.Print(n, " bytes written.\n")
|
|
|
|
// Output:
|
|
// Kim is 22 years old.
|
|
// 21 bytes written.
|
|
}
|
|
|
|
func ExampleFprintln() {
|
|
const name, age = "Kim", 22
|
|
n, err := fmt.Fprintln(os.Stdout, name, "is", age, "years old.")
|
|
|
|
// The n and err return values from Fprintln are
|
|
// those returned by the underlying io.Writer.
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Fprintln: %v\n", err)
|
|
}
|
|
fmt.Println(n, "bytes written.")
|
|
|
|
// Output:
|
|
// Kim is 22 years old.
|
|
// 21 bytes written.
|
|
}
|
|
|
|
func ExampleFprintf() {
|
|
const name, age = "Kim", 22
|
|
n, err := fmt.Fprintf(os.Stdout, "%s is %d years old.\n", name, age)
|
|
|
|
// The n and err return values from Fprintf are
|
|
// those returned by the underlying io.Writer.
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Fprintf: %v\n", err)
|
|
}
|
|
fmt.Printf("%d bytes written.\n", n)
|
|
|
|
// Output:
|
|
// Kim is 22 years old.
|
|
// 21 bytes written.
|
|
}
|
|
|
|
// Print, Println, and Printf lay out their arguments differently. In this example
|
|
// we can compare their behaviors. Println always adds blanks between the items it
|
|
// prints, while Print adds blanks only between non-string arguments and Printf
|
|
// does exactly what it is told.
|
|
// Sprint, Sprintln, Sprintf, Fprint, Fprintln, and Fprintf behave the same as
|
|
// their corresponding Print, Println, and Printf functions shown here.
|
|
func Example_printers() {
|
|
a, b := 3.0, 4.0
|
|
h := math.Hypot(a, b)
|
|
|
|
// Print inserts blanks between arguments when neither is a string.
|
|
// It does not add a newline to the output, so we add one explicitly.
|
|
fmt.Print("The vector (", a, b, ") has length ", h, ".\n")
|
|
|
|
// Println always inserts spaces between its arguments,
|
|
// so it cannot be used to produce the same output as Print in this case;
|
|
// its output has extra spaces.
|
|
// Also, Println always adds a newline to the output.
|
|
fmt.Println("The vector (", a, b, ") has length", h, ".")
|
|
|
|
// Printf provides complete control but is more complex to use.
|
|
// It does not add a newline to the output, so we add one explicitly
|
|
// at the end of the format specifier string.
|
|
fmt.Printf("The vector (%g %g) has length %g.\n", a, b, h)
|
|
|
|
// Output:
|
|
// The vector (3 4) has length 5.
|
|
// The vector ( 3 4 ) has length 5 .
|
|
// The vector (3 4) has length 5.
|
|
}
|
|
|
|
// These examples demonstrate the basics of printing using a format string. Printf,
|
|
// Sprintf, and Fprintf all take a format string that specifies how to format the
|
|
// subsequent arguments. For example, %d (we call that a 'verb') says to print the
|
|
// corresponding argument, which must be an integer (or something containing an
|
|
// integer, such as a slice of ints) in decimal. The verb %v ('v' for 'value')
|
|
// always formats the argument in its default form, just how Print or Println would
|
|
// show it. The special verb %T ('T' for 'Type') prints the type of the argument
|
|
// rather than its value. The examples are not exhaustive; see the package comment
|
|
// for all the details.
|
|
func Example_formats() {
|
|
// A basic set of examples showing that %v is the default format, in this
|
|
// case decimal for integers, which can be explicitly requested with %d;
|
|
// the output is just what Println generates.
|
|
integer := 23
|
|
// Each of these prints "23" (without the quotes).
|
|
fmt.Println(integer)
|
|
fmt.Printf("%v\n", integer)
|
|
fmt.Printf("%d\n", integer)
|
|
|
|
// The special verb %T shows the type of an item rather than its value.
|
|
fmt.Printf("%T %T\n", integer, &integer)
|
|
// Result: int *int
|
|
|
|
// Println(x) is the same as Printf("%v\n", x) so we will use only Printf
|
|
// in the following examples. Each one demonstrates how to format values of
|
|
// a particular type, such as integers or strings. We start each format
|
|
// string with %v to show the default output and follow that with one or
|
|
// more custom formats.
|
|
|
|
// Booleans print as "true" or "false" with %v or %t.
|
|
truth := true
|
|
fmt.Printf("%v %t\n", truth, truth)
|
|
// Result: true true
|
|
|
|
// Integers print as decimals with %v and %d,
|
|
// or in hex with %x, octal with %o, or binary with %b.
|
|
answer := 42
|
|
fmt.Printf("%v %d %x %o %b\n", answer, answer, answer, answer, answer)
|
|
// Result: 42 42 2a 52 101010
|
|
|
|
// Floats have multiple formats: %v and %g print a compact representation,
|
|
// while %f prints a decimal point and %e uses exponential notation. The
|
|
// format %6.2f used here shows how to set the width and precision to
|
|
// control the appearance of a floating-point value. In this instance, 6 is
|
|
// the total width of the printed text for the value (note the extra spaces
|
|
// in the output) and 2 is the number of decimal places to show.
|
|
pi := math.Pi
|
|
fmt.Printf("%v %g %.2f (%6.2f) %e\n", pi, pi, pi, pi, pi)
|
|
// Result: 3.141592653589793 3.141592653589793 3.14 ( 3.14) 3.141593e+00
|
|
|
|
// Complex numbers format as parenthesized pairs of floats, with an 'i'
|
|
// after the imaginary part.
|
|
point := 110.7 + 22.5i
|
|
fmt.Printf("%v %g %.2f %.2e\n", point, point, point, point)
|
|
// Result: (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)
|
|
|
|
// Runes are integers but when printed with %c show the character with that
|
|
// Unicode value. The %q verb shows them as quoted characters, %U as a
|
|
// hex Unicode code point, and %#U as both a code point and a quoted
|
|
// printable form if the rune is printable.
|
|
smile := '😀'
|
|
fmt.Printf("%v %d %c %q %U %#U\n", smile, smile, smile, smile, smile, smile)
|
|
// Result: 128512 128512 😀 '😀' U+1F600 U+1F600 '😀'
|
|
|
|
// Strings are formatted with %v and %s as-is, with %q as quoted strings,
|
|
// and %#q as backquoted strings.
|
|
placeholders := `foo "bar"`
|
|
fmt.Printf("%v %s %q %#q\n", placeholders, placeholders, placeholders, placeholders)
|
|
// Result: foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`
|
|
|
|
// Maps formatted with %v show keys and values in their default formats.
|
|
// The %#v form (the # is called a "flag" in this context) shows the map in
|
|
// the Go source format. Maps are printed in a consistent order, sorted
|
|
// by the values of the keys.
|
|
isLegume := map[string]bool{
|
|
"peanut": true,
|
|
"dachshund": false,
|
|
}
|
|
fmt.Printf("%v %#v\n", isLegume, isLegume)
|
|
// Result: map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}
|
|
|
|
// Structs formatted with %v show field values in their default formats.
|
|
// The %+v form shows the fields by name, while %#v formats the struct in
|
|
// Go source format.
|
|
person := struct {
|
|
Name string
|
|
Age int
|
|
}{"Kim", 22}
|
|
fmt.Printf("%v %+v %#v\n", person, person, person)
|
|
// Result: {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}
|
|
|
|
// The default format for a pointer shows the underlying value preceded by
|
|
// an ampersand. The %p verb prints the pointer value in hex. We use a
|
|
// typed nil for the argument to %p here because the value of any non-nil
|
|
// pointer would change from run to run; run the commented-out Printf
|
|
// call yourself to see.
|
|
pointer := &person
|
|
fmt.Printf("%v %p\n", pointer, (*int)(nil))
|
|
// Result: &{Kim 22} 0x0
|
|
// fmt.Printf("%v %p\n", pointer, pointer)
|
|
// Result: &{Kim 22} 0x010203 // See comment above.
|
|
|
|
// Arrays and slices are formatted by applying the format to each element.
|
|
greats := [5]string{"Kitano", "Kobayashi", "Kurosawa", "Miyazaki", "Ozu"}
|
|
fmt.Printf("%v %q\n", greats, greats)
|
|
// Result: [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]
|
|
|
|
kGreats := greats[:3]
|
|
fmt.Printf("%v %q %#v\n", kGreats, kGreats, kGreats)
|
|
// Result: [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}
|
|
|
|
// Byte slices are special. Integer verbs like %d print the elements in
|
|
// that format. The %s and %q forms treat the slice like a string. The %x
|
|
// verb has a special form with the space flag that puts a space between
|
|
// the bytes.
|
|
cmd := []byte("a⌘")
|
|
fmt.Printf("%v %d %s %q %x % x\n", cmd, cmd, cmd, cmd, cmd, cmd)
|
|
// Result: [97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98
|
|
|
|
// Types that implement Stringer are printed the same as strings. Because
|
|
// Stringers return a string, we can print them using a string-specific
|
|
// verb such as %q.
|
|
now := time.Unix(123456789, 0).UTC() // time.Time implements fmt.Stringer.
|
|
fmt.Printf("%v %q\n", now, now)
|
|
// Result: 1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"
|
|
|
|
// Output:
|
|
// 23
|
|
// 23
|
|
// 23
|
|
// int *int
|
|
// true true
|
|
// 42 42 2a 52 101010
|
|
// 3.141592653589793 3.141592653589793 3.14 ( 3.14) 3.141593e+00
|
|
// (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)
|
|
// 128512 128512 😀 '😀' U+1F600 U+1F600 '😀'
|
|
// foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`
|
|
// map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}
|
|
// {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}
|
|
// &{Kim 22} 0x0
|
|
// [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]
|
|
// [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}
|
|
// [97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98
|
|
// 1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"
|
|
}
|