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
5package io_test
6
7import (
8	"fmt"
9	"io"
10	"log"
11	"os"
12	"strings"
13)
14
15func 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
26func 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
46func 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
57func 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
84func 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
104func ExampleWriteString() {
105	if _, err := io.WriteString(os.Stdout, "Hello World"); err != nil {
106		log.Fatal(err)
107	}
108
109	// Output: Hello World
110}
111
112func 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
124func 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
138func 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
152func 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
164func 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
179func 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
194func 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
210func 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
220func 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
238func 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
256func 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
272func 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}
285