myapp/
├── math.go
└── math_test.go

func TestXxx(t *testing.T) {
    // منطق الاختبار
}

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2, 3) = %d، المتوقع 5", result)
    }
}

# تشغيل جميع الاختبارات في الحزمة الحالية
go test

# مخرجات مفصلة
go test -v

# تشغيل اختبارات مطابقة للاسم
go test -run TestAdd

# تشغيل في المجلد الحالي والمجلدات الفرعية
go test ./...

# عرض التغطية
go test -cover

calculator/
├── calc.go
└── calc_test.go

package calculator

// Add تعيد مجموع عددين
func Add(a, b int) int {
    return a + b
}

// Divide تعيد حاصل القسمة وما إذا كان هناك خطأ
func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("المقسوم عليه لا يمكن أن يكون صفراً")
    }
    return a / b, nil
}

package calculator

import (
    "testing"
)

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    want := 5
    if got != want {
        t.Errorf("Add(2, 3) = %d، المتوقع %d", got, want)
    }
}

func TestDivide(t *testing.T) {
    got, err := Divide(10, 3)
    if err != nil {
        t.Fatalf("خطأ غير متوقع: %v", err)
    }
    want := 3.3333333333333335
    if got != want {
        t.Errorf("Divide(10, 3) = %f، المتوقع %f", got, want)
    }
}

func TestDivideByZero(t *testing.T) {
    _, err := Divide(10, 0)
    if err == nil {
        t.Error("القسمة على صفر يجب أن تُرجع خطأ")
    }
}

$ go test -v
=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
=== RUN   TestDivide
--- PASS: TestDivide (0.00s)
=== RUN   TestDivideByZero
--- PASS: TestDivideByZero (0.00s)
PASS
ok      calculator      0.003s

package stringutil

import "unicode"

// Reverse تعكس نصاً
func Reverse(s string) string {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

// IsPalindrome تتحقق مما إذا كان نصاً معكوساً (palindrome)
func IsPalindrome(s string) bool {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        if unicode.ToLower(runes[i]) != unicode.ToLower(runes[j]) {
            return false
        }
    }
    return true
}

package stringutil

import "testing"

func TestReverse(t *testing.T) {
    // تعريف جدول حالات الاختبار
    tests := []struct {
        name  string // اسم الحالة
        input string
        want  string
    }{
        {"نص فارغ", "", ""},
        {"حرف واحد", "a", "a"},
        {"نص عادي", "hello", "olleh"},
        {"عربي", "مرحبا", "ابحرم"},
        {"معكوس", "racecar", "racecar"},
    }

    for _, tt := range tests {
        // t.Run ينشئ اختباراً فرعياً، كل حالة تعمل بشكل مستقل
        t.Run(tt.name, func(t *testing.T) {
            got := Reverse(tt.input)
            if got != tt.want {
                t.Errorf("Reverse(%q) = %q، المتوقع %q", tt.input, got, tt.want)
            }
        })
    }
}

func TestIsPalindrome(t *testing.T) {
    tests := []struct {
        name  string
        input string
        want  bool
    }{
        {"معكوس إنجليزي", "racecar", true},
        {"معكوس عربي", "مرحبا بالعالم", true},
        {"ليس معكوساً", "hello", false},
        {"غير حساس لحالة الأحرف", "RaceCar", true},
        {"نص فارغ", "", true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := IsPalindrome(tt.input)
            if got != tt.want {
                t.Errorf("IsPalindrome(%q) = %v، المتوقع %v", tt.input, got, tt.want)
            }
        })
    }
}

# تشغيل حالة المعكوس الصيني فقط
$ go test -v -run=TestIsPalindrome/معكوس_صيني
=== RUN   TestIsPalindrome/معكوس_صيني
--- PASS: TestIsPalindrome/معكوس_صيني (0.00s)
PASS

package handler

import (
    "encoding/json"
    "net/http"
)

type Response struct {
    Message string `json:"message"`
    Code    int    `json:"code"`
}

// HelloHandler يعالج طلبات /hello
func HelloHandler(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    if name == "" {
        name = "World"
    }

    resp := Response{
        Message: "Hello, " + name,
        Code:    200,
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(resp)
}

package handler

import (
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "os"
    "testing"
)

// TestMain يعمل قبل جميع الاختبارات، يمكن استخدامه للإعداد والتنظيف العام
func TestMain(m *testing.M) {
    // هنا يمكن إعداد اتصالات قاعدة البيانات، تهيئة التكوين، إلخ
    setup()

    // تشغيل جميع الاختبارات
    code := m.Run()

    // تنظيف الموارد
    teardown()

    // استخدام نتيجة الاختبار كرمز خروج
    os.Exit(code)
}

func setup() {
    // كود التهيئة (مثل تحميل تكوين الاختبار)
}

func teardown() {
    // كود التنظيف (مثل إغلاق اتصال قاعدة البيانات)
}

func TestHelloHandler(t *testing.T) {
    tests := []struct {
        name       string
        queryParam string
        wantMsg    string
        wantCode   int
    }{
        {"الاسم الافتراضي", "", "Hello, World", 200},
        {"اسم مخصص", "Go", "Hello, Go", 200},
        {"اسم عربي", "أحمد", "Hello, أحمد", 200},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            // بناء الطلب
            url := "/hello"
            if tt.queryParam != "" {
                url += "?name=" + tt.queryParam
            }
            req := httptest.NewRequest(http.MethodGet, url, nil)

            // إنشاء مسجل استجابة
            rr := httptest.NewRecorder()

            // استدعاء المعالج
            HelloHandler(rr, req)

            // التحقق من رمز الحالة
            if rr.Code != tt.wantCode {
                t.Errorf("رمز الحالة = %d، المتوقع %d", rr.Code, tt.wantCode)
            }

            // التحقق من جسم الاستجابة
            var resp Response
            if err := json.NewDecoder(rr.Body).Decode(&resp); err != nil {
                t.Fatalf("فشل تحليل الاستجابة: %v", err)
            }
            if resp.Message != tt.wantMsg {
                t.Errorf("الرسالة = %q، المتوقع %q", resp.Message, tt.wantMsg)
            }
        })
    }
}

// BenchmarkHelloHandler اختبار معياري، يقيس أداء المعالج
func BenchmarkHelloHandler(b *testing.B) {
    req := httptest.NewRequest(http.MethodGet, "/hello?name=Go", nil)

    // b.N يتم تعديله تلقائياً بواسطة إطار الاختبار لضمان نتائج مستقرة
    for i := 0; i < b.N; i++ {
        rr := httptest.NewRecorder()
        HelloHandler(rr, req)
    }
}

// BenchmarkReverse اختبار معياري لعكس النصوص
func BenchmarkReverse(b *testing.B) {
    s := "Hello, World! This is a test string"
    for i := 0; i < b.N; i++ {
        _ = Reverse(s) // افتراض أن Reverse في نفس الحزمة
    }
}

$ go test -bench=. -benchmem -count=3
goos: linux
goarch: amd64
pkg: handler
BenchmarkHelloHandler-8     200000    7523 ns/op    1248 B/op    18 allocs/op
BenchmarkHelloHandler-8     200000    7401 ns/op    1248 B/op    18 allocs/op
BenchmarkHelloHandler-8     200000    7350 ns/op    1248 B/op    18 allocs/op
PASS
ok      handler 4.832s

# إنشاء تقرير تغطية
$ go test -coverprofile=coverage.out

# عرض التغطية لكل دالة في الطرفية
$ go tool cover -func=coverage.out
total:  (statements)    85.7%

# إنشاء تقرير HTML (افتح في المتصفح)
$ go tool cover -html=coverage.out -o coverage.html

package middleware

import (
    "net/http"
    "strings"
)

// AuthMiddleware يتحقق من Token في رؤوس الطلبات
func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if !strings.HasPrefix(token, "Bearer ") {
            http.Error(w, "غير مصرح به", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

package middleware

import (
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestAuthMiddleware(t *testing.T) {
    // إنشاء معالج تابع بسيط
    nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("تماجاز"))
    })

    middleware := AuthMiddleware(nextHandler)

    t.Run("بدون token يجب أن يُرجع 401", func(t *testing.T) {
        req := httptest.NewRequest(http.MethodGet, "/api/data", nil)
        rr := httptest.NewRecorder()
        middleware.ServeHTTP(rr, req)

        if rr.Code != http.StatusUnauthorized {
            t.Errorf("رمز الحالة = %d، المتوقع %d", rr.Code, http.StatusUnauthorized)
        }
    })

    t.Run("token صالح يجب أن يمر", func(t *testing.T) {
        req := httptest.NewRequest(http.MethodGet, "/api/data", nil)
        req.Header.Set("Authorization", "Bearer my-secret-token")
        rr := httptest.NewRecorder()
        middleware.ServeHTTP(rr, req)

        if rr.Code != http.StatusOK {
            t.Errorf("رمز الحالة = %d، المتوقع %d", rr.Code, http.StatusOK)
        }
    })

    t.Run("بادئة غير صالحة يجب أن تُرجع 401", func(t *testing.T) {
        req := httptest.NewRequest(http.MethodGet, "/api/data", nil)
        req.Header.Set("Authorization", "Basic abc123")
        rr := httptest.NewRecorder()
        middleware.ServeHTTP(rr, req)

        if rr.Code != http.StatusUnauthorized {
            t.Errorf("رمز الحالة = %d، المتوقع %d", rr.Code, http.StatusUnauthorized)
        }
    })
}

package user

import "context"

// UserRepository يحدد واجهة الوصول إلى بيانات المستخدم
type UserRepository interface {
    GetByID(ctx context.Context, id int) (*User, error)
    Create(ctx context.Context, user *User) error
}

// User نموذج المستخدم
type User struct {
    ID   int
    Name string
}

// Service منطق أعمال المستخدم
type Service struct {
    repo UserRepository
}

// NewService ينشئ خدمة مستخدم
func NewService(repo UserRepository) *Service {
    return &Service{repo: repo}
}

// GetUser يحصل على مستخدم، يُرجع خطأ إذا لم يتم العثور عليه
func (s *Service) GetUser(ctx context.Context, id int) (*User, error) {
    if id <= 0 {
        return nil, fmt.Errorf("معرف مستخدم غير صالح: %d", id)
    }
    return s.repo.GetByID(ctx, id)
}

package user

import (
    "context"
    "testing"
)

// mockRepo ينفذ واجهة UserRepository للاختبار
type mockRepo struct {
    users map[int]*User
}

func (m *mockRepo) GetByID(_ context.Context, id int) (*User, error) {
    if u, ok := m.users[id]; ok {
        return u, nil
    }
    return nil, fmt.Errorf("المستخدم %d غير موجود", id)
}

func (m *mockRepo) Create(_ context.Context, user *User) error {
    m.users[user.ID] = user
    return nil
}

func TestGetUser(t *testing.T) {
    mock := &mockRepo{
        users: map[int]*User{
            1: {ID: 1, Name: "Alice"},
            2: {ID: 2, Name: "Bob"},
        },
    }
    svc := NewService(mock)

    t.Run("مستخدم موجود", func(t *testing.T) {
        user, err := svc.GetUser(context.Background(), 1)
        if err != nil {
            t.Fatalf("خطأ غير متوقع: %v", err)
        }
        if user.Name != "Alice" {
            t.Errorf("الاسم = %q، المتوقع %q", user.Name, "Alice")
        }
    })

    t.Run("مستخدم غير موجود", func(t *testing.T) {
        _, err := svc.GetUser(context.Background(), 99)
        if err == nil {
            t.Error("يُتوقع إرجاع خطأ")
        }
    })

    t.Run("معرف غير صالح", func(t *testing.T) {
        _, err := svc.GetUser(context.Background(), -1)
        if err == nil {
            t.Error("يُتوقع إرجاع خطأ")
        }
    })
}

# تشغيل اختبار محدد بالاسم
go test -run TestDivideByZero -v

# إذا كنت تستخدم go test -v، ستُعرض أسماء الاختبارات الفاشلة في المخرجات

go test -run TestSomething -count=1 -v

func TestSlowOperation(t *testing.T) {
    if testing.Short() {
        t.Skip("تخطي الاختبار الذي يستغرق وقتاً طويلاً (استخدم علامة -short)")
    }
    // عملية تستغرق وقتاً طويلاً...
}

go test -short

// Truncate تقطع النص إلى الطول المحدد، واستبدال الزائد بـ "..."
func Truncate(s string, maxLen int) string {
    runes := []rune(s)
    if len(runes) <= maxLen {
        return s
    }
    return string(runes[:maxLen-3]) + "..."
}

// ListHandler يُرجع قائمة مستخدمين
func ListHandler(w http.ResponseWriter, r *http.Request) {
    users := []User{{1, "Alice"}, {2, "Bob"}, {3, "Charlie"}}
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}