github.com/x04/go/src@v0.0.0-20200202162449-3d481ceb3525/testing/iotest/logger_test.go (about)

     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  	"github.com/x04/go/src/bytes"
     9  	"github.com/x04/go/src/errors"
    10  	"github.com/x04/go/src/fmt"
    11  	"github.com/x04/go/src/log"
    12  	"github.com/x04/go/src/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  type errReader struct {
    85  	err error
    86  }
    87  
    88  func (r errReader) Read([]byte) (int, error) {
    89  	return 0, r.err
    90  }
    91  
    92  func TestReadLogger(t *testing.T) {
    93  	olw := log.Writer()
    94  	olf := log.Flags()
    95  	olp := log.Prefix()
    96  
    97  	// Revert the original log settings before we exit.
    98  	defer func() {
    99  		log.SetFlags(olf)
   100  		log.SetPrefix(olp)
   101  		log.SetOutput(olw)
   102  	}()
   103  
   104  	lOut := new(bytes.Buffer)
   105  	log.SetPrefix("lr: ")
   106  	log.SetOutput(lOut)
   107  	log.SetFlags(0)
   108  
   109  	data := []byte("Hello, World!")
   110  	p := make([]byte, len(data))
   111  	lr := bytes.NewReader(data)
   112  	rl := NewReadLogger("read:", lr)
   113  
   114  	n, err := rl.Read(p)
   115  	if err != nil {
   116  		t.Fatalf("Unexpectedly failed to read: %v", err)
   117  	}
   118  
   119  	if g, w := p[:n], data; !bytes.Equal(g, w) {
   120  		t.Errorf("ReadLogger mismatch\n\tgot:  %q\n\twant: %q", g, w)
   121  	}
   122  
   123  	wantLogWithHex := fmt.Sprintf("lr: read: %x\n", "Hello, World!")
   124  	if g, w := lOut.String(), wantLogWithHex; g != w {
   125  		t.Errorf("ReadLogger mismatch\n\tgot:  %q\n\twant: %q", g, w)
   126  	}
   127  }
   128  
   129  func TestReadLogger_errorOnRead(t *testing.T) {
   130  	olw := log.Writer()
   131  	olf := log.Flags()
   132  	olp := log.Prefix()
   133  
   134  	// Revert the original log settings before we exit.
   135  	defer func() {
   136  		log.SetFlags(olf)
   137  		log.SetPrefix(olp)
   138  		log.SetOutput(olw)
   139  	}()
   140  
   141  	lOut := new(bytes.Buffer)
   142  	log.SetPrefix("lr: ")
   143  	log.SetOutput(lOut)
   144  	log.SetFlags(0)
   145  
   146  	data := []byte("Hello, World!")
   147  	p := make([]byte, len(data))
   148  
   149  	lr := errReader{err: errors.New("Read Error!")}
   150  	rl := NewReadLogger("read", lr)
   151  	n, err := rl.Read(p)
   152  	if err == nil {
   153  		t.Fatalf("Unexpectedly succeeded to read: %v", err)
   154  	}
   155  
   156  	wantLogWithHex := fmt.Sprintf("lr: read %x: %v\n", p[:n], "Read Error!")
   157  	if g, w := lOut.String(), wantLogWithHex; g != w {
   158  		t.Errorf("ReadLogger mismatch\n\tgot:  %q\n\twant: %q", g, w)
   159  	}
   160  }