//
// 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]])
//
// 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.
p func(format string, args ...interface{}) // print raw
pn func(format string, args ...interface{}) // print with indent and newline
}
func panicf(format string, args ...interface{}) {
panic(fmt.Sprintf(format, args...))
}
var buf bytes.Buffer
a.p = func(format string, args ...interface{}) {
_, err := fmt.Fprintf(&buf, format, args...)
}
a.pn = func(format string, args ...interface{}) {
a.p(format+"\n", args...)
}
p func(format string, args ...interface{}) // print raw
pn func(format string, args ...interface{}) // print with indent and newline
}
func panicf(format string, args ...interface{}) {
panic(fmt.Sprintf(format, args...))
}
var buf bytes.Buffer
a.p = func(format string, args ...interface{}) {
_, err := fmt.Fprintf(&buf, format, args...)
}
a.pn = func(format string, args ...interface{}) {
a.p(format+"\n", 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 {
// 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...))
func (d infoLogging) Printf(format string, args ...interface{}) {
if d {
log.Printf(format, args...)
func (d debugLogging) Printf(format string, args ...interface{}) {
if d {
debugLog.Printf(format, args...)
func (d errorLogging) Printf(format string, args ...interface{}) {
if d {
errorLog.Printf(format, args...)
func (d requestLogging) Printf(format string, args ...interface{}) {
if d {
//
// 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]])
//
func (check *checker) sprintf(format string, args ...interface{}) string {
for i, arg := range args {
}
return fmt.Sprintf(format, args...)
func (check *checker) trace(pos token.Pos, format string, args ...interface{}) {
strings.Repeat(". ", check.indent),
check.sprintf(format, args...),
// dump is only needed for debugging
func (check *checker) dump(format string, args ...interface{}) {
fmt.Println(check.sprintf(format, args...))
}
func (check *checker) errorf(pos token.Pos, format string, args ...interface{}) {
check.err(pos, check.sprintf(format, args...), false)
func (t *ginkgoTestingTProxy) Error(args ...interface{}) {
t.fail(fmt.Sprintln(args...), t.offset)
func (t *ginkgoTestingTProxy) Errorf(format string, args ...interface{}) {
t.fail(fmt.Sprintf(format, args...), t.offset)
}
func (t *ginkgoTestingTProxy) Fatalf(format string, args ...interface{}) {
t.fail(fmt.Sprintf(format, args...), t.offset)
}
func (t *ginkgoTestingTProxy) Logf(format string, args ...interface{}) {
fmt.Fprintf(t.writer, format, args...)
}
func (t *ginkgoTestingTProxy) Skipf(format string, args ...interface{}) {
func (c *context) logf(level, format string, args ...interface{}) {
log.Printf(level+": "+format, args...)
}
func (c *context) Debugf(format string, args ...interface{}) { c.logf("DEBUG", format, args...) }
func (c *context) Infof(format string, args ...interface{}) { c.logf("INFO", format, args...) }
func (c *context) Warningf(format string, args ...interface{}) { c.logf("WARNING", format, args...) }
func (c *context) Errorf(format string, args ...interface{}) { c.logf("ERROR", format, args...) }
func (c *context) Criticalf(format string, args ...interface{}) { c.logf("CRITICAL", format, args...) }
apiContentType: apiContentTypeValue,
apiDeadlineHeader: []string{strconv.FormatFloat(timeout.Seconds(), 'f', -1, 64)},
func (c *context) logf(level int64, format string, args ...interface{}) {
s := fmt.Sprintf(format, args...)
s = strings.TrimRight(s, "\n") // Remove any trailing newline characters.
func (c *context) Debugf(format string, args ...interface{}) { c.logf(0, format, args...) }
func (c *context) Infof(format string, args ...interface{}) { c.logf(1, format, args...) }
func (c *context) Warningf(format string, args ...interface{}) { c.logf(2, format, args...) }
func (c *context) Errorf(format string, args ...interface{}) { c.logf(3, format, args...) }
func (c *context) Criticalf(format string, args ...interface{}) { c.logf(4, format, args...) }
func (s *single) logf(level, format string, args ...interface{}) {
s.t.Logf(level+": "+format, args...)
}
func (s *single) Debugf(format string, args ...interface{}) { s.logf("DEBUG", format, args...) }
func (s *single) Infof(format string, args ...interface{}) { s.logf("INFO", format, args...) }
func (s *single) Warningf(format string, args ...interface{}) { s.logf("WARNING", format, args...) }
func (s *single) Errorf(format string, args ...interface{}) { s.logf("ERROR", format, args...) }
func (s *single) Criticalf(format string, args ...interface{}) { s.logf("CRITICAL", format, args...) }
func (*single) FullyQualifiedAppID() string { return "dev~fake-app" }
// Vet is a simple checker for static errors in Go source code.
// See doc.go for more information.
"shadow": triStateFlag("shadow", unset, "check for shadowed variables (experimental; must be set explicitly)"),
"structtags": triStateFlag("structtags", unset, "check that struct field tags have canonical format"),
func Usage() {
fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
fmt.Fprintf(os.Stderr, "\tvet [flags] files... # Must be a single package\n")
fmt.Fprintf(os.Stderr, "For more information run\n")
// identification and a newline, and exits.
func errorf(format string, args ...interface{}) {
fmt.Fprintf(os.Stderr, "vet: "+format+"\n", args...)
os.Exit(2)
// identification and a newline, but does not exit.
func warnf(format string, args ...interface{}) {
fmt.Fprintf(os.Stderr, "vet: "+format+"\n", args...)
setExit(1)