// 需要被测试的函数

func calcTriangle(a, b int) int {

    return int(math.Sqrt(float64(a*a + b*b)))

}

package main

import "testing"


// 注意测试函数必须以 Test开头

func TestTriangle(t *testing.T) {
　　// 表格驱动测试

    tests := []struct {a, b, c int} {

        {3,4,5},

        {5,12,13},

        {8,15,17},

        {12,35,37},

        {30000,40000,50000},

    }

    for _, tt := range tests {

        if actual := calcTriangle(tt.a, tt.b); actual != tt.c {

            t.Errorf("calcTriangle(%d, %d); got %d; expected %d", tt.a, tt.b, actual, tt.c)

        }

    }

}

package main

import "fmt"

func lengthOfNonRepeatingSubStr(s string) int {

    lastOccurred := make(map[rune]int)

    start := 0

    maxLength := 0

    for i, ch := range []rune(s) {

        if lastI, ok := lastOccurred[ch]; ok && lastI >= start {

            start = lastI + 1

        }

        if i - start + 1 > maxLength {

            maxLength = i - start + 1

        }

        lastOccurred[ch] = i

        }

    return maxLength

}

func main() {

    fmt.Println(

        lengthOfNonRepeatingSubStr("abcabcbb"))

    fmt.Println(

        lengthOfNonRepeatingSubStr("bbbbb"))

    fmt.Println(

        lengthOfNonRepeatingSubStr("pwwkew"))

    fmt.Println(

        lengthOfNonRepeatingSubStr(""))

    fmt.Println(

        lengthOfNonRepeatingSubStr("b"))

    fmt.Println(

        lengthOfNonRepeatingSubStr("abcdef"))

    fmt.Println(

        lengthOfNonRepeatingSubStr("这里是慕课网"))

    fmt.Println(

        lengthOfNonRepeatingSubStr("一二三二一"))

    fmt.Println(

        lengthOfNonRepeatingSubStr(

            "黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花"))

}

package main

import "testing"

// 功能测试

func TestSubstr(t *testing.T) {

    tests := []struct{s string; ans int} {

        {"abcabcbb", 3},

        {"bbbbb", 1},

        {"pwwkew", 3},

        {"", 0},

        {"b", 1},

        {"abcdef", 6},

        {"这里是慕课网", 6},

        {"一二三二一", 3},

        {"黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花", 8},

    }

    for _, tt := range tests {

        if actual := lengthOfNonRepeatingSubStr(tt.s); actual != tt.ans {

            t.Errorf("got %d for input %s; expected %d", actual, tt.s, tt.ans)

        }

    }

}

// 性能测试

func BenchmarkSubstr(b *testing.B) {

    s := "黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花"

    ans := 8

    // b.N 自动判断测试的次数

    for i := 0; i < b.N ; i++ {

        actual := lengthOfNonRepeatingSubStr(s)

        if actual != ans {

            b.Errorf("got %d for input %s; expected %d", actual, s, ans)

        }

    }

}