b.StopTimer()
		fset := token.NewFileSet()
		file, err := ParseFile(fset, "", src, SkipObjectResolution)
		if err != nil {
			b.Fatalf("benchmark failed due to parse error: %s", err)
		}
		b.StartTimer()
		handle := fset.File(file.Package)
		resolveFile(file, handle, nil)
	}

	N         int
	benchmark InternalBenchmark
	bytes     int64
	timerOn   bool
	result    BenchmarkResult
}

// StartTimer starts timing a test. This function is called automatically
// before a benchmark starts, but it can also used to resume timing after
// a call to StopTimer.
func (b *B) StartTimer() {
	if !b.timerOn {
		b.start = time.Now()
		b.timerOn = true
	}
}

package runtime_test

import (
	"runtime"
	"sync"
	"testing"
)

var wg sync.WaitGroup

func init() {
	runtime.NetpollGenericInit()
}

func BenchmarkNetpollBreak(b *testing.B) {
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		for j := 0; j < 10; j++ {
			wg.Add(1)
			go func() {
				runtime.NetpollBreak()
				wg.Done()
			}()
		}
	}
	wg.Wait()
	b.StopTimer()

	func (b *B) ResetTimer()

	// SetBytes records the number of bytes processed in a single ...
	func (b *B) SetBytes(n int64)

	// StartTimer starts timing a test. This function is called ...
	func (b *B) StartTimer()

	// StopTimer stops timing a test. This can be used to pause the ...
	func (b *B) StopTimer()

	// The results of a benchmark run. 
	type BenchmarkResult struct {

	func (b *B) ResetTimer()

	// SetBytes records the number of bytes processed in a single ...
	func (b *B) SetBytes(n int64)

	// StartTimer starts timing a test. This function is called ...
	func (b *B) StartTimer()

	// StopTimer stops timing a test. This can be used to pause the ...
	func (b *B) StopTimer()

	// The results of a benchmark run. 
	type BenchmarkResult struct {

-- go.mod --
module m

go 1.16
-- bench_test.go --
package testlist

import (
	"fmt"
	"testing"
)

func BenchmarkSimplefunc(b *testing.B) {
	b.StopTimer()
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		_ = fmt.Sprint("Test for bench")
	}
}
-- example_test.go --
package testlist

import (
	"fmt"
)

func ExampleSimple() {
	fmt.Println("Test with Output.")

  se->get_event_status = GetEventStatus;
  se->record_event = RecordEvent;
  se->wait_for_event = WaitForEvent;
  se->create_timer = CreateTimer;
  se->destroy_timer = DestroyTimer;
  se->start_timer = StartTimer;
  se->stop_timer = StopTimer;
  se->memcpy_dtoh = MemcpyDToH;
  se->memcpy_htod = MemcpyHToD;
  se->sync_memcpy_dtoh = SyncMemcpyDToH;
  se->sync_memcpy_htod = SyncMemcpyHToD;

        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Evaluating {} using {}.", project, scriptSource.getDisplayName());
        }

        final Timer clock = Time.startTimer();
        try {
            final ScriptPlugin configurer = configurerFactory.create(scriptSource, project.getBuildscript(), project.getClassLoaderScope(), project.getBaseClassLoaderScope(), true);

    }

    @Override
    public TaskExecuterResult execute(final TaskInternal task, TaskStateInternal state, final TaskExecutionContext context) {
        Timer clock = Time.startTimer();
        TaskExecutionMode taskExecutionMode = executionModeResolver.getExecutionMode(task, context.getTaskProperties());
        context.setTaskExecutionMode(taskExecutionMode);

	b.StopTimer()
	var r = rand.New(rand.NewSource(1234))
	aa := randInt(r, aSize)
	bb := randInt(r, bSize)
	var x, y *Int
	if calcXY {
		x = new(Int)
		y = new(Int)
	}
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		new(Int).GCD(x, y, aa, bb)
	}
}

func BenchmarkGCD10x10(b *testing.B)         { runGCD(b, 10, 10) }
func BenchmarkGCD10x100(b *testing.B)        { runGCD(b, 10, 100) }