func TestAdd(t *testing.T){
	//測試邏輯
}

func TestAdd(t *testing.T){
	//使用結(jié)構(gòu)體切片定義多個測試用例
	tests:=[]struct{
		a,b,want int
	}{
		{1,2,3},
		{3,4,7},
		{5,6,11},
	}
	//循環(huán)遍歷執(zhí)行
	for _,v:=range tests{
		sum:=Add(v.a,v.b)
		if sum != v.want{
			t.Errorf("Add(%d,%d)=%d;want %d\n",v.a,v.b,sum,v.want)
		}
	}
}

func TestAdd(t *testing.T){
	//使用結(jié)構(gòu)體切片定義多個測試用例
	tests:=[]struct{
		name string
		a,b,want int
	}{
		//分組
		{"正數(shù)",1,2,3},
		{"負數(shù)",-3,-4,-7},
		{"零值",0,0,0},
	}
	//循環(huán)遍歷執(zhí)行
	for _,v:=range tests{
		sum:=Add(v.a,v.b)
		if sum != v.want{
			t.Errorf("Add(%d,%d)=%d;want %d\n",v.a,v.b,sum,v.want)
		}
	}
}

func TestDivide(t *testing.T){
	_,err:=Divide(6,0)
	if err ==nil{
		t.Fatal("預(yù)期錯誤，并未返回")
	}
	if err.Error()!="除零錯誤"{
		t.Error("錯誤消息不符：%s",err)
	}
}

go test -coverprofile=coverage.out
go tool cover -html=coverage.out

func TestMain(m *testing.M){
	setup()
	code:=m.Run()
	teardown()
	os.Exit(code)
}

func TestDB(t *testing.T){
	db:=setupDB()
	t.Cleanup(func(){
		teardownDB(db)
	})
	//測試邏輯
}

type Storage interface{
	Get(id int) string
}

type MockStorage struct{}
func (m*MockStorage)Get(id int)string{
	return "mock"
}

func TestService(t*testing.T){
	s:=&Service{storage:&MockStorage{}}
	//測試邏輯
}

func TestNetwork(t *testing.T){
	if testing.Short(){
		t.Skip("短模式下跳過")
	}
	//網(wǎng)絡(luò)相關(guān)測試
}

func TestParallel(t *testing.T){
	t.Parallel()
	//并發(fā)安全測試邏輯
}

package main

// 計算兩個數(shù)的和
func Add(a, b int) int {
    return a + b
}

// 計算階乘
func Factorial(n int) int {
    if n < 0 {
        return -1
    }
    if n == 0 {
        return 1
    }
    return n * Factorial(n-1)
}

// 判斷是否為素數(shù)
func IsPrime(n int) bool {
    if n < 2 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

package main

import (
    "testing"
)

func TestAdd(t *testing.T) {
    tests := []struct {
        a, b, expected int
    }{
        {1, 2, 3},
        {-1, 1, 0},
        {0, 0, 0},
        {100, 200, 300},
    }

    for _, tt := range tests {
        result := Add(tt.a, tt.b)
        if result != tt.expected {
            t.Errorf("Add(%d, %d) = %d; expected %d", tt.a, tt.b, result, tt.expected)
        }
    }
}

func TestFactorial(t *testing.T) {
    tests := []struct {
        n, expected int
    }{
        {0, 1},
        {1, 1},
        {5, 120},
        {10, 3628800},
        {-1, -1},
    }

    for _, tt := range tests {
        result := Factorial(tt.n)
        if result != tt.expected {
            t.Errorf("Factorial(%d) = %d; expected %d", tt.n, result, tt.expected)
        }
    }
}

func TestIsPrime(t *testing.T) {
    tests := []struct {
        n        int
        expected bool
    }{
        {2, true},
        {3, true},
        {4, false},
        {17, true},
        {1, false},
        {0, false},
        {-1, false},
    }

    for _, tt := range tests {
        result := IsPrime(tt.n)
        if result != tt.expected {
            t.Errorf("IsPrime(%d) = %v; expected %v", tt.n, result, tt.expected)
        }
    }
}

go test -v

package main
import(
	"fmt"
	"time"
)

func test(){
	for i:=0;i<10;i++{
		fmt.Printf("test()~%v\n",i)
		time.Sleep(1000*time.Millisecond)//休眠一秒
	}
}

func main(){
	//啟動協(xié)程
	go test()

	for i:=0;i<5;i++{
		fmt.Printf("main()~%v\n",i)
		time.Sleep(1000*time.Millisecond)//休眠一秒
	}
}

package main
import (
	"fmt"
	"runtime"
)

func main(){
	//獲取當(dāng)前(邏輯)cpu的數(shù)量
	num:=runtime.NumCPU()
	//設(shè)置num-1的cpu運行g(shù)o程序
	runtime.GOMAXPROCS(num)
	fmt.Println(num)
}

package main
import (
	"fmt"
	"sync"
	"time"
)
 
var (
	myMap =make(map[int]int,10)
	//聲明一個全局的互斥鎖
	lock sync.Mutex
)

func test(n int){
	res:=1
	for i:=1;i<=n;i++{
		res*=i
	}
	//這里我們將res放入myMap中
	//加鎖
	lock.Lock()
	myMap[n]=res
	//解鎖
	lock.Unlock()
}

func main(){
	//開啟多個協(xié)程完成求階乘
	for i:=1;i<=20;i++{
		go test(i)
	}

	//休眠5秒
	time.Sleep(5*time.Second)
	//加鎖
	lock.Lock()
	for i,v:=range myMap{
		fmt.Printf("map[%d]=%d\n",i,v)
	}
	//解鎖
	lock.Unlock()
	 
}

var 名字 chan 類型 

ch := make(chan int) // 創(chuàng)建一個無緩沖的int類型channel
ch := make(chan string, 10) // 創(chuàng)建一個緩沖大小為10的string類型channel

ch <- 42 // 發(fā)送數(shù)據(jù)到channel
value := <-ch // 從channel接收數(shù)據(jù)
<-ch    //也可以不接受數(shù)據(jù)，將數(shù)據(jù)推出

package main
import (
	"fmt"
)

func main(){
	//定義一個接受int類型的channel
	var intChan chan int
	//使用channel前需要make
	intChan=make(chan int,4)

	//進channel
	intChan<-1
	intChan<-2
	intChan<-3
	intChan<-4
	// intChan<-5  注意，當(dāng)我們給channel寫入數(shù)據(jù)時，不能超過其容量

	//看看intChan是什么
	fmt.Printf("intChan 的值是%v,地址為%p,長度為%v,容量為%v\n",intChan,&intChan,len(intChan),cap(intChan))
	
	//從channel中取數(shù)據(jù)
	var num int
	num=<-intChan
	fmt.Println("num=",num)
	fmt.Printf("intChan 的長度為%v,容量為%v\n",len(intChan),cap(intChan))

	//注意：在沒有使用協(xié)程的情況下，如果我們的管道數(shù)據(jù)已經(jīng)全部取出，繼續(xù)取數(shù)據(jù)就會報deadlock
	num2:=<-intChan
	<-intChan  //數(shù)據(jù)出channel 也可以不接受，相當(dāng)于丟棄
	num3:=<-intChan

	fmt.Printf("num2=%d , num3=%d\n",num2,num3)
	//num2=2 , num3=4
	//數(shù)據(jù)出channel時先進先出的
}

package main
import (
	"fmt"
)

type Cat struct{
	Name string
	Age int
}

func main(){
	//structChan
	cat1:=Cat{"jav",12}
	cat2:=Cat{"mimi",3}
	var catChan chan Cat
	catChan=make(chan Cat,3)
	catChan<-cat1
	catChan<-cat2
	fmt.Println(<-catChan)
	cat3:=<-catChan
	fmt.Println(cat3)

	//mapChan
	var mapChan chan map[string]string
	mapChan=make(chan map[string]string,5)
	m1:=make(map[string]string,10)
	m1["功法1"]="九幽玄天"
	m1["功法2"]="天罡決"
	mapChan<-m1

	m2:=make(map[string]string)
	m2["神通1"]="古神決"
	m2["神通2"]="呼風(fēng)喚雨"
	mapChan<-m2
	//輸出
	fmt.Println(<-mapChan)
	fmt.Println(<-mapChan)
}

package main
import(
	"fmt"
)

type Person struct{
	Name string
	Age int
}
type Dog struct{
	Name string
	Age int
}

func main(){
	//能接受任意類型的管道
	var allChan chan interface{}
	allChan=make(chan interface{},10)//不指定空間10則無法使用
	//定義變量
	num1:=2
	str1:="channel is interesting"
	person1:=Person{"李星云",21}
	dog1:=Dog{"小紅",4}
	//chan接受數(shù)據(jù)
	allChan<-num1
	allChan<-str1
	allChan<-person1
	allChan<-dog1

	//取數(shù)據(jù)
	num2:=<-allChan
	str2:=<-allChan
	person2:=<-allChan
	dog2:=<-allChan
	//打印
	fmt.Printf("num2的類型為%T,值為%v\n",num2,num2)
	fmt.Printf("str2的類型為%T,值為%v\n",str2,str2)
	fmt.Printf("person2的類型為%T,值為%v\n",person2,person2)
	fmt.Printf("dog2的類型為%T,值為%v\n",dog2,dog2)

	//驗證
	// fmt.Println(person2.Name)
	//會報錯，此時是interface{}類型，不能由屬性
	//需類型斷言解決該問題
	person3,ok:=person2.(Person)
	if ok==false{
		fmt.Println("類型斷言失敗")
	}
	fmt.Printf("person3的類型為%T,值為%v\n",person3,person3)
	fmt.Println(person3.Name) 
}

package main
import (
	"fmt"
)

func main(){
	var intChan chan int
	intChan=make(chan int,5)
	intChan<-1
	intChan<-2
	intChan<-3
	//關(guān)閉管道
	close(intChan)
	//這時不能再寫數(shù)據(jù)到intChan
	//intChan<-4
	//panic: send on closed channel
	//但是可以讀數(shù)據(jù)
	fmt.Println(<-intChan)
}

package main
import (
	"fmt"
)

func main(){
	var intChan chan int =make(chan int,100)

	//遍歷chan，接受數(shù)據(jù)
	for i:=0;i<100;i++{
		intChan<-i*2
	}

	//在遍歷讀數(shù)據(jù)時，如果channel沒有關(guān)閉，
	//則會出現(xiàn)fatal error: all goroutines are asleep - deadlock!
	for v:=range intChan{
		fmt.Println(v)
	}
	fmt.Println("遍歷完成~")//不會輸出
}

package main
import (
	"fmt"
)

func main(){
	var intChan chan int =make(chan int,100)

	//遍歷chan，接受數(shù)據(jù)
	for i:=0;i<100;i++{
		intChan<-i*2
	}

	//在遍歷讀數(shù)據(jù)時，如果channel已經(jīng)關(guān)閉，
	//則會正常遍歷數(shù)據(jù)，遍歷完數(shù)據(jù)后就會退出遍歷
	close(intChan)
	for v:=range intChan{
		fmt.Println(v)
	}
	fmt.Println("遍歷完成~")//正常輸出
}

package main
import (
	"fmt"
	_ "time"
)

//writer Data
func writeData(intChan chan int){
	for i:=1;i<=200;i++{
		//放入數(shù)據(jù)
		intChan<-i 
		fmt.Println("writeData.............寫入數(shù)據(jù)：",i)
	}
	//關(guān)閉
	close(intChan)
}

//read Data
func readData(intChan chan int,exitChan chan bool){
	for{
		v,ok:=<-intChan
		if !ok{
			break
		}
		fmt.Printf("readData 讀到數(shù)據(jù)=%v\n",v)
	}
	//讀完數(shù)據(jù)
	exitChan<-true
	close(exitChan)
}


func main(){
	//創(chuàng)建兩個管道
	intChan := make(chan int,200)
	exitChan := make(chan bool,1)

	go writeData(intChan)
	go readData(intChan,exitChan)

	// time.Sleep(5*time.Second)
	for {
		_,ok:=<-exitChan
		if !ok{
			break
		}
	}
}

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan int) // 無緩沖管道

	go func() {
		time.Sleep(2 * time.Second)
		fmt.Println("準(zhǔn)備發(fā)送數(shù)據(jù)")
		ch <- 42
		fmt.Println("數(shù)據(jù)已發(fā)送")
	}()

	fmt.Println("等待接收數(shù)據(jù)")
	value := <-ch
	fmt.Println("接收到數(shù)據(jù):", value)
}

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan int)

	// 啟動一個goroutine，延遲發(fā)送數(shù)據(jù)
	go func() {
		time.Sleep(2 * time.Second)
		ch <- 42
		fmt.Println("數(shù)據(jù)已發(fā)送")
	}()

	// 主goroutine嘗試接收數(shù)據(jù)，會阻塞直到有數(shù)據(jù)
	fmt.Println("等待接收數(shù)據(jù)...")
	value := <-ch
	fmt.Println("接收到數(shù)據(jù):", value)

	// 使用select實現(xiàn)超時解除阻塞
	select {
	case v := <-ch:
		fmt.Println("接收到數(shù)據(jù):", v)
	case <-time.After(1 * time.Second):
		fmt.Println("超時，解除阻塞")
	}

	// 關(guān)閉管道解除阻塞
	close(ch)
	v, ok := <-ch
	fmt.Println("從關(guān)閉的管道接收:", v, "是否成功:", ok)
}