golang.org/x/sync v0.21.0: semaphore.NewWeighted

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify golang.org/x/sync/semaphore.NewWeighted in pkg:golang/golang.org/x/sync@v0.21.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/sync@v0.21.0
Demonstrate these symbols/APIs:
  - golang.org/x/sync/semaphore.NewWeighted

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:46baa04bb1a3f210581fa7e6fb824c30d55dc6a3a90efec7ecd1c4ae6fe3c593","contract":["semaphore.NewWeighted returns a new Weighted semaphore initialized with the given capacity","Weighted.TryAcquire acquires available weight immediately and returns false when capacity is exceeded","Weighted.Release restores capacity so subsequent TryAcquire can succeed","Weighted.Acquire blocks until weight is available or returns error when context is canceled","Weighted.Acquire with zero or valid weight succeeds when capacity is available"],"goal":"verify golang.org/x/sync/semaphore.NewWeighted in pkg:golang/golang.org/x/sync@v0.21.0","kind":"HOW","packages":["pkg:golang/golang.org/x/sync@v0.21.0"],"schemaVersion":1,"symbols":["golang.org/x/sync/semaphore.NewWeighted"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/golang.org/x/sync@v0.21.0"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/sync@v0.21.0","symbols":["golang.org/x/sync/semaphore.NewWeighted"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require golang.org/x/sync v0.21.0

golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=

package main

import (
	"context"
	"fmt"
	"sync"
	"time"

	"golang.org/x/sync/semaphore"
)

func main() {
	ctx := context.Background()
	sem := semaphore.NewWeighted(2)

	var wg sync.WaitGroup
	for i := 1; i <= 4; i++ {
		wg.Add(1)
		workerID := i
		go func() {
			defer wg.Done()
			if err := sem.Acquire(ctx, 1); err != nil {
				fmt.Printf("Worker %d failed to acquire: %v\n", workerID, err)
				return
			}
			defer sem.Release(1)

			fmt.Printf("Worker %d acquired permit\n", workerID)
			time.Sleep(10 * time.Millisecond)
		}()
	}

	wg.Wait()

	if sem.TryAcquire(2) {
		fmt.Println("Successfully acquired full capacity with TryAcquire")
		sem.Release(2)
	}
}

{
  "schemaVersion": 1,
  "goal": "verify golang.org/x/sync/semaphore.NewWeighted in pkg:golang/golang.org/x/sync@v0.21.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/sync@v0.21.0"
  ],
  "symbols": [
    "golang.org/x/sync/semaphore.NewWeighted"
  ]
}

package main

import (
	"context"
	"errors"
	"fmt"
	"os"
	"time"

	"golang.org/x/sync/semaphore"
)

func main() {
	if err := runTests(); err != nil {
		fmt.Fprintf(os.Stderr, "Contract test failed: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("All contract assertions passed.")
}

func runTests() error {
	// Assertion 1: semaphore.NewWeighted returns a new Weighted semaphore initialized with the given capacity
	{
		sem := semaphore.NewWeighted(3)
		if sem == nil {
			return errors.New("semaphore.NewWeighted returned nil")
		}
	}

	// Assertion 2: Weighted.TryAcquire acquires available weight immediately and returns false when capacity is exceeded
	{
		sem := semaphore.NewWeighted(2)
		if !sem.TryAcquire(1) {
			return errors.New("TryAcquire(1) should have succeeded")
		}
		if !sem.TryAcquire(1) {
			return errors.New("second TryAcquire(1) should have succeeded")
		}
		if sem.TryAcquire(1) {
			return errors.New("third TryAcquire(1) should have failed when capacity is 2")
		}
		if sem.TryAcquire(2) {
			return errors.New("TryAcquire(2) should have failed when capacity is exhausted")
		}
	}

	// Assertion 3: Weighted.Release restores capacity so subsequent TryAcquire can succeed
	{
		sem := semaphore.NewWeighted(2)
		if !sem.TryAcquire(2) {
			return errors.New("initial TryAcquire(2) should have succeeded")
		}
		if sem.TryAcquire(1) {
			return errors.New("TryAcquire(1) should fail when all weight is acquired")
		}
		sem.Release(1)
		if !sem.TryAcquire(1) {
			return errors.New("TryAcquire(1) should succeed after Release(1)")
		}
		sem.Release(2)
		if !sem.TryAcquire(2) {
			return errors.New("TryAcquire(2) should succeed after full Release")
		}
	}

	// Assertion 4: Weighted.Acquire blocks until weight is available or returns error when context is canceled
	{
		sem := semaphore.NewWeighted(1)
		if !sem.TryAcquire(1) {
			return errors.New("setup TryAcquire failed")
		}

		ctx, cancel := context.WithCancel(context.Background())
		cancel()

		err := sem.Acquire(ctx, 1)
		if !errors.Is(err, context.Canceled) {
			return fmt.Errorf("expected context.Canceled, got %v", err)
		}

		sem.Release(1)
		ctx2 := context.Background()
		if err := sem.Acquire(ctx2, 1); err != nil {
			return fmt.Errorf("Acquire should succeed after release: %w", err)
		}
		sem.Release(1)
	}

	// Assertion 5: Weighted.Acquire with zero or valid weight succeeds when capacity is available
	{
		sem := semaphore.NewWeighted(5)
		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
		defer cancel()

		if err := sem.Acquire(ctx, 0); err != nil {
			return fmt.Errorf("Acquire(0) failed: %w", err)
		}
		if err := sem.Acquire(ctx, 5); err != nil {
			return fmt.Errorf("Acquire(5) failed: %w", err)
		}
		sem.Release(5)
	}

	return nil
}