func ExampleBufferedVectorio() {
// Create a temp file to use
f, err := ioutil.TempFile("", "vectorio")
if err != nil {
panic(err)
}
defer f.Close()
data1 := []byte("foobarbaz")
data2 := []byte("foobazbar")
w, err := vectorio.NewBufferedWritev(f)
nw, err := w.Write(data2)
nw, err = w.WriteIovec(syscall.Iovec{&data1[0], 9})
nw, err = w.Flush()
if err != nil {
fmt.Printf("Flush threw error: %s", err)
}
if nw == 9*2 {
fmt.Println("Wrote", nw, "bytes to file!")
} else {
fmt.Println("did not write 9 * 2 bytes, wrote ", nw)
}
// Output:
// Wrote 18 bytes to file!
}
func ExampleVectorioCombined() {
// Create a temp file for demo purposes
f, err := ioutil.TempFile("", "vectorio")
if err != nil {
panic(err)
}
defer f.Close()
data1 := []byte("foobarbaz_buf\n")
data2 := []byte("barbazfoo_buf\n")
// This demonstrates the "buffered" form of the library, similar to bufio.
// w implements io.Writer.
w, err := vectorio.NewBufferedWritev(f)
if err != nil {
panic(err)
}
// The simple method is to just write a byte slice;
// this is converted to a syscall.Iovec and queued
// for writing
w.Write(data2)
// The user can also gain more control with WriteIovec,
// although this does not have a significant advantage over Write.
// This is what Write does on your behalf.
w.WriteIovec(syscall.Iovec{&data1[0], uint64(len(data1))})
// Flush must be called after writes are complete, to empty out
// the buffer of pending Iovec.
// Returns the total number of bytes written, as reported by the underlying syscall.
nw1, err := w.Flush()
if err != nil {
panic(err)
}
// One can also write a slice of byte slices ([][]byte) all at once.
// Note, this usage does *not* implement io.Writer, but if you have a slice
// of byte slices to write, this is a way to do that without looping.
multiple := [][]byte{
[]byte("foobarbaz_slice\n"),
[]byte("foobazbar_slice\n"),
}
// we return the number of bytes written, as reported by the underlying syscall.
nw2, err := vectorio.Writev(f, multiple)
if err != nil {
panic(err)
}
fmt.Println("Wrote", nw1+nw2, "bytes to file")
// Output:
// Wrote 60 bytes to file
}
func ExampleBufferedVectorioUnsafe() {
// Create a temp file to use
f, _ := ioutil.TempFile("", "vectorio")
defer f.Close()
data1 := []byte("foobarbaz")
data2 := []byte("foobazbar")
w, _ := vectorio.NewBufferedWritev(f)
w.Write(data2)
w.WriteIovec(syscall.Iovec{&data1[0], 9})
nw, _ := w.Flush()
fmt.Println("Wrote", nw, "bytes to file!")
// Output:
// Wrote 18 bytes to file!
}
func TestBufferedWritevHuge(t *testing.T) {
f, err := os.Create("testbufferedwritevhuge")
if err != nil {
panic(err)
}
defer f.Close()
data := []byte("foobarba")
final := []byte("attheend")
bw, _ := vectorio.NewBufferedWritev(f)
// write a little more than our buffer size
for i := 0; i < 1024; i++ {
bw.Write(data)
}
bw.Write(final)
_, err = bw.Flush()
if err != nil {
t.Errorf("Flush threw error: %s", err)
}
stats, err := f.Stat()
if err != nil {
t.Errorf("Stat threw error: %s", err)
}
filesize := stats.Size()
if filesize != int64(1024*len(data)+len(final)) {
t.Errorf("Length %d of input does not match %d written bytes", len(data), filesize)
}
// Maybe make this validate file contents later??
f.Seek(0, 0)
fromdisk, err := ioutil.ReadAll(f)
if err != nil {
t.Errorf("can't read file back, %s", err)
}
compared := fromdisk[1024*8:]
if bytes.Compare(compared, final) != 0 {
t.Errorf("contents of file don't match input, %s != %s or %d != %d", compared, final, len(compared), len(final))
}
os.Remove("testbufferedwritevhuge")
}
func TestBufferedWritev(t *testing.T) {
f, err := os.Create("testbufferedwritev")
if err != nil {
panic(err)
}
defer f.Close()
data := []byte("foobarbaz")
data_desired := []byte("foobazbar")
bw, _ := vectorio.NewBufferedWritev(f)
bw.WriteIovec(syscall.Iovec{&data[0], 3})
bw.WriteIovec(syscall.Iovec{&data[6], 3})
bw.Write(data[3:6])
nw, err := bw.Flush()
if err != nil {
t.Errorf("Flush threw error: %s", err)
}
if nw != 3*3 {
t.Errorf("Flush wrote wrong number of bytes, expected 3 * 3 but got %d", nw)
}
stats, err := f.Stat()
if err != nil {
t.Errorf("Stat threw error: %s", err)
}
filesize := stats.Size()
if filesize != int64(len(data)) {
t.Errorf("Length %d of input does not match %d written bytes", len(data), filesize)
}
f.Seek(0, 0)
fromdisk, err := ioutil.ReadAll(f)
if err != nil {
t.Errorf("can't read file back, %s", err)
}
if bytes.Compare(fromdisk, data_desired) != 0 {
t.Errorf("contents of file don't match input, %s != %s or %d != %d", fromdisk, data_desired, len(fromdisk), len(data_desired))
}
os.Remove("testbufferedwritev")
}
