Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package log

// These tests are too simple.

import (
        "bytes"
        "os"
        "regexp"
        "testing"
)

const (
        Rdate         = `[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9]`
        Rtime         = `[0-9][0-9]:[0-9][0-9]:[0-9][0-9]`
        Rmicroseconds = `\.[0-9][0-9][0-9][0-9][0-9][0-9]`
        Rline         = `[0-9]+:` // must update if the calls to l.Printf / l.Print below move
        Rlongfile     = `.*/[A-Za-z0-9_\-]+\.go:|\?\?\?:` + Rline
        Rshortfile    = `[A-Za-z0-9_\-]+\.go:|\?\?\?:` + Rline
)

type tester struct {
        flag    int
        prefix  string
        pattern string // regexp that log output must match; we add ^ and expected_text$ always
}

var tests = []tester{
        // individual pieces:
        {0, "", ""},
        {0, "XXX", "XXX"},
        {Ldate, "", Rdate + " "},
        {Ltime, "", Rtime + " "},
        {Ltime | Lmicroseconds, "", Rtime + Rmicroseconds + " "},
        {Lmicroseconds, "", Rtime + Rmicroseconds + " "}, // microsec implies time
        {Llongfile, "", Rlongfile + " "},
        {Lshortfile, "", Rshortfile + " "},
        {Llongfile | Lshortfile, "", Rshortfile + " "}, // shortfile overrides longfile
        // everything at once:
        {Ldate | Ltime | Lmicroseconds | Llongfile, "XXX", "XXX" + Rdate + " " + Rtime + Rmicroseconds + " " + Rlongfile + " "},
        {Ldate | Ltime | Lmicroseconds | Lshortfile, "XXX", "XXX" + Rdate + " " + Rtime + Rmicroseconds + " " + Rshortfile + " "},
}

// Test using Println("hello", 23, "world") or using Printf("hello %d world", 23)
func testPrint(t *testing.T, flag int, prefix string, pattern string, useFormat bool) {
        buf := new(bytes.Buffer)
        SetOutput(buf)
        SetFlags(flag)
        SetPrefix(prefix)
        if useFormat {
                Printf("hello %d world", 23)
        } else {
                Println("hello", 23, "world")
        }
        line := buf.String()
        line = line[0 : len(line)-1]
        pattern = "^" + pattern + "hello 23 world$"
        matched, err4 := regexp.MatchString(pattern, line)
        if err4 != nil {
                t.Fatal("pattern did not compile:", err4)
        }
        if !matched {
                t.Errorf("log output should match %q is %q", pattern, line)
        }
        SetOutput(os.Stderr)
}

func TestAll(t *testing.T) {
        for _, testcase := range tests {
                testPrint(t, testcase.flag, testcase.prefix, testcase.pattern, false)
                testPrint(t, testcase.flag, testcase.prefix, testcase.pattern, true)
        }
}

func TestOutput(t *testing.T) {
        const testString = "test"
        var b bytes.Buffer
        l := New(&b, "", 0)
        l.Println(testString)
        if expect := testString + "\n"; b.String() != expect {
                t.Errorf("log output should match %q is %q", expect, b.String())
        }
}

func TestFlagAndPrefixSetting(t *testing.T) {
        var b bytes.Buffer
        l := New(&b, "Test:", LstdFlags)
        f := l.Flags()
        if f != LstdFlags {
                t.Errorf("Flags 1: expected %x got %x", LstdFlags, f)
        }
        l.SetFlags(f | Lmicroseconds)
        f = l.Flags()
        if f != LstdFlags|Lmicroseconds {
                t.Errorf("Flags 2: expected %x got %x", LstdFlags|Lmicroseconds, f)
        }
        p := l.Prefix()
        if p != "Test:" {
                t.Errorf(`Prefix: expected "Test:" got %q`, p)
        }
        l.SetPrefix("Reality:")
        p = l.Prefix()
        if p != "Reality:" {
                t.Errorf(`Prefix: expected "Reality:" got %q`, p)
        }
        // Verify a log message looks right, with our prefix and microseconds present.
        l.Print("hello")
        pattern := "^Reality:" + Rdate + " " + Rtime + Rmicroseconds + " hello\n"
        matched, err := regexp.Match(pattern, b.Bytes())
        if err != nil {
                t.Fatalf("pattern %q did not compile: %s", pattern, err)
        }
        if !matched {
                t.Error("message did not match pattern")
        }
}