Function TestContextWatcherStress

pgconn/ctxwatch/context_watcher_test.go:103–153

(t *testing.T)

}

func TestContextWatcherStress(t *testing.T) {
	var cancelFuncCalls atomic.Int64
	var cleanupFuncCalls atomic.Int64

	cw := ctxwatch.NewContextWatcher(&testHandler{
		handleCancel: func(context.Context) {
			cancelFuncCalls.Add(1)
		}, handleUnwatchAfterCancel: func() {
			cleanupFuncCalls.Add(1)
		},
	})

	cycleCount := 100_000

	for i := range cycleCount {
		ctx, cancel := context.WithCancel(context.Background())
		defer cancel() // satisfy linter; cancel is idempotent
		cw.Watch(ctx)
		if i%2 == 0 {
			cancel()
		}

		// Without time.Sleep, cw.Unwatch will almost always run before the cancel func which means cancel will never happen. This gives us a better mix.
		if i%333 == 0 {
			// on Windows Sleep takes more time than expected so we try to get here less frequently to avoid
			// the CI takes a long time
			time.Sleep(time.Nanosecond)
		}

		cw.Unwatch()
		if i%2 == 1 {
			cancel()
		}
	}

	actualCancelFuncCalls := cancelFuncCalls.Load()
	actualCleanupFuncCalls := cleanupFuncCalls.Load()

	if actualCancelFuncCalls == 0 {
		t.Fatal("actualCancelFuncCalls == 0")
	}

	maxCancelFuncCalls := int64(cycleCount) / 2
	if actualCancelFuncCalls > maxCancelFuncCalls {
		t.Errorf("cancel func calls should be no more than %d but was %d", actualCancelFuncCalls, maxCancelFuncCalls)
	}

	if actualCancelFuncCalls != actualCleanupFuncCalls {
		t.Errorf("cancel func calls (%d) should be equal to cleanup func calls (%d) but was not", actualCancelFuncCalls, actualCleanupFuncCalls)
	}
}

func BenchmarkContextWatcherUncancellable(b *testing.B) {
	cw := ctxwatch.NewContextWatcher(&testHandler{handleCancel: func(context.Context) {}, handleUnwatchAfterCancel: func() {}})