src/io/example_test.go

   1 // Copyright 2015 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package io_test
   6
   7 import (
   8         "fmt"
   9         "io"
  10         "log"
  11         "os"
  12         "strings"
  13 )
  14
  15 func ExampleCopy() {
  16         r := strings.NewReader("some io.Reader stream to be read\n")
  17
  18         if _, err := io.Copy(os.Stdout, r); err != nil {
  19                 log.Fatal(err)
  20         }
  21
  22         // Output:
  23         // some io.Reader stream to be read
  24 }
  25
  26 func ExampleCopyBuffer() {
  27         r1 := strings.NewReader("first reader\n")
  28         r2 := strings.NewReader("second reader\n")
  29         buf := make([]byte, 8)
  30
  31         // buf is used here...
  32         if _, err := io.CopyBuffer(os.Stdout, r1, buf); err != nil {
  33                 log.Fatal(err)
  34         }
  35
  36         // ... reused here also. No need to allocate an extra buffer.
  37         if _, err := io.CopyBuffer(os.Stdout, r2, buf); err != nil {
  38                 log.Fatal(err)
  39         }
  40
  41         // Output:
  42         // first reader
  43         // second reader
  44 }
  45
  46 func ExampleCopyN() {
  47         r := strings.NewReader("some io.Reader stream to be read")
  48
  49         if _, err := io.CopyN(os.Stdout, r, 4); err != nil {
  50                 log.Fatal(err)
  51         }
  52
  53         // Output:
  54         // some
  55 }
  56
  57 func ExampleReadAtLeast() {
  58         r := strings.NewReader("some io.Reader stream to be read\n")
  59
  60         buf := make([]byte, 14)
  61         if _, err := io.ReadAtLeast(r, buf, 4); err != nil {
  62                 log.Fatal(err)
  63         }
  64         fmt.Printf("%s\n", buf)
  65
  66         // buffer smaller than minimal read size.
  67         shortBuf := make([]byte, 3)
  68         if _, err := io.ReadAtLeast(r, shortBuf, 4); err != nil {
  69                 fmt.Println("error:", err)
  70         }
  71
  72         // minimal read size bigger than io.Reader stream
  73         longBuf := make([]byte, 64)
  74         if _, err := io.ReadAtLeast(r, longBuf, 64); err != nil {
  75                 fmt.Println("error:", err)
  76         }
  77
  78         // Output:
  79         // some io.Reader
  80         // error: short buffer
  81         // error: unexpected EOF
  82 }
  83
  84 func ExampleReadFull() {
  85         r := strings.NewReader("some io.Reader stream to be read\n")
  86
  87         buf := make([]byte, 4)
  88         if _, err := io.ReadFull(r, buf); err != nil {
  89                 log.Fatal(err)
  90         }
  91         fmt.Printf("%s\n", buf)
  92
  93         // minimal read size bigger than io.Reader stream
  94         longBuf := make([]byte, 64)
  95         if _, err := io.ReadFull(r, longBuf); err != nil {
  96                 fmt.Println("error:", err)
  97         }
  98
  99         // Output:
 100         // some
 101         // error: unexpected EOF
 102 }
 103
 104 func ExampleWriteString() {
 105         if _, err := io.WriteString(os.Stdout, "Hello World"); err != nil {
 106                 log.Fatal(err)
 107         }
 108
 109         // Output: Hello World
 110 }
 111
 112 func ExampleLimitReader() {
 113         r := strings.NewReader("some io.Reader stream to be read\n")
 114         lr := io.LimitReader(r, 4)
 115
 116         if _, err := io.Copy(os.Stdout, lr); err != nil {
 117                 log.Fatal(err)
 118         }
 119
 120         // Output:
 121         // some
 122 }
 123
 124 func ExampleMultiReader() {
 125         r1 := strings.NewReader("first reader ")
 126         r2 := strings.NewReader("second reader ")
 127         r3 := strings.NewReader("third reader\n")
 128         r := io.MultiReader(r1, r2, r3)
 129
 130         if _, err := io.Copy(os.Stdout, r); err != nil {
 131                 log.Fatal(err)
 132         }
 133
 134         // Output:
 135         // first reader second reader third reader
 136 }
 137
 138 func ExampleTeeReader() {
 139         var r io.Reader = strings.NewReader("some io.Reader stream to be read\n")
 140
 141         r = io.TeeReader(r, os.Stdout)
 142
 143         // Everything read from r will be copied to stdout.
 144         if _, err := io.ReadAll(r); err != nil {
 145                 log.Fatal(err)
 146         }
 147
 148         // Output:
 149         // some io.Reader stream to be read
 150 }
 151
 152 func ExampleSectionReader() {
 153         r := strings.NewReader("some io.Reader stream to be read\n")
 154         s := io.NewSectionReader(r, 5, 17)
 155
 156         if _, err := io.Copy(os.Stdout, s); err != nil {
 157                 log.Fatal(err)
 158         }
 159
 160         // Output:
 161         // io.Reader stream
 162 }
 163
 164 func ExampleSectionReader_Read() {
 165         r := strings.NewReader("some io.Reader stream to be read\n")
 166         s := io.NewSectionReader(r, 5, 17)
 167
 168         buf := make([]byte, 9)
 169         if _, err := s.Read(buf); err != nil {
 170                 log.Fatal(err)
 171         }
 172
 173         fmt.Printf("%s\n", buf)
 174
 175         // Output:
 176         // io.Reader
 177 }
 178
 179 func ExampleSectionReader_ReadAt() {
 180         r := strings.NewReader("some io.Reader stream to be read\n")
 181         s := io.NewSectionReader(r, 5, 17)
 182
 183         buf := make([]byte, 6)
 184         if _, err := s.ReadAt(buf, 10); err != nil {
 185                 log.Fatal(err)
 186         }
 187
 188         fmt.Printf("%s\n", buf)
 189
 190         // Output:
 191         // stream
 192 }
 193
 194 func ExampleSectionReader_Seek() {
 195         r := strings.NewReader("some io.Reader stream to be read\n")
 196         s := io.NewSectionReader(r, 5, 17)
 197
 198         if _, err := s.Seek(10, io.SeekStart); err != nil {
 199                 log.Fatal(err)
 200         }
 201
 202         if _, err := io.Copy(os.Stdout, s); err != nil {
 203                 log.Fatal(err)
 204         }
 205
 206         // Output:
 207         // stream
 208 }
 209
 210 func ExampleSectionReader_Size() {
 211         r := strings.NewReader("some io.Reader stream to be read\n")
 212         s := io.NewSectionReader(r, 5, 17)
 213
 214         fmt.Println(s.Size())
 215
 216         // Output:
 217         // 17
 218 }
 219
 220 func ExampleSeeker_Seek() {
 221         r := strings.NewReader("some io.Reader stream to be read\n")
 222
 223         r.Seek(5, io.SeekStart) // move to the 5th char from the start
 224         if _, err := io.Copy(os.Stdout, r); err != nil {
 225                 log.Fatal(err)
 226         }
 227
 228         r.Seek(-5, io.SeekEnd)
 229         if _, err := io.Copy(os.Stdout, r); err != nil {
 230                 log.Fatal(err)
 231         }
 232
 233         // Output:
 234         // io.Reader stream to be read
 235         // read
 236 }
 237
 238 func ExampleMultiWriter() {
 239         r := strings.NewReader("some io.Reader stream to be read\n")
 240
 241         var buf1, buf2 strings.Builder
 242         w := io.MultiWriter(&buf1, &buf2)
 243
 244         if _, err := io.Copy(w, r); err != nil {
 245                 log.Fatal(err)
 246         }
 247
 248         fmt.Print(buf1.String())
 249         fmt.Print(buf2.String())
 250
 251         // Output:
 252         // some io.Reader stream to be read
 253         // some io.Reader stream to be read
 254 }
 255
 256 func ExamplePipe() {
 257         r, w := io.Pipe()
 258
 259         go func() {
 260                 fmt.Fprint(w, "some io.Reader stream to be read\n")
 261                 w.Close()
 262         }()
 263
 264         if _, err := io.Copy(os.Stdout, r); err != nil {
 265                 log.Fatal(err)
 266         }
 267
 268         // Output:
 269         // some io.Reader stream to be read
 270 }
 271
 272 func ExampleReadAll() {
 273         r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
 274
 275         b, err := io.ReadAll(r)
 276         if err != nil {
 277                 log.Fatal(err)
 278         }
 279
 280         fmt.Printf("%s", b)
 281
 282         // Output:
 283         // Go is a general-purpose language designed with systems programming in mind.
 284 }