* Returns a byte array */
func formatArgs(args [][]byte) []byte {
// * args count \r\n
n := 1 + intlen(len(args)) + 2
for i := 0; i < len(args); i++ {
n += arglen(args[i])
}
* Returns a byte array */
func format(args ...interface{}) []byte {
buf := make([][]byte, len(args))
for i, arg := range args {
return formatArgs(buf)
func NewUnmarshalError(n *Node, t reflect.Type, format string, args ...interface{}) *UnmarshalError {
Node: n,
message: fmt.Sprintf(format, args...),
func (e *UnmarshalError) Error() string {
args := []interface{}{e.message}
format := "%s"
if e.Node != nil {
if e.Node.IsList() {
format += " (list value)"
} else {
return fmt.Sprintf(format, args...)
func (n *Node) unmarshal_error(t reflect.Type, format string, args ...interface{}) {
panic(NewUnmarshalError(n, t, fmt.Sprintf(format, args...)))
}
func Infof(format string, args ...interface{}) {
defer file.Close()
New(file).Printf(format, args...)
func Infoln(args ...interface{}) {
defer file.Close()
New(file).Println(args...)
func Errorf(format string, args ...interface{}) {
defer file.Close()
New(file).Printf(format, args...)
func Errorln(args ...interface{}) {
defer file.Close()
New(file).Println(args...)
// SetFormatter sets the standard logger formatter.
func SetFormatter(formatter Formatter) {
std.mu.Lock()
defer std.mu.Unlock()
std.Formatter = formatter
// Debug logs a message at level Debug on the standard logger.
func Debug(args ...interface{}) {
std.Debug(args...)
}
// Print logs a message at level Info on the standard logger.
func Print(args ...interface{}) {
std.Print(args...)
}
// Info logs a message at level Info on the standard logger.
func Info(args ...interface{}) {
std.Info(args...)
Hooks LevelHooks
// All log entries pass through the formatter before logged to Out. The
// included formatters are `TextFormatter` and `JSONFormatter` for which
func (logger *Logger) Debugf(format string, args ...interface{}) {
if logger.Level >= DebugLevel {
NewEntry(logger).Debugf(format, args...)
func (logger *Logger) Infof(format string, args ...interface{}) {
if logger.Level >= InfoLevel {
NewEntry(logger).Infof(format, args...)
func (logger *Logger) Printf(format string, args ...interface{}) {
NewEntry(logger).Printf(format, args...)
}
Hooks LevelHooks
// All log entries pass through the formatter before logged to Out. The
// included formatters are `TextFormatter` and `JSONFormatter` for which
func (logger *Logger) Debugf(format string, args ...interface{}) {
if logger.Level >= DebugLevel {
NewEntry(logger).Debugf(format, args...)
func (logger *Logger) Infof(format string, args ...interface{}) {
if logger.Level >= InfoLevel {
NewEntry(logger).Infof(format, args...)
func (logger *Logger) Printf(format string, args ...interface{}) {
NewEntry(logger).Printf(format, args...)
}
// SetFormatter sets the standard logger formatter.
func SetFormatter(formatter Formatter) {
std.mu.Lock()
defer std.mu.Unlock()
std.Formatter = formatter
// Debug logs a message at level Debug on the standard logger.
func Debug(args ...interface{}) {
std.Debug(args...)
}
// Print logs a message at level Info on the standard logger.
func Print(args ...interface{}) {
std.Print(args...)
}
// Info logs a message at level Info on the standard logger.
func Info(args ...interface{}) {
std.Info(args...)
// Returns a reader for the entry, which is a proxy to the formatter.
func (entry *Entry) Reader() (*bytes.Buffer, error) {
if entry.Logger.Level >= InfoLevel {
entry.log(InfoLevel, fmt.Sprint(args...))
func (entry *Entry) Warn(args ...interface{}) {
if entry.Logger.Level >= WarnLevel {
entry.log(WarnLevel, fmt.Sprint(args...))
func (entry *Entry) Warning(args ...interface{}) {
entry.Warn(args...)
}
func (entry *Entry) Error(args ...interface{}) {
if entry.Logger.Level >= ErrorLevel {
entry.log(ErrorLevel, fmt.Sprint(args...))
// and records the text as a log message at Debug level.
Debugf(format string, args ...interface{})
// Infof is like Debugf, but at Info level.
Infof(format string, args ...interface{})
// Warningf is like Debugf, but at Warning level.
Warningf(format string, args ...interface{})
// Errorf is like Debugf, but at Error level.
Errorf(format string, args ...interface{})
// Criticalf is like Debugf, but at Critical level.
Criticalf(format string, args ...interface{})
func (l *writerLog) Debugf(format string, args ...interface{}) {
l.output("DEBUG: " + fmt.Sprintf(format, args...))
}
func (l *writerLog) Infof(format string, args ...interface{}) {
l.output("INFO: " + fmt.Sprintf(format, args...))
//
// assert.Equal(t, expected, actual [, message [, format-args])
//
// assert.NotEqual(t, notExpected, actual [, message [, format-args]])
//
// assert.True(t, actualBool [, message [, format-args]])
//
// assert.False(t, actualBool [, message [, format-args]])
//
// assert.Nil(t, actualObject [, message [, format-args]])
//
// assert.NotNil(t, actualObject [, message [, format-args]])
//
// assert.Empty(t, actualObject [, message [, format-args]])
//
// Govet is a simple checker for static errors in Go source code.
// See doc.go for more information.
// identification and a newline
func errorf(format string, args ...interface{}) {
fmt.Fprintf(os.Stderr, "govet: "+format+"\n", args...)
setExit(2)
// Println is fmt.Println guarded by -v.
func Println(args ...interface{}) {
// Printf is fmt.Printf guarded by -v.
func Printf(format string, args ...interface{}) {
}
fmt.Printf(format+"\n", args...)
// Badf reports a formatted error and sets the exit code.
func (f *File) Badf(pos token.Pos, format string, args ...interface{}) {
f.Warnf(pos, format, args...)
Hooks levelHooks
// All log entries pass through the formatter before logged to Out. The
// included formatters are `TextFormatter` and `JSONFormatter` for which
func (logger *Logger) Debugf(format string, args ...interface{}) {
NewEntry(logger).Debugf(format, args...)
}
func (logger *Logger) Infof(format string, args ...interface{}) {
NewEntry(logger).Infof(format, args...)
}
func (logger *Logger) Printf(format string, args ...interface{}) {
NewEntry(logger).Printf(format, args...)
}
func (entry *Entry) Reader() (*bytes.Buffer, error) {
serialized, err := entry.Logger.Formatter.Format(entry)
func (entry *Entry) Debug(args ...interface{}) {
if entry.Logger.Level >= Debug {
entry.log("debug", Debug, fmt.Sprint(args...))
func (entry *Entry) Print(args ...interface{}) {
entry.Info(args...)
}
func (entry *Entry) Info(args ...interface{}) {
if entry.Logger.Level >= Info {
entry.log("info", Info, fmt.Sprint(args...))
func (entry *Entry) Warn(args ...interface{}) {
if entry.Logger.Level >= Warn {
// Package glog implements logging analogous to the Google-internal C++ INFO/ERROR/V setup.
// It provides functions Info, Warning, Error, Fatal, plus formatting variants such as
/*
header formats a log header as defined by the C++ implementation.
It returns a buffer containing the formatted header.
// Avoid Fprintf, for speed. The format is so simple that we can do it quickly by hand.
// twoDigits formats a zero-prefixed two-digit integer at buf.tmp[i].
// someDigits formats a zero-prefixed variable-width integer at buf.tmp[i].
func (l *loggingT) printf(s severity, format string, args ...interface{}) {
buf := l.header(s)
fmt.Fprintf(buf, format, args...)
//
// require.Equal(t, expected, actual [, message [, format-args])
//
// require.NotEqual(t, notExpected, actual [, message [, format-args]])
//
// require.True(t, actualBool [, message [, format-args]])
//
// require.False(t, actualBool [, message [, format-args]])
//
// require.Nil(t, actualObject [, message [, format-args]])
//
// require.NotNil(t, actualObject [, message [, format-args]])
//
// require.Empty(t, actualObject [, message [, format-args]])
//
func (entry *Entry) Reader() (*bytes.Buffer, error) {
serialized, err := entry.Logger.Formatter.Format(entry)
func (entry *Entry) Debug(args ...interface{}) {
if entry.Logger.Level >= Debug {
entry.log("debug", Debug, fmt.Sprint(args...))
func (entry *Entry) Print(args ...interface{}) {
entry.Info(args...)
}
func (entry *Entry) Info(args ...interface{}) {
if entry.Logger.Level >= Info {
entry.log("info", Info, fmt.Sprint(args...))
func (entry *Entry) Warn(args ...interface{}) {
if entry.Logger.Level >= Warn {
// Package glog implements logging analogous to the Google-internal C++ INFO/ERROR/V setup.
// It provides functions Info, Warning, Error, Fatal, plus formatting variants such as
func (s *severity) String() string {
return strconv.FormatInt(int64(*s), 10)
/*
header formats a log header as defined by the C++ implementation.
It returns a buffer containing the formatted header and the user's file and line number.
The depth specifies how many stack frames above lives the source line to be identified in the log message.
}
return l.formatHeader(s, file, line), file, line
// formatHeader formats a log header using the provided file name and line number.
func (l *loggingT) formatHeader(s severity, file string, line int) *buffer {
now := timeNow()
// Avoid Fprintf, for speed. The format is so simple that we can do it quickly by hand.
// SetFormatter sets the standard logger formatter.
func SetFormatter(formatter Formatter) {
std.mu.Lock()
defer std.mu.Unlock()
std.Formatter = formatter
// Debug logs a message at level Debug on the standard logger.
func Debug(args ...interface{}) {
std.Debug(args...)
}
// Print logs a message at level Info on the standard logger.
func Print(args ...interface{}) {
std.Print(args...)
}
// Info logs a message at level Info on the standard logger.
func Info(args ...interface{}) {
std.Info(args...)
Hooks levelHooks
// All log entries pass through the formatter before logged to Out. The
// included formatters are `TextFormatter` and `JSONFormatter` for which
func (logger *Logger) Debugf(format string, args ...interface{}) {
NewEntry(logger).Debugf(format, args...)
}
func (logger *Logger) Infof(format string, args ...interface{}) {
NewEntry(logger).Infof(format, args...)
}
func (logger *Logger) Printf(format string, args ...interface{}) {
NewEntry(logger).Printf(format, args...)
}
// Returns a reader for the entry, which is a proxy to the formatter.
func (entry *Entry) Reader() (*bytes.Buffer, error) {
serialized, err := entry.Logger.Formatter.Format(entry)
// Returns the string representation from the reader and ultimately the
// formatter.
func (entry *Entry) Debug(args ...interface{}) {
if entry.Logger.Level >= DebugLevel {
func (entry *Entry) Error(args ...interface{}) {
if entry.Logger.Level >= ErrorLevel {
entry.log(ErrorLevel, fmt.Sprint(args...))
func (entry *Entry) Fatal(args ...interface{}) {
if entry.Logger.Level >= FatalLevel {
entry.log(FatalLevel, fmt.Sprint(args...))