//
// 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]])
//
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 {
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...))
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...)
}
// 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...)
}
//
// 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
/*
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 (check *checker) printTrace(format string, args []interface{}) {
fmt.Print(dots[0:i])
fmt.Println(check.formatMsg(format, args))
func (check *checker) trace(pos token.Pos, format string, args ...interface{}) {
check.pos = append(check.pos, pos)
check.printTrace(format, args)
func (check *checker) untrace(format string, args ...interface{}) {
if len(format) > 0 {
check.printTrace(format, args)
}
func (check *checker) formatMsg(format string, args []interface{}) string {
for i, arg := range args {
func (check *checker) printTrace(format string, args []interface{}) {
fmt.Print(dots[0:i])
fmt.Println(check.formatMsg(format, args))
func (check *checker) trace(pos token.Pos, format string, args ...interface{}) {
check.pos = append(check.pos, pos)
check.printTrace(format, args)
func (check *checker) untrace(format string, args ...interface{}) {
if len(format) > 0 {
check.printTrace(format, args)
}
func (check *checker) formatMsg(format string, args []interface{}) string {
for i, arg := range args {
func (check *checker) printTrace(format string, args []interface{}) {
fmt.Print(dots[0:i])
fmt.Println(check.formatMsg(format, args))
func (check *checker) trace(pos token.Pos, format string, args ...interface{}) {
check.pos = append(check.pos, pos)
check.printTrace(format, args)
func (check *checker) untrace(format string, args ...interface{}) {
if len(format) > 0 {
check.printTrace(format, args)
}
func (check *checker) formatMsg(format string, args []interface{}) string {
for i, arg := range args {
// Send a message to a User
func (self *Server) SendLine(user *User, format string, args ...interface{}) {
if local := user.Local(); local != nil {
line := fmt.Sprintf(format, args...)
self.SendNode(user.Server, ":%s PUSH %s :%s",
self.Id, user.Id, fmt.Sprintf(format, args...))
// Send a message to a User, sourced by another User
func (self *Server) Send(source *User, target *User, format string, args ...interface{}) {
self.SendLine(target, ":%s %s", src, fmt.Sprintf(format, args...))
// Send a message to a User with the server as source
func (self *Server) SendServer(user *User, format string, args ...interface{}) {
self.Send(nil, user, format, args...)
}
// Send a message to all local Users
func (self *Server) SendAll(source *User, format string, args ...interface{}) {
for _, user := range self.LocalUsers {
func (c *compiler) printValues(println_ bool, values ...Value) Value {
var args []llvm.Value = nil
if len(values) > 0 {
format := ""
args = make([]llvm.Value, 0, len(values)+1)
for i, value := range values {
if println_ && i > 0 {
format += " "
case types.Uint8:
format += "%hhu"
case types.Uint16:
format += "%hu"
case types.Uint32:
format += "%u"
case types.Uintptr, types.Uint: