launchpad.net/gocheck@v0.0.0-20140225173054-000000000087/run_test.go (about)

     1  // These tests verify the test running logic.
     2  
     3  package gocheck_test
     4  
     5  import (
     6  	"errors"
     7  	. "launchpad.net/gocheck"
     8  	"sync"
     9  )
    10  
    11  var runnerS = Suite(&RunS{})
    12  
    13  type RunS struct{}
    14  
    15  func (s *RunS) TestCountSuite(c *C) {
    16  	suitesRun += 1
    17  }
    18  
    19  // -----------------------------------------------------------------------
    20  // Tests ensuring result counting works properly.
    21  
    22  func (s *RunS) TestSuccess(c *C) {
    23  	output := String{}
    24  	result := Run(&SuccessHelper{}, &RunConf{Output: &output})
    25  	c.Check(result.Succeeded, Equals, 1)
    26  	c.Check(result.Failed, Equals, 0)
    27  	c.Check(result.Skipped, Equals, 0)
    28  	c.Check(result.Panicked, Equals, 0)
    29  	c.Check(result.FixturePanicked, Equals, 0)
    30  	c.Check(result.Missed, Equals, 0)
    31  	c.Check(result.RunError, IsNil)
    32  }
    33  
    34  func (s *RunS) TestFailure(c *C) {
    35  	output := String{}
    36  	result := Run(&FailHelper{}, &RunConf{Output: &output})
    37  	c.Check(result.Succeeded, Equals, 0)
    38  	c.Check(result.Failed, Equals, 1)
    39  	c.Check(result.Skipped, Equals, 0)
    40  	c.Check(result.Panicked, Equals, 0)
    41  	c.Check(result.FixturePanicked, Equals, 0)
    42  	c.Check(result.Missed, Equals, 0)
    43  	c.Check(result.RunError, IsNil)
    44  }
    45  
    46  func (s *RunS) TestFixture(c *C) {
    47  	output := String{}
    48  	result := Run(&FixtureHelper{}, &RunConf{Output: &output})
    49  	c.Check(result.Succeeded, Equals, 2)
    50  	c.Check(result.Failed, Equals, 0)
    51  	c.Check(result.Skipped, Equals, 0)
    52  	c.Check(result.Panicked, Equals, 0)
    53  	c.Check(result.FixturePanicked, Equals, 0)
    54  	c.Check(result.Missed, Equals, 0)
    55  	c.Check(result.RunError, IsNil)
    56  }
    57  
    58  func (s *RunS) TestPanicOnTest(c *C) {
    59  	output := String{}
    60  	helper := &FixtureHelper{panicOn: "Test1"}
    61  	result := Run(helper, &RunConf{Output: &output})
    62  	c.Check(result.Succeeded, Equals, 1)
    63  	c.Check(result.Failed, Equals, 0)
    64  	c.Check(result.Skipped, Equals, 0)
    65  	c.Check(result.Panicked, Equals, 1)
    66  	c.Check(result.FixturePanicked, Equals, 0)
    67  	c.Check(result.Missed, Equals, 0)
    68  	c.Check(result.RunError, IsNil)
    69  }
    70  
    71  func (s *RunS) TestPanicOnSetUpTest(c *C) {
    72  	output := String{}
    73  	helper := &FixtureHelper{panicOn: "SetUpTest"}
    74  	result := Run(helper, &RunConf{Output: &output})
    75  	c.Check(result.Succeeded, Equals, 0)
    76  	c.Check(result.Failed, Equals, 0)
    77  	c.Check(result.Skipped, Equals, 0)
    78  	c.Check(result.Panicked, Equals, 0)
    79  	c.Check(result.FixturePanicked, Equals, 1)
    80  	c.Check(result.Missed, Equals, 2)
    81  	c.Check(result.RunError, IsNil)
    82  }
    83  
    84  func (s *RunS) TestPanicOnSetUpSuite(c *C) {
    85  	output := String{}
    86  	helper := &FixtureHelper{panicOn: "SetUpSuite"}
    87  	result := Run(helper, &RunConf{Output: &output})
    88  	c.Check(result.Succeeded, Equals, 0)
    89  	c.Check(result.Failed, Equals, 0)
    90  	c.Check(result.Skipped, Equals, 0)
    91  	c.Check(result.Panicked, Equals, 0)
    92  	c.Check(result.FixturePanicked, Equals, 1)
    93  	c.Check(result.Missed, Equals, 2)
    94  	c.Check(result.RunError, IsNil)
    95  }
    96  
    97  // -----------------------------------------------------------------------
    98  // Check result aggregation.
    99  
   100  func (s *RunS) TestAdd(c *C) {
   101  	result := &Result{
   102  		Succeeded:        1,
   103  		Skipped:          2,
   104  		Failed:           3,
   105  		Panicked:         4,
   106  		FixturePanicked:  5,
   107  		Missed:           6,
   108  		ExpectedFailures: 7,
   109  	}
   110  	result.Add(&Result{
   111  		Succeeded:        10,
   112  		Skipped:          20,
   113  		Failed:           30,
   114  		Panicked:         40,
   115  		FixturePanicked:  50,
   116  		Missed:           60,
   117  		ExpectedFailures: 70,
   118  	})
   119  	c.Check(result.Succeeded, Equals, 11)
   120  	c.Check(result.Skipped, Equals, 22)
   121  	c.Check(result.Failed, Equals, 33)
   122  	c.Check(result.Panicked, Equals, 44)
   123  	c.Check(result.FixturePanicked, Equals, 55)
   124  	c.Check(result.Missed, Equals, 66)
   125  	c.Check(result.ExpectedFailures, Equals, 77)
   126  	c.Check(result.RunError, IsNil)
   127  }
   128  
   129  // -----------------------------------------------------------------------
   130  // Check the Passed() method.
   131  
   132  func (s *RunS) TestPassed(c *C) {
   133  	c.Assert((&Result{}).Passed(), Equals, true)
   134  	c.Assert((&Result{Succeeded: 1}).Passed(), Equals, true)
   135  	c.Assert((&Result{Skipped: 1}).Passed(), Equals, true)
   136  	c.Assert((&Result{Failed: 1}).Passed(), Equals, false)
   137  	c.Assert((&Result{Panicked: 1}).Passed(), Equals, false)
   138  	c.Assert((&Result{FixturePanicked: 1}).Passed(), Equals, false)
   139  	c.Assert((&Result{Missed: 1}).Passed(), Equals, false)
   140  	c.Assert((&Result{RunError: errors.New("!")}).Passed(), Equals, false)
   141  }
   142  
   143  // -----------------------------------------------------------------------
   144  // Check that result printing is working correctly.
   145  
   146  func (s *RunS) TestPrintSuccess(c *C) {
   147  	result := &Result{Succeeded: 5}
   148  	c.Check(result.String(), Equals, "OK: 5 passed")
   149  }
   150  
   151  func (s *RunS) TestPrintFailure(c *C) {
   152  	result := &Result{Failed: 5}
   153  	c.Check(result.String(), Equals, "OOPS: 0 passed, 5 FAILED")
   154  }
   155  
   156  func (s *RunS) TestPrintSkipped(c *C) {
   157  	result := &Result{Skipped: 5}
   158  	c.Check(result.String(), Equals, "OK: 0 passed, 5 skipped")
   159  }
   160  
   161  func (s *RunS) TestPrintExpectedFailures(c *C) {
   162  	result := &Result{ExpectedFailures: 5}
   163  	c.Check(result.String(), Equals, "OK: 0 passed, 5 expected failures")
   164  }
   165  
   166  func (s *RunS) TestPrintPanicked(c *C) {
   167  	result := &Result{Panicked: 5}
   168  	c.Check(result.String(), Equals, "OOPS: 0 passed, 5 PANICKED")
   169  }
   170  
   171  func (s *RunS) TestPrintFixturePanicked(c *C) {
   172  	result := &Result{FixturePanicked: 5}
   173  	c.Check(result.String(), Equals, "OOPS: 0 passed, 5 FIXTURE-PANICKED")
   174  }
   175  
   176  func (s *RunS) TestPrintMissed(c *C) {
   177  	result := &Result{Missed: 5}
   178  	c.Check(result.String(), Equals, "OOPS: 0 passed, 5 MISSED")
   179  }
   180  
   181  func (s *RunS) TestPrintAll(c *C) {
   182  	result := &Result{Succeeded: 1, Skipped: 2, ExpectedFailures: 3,
   183  		Panicked: 4, FixturePanicked: 5, Missed: 6}
   184  	c.Check(result.String(), Equals,
   185  		"OOPS: 1 passed, 2 skipped, 3 expected failures, 4 PANICKED, "+
   186  			"5 FIXTURE-PANICKED, 6 MISSED")
   187  }
   188  
   189  func (s *RunS) TestPrintRunError(c *C) {
   190  	result := &Result{Succeeded: 1, Failed: 1,
   191  		RunError: errors.New("Kaboom!")}
   192  	c.Check(result.String(), Equals, "ERROR: Kaboom!")
   193  }
   194  
   195  // -----------------------------------------------------------------------
   196  // Verify that the method pattern flag works correctly.
   197  
   198  func (s *RunS) TestFilterTestName(c *C) {
   199  	helper := FixtureHelper{}
   200  	output := String{}
   201  	runConf := RunConf{Output: &output, Filter: "Test[91]"}
   202  	Run(&helper, &runConf)
   203  	c.Check(helper.calls[0], Equals, "SetUpSuite")
   204  	c.Check(helper.calls[1], Equals, "SetUpTest")
   205  	c.Check(helper.calls[2], Equals, "Test1")
   206  	c.Check(helper.calls[3], Equals, "TearDownTest")
   207  	c.Check(helper.calls[4], Equals, "TearDownSuite")
   208  	c.Check(len(helper.calls), Equals, 5)
   209  }
   210  
   211  func (s *RunS) TestFilterTestNameWithAll(c *C) {
   212  	helper := FixtureHelper{}
   213  	output := String{}
   214  	runConf := RunConf{Output: &output, Filter: ".*"}
   215  	Run(&helper, &runConf)
   216  	c.Check(helper.calls[0], Equals, "SetUpSuite")
   217  	c.Check(helper.calls[1], Equals, "SetUpTest")
   218  	c.Check(helper.calls[2], Equals, "Test1")
   219  	c.Check(helper.calls[3], Equals, "TearDownTest")
   220  	c.Check(helper.calls[4], Equals, "SetUpTest")
   221  	c.Check(helper.calls[5], Equals, "Test2")
   222  	c.Check(helper.calls[6], Equals, "TearDownTest")
   223  	c.Check(helper.calls[7], Equals, "TearDownSuite")
   224  	c.Check(len(helper.calls), Equals, 8)
   225  }
   226  
   227  func (s *RunS) TestFilterSuiteName(c *C) {
   228  	helper := FixtureHelper{}
   229  	output := String{}
   230  	runConf := RunConf{Output: &output, Filter: "FixtureHelper"}
   231  	Run(&helper, &runConf)
   232  	c.Check(helper.calls[0], Equals, "SetUpSuite")
   233  	c.Check(helper.calls[1], Equals, "SetUpTest")
   234  	c.Check(helper.calls[2], Equals, "Test1")
   235  	c.Check(helper.calls[3], Equals, "TearDownTest")
   236  	c.Check(helper.calls[4], Equals, "SetUpTest")
   237  	c.Check(helper.calls[5], Equals, "Test2")
   238  	c.Check(helper.calls[6], Equals, "TearDownTest")
   239  	c.Check(helper.calls[7], Equals, "TearDownSuite")
   240  	c.Check(len(helper.calls), Equals, 8)
   241  }
   242  
   243  func (s *RunS) TestFilterSuiteNameAndTestName(c *C) {
   244  	helper := FixtureHelper{}
   245  	output := String{}
   246  	runConf := RunConf{Output: &output, Filter: "FixtureHelper\\.Test2"}
   247  	Run(&helper, &runConf)
   248  	c.Check(helper.calls[0], Equals, "SetUpSuite")
   249  	c.Check(helper.calls[1], Equals, "SetUpTest")
   250  	c.Check(helper.calls[2], Equals, "Test2")
   251  	c.Check(helper.calls[3], Equals, "TearDownTest")
   252  	c.Check(helper.calls[4], Equals, "TearDownSuite")
   253  	c.Check(len(helper.calls), Equals, 5)
   254  }
   255  
   256  func (s *RunS) TestFilterAllOut(c *C) {
   257  	helper := FixtureHelper{}
   258  	output := String{}
   259  	runConf := RunConf{Output: &output, Filter: "NotFound"}
   260  	Run(&helper, &runConf)
   261  	c.Check(len(helper.calls), Equals, 0)
   262  }
   263  
   264  func (s *RunS) TestRequirePartialMatch(c *C) {
   265  	helper := FixtureHelper{}
   266  	output := String{}
   267  	runConf := RunConf{Output: &output, Filter: "est"}
   268  	Run(&helper, &runConf)
   269  	c.Check(len(helper.calls), Equals, 8)
   270  }
   271  
   272  func (s *RunS) TestFilterError(c *C) {
   273  	helper := FixtureHelper{}
   274  	output := String{}
   275  	runConf := RunConf{Output: &output, Filter: "]["}
   276  	result := Run(&helper, &runConf)
   277  	c.Check(result.String(), Equals,
   278  		"ERROR: Bad filter expression: error parsing regexp: missing closing ]: `[`")
   279  	c.Check(len(helper.calls), Equals, 0)
   280  }
   281  
   282  // -----------------------------------------------------------------------
   283  // Verify that List works correctly.
   284  
   285  func (s *RunS) TestListFiltered(c *C) {
   286  	names := List(&FixtureHelper{}, &RunConf{Filter: "1"})
   287  	c.Assert(names, DeepEquals, []string{
   288  		"FixtureHelper.Test1",
   289  	})
   290  }
   291  
   292  func (s *RunS) TestList(c *C) {
   293  	names := List(&FixtureHelper{}, &RunConf{})
   294  	c.Assert(names, DeepEquals, []string{
   295  		"FixtureHelper.Test1",
   296  		"FixtureHelper.Test2",
   297  	})
   298  }
   299  
   300  // -----------------------------------------------------------------------
   301  // Verify that verbose mode prints tests which pass as well.
   302  
   303  func (s *RunS) TestVerboseMode(c *C) {
   304  	helper := FixtureHelper{}
   305  	output := String{}
   306  	runConf := RunConf{Output: &output, Verbose: true}
   307  	Run(&helper, &runConf)
   308  
   309  	expected := "PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Test1\t *[.0-9]+s\n" +
   310  		"PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Test2\t *[.0-9]+s\n"
   311  
   312  	c.Assert(output.value, Matches, expected)
   313  }
   314  
   315  func (s *RunS) TestVerboseModeWithFailBeforePass(c *C) {
   316  	helper := FixtureHelper{panicOn: "Test1"}
   317  	output := String{}
   318  	runConf := RunConf{Output: &output, Verbose: true}
   319  	Run(&helper, &runConf)
   320  
   321  	expected := "(?s).*PANIC.*\n-+\n" + // Should have an extra line.
   322  		"PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Test2\t *[.0-9]+s\n"
   323  
   324  	c.Assert(output.value, Matches, expected)
   325  }
   326  
   327  // -----------------------------------------------------------------------
   328  // Verify the stream output mode.  In this mode there's no output caching.
   329  
   330  type StreamHelper struct {
   331  	l2 sync.Mutex
   332  	l3 sync.Mutex
   333  }
   334  
   335  func (s *StreamHelper) SetUpSuite(c *C) {
   336  	c.Log("0")
   337  }
   338  
   339  func (s *StreamHelper) Test1(c *C) {
   340  	c.Log("1")
   341  	s.l2.Lock()
   342  	s.l3.Lock()
   343  	go func() {
   344  		s.l2.Lock() // Wait for "2".
   345  		c.Log("3")
   346  		s.l3.Unlock()
   347  	}()
   348  }
   349  
   350  func (s *StreamHelper) Test2(c *C) {
   351  	c.Log("2")
   352  	s.l2.Unlock()
   353  	s.l3.Lock() // Wait for "3".
   354  	c.Fail()
   355  	c.Log("4")
   356  }
   357  
   358  func (s *RunS) TestStreamMode(c *C) {
   359  	helper := &StreamHelper{}
   360  	output := String{}
   361  	runConf := RunConf{Output: &output, Stream: true}
   362  	Run(helper, &runConf)
   363  
   364  	expected := "START: run_test\\.go:[0-9]+: StreamHelper\\.SetUpSuite\n0\n" +
   365  		"PASS: run_test\\.go:[0-9]+: StreamHelper\\.SetUpSuite\t *[.0-9]+s\n\n" +
   366  		"START: run_test\\.go:[0-9]+: StreamHelper\\.Test1\n1\n" +
   367  		"PASS: run_test\\.go:[0-9]+: StreamHelper\\.Test1\t *[.0-9]+s\n\n" +
   368  		"START: run_test\\.go:[0-9]+: StreamHelper\\.Test2\n2\n3\n4\n" +
   369  		"FAIL: run_test\\.go:[0-9]+: StreamHelper\\.Test2\n\n"
   370  
   371  	c.Assert(output.value, Matches, expected)
   372  }
   373  
   374  type StreamMissHelper struct{}
   375  
   376  func (s *StreamMissHelper) SetUpSuite(c *C) {
   377  	c.Log("0")
   378  	c.Fail()
   379  }
   380  
   381  func (s *StreamMissHelper) Test1(c *C) {
   382  	c.Log("1")
   383  }
   384  
   385  func (s *RunS) TestStreamModeWithMiss(c *C) {
   386  	helper := &StreamMissHelper{}
   387  	output := String{}
   388  	runConf := RunConf{Output: &output, Stream: true}
   389  	Run(helper, &runConf)
   390  
   391  	expected := "START: run_test\\.go:[0-9]+: StreamMissHelper\\.SetUpSuite\n0\n" +
   392  		"FAIL: run_test\\.go:[0-9]+: StreamMissHelper\\.SetUpSuite\n\n" +
   393  		"START: run_test\\.go:[0-9]+: StreamMissHelper\\.Test1\n" +
   394  		"MISS: run_test\\.go:[0-9]+: StreamMissHelper\\.Test1\n\n"
   395  
   396  	c.Assert(output.value, Matches, expected)
   397  }