logger_test.go

Documentation: testing/iotest

		 1  // Copyright 2019 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 iotest
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"errors"
		10  	"fmt"
		11  	"log"
		12  	"testing"
		13  )
		14  
		15  type errWriter struct {
		16  	err error
		17  }
		18  
		19  func (w errWriter) Write([]byte) (int, error) {
		20  	return 0, w.err
		21  }
		22  
		23  func TestWriteLogger(t *testing.T) {
		24  	olw := log.Writer()
		25  	olf := log.Flags()
		26  	olp := log.Prefix()
		27  
		28  	// Revert the original log settings before we exit.
		29  	defer func() {
		30  		log.SetFlags(olf)
		31  		log.SetPrefix(olp)
		32  		log.SetOutput(olw)
		33  	}()
		34  
		35  	lOut := new(bytes.Buffer)
		36  	log.SetPrefix("lw: ")
		37  	log.SetOutput(lOut)
		38  	log.SetFlags(0)
		39  
		40  	lw := new(bytes.Buffer)
		41  	wl := NewWriteLogger("write:", lw)
		42  	if _, err := wl.Write([]byte("Hello, World!")); err != nil {
		43  		t.Fatalf("Unexpectedly failed to write: %v", err)
		44  	}
		45  
		46  	if g, w := lw.String(), "Hello, World!"; g != w {
		47  		t.Errorf("WriteLogger mismatch\n\tgot:	%q\n\twant: %q", g, w)
		48  	}
		49  	wantLogWithHex := fmt.Sprintf("lw: write: %x\n", "Hello, World!")
		50  	if g, w := lOut.String(), wantLogWithHex; g != w {
		51  		t.Errorf("WriteLogger mismatch\n\tgot:	%q\n\twant: %q", g, w)
		52  	}
		53  }
		54  
		55  func TestWriteLogger_errorOnWrite(t *testing.T) {
		56  	olw := log.Writer()
		57  	olf := log.Flags()
		58  	olp := log.Prefix()
		59  
		60  	// Revert the original log settings before we exit.
		61  	defer func() {
		62  		log.SetFlags(olf)
		63  		log.SetPrefix(olp)
		64  		log.SetOutput(olw)
		65  	}()
		66  
		67  	lOut := new(bytes.Buffer)
		68  	log.SetPrefix("lw: ")
		69  	log.SetOutput(lOut)
		70  	log.SetFlags(0)
		71  
		72  	lw := errWriter{err: errors.New("Write Error!")}
		73  	wl := NewWriteLogger("write:", lw)
		74  	if _, err := wl.Write([]byte("Hello, World!")); err == nil {
		75  		t.Fatalf("Unexpectedly succeeded to write: %v", err)
		76  	}
		77  
		78  	wantLogWithHex := fmt.Sprintf("lw: write: %x: %v\n", "", "Write Error!")
		79  	if g, w := lOut.String(), wantLogWithHex; g != w {
		80  		t.Errorf("WriteLogger mismatch\n\tgot:	%q\n\twant: %q", g, w)
		81  	}
		82  }
		83  
		84  func TestReadLogger(t *testing.T) {
		85  	olw := log.Writer()
		86  	olf := log.Flags()
		87  	olp := log.Prefix()
		88  
		89  	// Revert the original log settings before we exit.
		90  	defer func() {
		91  		log.SetFlags(olf)
		92  		log.SetPrefix(olp)
		93  		log.SetOutput(olw)
		94  	}()
		95  
		96  	lOut := new(bytes.Buffer)
		97  	log.SetPrefix("lr: ")
		98  	log.SetOutput(lOut)
		99  	log.SetFlags(0)
	 100  
	 101  	data := []byte("Hello, World!")
	 102  	p := make([]byte, len(data))
	 103  	lr := bytes.NewReader(data)
	 104  	rl := NewReadLogger("read:", lr)
	 105  
	 106  	n, err := rl.Read(p)
	 107  	if err != nil {
	 108  		t.Fatalf("Unexpectedly failed to read: %v", err)
	 109  	}
	 110  
	 111  	if g, w := p[:n], data; !bytes.Equal(g, w) {
	 112  		t.Errorf("ReadLogger mismatch\n\tgot:	%q\n\twant: %q", g, w)
	 113  	}
	 114  
	 115  	wantLogWithHex := fmt.Sprintf("lr: read: %x\n", "Hello, World!")
	 116  	if g, w := lOut.String(), wantLogWithHex; g != w {
	 117  		t.Errorf("ReadLogger mismatch\n\tgot:	%q\n\twant: %q", g, w)
	 118  	}
	 119  }
	 120  
	 121  func TestReadLogger_errorOnRead(t *testing.T) {
	 122  	olw := log.Writer()
	 123  	olf := log.Flags()
	 124  	olp := log.Prefix()
	 125  
	 126  	// Revert the original log settings before we exit.
	 127  	defer func() {
	 128  		log.SetFlags(olf)
	 129  		log.SetPrefix(olp)
	 130  		log.SetOutput(olw)
	 131  	}()
	 132  
	 133  	lOut := new(bytes.Buffer)
	 134  	log.SetPrefix("lr: ")
	 135  	log.SetOutput(lOut)
	 136  	log.SetFlags(0)
	 137  
	 138  	data := []byte("Hello, World!")
	 139  	p := make([]byte, len(data))
	 140  
	 141  	lr := ErrReader(errors.New("io failure"))
	 142  	rl := NewReadLogger("read", lr)
	 143  	n, err := rl.Read(p)
	 144  	if err == nil {
	 145  		t.Fatalf("Unexpectedly succeeded to read: %v", err)
	 146  	}
	 147  
	 148  	wantLogWithHex := fmt.Sprintf("lr: read %x: io failure\n", p[:n])
	 149  	if g, w := lOut.String(), wantLogWithHex; g != w {
	 150  		t.Errorf("ReadLogger mismatch\n\tgot:	%q\n\twant: %q", g, w)
	 151  	}
	 152  }
	 153
View as plain text