github.com/woremacx/kocha@v0.7.1-0.20150731103243-a5889322afc9/log/logger_test.go (about)

     1  package log_test
     2  
     3  import (
     4  	"bytes"
     5  	"io/ioutil"
     6  	"reflect"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/woremacx/kocha/log"
    11  	"github.com/woremacx/kocha/util"
    12  )
    13  
    14  func TestLogger_Debug(t *testing.T) {
    15  	now := time.Now()
    16  	util.Now = func() time.Time { return now }
    17  	defer func() { util.Now = time.Now }()
    18  	var buf bytes.Buffer
    19  	msg := "test log"
    20  	expected := "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
    21  	for _, v := range []struct {
    22  		level    log.Level
    23  		expected string
    24  	}{
    25  		{log.NONE, expected},
    26  		{log.DEBUG, expected},
    27  		{log.INFO, ""},
    28  		{log.WARN, ""},
    29  		{log.ERROR, ""},
    30  		{log.FATAL, ""},
    31  		{log.PANIC, ""},
    32  	} {
    33  		buf.Reset()
    34  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
    35  		logger.Debug(msg)
    36  		actual := buf.String()
    37  		expected := v.expected
    38  		if !reflect.DeepEqual(actual, expected) {
    39  			t.Errorf(`log level => %v; logger.Debug(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
    40  		}
    41  	}
    42  }
    43  
    44  func TestLogger_Debugf(t *testing.T) {
    45  	now := time.Now()
    46  	util.Now = func() time.Time { return now }
    47  	defer func() { util.Now = time.Now }()
    48  	var buf bytes.Buffer
    49  	format := "test log: %v"
    50  	msg := "this is test"
    51  	expected := "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\n"
    52  	for _, v := range []struct {
    53  		level    log.Level
    54  		expected string
    55  	}{
    56  		{log.NONE, expected},
    57  		{log.DEBUG, expected},
    58  		{log.INFO, ""},
    59  		{log.WARN, ""},
    60  		{log.ERROR, ""},
    61  		{log.FATAL, ""},
    62  		{log.PANIC, ""},
    63  	} {
    64  		buf.Reset()
    65  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
    66  		logger.Debugf(format, msg)
    67  		actual := buf.String()
    68  		expected := v.expected
    69  		if !reflect.DeepEqual(actual, expected) {
    70  			t.Errorf(`log level => %v; logger.Debugf(%#v, %#v) prints %#v; want %#v`, v.level, format, msg, actual, expected)
    71  		}
    72  	}
    73  }
    74  
    75  func TestLogger_Debugln(t *testing.T) {
    76  	now := time.Now()
    77  	util.Now = func() time.Time { return now }
    78  	defer func() { util.Now = time.Now }()
    79  	var buf bytes.Buffer
    80  	msg := "test log"
    81  	expected := "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
    82  	for _, v := range []struct {
    83  		level    log.Level
    84  		expected string
    85  	}{
    86  		{log.NONE, expected},
    87  		{log.DEBUG, expected},
    88  		{log.INFO, ""},
    89  		{log.WARN, ""},
    90  		{log.ERROR, ""},
    91  		{log.FATAL, ""},
    92  		{log.PANIC, ""},
    93  	} {
    94  		buf.Reset()
    95  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
    96  		logger.Debugln(msg)
    97  		actual := buf.String()
    98  		expected := v.expected
    99  		if !reflect.DeepEqual(actual, expected) {
   100  			t.Errorf(`log level => %v; logger.Debugln(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   101  		}
   102  	}
   103  }
   104  
   105  func TestLogger_Info(t *testing.T) {
   106  	now := time.Now()
   107  	util.Now = func() time.Time { return now }
   108  	defer func() { util.Now = time.Now }()
   109  	var buf bytes.Buffer
   110  	msg := "test log"
   111  	expected := "level:INFO\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   112  	for _, v := range []struct {
   113  		level    log.Level
   114  		expected string
   115  	}{
   116  		{log.NONE, expected},
   117  		{log.DEBUG, expected},
   118  		{log.INFO, expected},
   119  		{log.WARN, ""},
   120  		{log.ERROR, ""},
   121  		{log.FATAL, ""},
   122  		{log.PANIC, ""},
   123  	} {
   124  		buf.Reset()
   125  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   126  		logger.Info(msg)
   127  		actual := buf.String()
   128  		expected := v.expected
   129  		if !reflect.DeepEqual(actual, expected) {
   130  			t.Errorf(`log level => %v; logger.Info(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   131  		}
   132  	}
   133  }
   134  
   135  func TestLogger_Infof(t *testing.T) {
   136  	now := time.Now()
   137  	util.Now = func() time.Time { return now }
   138  	defer func() { util.Now = time.Now }()
   139  	var buf bytes.Buffer
   140  	format := "test log: %v"
   141  	msg := "this is test"
   142  	expected := "level:INFO\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\n"
   143  	for _, v := range []struct {
   144  		level    log.Level
   145  		expected string
   146  	}{
   147  		{log.NONE, expected},
   148  		{log.DEBUG, expected},
   149  		{log.INFO, expected},
   150  		{log.WARN, ""},
   151  		{log.ERROR, ""},
   152  		{log.FATAL, ""},
   153  		{log.PANIC, ""},
   154  	} {
   155  		buf.Reset()
   156  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   157  		logger.Infof(format, msg)
   158  		actual := buf.String()
   159  		expected := v.expected
   160  		if !reflect.DeepEqual(actual, expected) {
   161  			t.Errorf(`log level => %v; logger.Infof(%#v, %#v) prints %#v; want %#v`, v.level, format, msg, actual, expected)
   162  		}
   163  	}
   164  }
   165  
   166  func TestLogger_Infoln(t *testing.T) {
   167  	now := time.Now()
   168  	util.Now = func() time.Time { return now }
   169  	defer func() { util.Now = time.Now }()
   170  	var buf bytes.Buffer
   171  	msg := "test log"
   172  	expected := "level:INFO\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   173  	for _, v := range []struct {
   174  		level    log.Level
   175  		expected string
   176  	}{
   177  		{log.NONE, expected},
   178  		{log.DEBUG, expected},
   179  		{log.INFO, expected},
   180  		{log.WARN, ""},
   181  		{log.ERROR, ""},
   182  		{log.FATAL, ""},
   183  		{log.PANIC, ""},
   184  	} {
   185  		buf.Reset()
   186  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   187  		logger.Infoln(msg)
   188  		actual := buf.String()
   189  		expected := v.expected
   190  		if !reflect.DeepEqual(actual, expected) {
   191  			t.Errorf(`log level => %v; logger.Infoln(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   192  		}
   193  	}
   194  }
   195  
   196  func TestLogger_Warn(t *testing.T) {
   197  	now := time.Now()
   198  	util.Now = func() time.Time { return now }
   199  	defer func() { util.Now = time.Now }()
   200  	var buf bytes.Buffer
   201  	msg := "test log"
   202  	expected := "level:WARN\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   203  	for _, v := range []struct {
   204  		level    log.Level
   205  		expected string
   206  	}{
   207  		{log.NONE, expected},
   208  		{log.DEBUG, expected},
   209  		{log.INFO, expected},
   210  		{log.WARN, expected},
   211  		{log.ERROR, ""},
   212  		{log.FATAL, ""},
   213  		{log.PANIC, ""},
   214  	} {
   215  		buf.Reset()
   216  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   217  		logger.Warn(msg)
   218  		actual := buf.String()
   219  		expected := v.expected
   220  		if !reflect.DeepEqual(actual, expected) {
   221  			t.Errorf(`log level => %v; logger.Warn(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   222  		}
   223  	}
   224  }
   225  
   226  func TestLogger_Warnf(t *testing.T) {
   227  	now := time.Now()
   228  	util.Now = func() time.Time { return now }
   229  	defer func() { util.Now = time.Now }()
   230  	var buf bytes.Buffer
   231  	format := "test log: %v"
   232  	msg := "this is test"
   233  	expected := "level:WARN\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\n"
   234  	for _, v := range []struct {
   235  		level    log.Level
   236  		expected string
   237  	}{
   238  		{log.NONE, expected},
   239  		{log.DEBUG, expected},
   240  		{log.INFO, expected},
   241  		{log.WARN, expected},
   242  		{log.ERROR, ""},
   243  		{log.FATAL, ""},
   244  		{log.PANIC, ""},
   245  	} {
   246  		buf.Reset()
   247  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   248  		logger.Warnf(format, msg)
   249  		actual := buf.String()
   250  		expected := v.expected
   251  		if !reflect.DeepEqual(actual, expected) {
   252  			t.Errorf(`log level => %v; logger.Warnf(%#v, %#v) prints %#v; want %#v`, v.level, format, msg, actual, expected)
   253  		}
   254  	}
   255  }
   256  
   257  func TestLogger_Warnln(t *testing.T) {
   258  	now := time.Now()
   259  	util.Now = func() time.Time { return now }
   260  	defer func() { util.Now = time.Now }()
   261  	var buf bytes.Buffer
   262  	msg := "test log"
   263  	expected := "level:WARN\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   264  	for _, v := range []struct {
   265  		level    log.Level
   266  		expected string
   267  	}{
   268  		{log.NONE, expected},
   269  		{log.DEBUG, expected},
   270  		{log.INFO, expected},
   271  		{log.WARN, expected},
   272  		{log.ERROR, ""},
   273  		{log.FATAL, ""},
   274  		{log.PANIC, ""},
   275  	} {
   276  		buf.Reset()
   277  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   278  		logger.Warnln(msg)
   279  		actual := buf.String()
   280  		expected := v.expected
   281  		if !reflect.DeepEqual(actual, expected) {
   282  			t.Errorf(`log level => %v; logger.Warnln(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   283  		}
   284  	}
   285  }
   286  
   287  func TestLogger_Error(t *testing.T) {
   288  	now := time.Now()
   289  	util.Now = func() time.Time { return now }
   290  	defer func() { util.Now = time.Now }()
   291  	var buf bytes.Buffer
   292  	msg := "test log"
   293  	expected := "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   294  	for _, v := range []struct {
   295  		level    log.Level
   296  		expected string
   297  	}{
   298  		{log.NONE, expected},
   299  		{log.DEBUG, expected},
   300  		{log.INFO, expected},
   301  		{log.WARN, expected},
   302  		{log.ERROR, expected},
   303  		{log.FATAL, ""},
   304  		{log.PANIC, ""},
   305  	} {
   306  		buf.Reset()
   307  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   308  		logger.Error(msg)
   309  		actual := buf.String()
   310  		expected := v.expected
   311  		if !reflect.DeepEqual(actual, expected) {
   312  			t.Errorf(`log level => %v; logger.Error(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   313  		}
   314  	}
   315  }
   316  
   317  func TestLogger_Errorf(t *testing.T) {
   318  	now := time.Now()
   319  	util.Now = func() time.Time { return now }
   320  	defer func() { util.Now = time.Now }()
   321  	var buf bytes.Buffer
   322  	format := "test log: %v"
   323  	msg := "this is test"
   324  	expected := "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\n"
   325  	for _, v := range []struct {
   326  		level    log.Level
   327  		expected string
   328  	}{
   329  		{log.NONE, expected},
   330  		{log.DEBUG, expected},
   331  		{log.INFO, expected},
   332  		{log.WARN, expected},
   333  		{log.ERROR, expected},
   334  		{log.FATAL, ""},
   335  		{log.PANIC, ""},
   336  	} {
   337  		buf.Reset()
   338  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   339  		logger.Errorf(format, msg)
   340  		actual := buf.String()
   341  		expected := v.expected
   342  		if !reflect.DeepEqual(actual, expected) {
   343  			t.Errorf(`log level => %v; logger.Errorf(%#v, %#v) prints %#v; want %#v`, v.level, format, msg, actual, expected)
   344  		}
   345  	}
   346  }
   347  
   348  func TestLogger_Errorln(t *testing.T) {
   349  	now := time.Now()
   350  	util.Now = func() time.Time { return now }
   351  	defer func() { util.Now = time.Now }()
   352  	var buf bytes.Buffer
   353  	msg := "test log"
   354  	expected := "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   355  	for _, v := range []struct {
   356  		level    log.Level
   357  		expected string
   358  	}{
   359  		{log.NONE, expected},
   360  		{log.DEBUG, expected},
   361  		{log.INFO, expected},
   362  		{log.WARN, expected},
   363  		{log.ERROR, expected},
   364  		{log.FATAL, ""},
   365  		{log.PANIC, ""},
   366  	} {
   367  		buf.Reset()
   368  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   369  		logger.Errorln(msg)
   370  		actual := buf.String()
   371  		expected := v.expected
   372  		if !reflect.DeepEqual(actual, expected) {
   373  			t.Errorf(`log level => %v; logger.Errorln(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   374  		}
   375  	}
   376  }
   377  
   378  func TestLogger_Fatal(t *testing.T) {
   379  	t.Skip("cannot test because Logger.Fatal() calls os.Exit(1)")
   380  }
   381  
   382  func TestLogger_Fatalf(t *testing.T) {
   383  	t.Skip("cannot test because Logger.Fatalf() calls os.Exit(1)")
   384  }
   385  
   386  func TestLogger_Fatalln(t *testing.T) {
   387  	t.Skip("cannot test because Logger.Fatalln() calls os.Exit(1)")
   388  }
   389  
   390  func TestLogger_Panic(t *testing.T) {
   391  	now := time.Now()
   392  	util.Now = func() time.Time { return now }
   393  	defer func() { util.Now = time.Now }()
   394  	var buf bytes.Buffer
   395  	msg := "test log"
   396  	expected := "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   397  	for _, v := range []struct {
   398  		level    log.Level
   399  		expected string
   400  	}{
   401  		{log.NONE, expected},
   402  		{log.DEBUG, expected},
   403  		{log.INFO, expected},
   404  		{log.WARN, expected},
   405  		{log.ERROR, expected},
   406  		{log.FATAL, expected},
   407  		{log.PANIC, expected},
   408  	} {
   409  		buf.Reset()
   410  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   411  		func() {
   412  			defer func() {
   413  				if err := recover(); err == nil {
   414  					t.Errorf("log level => %v; logger.Panic(%#v) isn't calling panic()", v.level, msg)
   415  				}
   416  			}()
   417  			logger.Panic(msg)
   418  		}()
   419  		actual := buf.String()
   420  		expected := v.expected
   421  		if !reflect.DeepEqual(actual, expected) {
   422  			t.Errorf(`log level => %v; logger.Panic(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   423  		}
   424  	}
   425  }
   426  
   427  func TestLogger_Panicf(t *testing.T) {
   428  	now := time.Now()
   429  	util.Now = func() time.Time { return now }
   430  	defer func() { util.Now = time.Now }()
   431  	var buf bytes.Buffer
   432  	format := "test log: %v"
   433  	msg := "this is test"
   434  	expected := "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\n"
   435  	for _, v := range []struct {
   436  		level    log.Level
   437  		expected string
   438  	}{
   439  		{log.NONE, expected},
   440  		{log.DEBUG, expected},
   441  		{log.INFO, expected},
   442  		{log.WARN, expected},
   443  		{log.ERROR, expected},
   444  		{log.FATAL, expected},
   445  		{log.PANIC, expected},
   446  	} {
   447  		buf.Reset()
   448  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   449  		func() {
   450  			defer func() {
   451  				if err := recover(); err == nil {
   452  					t.Errorf("log level => %v; logger.Panicf(%#v, %#v) isn't calling panic()", v.level, format, msg)
   453  				}
   454  			}()
   455  			logger.Panicf(format, msg)
   456  		}()
   457  		actual := buf.String()
   458  		expected := v.expected
   459  		if !reflect.DeepEqual(actual, expected) {
   460  			t.Errorf(`log level => %v; logger.Panicf(%#v, %#v) prints %#v; want %#v`, v.level, format, msg, actual, expected)
   461  		}
   462  	}
   463  }
   464  
   465  func TestLogger_Panicln(t *testing.T) {
   466  	now := time.Now()
   467  	util.Now = func() time.Time { return now }
   468  	defer func() { util.Now = time.Now }()
   469  	var buf bytes.Buffer
   470  	msg := "test log"
   471  	expected := "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   472  	for _, v := range []struct {
   473  		level    log.Level
   474  		expected string
   475  	}{
   476  		{log.NONE, expected},
   477  		{log.DEBUG, expected},
   478  		{log.INFO, expected},
   479  		{log.WARN, expected},
   480  		{log.ERROR, expected},
   481  		{log.FATAL, expected},
   482  		{log.PANIC, expected},
   483  	} {
   484  		buf.Reset()
   485  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   486  		func() {
   487  			defer func() {
   488  				if err := recover(); err == nil {
   489  					t.Errorf("log level => %v; logger.Panicln(%#v) isn't calling panic()", v.level, msg)
   490  				}
   491  			}()
   492  			logger.Panicln(msg)
   493  		}()
   494  		actual := buf.String()
   495  		expected := v.expected
   496  		if !reflect.DeepEqual(actual, expected) {
   497  			t.Errorf(`log level => %v; logger.Panicln(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   498  		}
   499  	}
   500  }
   501  
   502  func TestLogger_Print(t *testing.T) {
   503  	now := time.Now()
   504  	util.Now = func() time.Time { return now }
   505  	defer func() { util.Now = time.Now }()
   506  	var buf bytes.Buffer
   507  	msg := "test log"
   508  	expected := "level:NONE\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   509  	for _, v := range []struct {
   510  		level    log.Level
   511  		expected string
   512  	}{
   513  		{log.NONE, expected},
   514  		{log.DEBUG, expected},
   515  		{log.INFO, expected},
   516  		{log.WARN, expected},
   517  		{log.ERROR, expected},
   518  		{log.FATAL, expected},
   519  		{log.PANIC, expected},
   520  	} {
   521  		buf.Reset()
   522  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   523  		logger.Print(msg)
   524  		actual := buf.String()
   525  		expected := v.expected
   526  		if !reflect.DeepEqual(actual, expected) {
   527  			t.Errorf(`log level => %v; logger.Print(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   528  		}
   529  	}
   530  }
   531  
   532  func TestLogger_Printf(t *testing.T) {
   533  	now := time.Now()
   534  	util.Now = func() time.Time { return now }
   535  	defer func() { util.Now = time.Now }()
   536  	var buf bytes.Buffer
   537  	format := "test log: %v"
   538  	msg := "this is test"
   539  	expected := "level:NONE\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\n"
   540  	for _, v := range []struct {
   541  		level    log.Level
   542  		expected string
   543  	}{
   544  		{log.NONE, expected},
   545  		{log.DEBUG, expected},
   546  		{log.INFO, expected},
   547  		{log.WARN, expected},
   548  		{log.ERROR, expected},
   549  		{log.FATAL, expected},
   550  		{log.PANIC, expected},
   551  	} {
   552  		buf.Reset()
   553  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   554  		logger.Printf(format, msg)
   555  		actual := buf.String()
   556  		expected := v.expected
   557  		if !reflect.DeepEqual(actual, expected) {
   558  			t.Errorf(`log level => %v; logger.Printf(%#v, %#v) prints %#v; want %#v`, v.level, format, msg, actual, expected)
   559  		}
   560  	}
   561  }
   562  
   563  func TestLogger_Println(t *testing.T) {
   564  	now := time.Now()
   565  	util.Now = func() time.Time { return now }
   566  	defer func() { util.Now = time.Now }()
   567  	var buf bytes.Buffer
   568  	msg := "test log"
   569  	expected := "level:NONE\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
   570  	for _, v := range []struct {
   571  		level    log.Level
   572  		expected string
   573  	}{
   574  		{log.NONE, expected},
   575  		{log.DEBUG, expected},
   576  		{log.INFO, expected},
   577  		{log.WARN, expected},
   578  		{log.ERROR, expected},
   579  		{log.FATAL, expected},
   580  		{log.PANIC, expected},
   581  	} {
   582  		buf.Reset()
   583  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
   584  		logger.Println(msg)
   585  		actual := buf.String()
   586  		expected := v.expected
   587  		if !reflect.DeepEqual(actual, expected) {
   588  			t.Errorf(`log level => %v; logger.Println(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
   589  		}
   590  	}
   591  }
   592  
   593  func TestLogger_Output(t *testing.T) {
   594  	now := time.Now()
   595  	util.Now = func() time.Time { return now }
   596  	defer func() { util.Now = time.Now }()
   597  	var buf bytes.Buffer
   598  	msg := "test log"
   599  	for _, currentLevel := range []log.Level{
   600  		log.NONE,
   601  		log.DEBUG,
   602  		log.INFO,
   603  		log.WARN,
   604  		log.ERROR,
   605  		log.FATAL,
   606  		log.PANIC,
   607  	} {
   608  		for _, v := range []struct {
   609  			level    log.Level
   610  			expected string
   611  		}{
   612  			{log.NONE, "level:NONE\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"},
   613  			{log.DEBUG, "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"},
   614  			{log.INFO, "level:INFO\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"},
   615  			{log.WARN, "level:WARN\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"},
   616  			{log.ERROR, "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"},
   617  			{log.FATAL, "level:FATAL\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"},
   618  			{log.PANIC, "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"},
   619  		} {
   620  			buf.Reset()
   621  			logger := log.New(&buf, &log.LTSVFormatter{}, currentLevel)
   622  			logger.Output(v.level, msg)
   623  			actual := buf.String()
   624  			expected := v.expected
   625  			if !reflect.DeepEqual(actual, expected) {
   626  				t.Errorf(`log level => %v; logger.Output(%v, %#v) prints %#v; want %#v`, currentLevel, v.level, msg, actual, expected)
   627  			}
   628  		}
   629  	}
   630  }
   631  
   632  func TestLogger_With_Debug(t *testing.T) {
   633  	now := time.Now()
   634  	util.Now = func() time.Time { return now }
   635  	defer func() { util.Now = time.Now }()
   636  	var buf bytes.Buffer
   637  	msg := "test log"
   638  	fields := log.Fields{
   639  		"first":  1,
   640  		"second": "two",
   641  	}
   642  	expected := "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
   643  	for _, v := range []struct {
   644  		level    log.Level
   645  		expected string
   646  	}{
   647  		{log.NONE, expected},
   648  		{log.DEBUG, expected},
   649  		{log.INFO, ""},
   650  		{log.WARN, ""},
   651  		{log.ERROR, ""},
   652  		{log.FATAL, ""},
   653  		{log.PANIC, ""},
   654  	} {
   655  		buf.Reset()
   656  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   657  		logger.Debug(msg)
   658  		actual := buf.String()
   659  		expected := v.expected
   660  		if !reflect.DeepEqual(actual, expected) {
   661  			t.Errorf(`log level => %v; logger.With(%#v).Debug(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
   662  		}
   663  	}
   664  }
   665  
   666  func TestLogger_With_Debugf(t *testing.T) {
   667  	now := time.Now()
   668  	util.Now = func() time.Time { return now }
   669  	defer func() { util.Now = time.Now }()
   670  	var buf bytes.Buffer
   671  	format := "test log: %v"
   672  	msg := "this is test"
   673  	fields := log.Fields{
   674  		"first":  1,
   675  		"second": "two",
   676  	}
   677  	expected := "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\tfirst:1\tsecond:two\n"
   678  	for _, v := range []struct {
   679  		level    log.Level
   680  		expected string
   681  	}{
   682  		{log.NONE, expected},
   683  		{log.DEBUG, expected},
   684  		{log.INFO, ""},
   685  		{log.WARN, ""},
   686  		{log.ERROR, ""},
   687  		{log.FATAL, ""},
   688  		{log.PANIC, ""},
   689  	} {
   690  		buf.Reset()
   691  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   692  		logger.Debugf(format, msg)
   693  		actual := buf.String()
   694  		expected := v.expected
   695  		if !reflect.DeepEqual(actual, expected) {
   696  			t.Errorf(`log level => %v; logger.With(%#v).Debugf(%#v, %#v) prints %#v; want %#v`, v.level, fields, format, msg, actual, expected)
   697  		}
   698  	}
   699  }
   700  
   701  func TestLogger_With_Debugln(t *testing.T) {
   702  	now := time.Now()
   703  	util.Now = func() time.Time { return now }
   704  	defer func() { util.Now = time.Now }()
   705  	var buf bytes.Buffer
   706  	msg := "test log"
   707  	fields := log.Fields{
   708  		"first":  1,
   709  		"second": "two",
   710  	}
   711  	expected := "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
   712  	for _, v := range []struct {
   713  		level    log.Level
   714  		expected string
   715  	}{
   716  		{log.NONE, expected},
   717  		{log.DEBUG, expected},
   718  		{log.INFO, ""},
   719  		{log.WARN, ""},
   720  		{log.ERROR, ""},
   721  		{log.FATAL, ""},
   722  		{log.PANIC, ""},
   723  	} {
   724  		buf.Reset()
   725  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   726  		logger.Debugln(msg)
   727  		actual := buf.String()
   728  		expected := v.expected
   729  		if !reflect.DeepEqual(actual, expected) {
   730  			t.Errorf(`log level => %v; logger.With(%#v).Debugln(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
   731  		}
   732  	}
   733  }
   734  
   735  func TestLogger_With_Info(t *testing.T) {
   736  	now := time.Now()
   737  	util.Now = func() time.Time { return now }
   738  	defer func() { util.Now = time.Now }()
   739  	var buf bytes.Buffer
   740  	msg := "test log"
   741  	fields := log.Fields{
   742  		"first":  1,
   743  		"second": "two",
   744  	}
   745  	expected := "level:INFO\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
   746  	for _, v := range []struct {
   747  		level    log.Level
   748  		expected string
   749  	}{
   750  		{log.NONE, expected},
   751  		{log.DEBUG, expected},
   752  		{log.INFO, expected},
   753  		{log.WARN, ""},
   754  		{log.ERROR, ""},
   755  		{log.FATAL, ""},
   756  		{log.PANIC, ""},
   757  	} {
   758  		buf.Reset()
   759  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   760  		logger.Info(msg)
   761  		actual := buf.String()
   762  		expected := v.expected
   763  		if !reflect.DeepEqual(actual, expected) {
   764  			t.Errorf(`log level => %v; logger.With(%#v).Info(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
   765  		}
   766  	}
   767  }
   768  
   769  func TestLogger_With_Infof(t *testing.T) {
   770  	now := time.Now()
   771  	util.Now = func() time.Time { return now }
   772  	defer func() { util.Now = time.Now }()
   773  	var buf bytes.Buffer
   774  	format := "test log: %v"
   775  	msg := "this is test"
   776  	fields := log.Fields{
   777  		"first":  1,
   778  		"second": "two",
   779  	}
   780  	expected := "level:INFO\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\tfirst:1\tsecond:two\n"
   781  	for _, v := range []struct {
   782  		level    log.Level
   783  		expected string
   784  	}{
   785  		{log.NONE, expected},
   786  		{log.DEBUG, expected},
   787  		{log.INFO, expected},
   788  		{log.WARN, ""},
   789  		{log.ERROR, ""},
   790  		{log.FATAL, ""},
   791  		{log.PANIC, ""},
   792  	} {
   793  		buf.Reset()
   794  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   795  		logger.Infof(format, msg)
   796  		actual := buf.String()
   797  		expected := v.expected
   798  		if !reflect.DeepEqual(actual, expected) {
   799  			t.Errorf(`log level => %v; logger.With(%#v).Infof(%#v, %#v) prints %#v; want %#v`, v.level, fields, format, msg, actual, expected)
   800  		}
   801  	}
   802  }
   803  
   804  func TestLogger_With_Infoln(t *testing.T) {
   805  	now := time.Now()
   806  	util.Now = func() time.Time { return now }
   807  	defer func() { util.Now = time.Now }()
   808  	var buf bytes.Buffer
   809  	msg := "test log"
   810  	fields := log.Fields{
   811  		"first":  1,
   812  		"second": "two",
   813  	}
   814  	expected := "level:INFO\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
   815  	for _, v := range []struct {
   816  		level    log.Level
   817  		expected string
   818  	}{
   819  		{log.NONE, expected},
   820  		{log.DEBUG, expected},
   821  		{log.INFO, expected},
   822  		{log.WARN, ""},
   823  		{log.ERROR, ""},
   824  		{log.FATAL, ""},
   825  		{log.PANIC, ""},
   826  	} {
   827  		buf.Reset()
   828  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   829  		logger.Infoln(msg)
   830  		actual := buf.String()
   831  		expected := v.expected
   832  		if !reflect.DeepEqual(actual, expected) {
   833  			t.Errorf(`log level => %v; logger.With(%#v).Infoln(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
   834  		}
   835  	}
   836  }
   837  
   838  func TestLogger_With_Warn(t *testing.T) {
   839  	now := time.Now()
   840  	util.Now = func() time.Time { return now }
   841  	defer func() { util.Now = time.Now }()
   842  	var buf bytes.Buffer
   843  	msg := "test log"
   844  	fields := log.Fields{
   845  		"first":  1,
   846  		"second": "two",
   847  	}
   848  	expected := "level:WARN\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
   849  	for _, v := range []struct {
   850  		level    log.Level
   851  		expected string
   852  	}{
   853  		{log.NONE, expected},
   854  		{log.DEBUG, expected},
   855  		{log.INFO, expected},
   856  		{log.WARN, expected},
   857  		{log.ERROR, ""},
   858  		{log.FATAL, ""},
   859  		{log.PANIC, ""},
   860  	} {
   861  		buf.Reset()
   862  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   863  		logger.Warn(msg)
   864  		actual := buf.String()
   865  		expected := v.expected
   866  		if !reflect.DeepEqual(actual, expected) {
   867  			t.Errorf(`log level => %v; logger.With(%#v).Warn(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
   868  		}
   869  	}
   870  }
   871  
   872  func TestLogger_With_Warnf(t *testing.T) {
   873  	now := time.Now()
   874  	util.Now = func() time.Time { return now }
   875  	defer func() { util.Now = time.Now }()
   876  	var buf bytes.Buffer
   877  	format := "test log: %v"
   878  	msg := "this is test"
   879  	fields := log.Fields{
   880  		"first":  1,
   881  		"second": "two",
   882  	}
   883  	expected := "level:WARN\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\tfirst:1\tsecond:two\n"
   884  	for _, v := range []struct {
   885  		level    log.Level
   886  		expected string
   887  	}{
   888  		{log.NONE, expected},
   889  		{log.DEBUG, expected},
   890  		{log.INFO, expected},
   891  		{log.WARN, expected},
   892  		{log.ERROR, ""},
   893  		{log.FATAL, ""},
   894  		{log.PANIC, ""},
   895  	} {
   896  		buf.Reset()
   897  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   898  		logger.Warnf(format, msg)
   899  		actual := buf.String()
   900  		expected := v.expected
   901  		if !reflect.DeepEqual(actual, expected) {
   902  			t.Errorf(`log level => %v; logger.With(%#v).Warnf(%#v, %#v) prints %#v; want %#v`, v.level, fields, format, msg, actual, expected)
   903  		}
   904  	}
   905  }
   906  
   907  func TestLogger_With_Warnln(t *testing.T) {
   908  	now := time.Now()
   909  	util.Now = func() time.Time { return now }
   910  	defer func() { util.Now = time.Now }()
   911  	var buf bytes.Buffer
   912  	msg := "test log"
   913  	fields := log.Fields{
   914  		"first":  1,
   915  		"second": "two",
   916  	}
   917  	expected := "level:WARN\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
   918  	for _, v := range []struct {
   919  		level    log.Level
   920  		expected string
   921  	}{
   922  		{log.NONE, expected},
   923  		{log.DEBUG, expected},
   924  		{log.INFO, expected},
   925  		{log.WARN, expected},
   926  		{log.ERROR, ""},
   927  		{log.FATAL, ""},
   928  		{log.PANIC, ""},
   929  	} {
   930  		buf.Reset()
   931  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   932  		logger.Warnln(msg)
   933  		actual := buf.String()
   934  		expected := v.expected
   935  		if !reflect.DeepEqual(actual, expected) {
   936  			t.Errorf(`log level => %v; logger.With(%#v).Warnln(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
   937  		}
   938  	}
   939  }
   940  
   941  func TestLogger_With_Error(t *testing.T) {
   942  	now := time.Now()
   943  	util.Now = func() time.Time { return now }
   944  	defer func() { util.Now = time.Now }()
   945  	var buf bytes.Buffer
   946  	msg := "test log"
   947  	fields := log.Fields{
   948  		"first":  1,
   949  		"second": "two",
   950  	}
   951  	expected := "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
   952  	for _, v := range []struct {
   953  		level    log.Level
   954  		expected string
   955  	}{
   956  		{log.NONE, expected},
   957  		{log.DEBUG, expected},
   958  		{log.INFO, expected},
   959  		{log.WARN, expected},
   960  		{log.ERROR, expected},
   961  		{log.FATAL, ""},
   962  		{log.PANIC, ""},
   963  	} {
   964  		buf.Reset()
   965  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
   966  		logger.Error(msg)
   967  		actual := buf.String()
   968  		expected := v.expected
   969  		if !reflect.DeepEqual(actual, expected) {
   970  			t.Errorf(`log level => %v; logger.With(%#v).Error(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
   971  		}
   972  	}
   973  }
   974  
   975  func TestLogger_With_Errorf(t *testing.T) {
   976  	now := time.Now()
   977  	util.Now = func() time.Time { return now }
   978  	defer func() { util.Now = time.Now }()
   979  	var buf bytes.Buffer
   980  	format := "test log: %v"
   981  	msg := "this is test"
   982  	fields := log.Fields{
   983  		"first":  1,
   984  		"second": "two",
   985  	}
   986  	expected := "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\tfirst:1\tsecond:two\n"
   987  	for _, v := range []struct {
   988  		level    log.Level
   989  		expected string
   990  	}{
   991  		{log.NONE, expected},
   992  		{log.DEBUG, expected},
   993  		{log.INFO, expected},
   994  		{log.WARN, expected},
   995  		{log.ERROR, expected},
   996  		{log.FATAL, ""},
   997  		{log.PANIC, ""},
   998  	} {
   999  		buf.Reset()
  1000  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
  1001  		logger.Errorf(format, msg)
  1002  		actual := buf.String()
  1003  		expected := v.expected
  1004  		if !reflect.DeepEqual(actual, expected) {
  1005  			t.Errorf(`log level => %v; logger.With(%#v).Errorf(%#v, %#v) prints %#v; want %#v`, v.level, fields, format, msg, actual, expected)
  1006  		}
  1007  	}
  1008  }
  1009  
  1010  func TestLogger_With_Errorln(t *testing.T) {
  1011  	now := time.Now()
  1012  	util.Now = func() time.Time { return now }
  1013  	defer func() { util.Now = time.Now }()
  1014  	var buf bytes.Buffer
  1015  	msg := "test log"
  1016  	fields := log.Fields{
  1017  		"first":  1,
  1018  		"second": "two",
  1019  	}
  1020  	expected := "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
  1021  	for _, v := range []struct {
  1022  		level    log.Level
  1023  		expected string
  1024  	}{
  1025  		{log.NONE, expected},
  1026  		{log.DEBUG, expected},
  1027  		{log.INFO, expected},
  1028  		{log.WARN, expected},
  1029  		{log.ERROR, expected},
  1030  		{log.FATAL, ""},
  1031  		{log.PANIC, ""},
  1032  	} {
  1033  		buf.Reset()
  1034  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
  1035  		logger.Errorln(msg)
  1036  		actual := buf.String()
  1037  		expected := v.expected
  1038  		if !reflect.DeepEqual(actual, expected) {
  1039  			t.Errorf(`log level => %v; logger.With(%#v).Errorln(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
  1040  		}
  1041  	}
  1042  }
  1043  
  1044  func TestLogger_With_Fatal(t *testing.T) {
  1045  	t.Skip("cannot test because Logger.With().Fatal() calls os.Exit(1)")
  1046  }
  1047  
  1048  func TestLogger_With_Fatalf(t *testing.T) {
  1049  	t.Skip("cannot test because Logger.With().Fatalf() calls os.Exit(1)")
  1050  }
  1051  
  1052  func TestLogger_With_Fatalln(t *testing.T) {
  1053  	t.Skip("cannot test because Logger.With().Fatalln() calls os.Exit(1)")
  1054  }
  1055  
  1056  func TestLogger_With_Panic(t *testing.T) {
  1057  	now := time.Now()
  1058  	util.Now = func() time.Time { return now }
  1059  	defer func() { util.Now = time.Now }()
  1060  	var buf bytes.Buffer
  1061  	msg := "test log"
  1062  	fields := log.Fields{
  1063  		"first":  1,
  1064  		"second": "two",
  1065  	}
  1066  	expected := "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
  1067  	for _, v := range []struct {
  1068  		level    log.Level
  1069  		expected string
  1070  	}{
  1071  		{log.NONE, expected},
  1072  		{log.DEBUG, expected},
  1073  		{log.INFO, expected},
  1074  		{log.WARN, expected},
  1075  		{log.ERROR, expected},
  1076  		{log.FATAL, expected},
  1077  		{log.PANIC, expected},
  1078  	} {
  1079  		buf.Reset()
  1080  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
  1081  		func() {
  1082  			defer func() {
  1083  				if err := recover(); err == nil {
  1084  					t.Errorf("log level => %v; logger.With(%#v).Panic(%#v) isn't calling panic()", v.level, fields, msg)
  1085  				}
  1086  			}()
  1087  			logger.Panic(msg)
  1088  		}()
  1089  		actual := buf.String()
  1090  		expected := v.expected
  1091  		if !reflect.DeepEqual(actual, expected) {
  1092  			t.Errorf(`log level => %v; logger.With(%#v).Panic(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
  1093  		}
  1094  	}
  1095  }
  1096  
  1097  func TestLogger_With_Panicf(t *testing.T) {
  1098  	now := time.Now()
  1099  	util.Now = func() time.Time { return now }
  1100  	defer func() { util.Now = time.Now }()
  1101  	var buf bytes.Buffer
  1102  	format := "test log: %v"
  1103  	msg := "this is test"
  1104  	fields := log.Fields{
  1105  		"first":  1,
  1106  		"second": "two",
  1107  	}
  1108  	expected := "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\tfirst:1\tsecond:two\n"
  1109  	for _, v := range []struct {
  1110  		level    log.Level
  1111  		expected string
  1112  	}{
  1113  		{log.NONE, expected},
  1114  		{log.DEBUG, expected},
  1115  		{log.INFO, expected},
  1116  		{log.WARN, expected},
  1117  		{log.ERROR, expected},
  1118  		{log.FATAL, expected},
  1119  		{log.PANIC, expected},
  1120  	} {
  1121  		buf.Reset()
  1122  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
  1123  		func() {
  1124  			defer func() {
  1125  				if err := recover(); err == nil {
  1126  					t.Errorf("log level => %v; logger.With(%#v).Panicf(%#v, %#v) isn't calling panic()", v.level, fields, format, msg)
  1127  				}
  1128  			}()
  1129  			logger.Panicf(format, msg)
  1130  		}()
  1131  		actual := buf.String()
  1132  		expected := v.expected
  1133  		if !reflect.DeepEqual(actual, expected) {
  1134  			t.Errorf(`log level => %v; logger.With(%#v).Panicf(%#v, %#v) prints %#v; want %#v`, v.level, fields, format, msg, actual, expected)
  1135  		}
  1136  	}
  1137  }
  1138  
  1139  func TestLogger_With_Panicln(t *testing.T) {
  1140  	now := time.Now()
  1141  	util.Now = func() time.Time { return now }
  1142  	defer func() { util.Now = time.Now }()
  1143  	var buf bytes.Buffer
  1144  	msg := "test log"
  1145  	fields := log.Fields{
  1146  		"first":  1,
  1147  		"second": "two",
  1148  	}
  1149  	expected := "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
  1150  	for _, v := range []struct {
  1151  		level    log.Level
  1152  		expected string
  1153  	}{
  1154  		{log.NONE, expected},
  1155  		{log.DEBUG, expected},
  1156  		{log.INFO, expected},
  1157  		{log.WARN, expected},
  1158  		{log.ERROR, expected},
  1159  		{log.FATAL, expected},
  1160  		{log.PANIC, expected},
  1161  	} {
  1162  		buf.Reset()
  1163  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
  1164  		func() {
  1165  			defer func() {
  1166  				if err := recover(); err == nil {
  1167  					t.Errorf("log level => %v; logger.With(%#v).Panicln(%#v) isn't calling panic()", v.level, msg)
  1168  				}
  1169  			}()
  1170  			logger.Panicln(msg)
  1171  		}()
  1172  		actual := buf.String()
  1173  		expected := v.expected
  1174  		if !reflect.DeepEqual(actual, expected) {
  1175  			t.Errorf(`log level => %v; logger.With(%#v).Panicln(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
  1176  		}
  1177  	}
  1178  }
  1179  
  1180  func TestLogger_With_Print(t *testing.T) {
  1181  	now := time.Now()
  1182  	util.Now = func() time.Time { return now }
  1183  	defer func() { util.Now = time.Now }()
  1184  	var buf bytes.Buffer
  1185  	msg := "test log"
  1186  	fields := log.Fields{
  1187  		"first":  1,
  1188  		"second": "two",
  1189  	}
  1190  	expected := "level:NONE\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
  1191  	for _, v := range []struct {
  1192  		level    log.Level
  1193  		expected string
  1194  	}{
  1195  		{log.NONE, expected},
  1196  		{log.DEBUG, expected},
  1197  		{log.INFO, expected},
  1198  		{log.WARN, expected},
  1199  		{log.ERROR, expected},
  1200  		{log.FATAL, expected},
  1201  		{log.PANIC, expected},
  1202  	} {
  1203  		buf.Reset()
  1204  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
  1205  		logger.Print(msg)
  1206  		actual := buf.String()
  1207  		expected := v.expected
  1208  		if !reflect.DeepEqual(actual, expected) {
  1209  			t.Errorf(`log level => %v; logger.With(%#v).Print(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
  1210  		}
  1211  	}
  1212  }
  1213  
  1214  func TestLogger_With_Printf(t *testing.T) {
  1215  	now := time.Now()
  1216  	util.Now = func() time.Time { return now }
  1217  	defer func() { util.Now = time.Now }()
  1218  	var buf bytes.Buffer
  1219  	format := "test log: %v"
  1220  	msg := "this is test"
  1221  	fields := log.Fields{
  1222  		"first":  1,
  1223  		"second": "two",
  1224  	}
  1225  	expected := "level:NONE\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\tfirst:1\tsecond:two\n"
  1226  	for _, v := range []struct {
  1227  		level    log.Level
  1228  		expected string
  1229  	}{
  1230  		{log.NONE, expected},
  1231  		{log.DEBUG, expected},
  1232  		{log.INFO, expected},
  1233  		{log.WARN, expected},
  1234  		{log.ERROR, expected},
  1235  		{log.FATAL, expected},
  1236  		{log.PANIC, expected},
  1237  	} {
  1238  		buf.Reset()
  1239  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
  1240  		logger.Printf(format, msg)
  1241  		actual := buf.String()
  1242  		expected := v.expected
  1243  		if !reflect.DeepEqual(actual, expected) {
  1244  			t.Errorf(`log level => %v; logger.With(%#v).Printf(%#v, %#v) prints %#v; want %#v`, v.level, fields, format, msg, actual, expected)
  1245  		}
  1246  	}
  1247  }
  1248  
  1249  func TestLogger_With_Println(t *testing.T) {
  1250  	now := time.Now()
  1251  	util.Now = func() time.Time { return now }
  1252  	defer func() { util.Now = time.Now }()
  1253  	var buf bytes.Buffer
  1254  	msg := "test log"
  1255  	fields := log.Fields{
  1256  		"first":  1,
  1257  		"second": "two",
  1258  	}
  1259  	expected := "level:NONE\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
  1260  	for _, v := range []struct {
  1261  		level    log.Level
  1262  		expected string
  1263  	}{
  1264  		{log.NONE, expected},
  1265  		{log.DEBUG, expected},
  1266  		{log.INFO, expected},
  1267  		{log.WARN, expected},
  1268  		{log.ERROR, expected},
  1269  		{log.FATAL, expected},
  1270  		{log.PANIC, expected},
  1271  	} {
  1272  		buf.Reset()
  1273  		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
  1274  		logger.Println(msg)
  1275  		actual := buf.String()
  1276  		expected := v.expected
  1277  		if !reflect.DeepEqual(actual, expected) {
  1278  			t.Errorf(`log level => %v; logger.With(%#v).Println(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
  1279  		}
  1280  	}
  1281  }
  1282  
  1283  func TestLogger_With_Output(t *testing.T) {
  1284  	now := time.Now()
  1285  	util.Now = func() time.Time { return now }
  1286  	defer func() { util.Now = time.Now }()
  1287  	var buf bytes.Buffer
  1288  	msg := "test log"
  1289  	fields := log.Fields{
  1290  		"first":  1,
  1291  		"second": "two",
  1292  	}
  1293  	for _, currentLevel := range []log.Level{
  1294  		log.NONE,
  1295  		log.DEBUG,
  1296  		log.INFO,
  1297  		log.WARN,
  1298  		log.ERROR,
  1299  		log.FATAL,
  1300  		log.PANIC,
  1301  	} {
  1302  		for _, v := range []struct {
  1303  			level    log.Level
  1304  			expected string
  1305  		}{
  1306  			{log.NONE, "level:NONE\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
  1307  			{log.DEBUG, "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
  1308  			{log.INFO, "level:INFO\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
  1309  			{log.WARN, "level:WARN\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
  1310  			{log.ERROR, "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
  1311  			{log.FATAL, "level:FATAL\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
  1312  			{log.PANIC, "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
  1313  		} {
  1314  			buf.Reset()
  1315  			logger := log.New(&buf, &log.LTSVFormatter{}, currentLevel).With(fields)
  1316  			logger.Output(v.level, msg)
  1317  			actual := buf.String()
  1318  			expected := v.expected
  1319  			if !reflect.DeepEqual(actual, expected) {
  1320  				t.Errorf(`log level => %v; logger.With(%#v).Output(%v, %#v) prints %#v; want %#v`, currentLevel, fields, v.level, msg, actual, expected)
  1321  			}
  1322  		}
  1323  	}
  1324  }
  1325  
  1326  func TestLogger_Level(t *testing.T) {
  1327  	for _, level := range []log.Level{
  1328  		log.NONE,
  1329  		log.DEBUG,
  1330  		log.INFO,
  1331  		log.WARN,
  1332  		log.ERROR,
  1333  		log.FATAL,
  1334  		log.PANIC,
  1335  	} {
  1336  		logger := log.New(ioutil.Discard, &log.LTSVFormatter{}, level)
  1337  		actual := logger.Level()
  1338  		expected := level
  1339  		if !reflect.DeepEqual(actual, expected) {
  1340  			t.Errorf(`log level => %v; logger.Level() => %v; want %v`, level, actual, expected)
  1341  		}
  1342  	}
  1343  }
  1344  
  1345  func TestLogger_SetLevel(t *testing.T) {
  1346  	now := time.Now()
  1347  	util.Now = func() time.Time { return now }
  1348  	defer func() { util.Now = time.Now }()
  1349  	var buf bytes.Buffer
  1350  	logger := log.New(&buf, &log.LTSVFormatter{}, log.DEBUG)
  1351  	var actual interface{} = logger.Level()
  1352  	var expected interface{} = log.DEBUG
  1353  	if !reflect.DeepEqual(actual, expected) {
  1354  		t.Errorf(`logger.Level() => %v; want %v`, actual, expected)
  1355  	}
  1356  	msg := "test log"
  1357  	logger.Debug(msg)
  1358  	actual = buf.String()
  1359  	expected = "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:" + msg + "\n"
  1360  	if !reflect.DeepEqual(actual, expected) {
  1361  		t.Errorf(`logger.Debug(%#v) prints %#v; want %#v`, msg, actual, expected)
  1362  	}
  1363  	logger.SetLevel(log.INFO)
  1364  	actual = logger.Level()
  1365  	expected = log.INFO
  1366  	if !reflect.DeepEqual(actual, expected) {
  1367  		t.Errorf(`After logger.SetLevel(%v); logger.Level() => %v; want %v`, log.INFO, actual, expected)
  1368  	}
  1369  	buf.Reset()
  1370  	logger.Debug(msg)
  1371  	actual = buf.String()
  1372  	expected = ""
  1373  	if !reflect.DeepEqual(actual, expected) {
  1374  		t.Errorf(`After logger.SetLevel(%v); logger.Debug(%#v) => %#v; want %#v`, log.INFO, msg, actual, expected)
  1375  	}
  1376  }
  1377  
  1378  func TestLevel_String(t *testing.T) {
  1379  	for _, v := range []struct {
  1380  		level          log.Level
  1381  		name, expected string
  1382  	}{
  1383  		{log.NONE, "NONE", "NONE"},
  1384  		{log.DEBUG, "DEBUG", "DEBUG"},
  1385  		{log.INFO, "INFO", "INFO"},
  1386  		{log.WARN, "WARN", "WARN"},
  1387  		{log.ERROR, "ERROR", "ERROR"},
  1388  		{log.FATAL, "FATAL", "FATAL"},
  1389  		{log.PANIC, "PANIC", "PANIC"},
  1390  	} {
  1391  		actual := v.level.String()
  1392  		expected := v.expected
  1393  		if !reflect.DeepEqual(actual, expected) {
  1394  			t.Errorf(`%v.String() => %#v; want %#v`, v.name, actual, expected)
  1395  		}
  1396  	}
  1397  }
  1398  
  1399  func TestFields_Get(t *testing.T) {
  1400  	fields := log.Fields{
  1401  		"first":  1,
  1402  		"second": "two",
  1403  		"third":  '3',
  1404  	}
  1405  	for _, v := range []struct {
  1406  		key      string
  1407  		expected interface{}
  1408  	}{
  1409  		{"first", 1},
  1410  		{"second", "two"},
  1411  		{"third", '3'},
  1412  		{"fourth", nil},
  1413  	} {
  1414  		var actual interface{} = fields.Get(v.key)
  1415  		var expected interface{} = v.expected
  1416  		if !reflect.DeepEqual(actual, expected) {
  1417  			t.Errorf(`Fields.Get(%#v) => %#v; want %#v`, v.key, actual, expected)
  1418  		}
  1419  	}
  1420  }
  1421  
  1422  func TestFields_OrderedKeys(t *testing.T) {
  1423  	fields := log.Fields{
  1424  		"second": 1,
  1425  		"first":  3,
  1426  		"ant":    4,
  1427  		"third":  2,
  1428  	}
  1429  	actual := fields.OrderedKeys()
  1430  	expected := []string{"ant", "first", "second", "third"}
  1431  	if !reflect.DeepEqual(actual, expected) {
  1432  		t.Errorf(`Fields.OrderedKeys() => %#v; want %#v`, actual, expected)
  1433  	}
  1434  }