Go Testing

module bhylu.example/parcel-lab

go 1.22

package main

import (
	"bhylu.example/parcel-lab/internal/locker"
	"fmt"
)

func main() {
	desk := locker.Desk{Capacity: 5}
	for _, n := range []int{2, 0, 4, 3} {
		err := desk.Add(n)
		fmt.Println(err == nil, desk.Used)
	}
	fmt.Println("free", desk.Capacity-desk.Used)
}

package locker

import (
	"fmt"
	"strconv"
	"strings"
	"sync"
)

type Desk struct{ Capacity, Used int }

func (d *Desk) Add(n int) error {
	if d == nil || d.Capacity < 0 || d.Used < 0 || d.Used > d.Capacity {
		return fmt.Errorf("invalid state")
	}
	if n <= 0 || n > d.Capacity-d.Used {
		return fmt.Errorf("request does not fit")
	}
	d.Used += n
	return nil
}
func ParseCount(raw string) (int, error) {
	raw = strings.TrimSpace(raw)
	if len(raw) == 0 || len(raw) > 3 {
		return 0, fmt.Errorf("count length")
	}
	for _, ch := range raw {
		if ch < '0' || ch > '9' {
			return 0, fmt.Errorf("digits only")
		}
	}
	n, err := strconv.Atoi(raw)
	if err != nil || n > 100 {
		return 0, fmt.Errorf("count range")
	}
	return n, nil
}

type SafeDesk struct {
	mu   sync.Mutex
	desk Desk
}

func NewSafeDesk(capacity int) (*SafeDesk, error) {
	if capacity < 0 {
		return nil, fmt.Errorf("invalid capacity")
	}
	return &SafeDesk{desk: Desk{Capacity: capacity}}, nil
}
func (d *SafeDesk) Add(n int) error { d.mu.Lock(); defer d.mu.Unlock(); return d.desk.Add(n) }
func (d *SafeDesk) Used() int       { d.mu.Lock(); defer d.mu.Unlock(); return d.desk.Used }

package locker

import (
	"strings"
	"sync"
	"testing"
)

func TestAddBoundaries(t *testing.T) {
	max := int(^uint(0) >> 1)
	cases := []struct {
		cap, used, n, want int
		ok                 bool
	}{{5, 0, 2, 2, true}, {5, 2, 0, 2, false}, {5, 2, -1, 2, false}, {5, 2, 4, 2, false}, {5, 2, 3, 5, true}, {0, 0, 1, 0, false}, {-1, 0, 1, 0, false}, {5, 6, 1, 6, false}, {5, -1, 1, -1, false}, {max, max - 1, 2, max - 1, false}, {max, max - 1, 1, max, true}}
	for _, c := range cases {
		d := Desk{c.cap, c.used}
		err := d.Add(c.n)
		if (err == nil) != c.ok || d.Used != c.want {
			t.Fatalf("fixture %+v: used=%d err=%v", c, d.Used, err)
		}
	}
	var absent *Desk
	if absent.Add(1) == nil {
		t.Fatal("nil accepted")
	}
}
func TestSequenceModel(t *testing.T) {
	for capacity := 0; capacity < 12; capacity++ {
		d := Desk{Capacity: capacity}
		want := 0
		for _, n := range []int{1, 2, -1, 0, 4, 1, 9, 1} {
			ok := n > 0 && n <= capacity-want
			if ok {
				want += n
			}
			err := d.Add(n)
			if (err == nil) != ok || d.Used != want {
				t.Fatalf("capacity=%d n=%d used=%d want=%d", capacity, n, d.Used, want)
			}
		}
	}
}
func TestParseCount(t *testing.T) {
	for _, c := range []struct {
		raw  string
		want int
		ok   bool
	}{{"0", 0, true}, {" 17 ", 17, true}, {"100", 100, true}, {"101", 0, false}, {"-1", 0, false}, {"2.5", 0, false}, {"", 0, false}, {"1x", 0, false}, {"999999999999999999", 0, false}, {"１", 0, false}} {
		got, err := ParseCount(c.raw)
		if (err == nil) != c.ok || got != c.want {
			t.Fatalf("%q got=%d err=%v", c.raw, got, err)
		}
	}
}
func TestConcurrentLimit(t *testing.T) {
	for round := 0; round < 20; round++ {
		d, err := NewSafeDesk(7)
		if err != nil {
			t.Fatal(err)
		}
		var wg sync.WaitGroup
		out := make(chan bool, 40)
		for i := 0; i < 40; i++ {
			wg.Add(1)
			go func() { defer wg.Done(); out <- d.Add(1) == nil }()
		}
		wg.Wait()
		close(out)
		accepted := 0
		for ok := range out {
			if ok {
				accepted++
			}
		}
		if accepted != 7 || d.Used() != 7 {
			t.Fatalf("accepted=%d used=%d", accepted, d.Used())
		}
	}
	if _, err := NewSafeDesk(-1); err == nil {
		t.Fatal("negative capacity accepted")
	}
}
func FuzzParse(f *testing.F) {
	for _, seed := range []string{"0", "17", "-1", "bad", "101", ""} {
		f.Add(seed)
	}
	f.Fuzz(func(t *testing.T, raw string) {
		got, err := ParseCount(raw)
		if err != nil {
			return
		}
		if got < 0 || got > 100 {
			t.Fatalf("outside range: %d", got)
		}
		trimmed := strings.TrimSpace(raw)
		if len(trimmed) < 1 || len(trimmed) > 3 {
			t.Fatal("length")
		}
		want := 0
		for _, b := range []byte(trimmed) {
			if b < '0' || b > '9' {
				t.Fatal("non-digit")
			}
			want = want*10 + int(b-'0')
		}
		if got != want {
			t.Fatalf("got=%d want=%d", got, want)
		}
	})
}

var benchmarkText string

func BenchmarkJoin(b *testing.B) {
	names := []string{"P-81", "P-82", "P-83"}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		benchmarkText = strings.Join(names, ",")
	}
}