std - testingâ

Author: darjun

README.md

@@ -151,4 +151,6 @@
 * [gorilla/sessions](https://darjun/github.io/2021/07/25/godailylib/gorilla/sessions)
     gorilla Web 开发包之 session 处理库
 * [goth](https://darjun/github.io/2021/07/26/godailylib/goth)
-    第三方认证合集
+    第三方认证合集
+* [testing](https://darjun/github.io/2021/08/03/godailylib/testing)
+    标准库测试包

testing/fib/fib.go

@@ -0,0 +1,41 @@
+package fib
+
+func Fib1(n int) int {
+	if n <= 1 {
+		return n
+	}
+
+	return Fib1(n-1) + Fib1(n-2)
+}
+
+func fibHelper(n int, m map[int]int) int {
+	if n <= 1 {
+		return n
+	}
+
+	if v, ok := m[n]; ok {
+		return v
+	}
+
+	v := fibHelper(n-2, m) + fibHelper(n-1, m)
+	m[n] = v
+	return v
+}
+
+func Fib2(n int) int {
+	m := make(map[int]int)
+	return fibHelper(n, m)
+}
+
+func Fib3(n int) int {
+	if n <= 1 {
+		return n
+	}
+
+	f1, f2 := 0, 1
+	for i := 2; i <= n; i++ {
+		f1, f2 = f2, f1+f2
+	}
+
+	return f2
+}

testing/fib/fib_test.go

@@ -0,0 +1,21 @@
+package fib
+
+import "testing"
+
+func BenchmarkFib1(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Fib1(20)
+	}
+}
+
+func BenchmarkFib2(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Fib2(20)
+	}
+}
+
+func BenchmarkFib3(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Fib3(20)
+	}
+}

testing/go.mod

@@ -0,0 +1,3 @@
+module github.com/darjun/go-daily-lib/testing
+
+go 1.16

testing/roman/roman.go

@@ -0,0 +1,74 @@
+package roman
+
+import (
+	"bytes"
+	"errors"
+	"regexp"
+)
+
+type romanNumPair struct {
+	Roman string
+	Num   int
+}
+
+var (
+	romanNumParis []romanNumPair
+	romanRegex    *regexp.Regexp
+)
+
+var (
+	ErrOutOfRange   = errors.New("out of range")
+	ErrInvalidRoman = errors.New("invalid roman")
+)
+
+func init() {
+	romanNumParis = []romanNumPair{
+		{"M", 1000},
+		{"CM", 900},
+		{"D", 500},
+		{"CD", 400},
+		{"C", 100},
+		{"XC", 90},
+		{"L", 50},
+		{"XL", 40},
+		{"X", 10},
+		{"IX", 9},
+		{"V", 5},
+		{"IV", 4},
+		{"I", 1},
+	}
+
+	romanRegex = regexp.MustCompile(`^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$`)
+}
+
+func ToRoman(n int) (string, error) {
+	if n <= 0 || n >= 4000 {
+		return "", ErrOutOfRange
+	}
+	var buf bytes.Buffer
+	for _, pair := range romanNumParis {
+		for n >= pair.Num {
+			buf.WriteString(pair.Roman)
+			n -= pair.Num
+		}
+	}
+
+	return buf.String(), nil
+}
+
+func FromRoman(roman string) (int, error) {
+	if !romanRegex.MatchString(roman) {
+		return 0, ErrInvalidRoman
+	}
+
+	var result int
+	var index int
+	for _, pair := range romanNumParis {
+		for roman[index:index+len(pair.Roman)] == pair.Roman {
+			result += pair.Num
+			index += len(pair.Roman)
+		}
+	}
+
+	return result, nil
+}

testing/roman/roman_test.go

@@ -0,0 +1,81 @@
+package roman
+
+import "testing"
+
+func TestToRoman(t *testing.T) {
+	testCases := []struct {
+		num    int
+		expect string
+		err    error
+	}{
+		{0, "", ErrOutOfRange},
+		{1, "I", nil},
+		{2, "II", nil},
+		{3, "III", nil},
+		{4, "IV", nil},
+		{5, "V", nil},
+		{6, "VI", nil},
+		{7, "VII", nil},
+		{8, "VIII", nil},
+		{9, "IX", nil},
+		{10, "X", nil},
+		{50, "L", nil},
+		{100, "C", nil},
+		{500, "D", nil},
+		{1000, "M", nil},
+		{31, "XXXI", nil},
+		{148, "CXLVIII", nil},
+		{294, "CCXCIV", nil},
+		{312, "CCCXII", nil},
+		{421, "CDXXI", nil},
+		{528, "DXXVIII", nil},
+		{621, "DCXXI", nil},
+		{782, "DCCLXXXII", nil},
+		{870, "DCCCLXX", nil},
+		{941, "CMXLI", nil},
+		{1043, "MXLIII", nil},
+		{1110, "MCX", nil},
+		{1226, "MCCXXVI", nil},
+		{1301, "MCCCI", nil},
+		{1485, "MCDLXXXV", nil},
+		{1509, "MDIX", nil},
+		{1607, "MDCVII", nil},
+		{1754, "MDCCLIV", nil},
+		{1832, "MDCCCXXXII", nil},
+		{1993, "MCMXCIII", nil},
+		{2074, "MMLXXIV", nil},
+		{2152, "MMCLII", nil},
+		{2212, "MMCCXII", nil},
+		{2343, "MMCCCXLIII", nil},
+		{2499, "MMCDXCIX", nil},
+		{2574, "MMDLXXIV", nil},
+		{2646, "MMDCXLVI", nil},
+		{2723, "MMDCCXXIII", nil},
+		{2892, "MMDCCCXCII", nil},
+		{2975, "MMCMLXXV", nil},
+		{3051, "MMMLI", nil},
+		{3185, "MMMCLXXXV", nil},
+		{3250, "MMMCCL", nil},
+		{3313, "MMMCCCXIII", nil},
+		{3408, "MMMCDVIII", nil},
+		{3501, "MMMDI", nil},
+		{3610, "MMMDCX", nil},
+		{3743, "MMMDCCXLIII", nil},
+		{3844, "MMMDCCCXLIV", nil},
+		{3888, "MMMDCCCLXXXVIII", nil},
+		{3940, "MMMCMXL", nil},
+		{3999, "MMMCMXCIX", nil},
+		{4000, "", ErrOutOfRange},
+	}
+
+	for _, testCase := range testCases {
+		got, err := ToRoman(testCase.num)
+		if got != testCase.expect {
+			t.Errorf("ToRoman(%d) expect:%s got:%s", testCase.num, testCase.expect, got)
+		}
+
+		if err != testCase.err {
+			t.Errorf("ToRoman(%d) expect error:%v got:%v", testCase.num, testCase.err, err)
+		}
+	}
+}

testing/roman_test/roman_test.go

@@ -0,0 +1,125 @@
+package roman_test
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/darjun/go-daily-lib/testing/roman"
+)
+
+type toRomanCase struct {
+	num    int
+	expect string
+	err    error
+}
+
+var (
+	toRomanInvalidCases []toRomanCase
+	toRomanSingleCases  []toRomanCase
+	toRomanNormalCases  []toRomanCase
+)
+
+func init() {
+	toRomanInvalidCases = []toRomanCase{
+		{0, "", roman.ErrOutOfRange},
+		{4000, "", roman.ErrOutOfRange},
+	}
+
+	toRomanSingleCases = []toRomanCase{
+		{1, "I", nil},
+		{5, "V", nil},
+		// ...
+	}
+
+	toRomanNormalCases = []toRomanCase{
+		{2, "II", nil},
+		{3, "III", nil},
+		{4, "IV", nil},
+		{6, "VI", nil},
+		{7, "VII", nil},
+		{8, "VIII", nil},
+		{9, "IX", nil},
+		{31, "XXXI", nil},
+		{148, "CXLVIII", nil},
+		{294, "CCXCIV", nil},
+		{312, "CCCXII", nil},
+		{421, "CDXXI", nil},
+		{528, "DXXVIII", nil},
+		{621, "DCXXI", nil},
+		{782, "DCCLXXXII", nil},
+		{870, "DCCCLXX", nil},
+		{941, "CMXLI", nil},
+		{1043, "MXLIII", nil},
+		{1110, "MCX", nil},
+		{1226, "MCCXXVI", nil},
+		{1301, "MCCCI", nil},
+		{1485, "MCDLXXXV", nil},
+		{1509, "MDIX", nil},
+		{1607, "MDCVII", nil},
+		{1754, "MDCCLIV", nil},
+		{1832, "MDCCCXXXII", nil},
+		{1993, "MCMXCIII", nil},
+		{2074, "MMLXXIV", nil},
+		{2152, "MMCLII", nil},
+		{2212, "MMCCXII", nil},
+		{2343, "MMCCCXLIII", nil},
+		{2499, "MMCDXCIX", nil},
+		{2574, "MMDLXXIV", nil},
+		{2646, "MMDCXLVI", nil},
+		{2723, "MMDCCXXIII", nil},
+		{2892, "MMDCCCXCII", nil},
+		{2975, "MMCMLXXV", nil},
+		{3051, "MMMLI", nil},
+		{3185, "MMMCLXXXV", nil},
+		{3250, "MMMCCL", nil},
+		{3313, "MMMCCCXIII", nil},
+		{3408, "MMMCDVIII", nil},
+		{3501, "MMMDI", nil},
+		{3610, "MMMDCX", nil},
+		{3743, "MMMDCCXLIII", nil},
+		{3844, "MMMDCCCXLIV", nil},
+		{3888, "MMMDCCCLXXXVIII", nil},
+		{3940, "MMMCMXL", nil},
+		{3999, "MMMCMXCIX", nil},
+	}
+}
+func testToRomanCases(cases []toRomanCase, t *testing.T) {
+	for _, testCase := range cases {
+		got, err := roman.ToRoman(testCase.num)
+		if got != testCase.expect {
+			t.Errorf("ToRoman(%d) expect:%s got:%s", testCase.num, testCase.expect, got)
+		}
+
+		if err != testCase.err {
+			t.Errorf("ToRoman(%d) expect error:%v got:%v", testCase.num, testCase.err, err)
+		}
+	}
+}
+
+func testToRomanInvalid(t *testing.T) {
+	testToRomanCases(toRomanInvalidCases, t)
+}
+
+func testToRomanSingle(t *testing.T) {
+	testToRomanCases(toRomanSingleCases, t)
+}
+
+func testToRomanNormal(t *testing.T) {
+	testToRomanCases(toRomanNormalCases, t)
+}
+
+func TestToRoman(t *testing.T) {
+	t.Run("Invalid", testToRomanInvalid)
+	t.Run("Single", testToRomanSingle)
+	t.Run("Normal", testToRomanNormal)
+}
+
+func TestMain(m *testing.M) {
+	flag.Parse()
+	flag.VisitAll(func(f *flag.Flag) {
+		fmt.Printf("name:%s usage:%s value:%v\n", f.Name, f.Usage, f.Value)
+	})
+	os.Exit(m.Run())
+}