1a2f01efa6
Update the Go library to the 1.10beta1 release.
Requires a few changes to the compiler for modifications to the map
runtime code, and to handle some nowritebarrier cases in the runtime.
Reviewed-on: https://go-review.googlesource.com/86455
gotools/:
* Makefile.am (go_cmd_vet_files): New variable.
(go_cmd_buildid_files, go_cmd_test2json_files): New variables.
(s-zdefaultcc): Change from constants to functions.
(noinst_PROGRAMS): Add vet, buildid, and test2json.
(cgo$(EXEEXT)): Link against $(LIBGOTOOL).
(vet$(EXEEXT)): New target.
(buildid$(EXEEXT)): New target.
(test2json$(EXEEXT)): New target.
(install-exec-local): Install all $(noinst_PROGRAMS).
(uninstall-local): Uninstasll all $(noinst_PROGRAMS).
(check-go-tool): Depend on $(noinst_PROGRAMS). Copy down
objabi.go.
(check-runtime): Depend on $(noinst_PROGRAMS).
(check-cgo-test, check-carchive-test): Likewise.
(check-vet): New target.
(check): Depend on check-vet. Look at cmd_vet-testlog.
(.PHONY): Add check-vet.
* Makefile.in: Rebuild.
From-SVN: r256365
439 lines
11 KiB
Go
439 lines
11 KiB
Go
// Copyright 2011 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 bytes_test
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"sort"
|
|
"unicode"
|
|
)
|
|
|
|
func ExampleBuffer() {
|
|
var b bytes.Buffer // A Buffer needs no initialization.
|
|
b.Write([]byte("Hello "))
|
|
fmt.Fprintf(&b, "world!")
|
|
b.WriteTo(os.Stdout)
|
|
// Output: Hello world!
|
|
}
|
|
|
|
func ExampleBuffer_reader() {
|
|
// A Buffer can turn a string or a []byte into an io.Reader.
|
|
buf := bytes.NewBufferString("R29waGVycyBydWxlIQ==")
|
|
dec := base64.NewDecoder(base64.StdEncoding, buf)
|
|
io.Copy(os.Stdout, dec)
|
|
// Output: Gophers rule!
|
|
}
|
|
|
|
func ExampleBuffer_Grow() {
|
|
var b bytes.Buffer
|
|
b.Grow(64)
|
|
bb := b.Bytes()
|
|
b.Write([]byte("64 bytes or fewer"))
|
|
fmt.Printf("%q", bb[:b.Len()])
|
|
// Output: "64 bytes or fewer"
|
|
}
|
|
|
|
func ExampleCompare() {
|
|
// Interpret Compare's result by comparing it to zero.
|
|
var a, b []byte
|
|
if bytes.Compare(a, b) < 0 {
|
|
// a less b
|
|
}
|
|
if bytes.Compare(a, b) <= 0 {
|
|
// a less or equal b
|
|
}
|
|
if bytes.Compare(a, b) > 0 {
|
|
// a greater b
|
|
}
|
|
if bytes.Compare(a, b) >= 0 {
|
|
// a greater or equal b
|
|
}
|
|
|
|
// Prefer Equal to Compare for equality comparisons.
|
|
if bytes.Equal(a, b) {
|
|
// a equal b
|
|
}
|
|
if !bytes.Equal(a, b) {
|
|
// a not equal b
|
|
}
|
|
}
|
|
|
|
func ExampleCompare_search() {
|
|
// Binary search to find a matching byte slice.
|
|
var needle []byte
|
|
var haystack [][]byte // Assume sorted
|
|
i := sort.Search(len(haystack), func(i int) bool {
|
|
// Return haystack[i] >= needle.
|
|
return bytes.Compare(haystack[i], needle) >= 0
|
|
})
|
|
if i < len(haystack) && bytes.Equal(haystack[i], needle) {
|
|
// Found it!
|
|
}
|
|
}
|
|
|
|
func ExampleTrimSuffix() {
|
|
var b = []byte("Hello, goodbye, etc!")
|
|
b = bytes.TrimSuffix(b, []byte("goodbye, etc!"))
|
|
b = bytes.TrimSuffix(b, []byte("gopher"))
|
|
b = append(b, bytes.TrimSuffix([]byte("world!"), []byte("x!"))...)
|
|
os.Stdout.Write(b)
|
|
// Output: Hello, world!
|
|
}
|
|
|
|
func ExampleTrimPrefix() {
|
|
var b = []byte("Goodbye,, world!")
|
|
b = bytes.TrimPrefix(b, []byte("Goodbye,"))
|
|
b = bytes.TrimPrefix(b, []byte("See ya,"))
|
|
fmt.Printf("Hello%s", b)
|
|
// Output: Hello, world!
|
|
}
|
|
|
|
func ExampleFields() {
|
|
fmt.Printf("Fields are: %q", bytes.Fields([]byte(" foo bar baz ")))
|
|
// Output: Fields are: ["foo" "bar" "baz"]
|
|
}
|
|
|
|
func ExampleFieldsFunc() {
|
|
f := func(c rune) bool {
|
|
return !unicode.IsLetter(c) && !unicode.IsNumber(c)
|
|
}
|
|
fmt.Printf("Fields are: %q", bytes.FieldsFunc([]byte(" foo1;bar2,baz3..."), f))
|
|
// Output: Fields are: ["foo1" "bar2" "baz3"]
|
|
}
|
|
|
|
func ExampleContains() {
|
|
fmt.Println(bytes.Contains([]byte("seafood"), []byte("foo")))
|
|
fmt.Println(bytes.Contains([]byte("seafood"), []byte("bar")))
|
|
fmt.Println(bytes.Contains([]byte("seafood"), []byte("")))
|
|
fmt.Println(bytes.Contains([]byte(""), []byte("")))
|
|
// Output:
|
|
// true
|
|
// false
|
|
// true
|
|
// true
|
|
}
|
|
|
|
func ExampleContainsAny() {
|
|
fmt.Println(bytes.ContainsAny([]byte("I like seafood."), "fÄo!"))
|
|
fmt.Println(bytes.ContainsAny([]byte("I like seafood."), "去是伟大的."))
|
|
fmt.Println(bytes.ContainsAny([]byte("I like seafood."), ""))
|
|
fmt.Println(bytes.ContainsAny([]byte(""), ""))
|
|
// Output:
|
|
// true
|
|
// true
|
|
// false
|
|
// false
|
|
}
|
|
|
|
func ExampleContainsRune() {
|
|
fmt.Println(bytes.ContainsRune([]byte("I like seafood."), 'f'))
|
|
fmt.Println(bytes.ContainsRune([]byte("I like seafood."), 'ö'))
|
|
fmt.Println(bytes.ContainsRune([]byte("去是伟大的!"), '大'))
|
|
fmt.Println(bytes.ContainsRune([]byte("去是伟大的!"), '!'))
|
|
fmt.Println(bytes.ContainsRune([]byte(""), '@'))
|
|
// Output:
|
|
// true
|
|
// false
|
|
// true
|
|
// true
|
|
// false
|
|
}
|
|
|
|
func ExampleCount() {
|
|
fmt.Println(bytes.Count([]byte("cheese"), []byte("e")))
|
|
fmt.Println(bytes.Count([]byte("five"), []byte(""))) // before & after each rune
|
|
// Output:
|
|
// 3
|
|
// 5
|
|
}
|
|
|
|
func ExampleEqual() {
|
|
fmt.Println(bytes.Equal([]byte("Go"), []byte("Go")))
|
|
fmt.Println(bytes.Equal([]byte("Go"), []byte("C++")))
|
|
// Output:
|
|
// true
|
|
// false
|
|
}
|
|
|
|
func ExampleEqualFold() {
|
|
fmt.Println(bytes.EqualFold([]byte("Go"), []byte("go")))
|
|
// Output: true
|
|
}
|
|
|
|
func ExampleHasPrefix() {
|
|
fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("Go")))
|
|
fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("C")))
|
|
fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("")))
|
|
// Output:
|
|
// true
|
|
// false
|
|
// true
|
|
}
|
|
|
|
func ExampleHasSuffix() {
|
|
fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("go")))
|
|
fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("O")))
|
|
fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("Ami")))
|
|
fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("")))
|
|
// Output:
|
|
// true
|
|
// false
|
|
// false
|
|
// true
|
|
}
|
|
|
|
func ExampleIndex() {
|
|
fmt.Println(bytes.Index([]byte("chicken"), []byte("ken")))
|
|
fmt.Println(bytes.Index([]byte("chicken"), []byte("dmr")))
|
|
// Output:
|
|
// 4
|
|
// -1
|
|
}
|
|
|
|
func ExampleIndexByte() {
|
|
fmt.Println(bytes.IndexByte([]byte("chicken"), byte('k')))
|
|
fmt.Println(bytes.IndexByte([]byte("chicken"), byte('g')))
|
|
// Output:
|
|
// 4
|
|
// -1
|
|
}
|
|
|
|
func ExampleIndexFunc() {
|
|
f := func(c rune) bool {
|
|
return unicode.Is(unicode.Han, c)
|
|
}
|
|
fmt.Println(bytes.IndexFunc([]byte("Hello, 世界"), f))
|
|
fmt.Println(bytes.IndexFunc([]byte("Hello, world"), f))
|
|
// Output:
|
|
// 7
|
|
// -1
|
|
}
|
|
|
|
func ExampleIndexAny() {
|
|
fmt.Println(bytes.IndexAny([]byte("chicken"), "aeiouy"))
|
|
fmt.Println(bytes.IndexAny([]byte("crwth"), "aeiouy"))
|
|
// Output:
|
|
// 2
|
|
// -1
|
|
}
|
|
|
|
func ExampleIndexRune() {
|
|
fmt.Println(bytes.IndexRune([]byte("chicken"), 'k'))
|
|
fmt.Println(bytes.IndexRune([]byte("chicken"), 'd'))
|
|
// Output:
|
|
// 4
|
|
// -1
|
|
}
|
|
|
|
func ExampleLastIndex() {
|
|
fmt.Println(bytes.Index([]byte("go gopher"), []byte("go")))
|
|
fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("go")))
|
|
fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("rodent")))
|
|
// Output:
|
|
// 0
|
|
// 3
|
|
// -1
|
|
}
|
|
|
|
func ExampleLastIndexAny() {
|
|
fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "MüQp"))
|
|
fmt.Println(bytes.LastIndexAny([]byte("go 地鼠"), "地大"))
|
|
fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "z,!."))
|
|
// Output:
|
|
// 5
|
|
// 3
|
|
// -1
|
|
}
|
|
|
|
func ExampleLastIndexByte() {
|
|
fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('g')))
|
|
fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('r')))
|
|
fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('z')))
|
|
// Output:
|
|
// 3
|
|
// 8
|
|
// -1
|
|
}
|
|
|
|
func ExampleLastIndexFunc() {
|
|
fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsLetter))
|
|
fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsPunct))
|
|
fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsNumber))
|
|
// Output:
|
|
// 8
|
|
// 9
|
|
// -1
|
|
}
|
|
|
|
func ExampleJoin() {
|
|
s := [][]byte{[]byte("foo"), []byte("bar"), []byte("baz")}
|
|
fmt.Printf("%s", bytes.Join(s, []byte(", ")))
|
|
// Output: foo, bar, baz
|
|
}
|
|
|
|
func ExampleRepeat() {
|
|
fmt.Printf("ba%s", bytes.Repeat([]byte("na"), 2))
|
|
// Output: banana
|
|
}
|
|
|
|
func ExampleReplace() {
|
|
fmt.Printf("%s\n", bytes.Replace([]byte("oink oink oink"), []byte("k"), []byte("ky"), 2))
|
|
fmt.Printf("%s\n", bytes.Replace([]byte("oink oink oink"), []byte("oink"), []byte("moo"), -1))
|
|
// Output:
|
|
// oinky oinky oink
|
|
// moo moo moo
|
|
}
|
|
|
|
func ExampleRunes() {
|
|
rs := bytes.Runes([]byte("go gopher"))
|
|
for _, r := range rs {
|
|
fmt.Printf("%#U\n", r)
|
|
}
|
|
// Output:
|
|
// U+0067 'g'
|
|
// U+006F 'o'
|
|
// U+0020 ' '
|
|
// U+0067 'g'
|
|
// U+006F 'o'
|
|
// U+0070 'p'
|
|
// U+0068 'h'
|
|
// U+0065 'e'
|
|
// U+0072 'r'
|
|
}
|
|
|
|
func ExampleSplit() {
|
|
fmt.Printf("%q\n", bytes.Split([]byte("a,b,c"), []byte(",")))
|
|
fmt.Printf("%q\n", bytes.Split([]byte("a man a plan a canal panama"), []byte("a ")))
|
|
fmt.Printf("%q\n", bytes.Split([]byte(" xyz "), []byte("")))
|
|
fmt.Printf("%q\n", bytes.Split([]byte(""), []byte("Bernardo O'Higgins")))
|
|
// Output:
|
|
// ["a" "b" "c"]
|
|
// ["" "man " "plan " "canal panama"]
|
|
// [" " "x" "y" "z" " "]
|
|
// [""]
|
|
}
|
|
|
|
func ExampleSplitN() {
|
|
fmt.Printf("%q\n", bytes.SplitN([]byte("a,b,c"), []byte(","), 2))
|
|
z := bytes.SplitN([]byte("a,b,c"), []byte(","), 0)
|
|
fmt.Printf("%q (nil = %v)\n", z, z == nil)
|
|
// Output:
|
|
// ["a" "b,c"]
|
|
// [] (nil = true)
|
|
}
|
|
|
|
func ExampleSplitAfter() {
|
|
fmt.Printf("%q\n", bytes.SplitAfter([]byte("a,b,c"), []byte(",")))
|
|
// Output: ["a," "b," "c"]
|
|
}
|
|
|
|
func ExampleSplitAfterN() {
|
|
fmt.Printf("%q\n", bytes.SplitAfterN([]byte("a,b,c"), []byte(","), 2))
|
|
// Output: ["a," "b,c"]
|
|
}
|
|
|
|
func ExampleTitle() {
|
|
fmt.Printf("%s", bytes.Title([]byte("her royal highness")))
|
|
// Output: Her Royal Highness
|
|
}
|
|
|
|
func ExampleToTitle() {
|
|
fmt.Printf("%s\n", bytes.ToTitle([]byte("loud noises")))
|
|
fmt.Printf("%s\n", bytes.ToTitle([]byte("хлеб")))
|
|
// Output:
|
|
// LOUD NOISES
|
|
// ХЛЕБ
|
|
}
|
|
|
|
func ExampleTrim() {
|
|
fmt.Printf("[%q]", bytes.Trim([]byte(" !!! Achtung! Achtung! !!! "), "! "))
|
|
// Output: ["Achtung! Achtung"]
|
|
}
|
|
|
|
func ExampleTrimFunc() {
|
|
fmt.Println(string(bytes.TrimFunc([]byte("go-gopher!"), unicode.IsLetter)))
|
|
fmt.Println(string(bytes.TrimFunc([]byte("\"go-gopher!\""), unicode.IsLetter)))
|
|
fmt.Println(string(bytes.TrimFunc([]byte("go-gopher!"), unicode.IsPunct)))
|
|
fmt.Println(string(bytes.TrimFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
|
|
// Output:
|
|
// -gopher!
|
|
// "go-gopher!"
|
|
// go-gopher
|
|
// go-gopher!
|
|
}
|
|
|
|
func ExampleMap() {
|
|
rot13 := func(r rune) rune {
|
|
switch {
|
|
case r >= 'A' && r <= 'Z':
|
|
return 'A' + (r-'A'+13)%26
|
|
case r >= 'a' && r <= 'z':
|
|
return 'a' + (r-'a'+13)%26
|
|
}
|
|
return r
|
|
}
|
|
fmt.Printf("%s", bytes.Map(rot13, []byte("'Twas brillig and the slithy gopher...")))
|
|
// Output: 'Gjnf oevyyvt naq gur fyvgul tbcure...
|
|
}
|
|
|
|
func ExampleTrimLeft() {
|
|
fmt.Print(string(bytes.TrimLeft([]byte("453gopher8257"), "0123456789")))
|
|
// Output:
|
|
// gopher8257
|
|
}
|
|
|
|
func ExampleTrimLeftFunc() {
|
|
fmt.Println(string(bytes.TrimLeftFunc([]byte("go-gopher"), unicode.IsLetter)))
|
|
fmt.Println(string(bytes.TrimLeftFunc([]byte("go-gopher!"), unicode.IsPunct)))
|
|
fmt.Println(string(bytes.TrimLeftFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
|
|
// Output:
|
|
// -gopher
|
|
// go-gopher!
|
|
// go-gopher!567
|
|
}
|
|
|
|
func ExampleTrimSpace() {
|
|
fmt.Printf("%s", bytes.TrimSpace([]byte(" \t\n a lone gopher \n\t\r\n")))
|
|
// Output: a lone gopher
|
|
}
|
|
|
|
func ExampleTrimRight() {
|
|
fmt.Print(string(bytes.TrimRight([]byte("453gopher8257"), "0123456789")))
|
|
// Output:
|
|
// 453gopher
|
|
}
|
|
|
|
func ExampleTrimRightFunc() {
|
|
fmt.Println(string(bytes.TrimRightFunc([]byte("go-gopher"), unicode.IsLetter)))
|
|
fmt.Println(string(bytes.TrimRightFunc([]byte("go-gopher!"), unicode.IsPunct)))
|
|
fmt.Println(string(bytes.TrimRightFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
|
|
// Output:
|
|
// go-
|
|
// go-gopher
|
|
// 1234go-gopher!
|
|
}
|
|
|
|
func ExampleToUpper() {
|
|
fmt.Printf("%s", bytes.ToUpper([]byte("Gopher")))
|
|
// Output: GOPHER
|
|
}
|
|
|
|
func ExampleToLower() {
|
|
fmt.Printf("%s", bytes.ToLower([]byte("Gopher")))
|
|
// Output: gopher
|
|
}
|
|
|
|
func ExampleReader_Len() {
|
|
fmt.Println(bytes.NewReader([]byte("Hi!")).Len())
|
|
fmt.Println(bytes.NewReader([]byte("こんにちは!")).Len())
|
|
// Output:
|
|
// 3
|
|
// 16
|
|
}
|