all goroutines are asleep - deadlock, on a buffered channel, do not understand why

I want to only create certain number of go routines, say 5, but I can receive variable number of jobs.

Here is my code that attempts to do it and the test is below it.

package main

import (
	"context"
	"fmt"
	"runtime"
	"time"
)

func doWork(size int, capacity int) int {
	start := time.Now()
	jobs := make(chan *Job, capacity)
	results := make(chan *Job, capacity)
	sem := make(chan struct{}, capacity)
	go chanWorker(jobs, results, sem)
	for i := 0; i < size; i++ {
		jobs <- &Job{id: i}
	}
	close(jobs)
	successCount := 0
	for i := 0; i < size; i++ {
		item := <-results
		if item.result {
			successCount++
		}
		fmt.Printf("Job %d completed %v\n", item.id, item.result)
	}
	close(results)
	close(sem)
	fmt.Printf("Time taken to execute %d jobs with %d capacity = %v\n", size, capacity, time.Since(start))
	return successCount
}

func chanWorker(jobs <-chan *Job, results chan<- *Job, sem chan struct{}) {

	for item := range jobs {
		it := item
		sem <- struct{}{}
		fmt.Printf("Job %d started\n", it.id)
		go func() {
			timeOutCtx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond)
			defer cancel()
			time.Sleep(time.Duration(it.id) * 100 * time.Millisecond)
			select {
			case <-timeOutCtx.Done():
				fmt.Printf("Job %d timed out\n", it.id)
				it.result = false
				results <- it
				<-sem
				return
			default:
				fmt.Printf("Total number of routines %d\n", runtime.NumGoroutine())
				it.result = true
				results <- it
				<-sem
			}
		}()
	}
}

The test for this

package main

import (
	"testing"
)

func Test_doWork(t *testing.T) {
	type args struct {
		size     int
		capacity int
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		{
			name: "jobs 10 capacity 5",
			args: args{
				size:     10,
				capacity: 5,
			},
			want: 3,
		},
		{
			name: "jobs 100 capacity 5",
			args: args{
				size:     100,
				capacity: 5,
			},
			want: 3,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := doWork(tt.args.size, tt.args.capacity); got < tt.want {
				t.Errorf("doWork() = %v, want %v", got, tt.want)
			}
		})
	}
}

The test jobs 10 capacity 5 works, but jobs 100 capacity 5 fails.

If I make capacity 50 for 100 jobs, it works, doesn't work for 30 and cannot understand the behavior.

Here is how I understood of channels and expected it tow work.

A buffered channel will block if its full, until there is some free capacity available. I expected that as soon as the jobs channel is full, it will block until chanWorker frees some of it. The chanWorker itself receives a capacity and makes use of empty struct to ensure no more than 5 worker is created.

Why should I ever get an error
fatal error: all goroutines are asleep - deadlock! ?

Because the main goroutine does not receive values from results until all jobs are sent to jobs, the workers block on send to results. The main goroutine blocks sending to jobs because the works are blocked. Deadlock!

Fix by using goroutine to feed the work.

go func() {
for i := 0; i < size; i++ {
jobs <- &Job{id: i}
}
close(jobs)
}()

https://go.dev/play/p/WlbPRfxngRV