github.com/april1989/origin-go-tools@v0.0.32/cmd/cover/testdata/main.go (about)

     1  // Copyright 2013 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Test runner for coverage test. This file is not coverage-annotated; test.go is.
     6  // It knows the coverage counter is called "coverTest".
     7  
     8  package main
     9  
    10  import (
    11  	"fmt"
    12  	"os"
    13  )
    14  
    15  func main() {
    16  	testAll()
    17  	verify()
    18  }
    19  
    20  type block struct {
    21  	count uint32
    22  	line  uint32
    23  }
    24  
    25  var counters = make(map[block]bool)
    26  
    27  // check records the location and expected value for a counter.
    28  func check(line, count uint32) {
    29  	b := block{
    30  		count,
    31  		line,
    32  	}
    33  	counters[b] = true
    34  }
    35  
    36  // checkVal is a version of check that returns its extra argument,
    37  // so it can be used in conditionals.
    38  func checkVal(line, count uint32, val int) int {
    39  	b := block{
    40  		count,
    41  		line,
    42  	}
    43  	counters[b] = true
    44  	return val
    45  }
    46  
    47  var PASS = true
    48  
    49  // verify checks the expected counts against the actual. It runs after the test has completed.
    50  func verify() {
    51  	for b := range counters {
    52  		got, index := count(b.line)
    53  		if b.count == anything && got != 0 {
    54  			got = anything
    55  		}
    56  		if got != b.count {
    57  			fmt.Fprintf(os.Stderr, "test_go:%d expected count %d got %d [counter %d]\n", b.line, b.count, got, index)
    58  			PASS = false
    59  		}
    60  	}
    61  	verifyPanic()
    62  	if !PASS {
    63  		fmt.Fprintf(os.Stderr, "FAIL\n")
    64  		os.Exit(2)
    65  	}
    66  }
    67  
    68  // verifyPanic is a special check for the known counter that should be
    69  // after the panic call in testPanic.
    70  func verifyPanic() {
    71  	if coverTest.Count[panicIndex-1] != 1 {
    72  		// Sanity check for test before panic.
    73  		fmt.Fprintf(os.Stderr, "bad before panic")
    74  		PASS = false
    75  	}
    76  	if coverTest.Count[panicIndex] != 0 {
    77  		fmt.Fprintf(os.Stderr, "bad at panic: %d should be 0\n", coverTest.Count[panicIndex])
    78  		PASS = false
    79  	}
    80  	if coverTest.Count[panicIndex+1] != 1 {
    81  		fmt.Fprintf(os.Stderr, "bad after panic")
    82  		PASS = false
    83  	}
    84  }
    85  
    86  // count returns the count and index for the counter at the specified line.
    87  func count(line uint32) (uint32, int) {
    88  	// Linear search is fine. Choose perfect fit over approximate.
    89  	// We can have a closing brace for a range on the same line as a condition for an "else if"
    90  	// and we don't want that brace to steal the count for the condition on the "if".
    91  	// Therefore we test for a perfect (lo==line && hi==line) match, but if we can't
    92  	// find that we take the first imperfect match.
    93  	index := -1
    94  	indexLo := uint32(1e9)
    95  	for i := range coverTest.Count {
    96  		lo, hi := coverTest.Pos[3*i], coverTest.Pos[3*i+1]
    97  		if lo == line && line == hi {
    98  			return coverTest.Count[i], i
    99  		}
   100  		// Choose the earliest match (the counters are in unpredictable order).
   101  		if lo <= line && line <= hi && indexLo > lo {
   102  			index = i
   103  			indexLo = lo
   104  		}
   105  	}
   106  	if index == -1 {
   107  		fmt.Fprintln(os.Stderr, "cover_test: no counter for line", line)
   108  		PASS = false
   109  		return 0, 0
   110  	}
   111  	return coverTest.Count[index], index
   112  }