mirror of
https://github.com/autc04/Retro68.git
synced 2024-11-28 05:51:04 +00:00
116 lines
2.8 KiB
Go
116 lines
2.8 KiB
Go
// Copyright 2010 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 io_test
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha1"
|
|
"fmt"
|
|
. "io"
|
|
"io/ioutil"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestMultiReader(t *testing.T) {
|
|
var mr Reader
|
|
var buf []byte
|
|
nread := 0
|
|
withFooBar := func(tests func()) {
|
|
r1 := strings.NewReader("foo ")
|
|
r2 := strings.NewReader("")
|
|
r3 := strings.NewReader("bar")
|
|
mr = MultiReader(r1, r2, r3)
|
|
buf = make([]byte, 20)
|
|
tests()
|
|
}
|
|
expectRead := func(size int, expected string, eerr error) {
|
|
nread++
|
|
n, gerr := mr.Read(buf[0:size])
|
|
if n != len(expected) {
|
|
t.Errorf("#%d, expected %d bytes; got %d",
|
|
nread, len(expected), n)
|
|
}
|
|
got := string(buf[0:n])
|
|
if got != expected {
|
|
t.Errorf("#%d, expected %q; got %q",
|
|
nread, expected, got)
|
|
}
|
|
if gerr != eerr {
|
|
t.Errorf("#%d, expected error %v; got %v",
|
|
nread, eerr, gerr)
|
|
}
|
|
buf = buf[n:]
|
|
}
|
|
withFooBar(func() {
|
|
expectRead(2, "fo", nil)
|
|
expectRead(5, "o ", nil)
|
|
expectRead(5, "bar", nil)
|
|
expectRead(5, "", EOF)
|
|
})
|
|
withFooBar(func() {
|
|
expectRead(4, "foo ", nil)
|
|
expectRead(1, "b", nil)
|
|
expectRead(3, "ar", nil)
|
|
expectRead(1, "", EOF)
|
|
})
|
|
withFooBar(func() {
|
|
expectRead(5, "foo ", nil)
|
|
})
|
|
}
|
|
|
|
func TestMultiWriter(t *testing.T) {
|
|
sha1 := sha1.New()
|
|
sink := new(bytes.Buffer)
|
|
mw := MultiWriter(sha1, sink)
|
|
|
|
sourceString := "My input text."
|
|
source := strings.NewReader(sourceString)
|
|
written, err := Copy(mw, source)
|
|
|
|
if written != int64(len(sourceString)) {
|
|
t.Errorf("short write of %d, not %d", written, len(sourceString))
|
|
}
|
|
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
|
|
sha1hex := fmt.Sprintf("%x", sha1.Sum(nil))
|
|
if sha1hex != "01cb303fa8c30a64123067c5aa6284ba7ec2d31b" {
|
|
t.Error("incorrect sha1 value")
|
|
}
|
|
|
|
if sink.String() != sourceString {
|
|
t.Errorf("expected %q; got %q", sourceString, sink.String())
|
|
}
|
|
}
|
|
|
|
// Test that MultiReader copies the input slice and is insulated from future modification.
|
|
func TestMultiReaderCopy(t *testing.T) {
|
|
slice := []Reader{strings.NewReader("hello world")}
|
|
r := MultiReader(slice...)
|
|
slice[0] = nil
|
|
data, err := ioutil.ReadAll(r)
|
|
if err != nil || string(data) != "hello world" {
|
|
t.Errorf("ReadAll() = %q, %v, want %q, nil", data, err, "hello world")
|
|
}
|
|
}
|
|
|
|
// Test that MultiWriter copies the input slice and is insulated from future modification.
|
|
func TestMultiWriterCopy(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
slice := []Writer{&buf}
|
|
w := MultiWriter(slice...)
|
|
slice[0] = nil
|
|
n, err := w.Write([]byte("hello world"))
|
|
if err != nil || n != 11 {
|
|
t.Errorf("Write(`hello world`) = %d, %v, want 11, nil", n, err)
|
|
}
|
|
if buf.String() != "hello world" {
|
|
t.Errorf("buf.String() = %q, want %q", buf.String(), "hello world")
|
|
}
|
|
}
|