// These tests check that the foundations of gocheck are working properly.
// They already assume that fundamental failing is working already, though,
// since this was tested in bootstrap_test.go. Even then, some care may
// still have to be taken when using external functions, since they should
// of course not rely on functionality tested here.

package gocheck_test

import (
    "gocheck"
    gocheck_local "gocheck/local"
    "strings"
    "regexp"
    "fmt"
)


// -----------------------------------------------------------------------
// Foundation test suite.

type FoundationS struct{}

var foundationS = gocheck.Suite(&FoundationS{})

func (s *FoundationS) TestCountSuite(c *gocheck.C) {
    suitesRun += 1
}

func (s *FoundationS) TestErrorf(c *gocheck.C) {
    // Do not use checkState() here.  It depends on Errorf() working.
    expectedLog := fmt.Sprintf("foundation_test.go:%d:\n" +
                               "... Error: Error message!\n", getMyLine()+1)
    c.Errorf("Error %v!", "message")
    failed := c.Failed()
    c.Succeed()
    if log := c.GetTestLog(); log != expectedLog {
        c.Logf("Errorf() logged %#v rather than %#v", log, expectedLog)
        c.Fail()
    }
    if !failed {
        c.Logf("Errorf() didn't put the test in a failed state")
        c.Fail()
    }
}

func (s *FoundationS) TestError(c *gocheck.C) {
    expectedLog := fmt.Sprintf("foundation_test.go:%d:\n" +
                               "... Error: Error message!\n", getMyLine()+1)
    c.Error("Error ", "message!")
    checkState(c, nil,
               &expectedState{
                    name: "Error(`Error `, `message!`)",
                    failed: true,
                    log: expectedLog,
               })
}

func (s *FoundationS) TestFailNow(c *gocheck.C) {
    defer (func() {
        if !c.Failed() {
            c.Error("FailNow() didn't fail the test")
        } else {
            c.Succeed()
            if c.GetTestLog() != "" {
                c.Error("Something got logged:\n" + c.GetTestLog())
            }
        }
    })()

    c.FailNow()
    c.Log("FailNow() didn't stop the test")
}

func (s *FoundationS) TestSucceedNow(c *gocheck.C) {
    defer (func() {
        if c.Failed() {
            c.Error("SucceedNow() didn't succeed the test")
        }
        if c.GetTestLog() != "" {
            c.Error("Something got logged:\n" + c.GetTestLog())
        }
    })()

    c.Fail()
    c.SucceedNow()
    c.Log("SucceedNow() didn't stop the test")
}

func (s *FoundationS) TestFailureHeader(c *gocheck.C) {
    output := String{}
    failHelper := FailHelper{}
    gocheck.Run(&failHelper, &gocheck.RunConf{Output: &output})
    header := fmt.Sprintf(
        "\n-----------------------------------" +
        "-----------------------------------\n" +
        "FAIL: gocheck_test.go:%d: FailHelper.TestLogAndFail\n",
        failHelper.testLine)
    if strings.Index(output.value, header) == -1 {
        c.Errorf("Failure didn't print a proper header.\n" +
                 "... Got:\n%s... Expected something with:\n%s",
                 output.value, header)
    }
}

func (s *FoundationS) TestFatal(c *gocheck.C) {
    var line int
    defer (func() {
        if !c.Failed() {
            c.Error("Fatal() didn't fail the test")
        } else {
            c.Succeed()
            expected := fmt.Sprintf("foundation_test.go:%d:\n" +
                                    "... Error: Die now!\n", line)
            if c.GetTestLog() != expected {
                c.Error("Incorrect log:\n" + c.GetTestLog())
            }
        }
    })()

    line = getMyLine()+1
    c.Fatal("Die ", "now!")
    c.Log("Fatal() didn't stop the test")
}

func (s *FoundationS) TestFatalf(c *gocheck.C) {
    var line int
    defer (func() {
        if !c.Failed() {
            c.Error("Fatalf() didn't fail the test")
        } else {
            c.Succeed()
            expected := fmt.Sprintf("foundation_test.go:%d:\n" +
                                    "... Error: Die now!\n", line)
            if c.GetTestLog() != expected {
                c.Error("Incorrect log:\n" + c.GetTestLog())
            }
        }
    })()

    line = getMyLine()+1
    c.Fatalf("Die %s!", "now")
    c.Log("Fatalf() didn't stop the test")
}


func (s *FoundationS) TestCallerLoggingInsideTest(c *gocheck.C) {
    log := fmt.Sprintf(
        "foundation_test.go:%d:\n" +
        "\\.\\.\\. Check\\(obtained, Equals, expected\\):\n" +
        "\\.\\.\\. Obtained \\(int\\): 10\n" +
        "\\.\\.\\. Expected \\(int\\): 20\n\n",
        getMyLine()+1)
    result := c.Check(10, gocheck_local.Equals, 20)
    checkState(c, result,
               &expectedState{
                    name: "Check(10, Equals, 20)",
                    result: false,
                    failed: true,
                    log: log,
               })
}

func (s *FoundationS) TestCallerLoggingInDifferentFile(c *gocheck.C) {
    result, line := checkEqualWrapper(c, 10, 20)
    testLine := getMyLine()-1
    log := fmt.Sprintf(
        "foundation_test.go:%d > gocheck_test.go:%d:\n" +
        "\\.\\.\\. Check\\(obtained, Equals, expected\\):\n" +
        "\\.\\.\\. Obtained \\(int\\): 10\n" +
        "\\.\\.\\. Expected \\(int\\): 20\n\n",
        testLine, line)
    checkState(c, result,
               &expectedState{
                    name: "Check(10, Equals, 20)",
                    result: false,
                    failed: true,
                    log: log,
               })
}

// -----------------------------------------------------------------------
// ExpectFailure() inverts the logic of failure.

type ExpectFailureHelper struct{}

func (s *ExpectFailureHelper) TestFail(c *gocheck.C) {
    c.ExpectFailure("It booms!")
    c.Error("Boom!")
}

func (s *ExpectFailureHelper) TestSucceed(c *gocheck.C) {
    c.ExpectFailure("Bug #XYZ")
}

func (s *FoundationS) TestExpectFailure(c *gocheck.C) {
    helper := ExpectFailureHelper{}
    output := String{}
    gocheck.Run(&helper, &gocheck.RunConf{Output: &output})

    expected :=
        "^\n-+\n" +
        "FAIL: foundation_test\\.go:[0-9]+:" +
        " ExpectFailureHelper\\.TestSucceed\n\n" +
        "\\.\\.\\. Error: Test succeeded, but was expected to fail\n" +
        "\\.\\.\\. Reason: Bug #XYZ\n$"

    matched, err := regexp.MatchString(expected, output.value)
    if err != nil {
        c.Error("Bad expression: ", expected)
    } else if !matched {
        c.Error("ExpectFailure() didn't log properly:\n", output.value)
    }
}


// -----------------------------------------------------------------------
// Ensure that suites with embedded types are working fine, including the
// the workaround for issue 906.

type EmbeddedInternalS struct {
    called bool
}

type EmbeddedS struct {
    EmbeddedInternalS
}

var embeddedS = gocheck.Suite(&EmbeddedS{})

func (s *EmbeddedS) TestCountSuite(c *gocheck.C) {
    suitesRun += 1
}

func (s *EmbeddedInternalS) TestMethod(c *gocheck.C) {
    c.Error("TestMethod() of the embedded type was called!?")
}

func (s *EmbeddedS) TestMethod(c *gocheck.C) {
    // http://code.google.com/p/go/issues/detail?id=906
    c.Check(s.called, gocheck_local.Equals, false,
            gocheck_local.Bug("The bug described in issue 906 is " +
                              "affecting the runner"))
    s.called = true
}