// 제네릭 스택 구현
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

// 사용 예시
intStack := Stack[int]{}
intStack.Push(1)
intStack.Push(2)
intStack.Push(3)

stringStack := Stack[string]{}
stringStack.Push("Hello")
stringStack.Push("World")

// Map 함수: 슬라이스의 각 요소를 변환
func Map[T, U any](slice []T, fn func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}

// Filter 함수: 조건에 맞는 요소만 필터링
func Filter[T any](slice []T, fn func(T) bool) []T {
    result := []T{}
    for _, v := range slice {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}

// Reduce 함수: 슬라이스를 하나의 값으로 축약
func Reduce[T, U any](slice []T, initial U, fn func(U, T) U) U {
    result := initial
    for _, v := range slice {
        result = fn(result, v)
    }
    return result
}

// 실전 활용 예시
numbers := []int{1, 2, 3, 4, 5}

// 각 숫자를 제곱
squared := Map(numbers, func(n int) int {
    return n * n
})
// 결과: [1, 4, 9, 16, 25]

// 짝수만 필터링
evens := Filter(numbers, func(n int) bool {
    return n%2 == 0
})
// 결과: [2, 4]

// 모든 숫자의 합
sum := Reduce(numbers, 0, func(acc, n int) int {
    return acc + n
})
// 결과: 15

import (
    "sync"
    "time"
)

type CacheItem[T any] struct {
    value      T
    expiration time.Time
}

type Cache[K comparable, V any] struct {
    items map[K]CacheItem[V]
    mu    sync.RWMutex
}

func NewCache[K comparable, V any]() *Cache[K, V] {
    return &Cache[K, V]{
        items: make(map[K]CacheItem[V]),
    }
}

func (c *Cache[K, V]) Set(key K, value V, duration time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    c.items[key] = CacheItem[V]{
        value:      value,
        expiration: time.Now().Add(duration),
    }
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    
    item, exists := c.items[key]
    if !exists {
        var zero V
        return zero, false
    }
    
    if time.Now().After(item.expiration) {
        var zero V
        return zero, false
    }
    
    return item.value, true
}

// 사용 예시
userCache := NewCache[int, string]()
userCache.Set(1, "Alice", 5*time.Minute)
userCache.Set(2, "Bob", 5*time.Minute)

if name, ok := userCache.Get(1); ok {
    fmt.Println("User found:", name)
}

productCache := NewCache[string, float64]()
productCache.Set("laptop", 999.99, 1*time.Hour)
productCache.Set("mouse", 29.99, 1*time.Hour)

package jsonutil

import (
    "encoding/json"
    "testing"
)

type User struct {
    ID       int    `json:"id"`
    Name     string `json:"name"`
    Email    string `json:"email"`
    Age      int    `json:"age"`
}

func FuzzJSONParsing(f *testing.F) {
    // 시드 코퍼스
    seeds := []string{
        `{"id":1,"name":"Alice","email":"alice@example.com","age":30}`,
        `{"id":2,"name":"Bob","email":"bob@example.com","age":25}`,
        `{}`,
        `{"id":0}`,
    }
    
    for _, seed := range seeds {
        f.Add([]byte(seed))
    }
    
    f.Fuzz(func(t *testing.T, data []byte) {
        var user User
        
        // 파싱이 패닉을 일으키지 않아야 함
        err := json.Unmarshal(data, &user)
        
        // 에러가 있어도 괜찮지만, 패닉은 안 됨
        if err != nil {
            return
        }
        
        // 재직렬화 테스트
        marshaled, err := json.Marshal(user)
        if err != nil {
            t.Errorf("Marshal failed: %v", err)
        }
        
        // 다시 파싱해서 일관성 확인
        var user2 User
        if err := json.Unmarshal(marshaled, &user2); err != nil {
            t.Errorf("Re-unmarshal failed: %v", err)
        }
        
        // 값이 같아야 함
        if user != user2 {
            t.Errorf("Mismatch: %+v vs %+v", user, user2)
        }
    })
}

package urlutil

import (
    "net/url"
    "testing"
)

func FuzzURLParsing(f *testing.F) {
    seeds := []string{
        "https://example.com/path?query=value",
        "http://localhost:8080",
        "ftp://files.example.com/file.txt",
        "mailto:user@example.com",
        "//example.com/path",
    }
    
    for _, seed := range seeds {
        f.Add(seed)
    }
    
    f.Fuzz(func(t *testing.T, rawURL string) {
        // 파싱이 패닉을 일으키지 않아야 함
        parsed, err := url.Parse(rawURL)
        if err != nil {
            return // 유효하지 않은 URL은 스킵
        }
        
        // 재직렬화 테스트
        serialized := parsed.String()
        
        // 다시 파싱
        reparsed, err := url.Parse(serialized)
        if err != nil {
            t.Errorf("Reparse failed for %q: %v", serialized, err)
            return
        }
        
        // 주요 필드 일관성 확인
        if parsed.Scheme != reparsed.Scheme {
            t.Errorf("Scheme mismatch: %q vs %q", parsed.Scheme, reparsed.Scheme)
        }
        if parsed.Host != reparsed.Host {
            t.Errorf("Host mismatch: %q vs %q", parsed.Host, reparsed.Host)
        }
    })
}

package cryptoutil

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "io"
    "testing"
)

func Encrypt(key, plaintext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    
    ciphertext := make([]byte, aes.BlockSize+len(plaintext))
    iv := ciphertext[:aes.BlockSize]
    
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        return nil, err
    }
    
    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)
    
    return ciphertext, nil
}

func Decrypt(key, ciphertext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    
    if len(ciphertext) < aes.BlockSize {
        return nil, errors.New("ciphertext too short")
    }
    
    iv := ciphertext[:aes.BlockSize]
    ciphertext = ciphertext[aes.BlockSize:]
    
    stream := cipher.NewCFBDecrypter(block, iv)
    stream.XORKeyStream(ciphertext, ciphertext)
    
    return ciphertext, nil
}

func FuzzEncryption(f *testing.F) {
    // 32바이트 키 (AES-256)
    key := make([]byte, 32)
    rand.Read(key)
    
    seeds := [][]byte{
        []byte("Hello, World!"),
        []byte(""),
        []byte("A"),
        make([]byte, 1024), // 큰 데이터
    }
    
    for _, seed := range seeds {
        f.Add(seed)
    }
    
    f.Fuzz(func(t *testing.T, plaintext []byte) {
        // 암호화
        ciphertext, err := Encrypt(key, plaintext)
        if err != nil {
            t.Errorf("Encrypt failed: %v", err)
            return
        }
        
        // 복호화
        decrypted, err := Decrypt(key, ciphertext)
        if err != nil {
            t.Errorf("Decrypt failed: %v", err)
            return
        }
        
        // 원본과 같아야 함
        if !bytes.Equal(plaintext, decrypted) {
            t.Errorf("Mismatch: original %d bytes, decrypted %d bytes",
                len(plaintext), len(decrypted))
        }
    })
}

package parser

import (
    "strings"
    "testing"
)

// 간단한 키-값 파서 예제
// 형식: "key1=value1;key2=value2"
func ParseKeyValue(input string) (map[string]string, error) {
    result := make(map[string]string)
    
    if input == "" {
        return result, nil
    }
    
    pairs := strings.Split(input, ";")
    for _, pair := range pairs {
        parts := strings.SplitN(pair, "=", 2)
        if len(parts) != 2 {
            return nil, errors.New("invalid format")
        }
        
        key := strings.TrimSpace(parts[0])
        value := strings.TrimSpace(parts[1])
        
        if key == "" {
            return nil, errors.New("empty key")
        }
        
        result[key] = value
    }
    
    return result, nil
}

func FuzzKeyValueParser(f *testing.F) {
    seeds := []string{
        "key1=value1;key2=value2",
        "name=Alice;age=30",
        "",
        "single=value",
        "key1=value1;key2=value2;key3=value3",
    }
    
    for _, seed := range seeds {
        f.Add(seed)
    }
    
    f.Fuzz(func(t *testing.T, input string) {
        // 파싱이 패닉을 일으키지 않아야 함
        result, err := ParseKeyValue(input)
        
        if err != nil {
            // 에러는 괜찮지만, 패닉은 안 됨
            return
        }
        
        // 파싱된 결과를 다시 문자열로 변환
        var parts []string
        for k, v := range result {
            parts = append(parts, k+"="+v)
        }
        reconstructed := strings.Join(parts, ";")
        
        // 다시 파싱
        result2, err := ParseKeyValue(reconstructed)
        if err != nil {
            t.Errorf("Reparse failed: %v", err)
            return
        }
        
        // 결과가 같아야 함
        if len(result) != len(result2) {
            t.Errorf("Length mismatch: %d vs %d", len(result), len(result2))
        }
        
        for k, v := range result {
            if v2, ok := result2[k]; !ok || v != v2 {
                t.Errorf("Value mismatch for key %q: %q vs %q", k, v, v2)
            }
        }
    })
}

// 제네릭 링크드 리스트
type Node[T any] struct {
    Value T
    Next  *Node[T]
}

type LinkedList[T any] struct {
    Head *Node[T]
    Size int
}

func (l *LinkedList[T]) Append(value T) {
    newNode := &Node[T]{Value: value}
    
    if l.Head == nil {
        l.Head = newNode
        l.Size = 1
        return
    }
    
    current := l.Head
    for current.Next != nil {
        current = current.Next
    }
    current.Next = newNode
    l.Size++
}

func (l *LinkedList[T]) Get(index int) (T, bool) {
    if index < 0 || index >= l.Size {
        var zero T
        return zero, false
    }
    
    current := l.Head
    for i := 0; i < index; i++ {
        current = current.Next
    }
    return current.Value, true
}

// 제네릭 링크드 리스트 Fuzzing!
func FuzzLinkedListInt(f *testing.F) {
    f.Add(5, 10)
    
    f.Fuzz(func(t *testing.T, count int, seed int) {
        if count < 0 || count > 1000 {
            return
        }
        
        list := &LinkedList[int]{}
        expected := make([]int, 0, count)
        
        // 랜덤 값 추가
        rng := rand.New(rand.NewSource(int64(seed)))
        for i := 0; i < count; i++ {
            value := rng.Int()
            list.Append(value)
            expected = append(expected, value)
        }
        
        // 크기 검증
        if list.Size != count {
            t.Errorf("Size mismatch: got %d, want %d", list.Size, count)
        }
        
        // 모든 값 검증
        for i := 0; i < count; i++ {
            got, ok := list.Get(i)
            if !ok {
                t.Errorf("Get(%d) failed", i)
            }
            if got != expected[i] {
                t.Errorf("Get(%d) = %d, want %d", i, got, expected[i])
            }
        }
        
        // 범위 밖 접근 검증
        if _, ok := list.Get(-1); ok {
            t.Error("Get(-1) should fail")
        }
        if _, ok := list.Get(count); ok {
            t.Errorf("Get(%d) should fail", count)
        }
    })
}

// 문자열 버전도 쉽게!
func FuzzLinkedListString(f *testing.F) {
    f.Add(5, "seed")
    
    f.Fuzz(func(t *testing.T, count int, prefix string) {
        if count < 0 || count > 100 {
            return
        }
        
        list := &LinkedList[string]{}
        expected := make([]string, 0, count)
        
        for i := 0; i < count; i++ {
            value := fmt.Sprintf("%s_%d", prefix, i)
            list.Append(value)
            expected = append(expected, value)
        }
        
        // 동일한 검증 로직...
        if list.Size != count {
            t.Errorf("Size mismatch: got %d, want %d", list.Size, count)
        }
        
        for i := 0; i < count; i++ {
            got, ok := list.Get(i)
            if !ok || got != expected[i] {
                t.Errorf("Get(%d) = %q, want %q", i, got, expected[i])
            }
        }
    })
}

// 제네릭 정렬 알고리즘
func QuickSort[T constraints.Ordered](arr []T) []T {
    if len(arr) <= 1 {
        return arr
    }
    
    pivot := arr[len(arr)/2]
    var left, middle, right []T
    
    for _, v := range arr {
        switch {
        case v < pivot:
            left = append(left, v)
        case v == pivot:
            middle = append(middle, v)
        case v > pivot:
            right = append(right, v)
        }
    }
    
    result := make([]T, 0, len(arr))
    result = append(result, QuickSort(left)...)
    result = append(result, middle...)
    result = append(result, QuickSort(right)...)
    
    return result
}

// 정렬 알고리즘 Fuzzing
func FuzzQuickSort(f *testing.F) {
    f.Add(10, int64(42))
    
    f.Fuzz(func(t *testing.T, size int, seed int64) {
        if size < 0 || size > 1000 {
            return
        }
        
        // 랜덤 슬라이스 생성
        rng := rand.New(rand.NewSource(seed))
        arr := make([]int, size)
        for i := range arr {
            arr[i] = rng.Intn(10000)
        }
        
        // 원본 복사
        original := make([]int, len(arr))
        copy(original, arr)
        
        // 정렬
        sorted := QuickSort(arr)
        
        // 검증 1: 길이가 같아야 함
        if len(sorted) != len(original) {
            t.Errorf("Length changed: %d -> %d", len(original), len(sorted))
        }
        
        // 검증 2: 정렬되어 있어야 함
        for i := 1; i < len(sorted); i++ {
            if sorted[i-1] > sorted[i] {
                t.Errorf("Not sorted at index %d: %d > %d",
                    i, sorted[i-1], sorted[i])
            }
        }
        
        // 검증 3: 같은 요소들을 포함해야 함
        originalMap := make(map[int]int)
        for _, v := range original {
            originalMap[v]++
        }
        
        sortedMap := make(map[int]int)
        for _, v := range sorted {
            sortedMap[v]++
        }
        
        for k, v := range originalMap {
            if sortedMap[k] != v {
                t.Errorf("Element count mismatch for %d: %d vs %d",
                    k, v, sortedMap[k])
            }
        }
    })
}

// 다양한 엣지 케이스를 시드로 추가
f.Add("")                    // 빈 문자열
f.Add("a")                   // 단일 문자
f.Add("안녕")                 // 유니코드
f.Add(strings.Repeat("x", 1000))  // 긴 문자열
f.Add("\x00\xff")            // 특수 바이트

f.Fuzz(func(t *testing.T, input string) {
    result := Process(input)
    
    // 불변 조건들
    if len(result) > len(input) * 2 {
        t.Error("Result too long")
    }
    
    if !utf8.ValidString(result) {
        t.Error("Invalid UTF-8 output")
    }
    
    // 역함수 테스트
    if reversed := Reverse(result); reversed != input {
        t.Error("Not reversible")
    }
})

# GitHub Actions 예제
name: Fuzz Testing
on: [push, pull_request]
jobs:
  fuzz:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-go@v4
        with:
          go-version: '1.21'
      - name: Run fuzz tests
        run: |
          go test -fuzz=. -fuzztime=30s ./...

// 작은 제네릭 함수는 인라이닝될 수 있도록
//go:inline
func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

// 제네릭 버전
func Sum[T Number](slice []T) T {
    var total T
    for _, v := range slice {
        total += v
    }
    return total
}

// 성능이 중요하면 특화 버전도 제공
func SumInt(slice []int) int {
    var total int
    // SIMD 최적화 가능
    for _, v := range slice {
        total += v
    }
    return total
}

// 나쁜 예: 매번 새로운 슬라이스 생성
func Filter[T any](slice []T, fn func(T) bool) []T {
    result := []T{}  // 용량 미지정
    for _, v := range slice {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}

// 좋은 예: 용량 미리 할당
func Filter[T any](slice []T, fn func(T) bool) []T {
    result := make([]T, 0, len(slice))  // 최대 용량 미리 할당
    for _, v := range slice {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}