test: format test code

cryptor/rsa_private_example.pem

@@ -1,51 +1,51 @@
 -----BEGIN rsa private key-----
-MIIJKAIBAAKCAgEA0HaqqGWnNqwRVKoJUUjYiH/dwkSK61La4RGYkvDfcuo9pDgc
+MIIJKQIBAAKCAgEAyA3SmuwPpYGw/JdzJ9Iah+Z09Q27sueuT1DpqFTYKeJmYQxe
-zHVhFUb/MYWeb3bAlFAGcZLYSBh6WAGxbeMjSkaLroaXnafhKZ2oXXUy8CzyYxZw
+I7N8STbmC3dYctsT3Fd+bcfLF2EMscRaae1DAEjli56e41VYvVXPgTSMPWboETDg
-pLCDgJLG7Pf0jer3STZW93ZT8UJixbKwbqD6b8fkpMANwCYrTlXDWBuZVaEKuQNn
+TtPssl0wZHZ23+cKhK9wBgLQ66mzFRM/ro+OLvydO8jZeaRvG5eATrUaB4ywnXp3
-C4XufQis4fwRxRgfrZuLMvuQVtnyYmssmnp8JHovYkr87giDjEgvlrC84Lez32Zh
+j8r42qTlR05EJWbzwPKkW61vePgOyObRwJrF47WGZG6cPCQMd5zSJPQw5o3xOEuh
-EhORRu5NGEDeZ1OewbkXGyQtbcBQYNAxgnOcO44MTTPhEdz4/A0xwzEe+yIOxWIA
+n0FD/GPtM8f+0dxjXpLkcJwnXyUbuAU2WWweJHaYOA2s2anlG6V8ZTUZvbdsKi24
-WuEM2rclXpZBW/MEK41gZ3C04KcX5R0KRdj2PTTH7vJ33yRC4hKtWetwMvsUrewr
+byCzHbKwhI48vKvnPRnJt5wxvg1PsiAYAalWDrIhod+Atdxp4LXzqM5Nyxfp9+BR
-RKVcUgaeFykDAlgIDoSWvG0nzb70AWSoNcj7krLlwEc2WLGy/kCYWppnfYKafEJX
+nxJZASrzqd/z3ZpZJ8q9g9A7XPpGgfSB6H9tcjoy5gD+jVJqN26PBqsiW5RyckI3
-pgblHrDFKlWvte68yrvGdCsWRLQ2uUF0xokQIg4u2bApyWNroxEtjHwUp1VeJuZB
+TXPAXRMnr2xshZ4pze6mDPyiHHruLUrnvHnVgg62g/MB0p/bipVxd18418yZ2gRl
-Qkfg+vIW+t3moQpMtlhy4aai/oGIxI5TIB82nv8TPVczjHmmE3hwL6nZ5OfbFyWp
+0PtmqD7EfKwgREcA20zWeQtYkioOUclX30uG3vVSf0j2KyoAqWmES52KqUp9pwNd
-RFvKLtXcaAKMi2HqOLRkQhqjjJUCO9Wyhu1BkX8RAeKLl3S7gRyhuOB5JNUGEpQ3
+opWvRtQGAey2b9mpdSgl69rM2RmbzFOIDrfw/1ftPpaUi2CVILviSeYtN2egkeB+
-89MdbUX5S12Qp1xTDS+otbC8tYS1gu0OOOWowxbuF5+Ci2SYgSHv/3zXKoMCAwEA
+ghCPCcIS9VUpnNTYcW8Y+cTnfi9FwSEwn13WpjiYO/K2412uWjNVNvvW3RECAwEA
-AQKCAgBASCdt0BLVABBEDD7dStpClTNbwWkZEa6e8p8ayJ4OwH6LkiYHQjbSqdbt
+AQKCAgA8KMv4gpyB7OpIS1L52pjX3Vm2h5a2Si2E9JQPZtRKZCbdcFau7b6mVbgA
-fWeStYrC8T5bbU22RZ4MX1FIMl9iewh9o9FC806yV4RgdVBk0WdY+MV5c1jJn/kp
+Ireacn8ad8UxRi+wrCKhIqb9y7emUkWVIvIs8vFonnF0LVUu8c8/vC74BYrcaGGx
-f3hw/sCMWe5NVrah0bfFgMl5A7jWGUy/JN3Yn6yA9l9LXw9UYVl+Hbd7zSvycGdn
+FF7THitvk0JgzF//Plz4LX2tBMaBIr41yER97BDtfzW6dYOKWaiS8s0ZlLQZLBU2
-NCSCo2K5VRqCeSJUNdbRVH0nkZeQZAESjU8bU5LFAklybUOBBAS6YcaTHWeR+M/b
+yDZ9+OO8VjtOxm0LN61ahO72uJRh0ajEcu7QtxZ4sdQQAM7jxjOP9k54EaxcLcCb
-J72tHRL6Z8nhO7Gqg0AF6o0pzd6iWrYeZF4F9R7uEl+C8jW8eQ8W/JZhb75X/1vN
+Hb1nZpsLSakgpBTC6+nWANtDMNwvoupLkPE1031uPumVlc5T2uDQHkekQ3UZrS6f
-pAW5heGGUI0muJF+KOhsZR0S1slvHbCSvwaNBQi8HEbOEPa7wVzsrGLfc+re5ysF
+7hYdtqQnH6YlbPcYa/BXZIdTmJSj9pYKz5Ml1of1KqB6KRxe2vUDtVkTJUwRkZC4
-X2n5GL4qBwNdMHrADnMWWVa9LEUSr3XmXfpmNDctmdv1ekWpJ44G/qrjKOuimtfk
+G8//taLRuaA1vC5bHaseI0uYlTPxueXSDStj7VcUS27nSRWdGxe24EVrIjsA9CNB
-t9haDjhN5lx3V05k18kb53tYAdi3CqrT4syiibtqZLvTRam/yoFJgSOczO5WxNNk
+RCVDeU6W4r1eGrvgM8QFNWi1jUMr1rRI7EFHV+24hsfiSWZQwhltzWZ3mn99i9VD
-xnhnEdr/FQcFQhzuQ6gU196SBi8Bqjz1t0cNozNu3wvp8Fu0G8Rr9gjYnH8m5xXz
+BmqI/JvX5d8+8/JlPOVG3HuuxNbU2tzHLhgLADfINvi3TpbdgAY8zm5NqumdwXp6
-xb9xevR7X/swfxd+/KUqoenYdU5ZFJpDRCmUMDKWR/3Q7s4SRxMN0+c/uBSaih3J
+JqQ6TXnO/G07fBuZnBP9+Qt5VBQV9rGF5HGpzznbBzSGgBPUNBYqFOyWrdp05J2X
-I9I8urHG6mFW2qWQZTvuostmb7vVHaefx0RZOhX0efJVMZPwiQKCAQEA8BUXRw9k
+bpO23G+2RM0ufXbukF3mI45NJUWOeHOGrxWTEI60Uy0Vf/+/MQKCAQEA5YXXfpHo
-Ms3tqmBMVM4sMcPgsffJxjAJUdunUgEpaBAqrDQmZ6uBjAYq7iTzLgJJuLI1o1sv
+z72IMQGwEUMw5vkyaoGd2Oi5g+Jjv1q/CKbmCw5sD+mfQTYh41mBpDDACbdSLYDu
-HtEWuGLHRRJpdoEamGweJE/o28OH2MBiiL2ezfRIHsg8RRr6os6KvlKevty6m7d9
+0wh9zw74HFOY9Jm7GO9LoIjZ76xv+RSBXLN8tpH1MiAQgBrepWhhlhmyTtiIDNXG
-hAvpS6XvZGK2eCSooL6zZ8XTgnDw+Hw8Q4i+dazjb5dDRRL97eHHUqzcYH5vIsAE
+crj1Yl76J5hBd4dR+gYlJjB+hWsQvV83RxXIUw6eIM6Ngi7RUNuywI1a9mjSY8H+
-EBaNXMKrhf/NyVWCJBVRHg8PZZjGXcrj8ZMx+ejDR0AL5BXUaAX3fYnQyJf6QzrD
+OET4kqDqJ2YUvE22ftEWPlNMxyfsVaJs8ihLGEhS8Sq3sPfbdGx9qs3nABjvX0Ab
-t5aNDoU6vPO77CLkqBavTePTToiVeTIMZP5yHZFQuPWtP/y67e0csNA6ezwpWEh4
+MvDdMx7HeLfD2Grn75mClNji0yUdtKNJGvFx33CTdqtOKvELZf9RJmqtBgrfbqQ6
-4MnpLWzC2YRZ/wKCAQEA3kjpB3977IHFw90Xn8TQu3/SzBMUBqdj5yo6gPBijKNf
+qGhoJ23SYD3R6wKCAQEA3yG4vmGB1/bBIV8FwmmH9mKGqd1nWBq4BJAv4dSrkEK1
-4mZ1shUp6vZkFOHbAmoafjqCzOO18tW4ci+UWAQgdXQWXwsQDUM+fZsr/5Z9LoIN
+xDsuc7ssmivqdBCAnhMx7oBObC2j/uaqeHAR/L2Ik9VdUzVB/50aFuedgN9FEQ/a
-TYuq98Yh/rjKABxkFdMmkLmykuAblDRwVeMf3e4x6/55hAkwvESBRdfnSjjoNmEM
+N3OiQmcYFz5u5On80aSFD4SeuvdDSegFAgSaMYpSKEFziDbESvYmQGe5nWsrxTG7
-MRVW4v5meDv0W4NS1eyohWPe/IoR09dSsmMhz311b7btBxc97NNqDD4SdxmASnOZ
+MgLRQym5OJjXX+Am7LAgyOgXD7dOCduWdevfUHHXcMg4KPUju5jCd2EuQYX/CYk2
-qsE2QxRHRFjpTvytpZH/lTQH6IYdh9REZgX7uvmlmTQwqLy6wX5T/oEzVPRhXgh9
+PkMFime07GL3TQiE2MvhzWsV7qVBqe5T1eBFu2sbpYVkYVmmckrSaKLC8gHDEk1s
-rgbPPJuoZwWF+fXipJ8c+laQ/sdzDKCxEEhRZr7HfQKCAQBKflDVtLnjZbA78Fte
+7WX0K49sxAAJauktikK4viOVvYkmDnaROSQ6TKgR8wKCAQEAtMo2MeZwgaIDMsbn
-6QYffubGcdtCyn7pzl0RfdjKOFH1Us0j17x/pR5G/GIUQZN8YpdwE4gAaOJC3it0
+jtFkJatIgQhT81VtO2sJsuKh8wizzyWvDOGypcUj8FbCfThBK+YQfvM+K1BW+NAL
-jCz7Hz4QU2Pa4oyfPAF3yOIKCcQvpX+HRZwl2SQxxiKYwWwOTtD8JiglA8kktt0b
+sxROOO0WqM9kvLDPKbCkCoiSVRi0NYLGppMHLED9+0A7DeZzwxNgJuwEgr0Z3EB/
-6eEyUDWegu2J4oEpdT/f6jSMw+5M9xMu+eFemnD+EdNWHNrYegKj5q6cC1Nbl+++
+vsx5VNNsSQqqHGi6YBEzgFcNzZpkzreG6sSIRnDmQ1Cqfm1ZpxpuDlHyExSQz76c
-yUuiEA0sgwzDZeriHFBYo+6sc37LS2TkQ8QsxnU8vbU4V73XsAhwOdimq2kjO0Wp
+cihAUQrNoxrC8Jjgs0bJK7LjKeN/M0NUwc4qHuU9IXmLiwzg1fzOIDL4ualsMyYd
-gXsq3vzSBw/n/CwBrzGqBFSCNc1UzVUdvuU9+H5L+wmu9z1eJaGyifIv1ZariJbB
+bQMi6sdapio+50vnbvWfbnfnz6c7UQr1vNW2nrB7j/4KR75jR40s7ZPC+IA0+knR
-BWcjAoIBACWRJPEDdqot9IJ5pzh1RuGpZLLgto25VIUI+gI4ni8unVHiBxolwYPY
+GinXvQKCAQAfsM5oW7jxT16GutQ6lHp3B+9QWN3AqarRGxlx3Z6wUok2YaFrVn4z
-SGnPEfiCfh+/O8Ps6B82R4nkyKlnaSTwjadac0gKiVEpHHKBuH5XtG/anvZpIe2u
+N2GJMn7R9K/2y8pXmvPb1C8KBADKALFRLdCfbMT+5PU7o5G/J/bLQZEgpw+4lqPZ
-xVTnd3LI0Me82pVAEuklQ6cAT65uRzmfNGJAO2BWI5LuPkSpAXXPSQQymxCZ9i9z
+SUi+wmzh6ZfsaE2TCGNKL+XmL3km6BpbFVCvW/ftHaC5LQIz1XDWBQYtSDEodNiV
-0oR02VcWPBTvIAyGOSUYSv2jC1/J0EMlI0IDh4+y20VeaDiAstHiX6IgLU+A6dp/
+rT+JonBk1W8SmcQMu2AeDk4EWYfSCRksL4OqbYaxsjSMeAT10W4zkIVfum0jBy+v
-PE8BHUfSOOO6e2us3ujJ0xV7BWRANOCDlYWu/9EbzI5Cv64n7xy5SqRSukt/8yIW
+Ey9EhZ04nVxorHjk+BunYu4NRlkhEUlP7O4g1XbKbM4NhnBhptZp1w1Nell/hlNQ
-KOJpz/gKfBdC8hZdFvCXZ9Vco4U90PECggEBAIwy5zuWqSaJ8kom7kMZj+JYfhVz
+UyEDSjLpnChY+PzfeocpLrXZg8ez83r5AoIBAQCrufc7Cu36/WoSKoMwd5n9kOQ9
-rdozFil1CkmWcw4E+rNcq8bKVTa9Er6/3nBTXfKX+4sYzMzbFr6xjFyrPA62wjiT
+W4kzu7ZCv/0PxXj8o3nyNkHD/uZHtGGPowhzt8cZR8JKfmDqrCM28WWyGk79x9bN
-2MRdHu9iB+Rtxn83Ilnh+Aqu/8bPFQUlYFr7nefy2t1aL76diQnsBu4xHOtEMgSv
+s/IVyTc5CHe0/zPJooTgpFA8etMhdc5JIYorSZaAgLiOqzDyGuNi9oyfotbLqiFZ
-F6d/pDFRC+PZN0B7glrz870jRaw9LNcuIBVoKN07hGBwD76EEZhCrn6eLqMI8srH
+4uiagMt+hdTP0yEwE1JvzQAwdJvOfMxhiNka6szKb+0QGwBLwCB71OAMXeIfzmBK
-YESDPUR/wl/PV8ZrA/hNRvjp44PYiLMYRDSQw8kpbLMMc0QgQCvhfMbYVvGteTmG
+i0PLomu7tlogS5cePt45lp3nAowreSru/DnfZobVlVFLV9rV+xFuLmxC4zB86cto
-qdCFyy2x70wSh6Rfzb7WEWl15I4yfBTddXkJX82S+MrZu/Xq4FDtng594h0=
+wfZvKgSI/hP6rg0RkcQbBad0ZsVm52NtCWYTB+bISke8wDN552wZVC6lyPat
 -----END rsa private key-----

cryptor/rsa_public_example.pem

@@ -1,14 +1,14 @@
 -----BEGIN rsa public key-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0HaqqGWnNqwRVKoJUUjY
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAyA3SmuwPpYGw/JdzJ9Ia
-iH/dwkSK61La4RGYkvDfcuo9pDgczHVhFUb/MYWeb3bAlFAGcZLYSBh6WAGxbeMj
+h+Z09Q27sueuT1DpqFTYKeJmYQxeI7N8STbmC3dYctsT3Fd+bcfLF2EMscRaae1D
-SkaLroaXnafhKZ2oXXUy8CzyYxZwpLCDgJLG7Pf0jer3STZW93ZT8UJixbKwbqD6
+AEjli56e41VYvVXPgTSMPWboETDgTtPssl0wZHZ23+cKhK9wBgLQ66mzFRM/ro+O
-b8fkpMANwCYrTlXDWBuZVaEKuQNnC4XufQis4fwRxRgfrZuLMvuQVtnyYmssmnp8
+LvydO8jZeaRvG5eATrUaB4ywnXp3j8r42qTlR05EJWbzwPKkW61vePgOyObRwJrF
-JHovYkr87giDjEgvlrC84Lez32ZhEhORRu5NGEDeZ1OewbkXGyQtbcBQYNAxgnOc
+47WGZG6cPCQMd5zSJPQw5o3xOEuhn0FD/GPtM8f+0dxjXpLkcJwnXyUbuAU2WWwe
-O44MTTPhEdz4/A0xwzEe+yIOxWIAWuEM2rclXpZBW/MEK41gZ3C04KcX5R0KRdj2
+JHaYOA2s2anlG6V8ZTUZvbdsKi24byCzHbKwhI48vKvnPRnJt5wxvg1PsiAYAalW
-PTTH7vJ33yRC4hKtWetwMvsUrewrRKVcUgaeFykDAlgIDoSWvG0nzb70AWSoNcj7
+DrIhod+Atdxp4LXzqM5Nyxfp9+BRnxJZASrzqd/z3ZpZJ8q9g9A7XPpGgfSB6H9t
-krLlwEc2WLGy/kCYWppnfYKafEJXpgblHrDFKlWvte68yrvGdCsWRLQ2uUF0xokQ
+cjoy5gD+jVJqN26PBqsiW5RyckI3TXPAXRMnr2xshZ4pze6mDPyiHHruLUrnvHnV
-Ig4u2bApyWNroxEtjHwUp1VeJuZBQkfg+vIW+t3moQpMtlhy4aai/oGIxI5TIB82
+gg62g/MB0p/bipVxd18418yZ2gRl0PtmqD7EfKwgREcA20zWeQtYkioOUclX30uG
-nv8TPVczjHmmE3hwL6nZ5OfbFyWpRFvKLtXcaAKMi2HqOLRkQhqjjJUCO9Wyhu1B
+3vVSf0j2KyoAqWmES52KqUp9pwNdopWvRtQGAey2b9mpdSgl69rM2RmbzFOIDrfw
-kX8RAeKLl3S7gRyhuOB5JNUGEpQ389MdbUX5S12Qp1xTDS+otbC8tYS1gu0OOOWo
+/1ftPpaUi2CVILviSeYtN2egkeB+ghCPCcIS9VUpnNTYcW8Y+cTnfi9FwSEwn13W
-wxbuF5+Ci2SYgSHv/3zXKoMCAwEAAQ==
+pjiYO/K2412uWjNVNvvW3RECAwEAAQ==
 -----END rsa public key-----

strutil/string_test.go

@@ -307,10 +307,21 @@ func TestBeforeLast(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestBeforeLast")
 
-	assert.Equal("lancet", BeforeLast("lancet", ""))
+	tests := []struct {
-	assert.Equal("lancet", BeforeLast("lancet", "abcdef"))
+		input    string
-	assert.Equal("github.com/test", BeforeLast("github.com/test/lancet", "/"))
+		char     string
-	assert.Equal("github.com/test/", BeforeLast("github.com/test/test/lancet", "test"))
+		expected string
+	}{
+		{"lancet", "", "lancet"},
+		{"lancet", "lancet", ""},
+		{"lancet", "abcdef", "lancet"},
+		{"github.com/test/lancet", "/", "github.com/test"},
+		{"github.com/test/test/lancet", "test", "github.com/test/"},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, BeforeLast(tt.input, tt.char))
+	}
 }
 
 func TestAfter(t *testing.T) {
@@ -318,11 +329,21 @@ func TestAfter(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestAfter")
 
-	assert.Equal("lancet", After("lancet", ""))
+	tests := []struct {
-	assert.Equal("", After("lancet", "lancet"))
+		input    string
-	assert.Equal("test/lancet", After("github.com/test/lancet", "/"))
+		char     string
-	assert.Equal("/lancet", After("github.com/test/lancet", "test"))
+		expected string
-	assert.Equal("lancet", After("lancet", "abcdef"))
+	}{
+		{"lancet", "", "lancet"},
+		{"lancet", "lancet", ""},
+		{"lancet", "abcdef", "lancet"},
+		{"github.com/test/lancet", "/", "test/lancet"},
+		{"github.com/test/lancet", "test", "/lancet"},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, After(tt.input, tt.char))
+	}
 }
 
 func TestAfterLast(t *testing.T) {
@@ -330,11 +351,21 @@ func TestAfterLast(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestAfterLast")
 
-	assert.Equal("lancet", AfterLast("lancet", ""))
+	tests := []struct {
-	assert.Equal("lancet", AfterLast("github.com/test/lancet", "/"))
+		input    string
-	assert.Equal("/lancet", AfterLast("github.com/test/lancet", "test"))
+		char     string
-	assert.Equal("/lancet", AfterLast("github.com/test/test/lancet", "test"))
+		expected string
-	assert.Equal("lancet", AfterLast("lancet", "abcdef"))
+	}{
+		{"lancet", "", "lancet"},
+		{"lancet", "lancet", ""},
+		{"lancet", "abcdef", "lancet"},
+		{"github.com/test/lancet", "/", "lancet"},
+		{"github.com/test/test/lancet", "test", "/lancet"},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, AfterLast(tt.input, tt.char))
+	}
 }
 
 func TestIsString(t *testing.T) {
@@ -342,11 +373,20 @@ func TestIsString(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsString")
 
-	assert.Equal(true, IsString("lancet"))
+	tests := []struct {
-	assert.Equal(true, IsString(""))
+		input    interface{}
-	assert.Equal(false, IsString(1))
+		expected bool
-	assert.Equal(false, IsString(true))
+	}{
-	assert.Equal(false, IsString([]string{}))
+		{"lancet", true},
+		{"", true},
+		{1, false},
+		{true, false},
+		{[]string{}, false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsString(tt.input))
+	}
 }
 
 func TestReverse(t *testing.T) {
@@ -363,11 +403,21 @@ func TestWrap(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestWrap")
 
-	assert.Equal("ab", Wrap("ab", ""))
+	tests := []struct {
-	assert.Equal("", Wrap("", "*"))
+		input    string
-	assert.Equal("*ab*", Wrap("ab", "*"))
+		wrapper  string
-	assert.Equal("\"ab\"", Wrap("ab", "\""))
+		expected string
-	assert.Equal("'ab'", Wrap("ab", "'"))
+	}{
+		{"", "", ""},
+		{"ab", "", "ab"},
+		{"ab", "*", "*ab*"},
+		{"ab", "\"", "\"ab\""},
+		{"ab", "'", "'ab'"},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, Wrap(tt.input, tt.wrapper))
+	}
 }
 
 func TestUnwrap(t *testing.T) {
@@ -485,10 +535,21 @@ func TestIsBlank(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsBlank")
 
-	assert.Equal(IsBlank(""), true)
+	tests := []struct {
-	assert.Equal(IsBlank("\t\v\f\n"), true)
+		input    string
+		expected bool
+	}{
+		{"", true},
+		{" ", true},
+		{"\t\v\f\n", true},
+		{"\t\v\f\nabc", false},
+		{"abc", false},
+		{" 中文", false},
+	}
 
-	assert.Equal(IsBlank(" 中文"), false)
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsBlank(tt.input))
+	}
 }
 
 func TestIsNotBlank(t *testing.T) {
@@ -496,12 +557,22 @@ func TestIsNotBlank(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsBlank")
 
-	assert.Equal(IsNotBlank(""), false)
+	tests := []struct {
-	assert.Equal(IsNotBlank("			"), false)
+		input    string
-	assert.Equal(IsNotBlank("\t\v\f\n"), false)
+		expected bool
+	}{
+		{"", false},
+		{"	", false},
+		{"\t\v\f\n", false},
+		{"\t\v\f\nabc", true},
+		{"abc", true},
+		{" 中文", true},
+		{"  	world	", true},
+	}
 
-	assert.Equal(IsNotBlank(" 中文"), true)
+	for _, tt := range tests {
-	assert.Equal(IsNotBlank(" 	world	"), true)
+		assert.Equal(tt.expected, IsNotBlank(tt.input))
+	}
 }
 
 func TestHasPrefixAny(t *testing.T) {
@@ -509,12 +580,19 @@ func TestHasPrefixAny(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestHasPrefixAny")
 
-	str := "foo bar"
+	tests := []struct {
-	prefixes := []string{"fo", "xyz", "hello"}
+		str      string
-	notMatches := []string{"oom", "world"}
+		prefixes []string
+		expected bool
+	}{
+		{"foo bar", []string{"fo", "xyz", "hello"}, true},
+		{"foo bar", []string{"oom", "world"}, false},
+		{"foo bar", []string{}, false},
+	}
 
-	assert.Equal(HasPrefixAny(str, prefixes), true)
+	for _, tt := range tests {
-	assert.Equal(HasPrefixAny(str, notMatches), false)
+		assert.Equal(tt.expected, HasPrefixAny(tt.str, tt.prefixes))
+	}
 }
 
 func TestHasSuffixAny(t *testing.T) {
@@ -522,25 +600,44 @@ func TestHasSuffixAny(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestHasSuffixAny")
 
-	str := "foo bar"
+	tests := []struct {
-	suffixes := []string{"bar", "xyz", "hello"}
+		str      string
-	notMatches := []string{"oom", "world"}
+		suffixes []string
+		expected bool
+	}{
+		{"foo bar", []string{"bar", "xyz", "hello"}, true},
+		{"foo bar", []string{"oom", "world"}, false},
+		{"foo bar", []string{}, false},
+	}
 
-	assert.Equal(HasSuffixAny(str, suffixes), true)
+	for _, tt := range tests {
-	assert.Equal(HasSuffixAny(str, notMatches), false)
+		assert.Equal(tt.expected, HasSuffixAny(tt.str, tt.suffixes))
+	}
 }
 
 func TestIndexOffset(t *testing.T) {
 	t.Parallel()
 
 	assert := internal.NewAssert(t, "TestIndexOffset")
+
 	str := "foo bar hello world"
 
-	assert.Equal(IndexOffset(str, "o", 5), 12)
+	tests := []struct {
-	assert.Equal(IndexOffset(str, "o", 0), 1)
+		str      string
-	assert.Equal(IndexOffset(str, "d", len(str)-1), len(str)-1)
+		substr   string
-	assert.Equal(IndexOffset(str, "d", len(str)), -1)
+		offset   int
-	assert.Equal(IndexOffset(str, "f", -1), -1)
+		expected int
+	}{
+		{str, "o", 5, 12},
+		{str, "o", 0, 1},
+		{str, "d", len(str) - 1, len(str) - 1},
+		{str, "d", len(str), -1},
+		{str, "f", -1, -1},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IndexOffset(tt.str, tt.substr, tt.offset))
+	}
 }
 
 func TestReplaceWithMap(t *testing.T) {
@@ -648,13 +745,23 @@ func TestSubInBetween(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestSubInBetween")
 
-	str := "abcde"
+	tests := []struct {
+		input    string
+		start    string
+		end      string
+		expected string
+	}{
+		{"abcde", "", "", ""},
+		{"abcde", "a", "d", "bc"},
+		{"abcde", "a", "e", "bcd"},
+		{"abcde", "a", "f", ""},
+		{"abcde", "a", "", ""},
+		{"abcde", "", "e", "abcd"},
+	}
 
-	assert.Equal("", SubInBetween(str, "", ""))
+	for _, tt := range tests {
-	assert.Equal("ab", SubInBetween(str, "", "c"))
+		assert.Equal(tt.expected, SubInBetween(tt.input, tt.start, tt.end))
-	assert.Equal("bc", SubInBetween(str, "a", "d"))
+	}
-	assert.Equal("", SubInBetween(str, "a", ""))
-	assert.Equal("", SubInBetween(str, "a", "f"))
 }
 
 func TestHammingDistance(t *testing.T) {
@@ -696,13 +803,22 @@ func TestConcat(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestConcat")
 
-	assert.Equal("", Concat(0))
+	tests := []struct {
-	assert.Equal("a", Concat(1, "a"))
+		args     []string
-	assert.Equal("ab", Concat(2, "a", "b"))
+		expected string
-	assert.Equal("abc", Concat(3, "a", "b", "c"))
+	}{
-	assert.Equal("abc", Concat(3, "a", "", "b", "c", ""))
+		{[]string{}, ""},
-	assert.Equal("你好，世界！", Concat(0, "你好", "，", "", "世界！", ""))
+		{[]string{"a"}, "a"},
-	assert.Equal("Hello World!", Concat(0, "Hello", " Wo", "r", "ld!", ""))
+		{[]string{"a", "b"}, "ab"},
+		{[]string{"a", "b", "c"}, "abc"},
+		{[]string{"a", "", "b", "c", ""}, "abc"},
+		{[]string{"你好", "，", "", "世界！", ""}, "你好，世界！"},
+		{[]string{"Hello", " Wo", "r", "ld!", ""}, "Hello World!"},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, Concat(0, tt.args...))
+	}
 }
 
 func TestEllipsis(t *testing.T) {

validator/validator_test.go

@@ -15,16 +15,25 @@ func TestIsAllUpper(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsAllUpper")
 
-	assert.Equal(true, IsAllUpper("ABC"))
+	tests := []struct {
-	assert.Equal(false, IsAllUpper(""))
+		input    string
-	assert.Equal(false, IsAllUpper("abc"))
+		expected bool
-	assert.Equal(false, IsAllUpper("aBC"))
+	}{
-	assert.Equal(false, IsAllUpper("1BC"))
+		{"ABC", true},
-	assert.Equal(false, IsAllUpper("1bc"))
+		{"", false},
-	assert.Equal(false, IsAllUpper("123"))
+		{"abc", false},
-	assert.Equal(false, IsAllUpper("你好"))
+		{"aBC", false},
-	assert.Equal(false, IsAllUpper("A&"))
+		{"1BC", false},
-	assert.Equal(false, IsAllUpper("&@#$%^&*"))
+		{"1bc", false},
+		{"123", false},
+		{"你好", false},
+		{"A&", false},
+		{"&@#$%^&*", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsAllUpper(tt.input))
+	}
 }
 
 func TestIsAllLower(t *testing.T) {
@@ -32,16 +41,25 @@ func TestIsAllLower(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsAllLower")
 
-	assert.Equal(true, IsAllLower("abc"))
+	tests := []struct {
-	assert.Equal(false, IsAllLower("ABC"))
+		input    string
-	assert.Equal(false, IsAllLower(""))
+		expected bool
-	assert.Equal(false, IsAllLower("aBC"))
+	}{
-	assert.Equal(false, IsAllLower("1BC"))
+		{"abc", true},
-	assert.Equal(false, IsAllLower("1bc"))
+		{"", false},
-	assert.Equal(false, IsAllLower("123"))
+		{"ABC", false},
-	assert.Equal(false, IsAllLower("你好"))
+		{"aBC", false},
-	assert.Equal(false, IsAllLower("A&"))
+		{"1BC", false},
-	assert.Equal(false, IsAllLower("&@#$%^&*"))
+		{"1bc", false},
+		{"123", false},
+		{"你好", false},
+		{"A&", false},
+		{"&@#$%^&*", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsAllLower(tt.input))
+	}
 }
 
 func TestContainLower(t *testing.T) {
@@ -49,17 +67,25 @@ func TestContainLower(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestContainLower")
 
-	assert.Equal(true, ContainLower("abc"))
+	tests := []struct {
-	assert.Equal(true, ContainLower("aBC"))
+		input    string
-	assert.Equal(true, ContainLower("1bc"))
+		expected bool
-	assert.Equal(true, ContainLower("a&"))
+	}{
+		{"abc", true},
+		{"aBC", true},
+		{"1bc", true},
+		{"a&", true},
+		{"ABC", false},
+		{"", false},
+		{"1BC", false},
+		{"123", false},
+		{"你好", false},
+		{"&@#$%^&*", false},
+	}
 
-	assert.Equal(false, ContainLower("ABC"))
+	for _, tt := range tests {
-	assert.Equal(false, ContainLower(""))
+		assert.Equal(tt.expected, ContainLower(tt.input))
-	assert.Equal(false, ContainLower("1BC"))
+	}
-	assert.Equal(false, ContainLower("123"))
-	assert.Equal(false, ContainLower("你好"))
-	assert.Equal(false, ContainLower("&@#$%^&*"))
 }
 
 func TestContainUpper(t *testing.T) {
@@ -67,17 +93,25 @@ func TestContainUpper(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestContainUpper")
 
-	assert.Equal(true, ContainUpper("ABC"))
+	tests := []struct {
-	assert.Equal(true, ContainUpper("aBC"))
+		input    string
-	assert.Equal(true, ContainUpper("1BC"))
+		expected bool
-	assert.Equal(true, ContainUpper("A&"))
+	}{
+		{"ABC", true},
+		{"aBC", true},
+		{"1BC", true},
+		{"A&", true},
+		{"abc", false},
+		{"", false},
+		{"1bc", false},
+		{"123", false},
+		{"你好", false},
+		{"&@#$%^&*", false},
+	}
 
-	assert.Equal(false, ContainUpper("abc"))
+	for _, tt := range tests {
-	assert.Equal(false, ContainUpper(""))
+		assert.Equal(tt.expected, ContainUpper(tt.input))
-	assert.Equal(false, ContainUpper("1bc"))
+	}
-	assert.Equal(false, ContainUpper("123"))
-	assert.Equal(false, ContainUpper("你好"))
-	assert.Equal(false, ContainUpper("&@#$%^&*"))
 }
 
 func TestContainLetter(t *testing.T) {
@@ -85,15 +119,23 @@ func TestContainLetter(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestContainLetter")
 
-	assert.Equal(true, ContainLetter("ABC"))
+	tests := []struct {
-	assert.Equal(true, ContainLetter("1Bc"))
+		input    string
-	assert.Equal(true, ContainLetter("1ab"))
+		expected bool
-	assert.Equal(true, ContainLetter("A&"))
+	}{
+		{"ABC", true},
+		{"1Bc", true},
+		{"1ab", true},
+		{"A&", true},
+		{"", false},
+		{"123", false},
+		{"你好", false},
+		{"&@#$%^&*", false},
+	}
 
-	assert.Equal(false, ContainLetter(""))
+	for _, tt := range tests {
-	assert.Equal(false, ContainLetter("123"))
+		assert.Equal(tt.expected, ContainLetter(tt.input))
-	assert.Equal(false, ContainLetter("你好"))
+	}
-	assert.Equal(false, ContainLetter("&@#$%^&*"))
 }
 
 func TestContainNumber(t *testing.T) {
@@ -101,18 +143,26 @@ func TestContainNumber(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestContainNumber")
 
-	assert.Equal(true, ContainNumber("123"))
+	tests := []struct {
-	assert.Equal(true, ContainNumber("1Bc"))
+		input    string
-	assert.Equal(true, ContainNumber("a2c"))
+		expected bool
-	assert.Equal(true, ContainNumber("ab3"))
+	}{
-	assert.Equal(true, ContainNumber("a23"))
+		{"123", true},
-	assert.Equal(true, ContainNumber("a23c"))
+		{"1Bc", true},
-	assert.Equal(true, ContainNumber("1%%%"))
+		{"a2c", true},
+		{"ab3", true},
+		{"a23", true},
+		{"a23c", true},
+		{"1%%%", true},
+		{"ABC", false},
+		{"", false},
+		{"你好", false},
+		{"&@#$%^&*", false},
+	}
 
-	assert.Equal(false, ContainNumber("ABC"))
+	for _, tt := range tests {
-	assert.Equal(false, ContainNumber(""))
+		assert.Equal(tt.expected, ContainNumber(tt.input))
-	assert.Equal(false, ContainNumber("你好"))
+	}
-	assert.Equal(false, ContainNumber("&@#$%^&*"))
 }
 
 func TestIsJSON(t *testing.T) {
@@ -120,15 +170,23 @@ func TestIsJSON(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsJSON")
 
-	assert.Equal(true, IsJSON("{}"))
+	tests := []struct {
-	assert.Equal(true, IsJSON("{\"name\": \"test\"}"))
+		input    string
-	assert.Equal(true, IsJSON("[]"))
+		expected bool
-	assert.Equal(true, IsJSON("123"))
+	}{
+		{"{}", true},
+		{"{\"name\": \"test\"}", true},
+		{"[]", true},
+		{"123", true},
+		{"", false},
+		{"abc", false},
+		{"你好", false},
+		{"&@#$%^&*", false},
+	}
 
-	assert.Equal(false, IsJSON(""))
+	for _, tt := range tests {
-	assert.Equal(false, IsJSON("abc"))
+		assert.Equal(tt.expected, IsJSON(tt.input))
-	assert.Equal(false, IsJSON("你好"))
+	}
-	assert.Equal(false, IsJSON("&@#$%^&*"))
 }
 
 func TestIsNumber(t *testing.T) {
@@ -136,10 +194,19 @@ func TestIsNumber(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsNumber")
 
-	assert.Equal(false, IsNumber(""))
+	tests := []struct {
-	assert.Equal(false, IsNumber("3"))
+		input    interface{}
-	assert.Equal(true, IsNumber(0))
+		expected bool
-	assert.Equal(true, IsNumber(0.1))
+	}{
+		{"", false},
+		{"3", false},
+		{0, true},
+		{0.1, true},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsNumber(tt.input))
+	}
 }
 
 func TestIsFloat(t *testing.T) {
@@ -147,10 +214,19 @@ func TestIsFloat(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsFloat")
 
-	assert.Equal(false, IsFloat(""))
+	tests := []struct {
-	assert.Equal(false, IsFloat("3"))
+		input    interface{}
-	assert.Equal(false, IsFloat(0))
+		expected bool
-	assert.Equal(true, IsFloat(0.1))
+	}{
+		{"", false},
+		{"3", false},
+		{0, false},
+		{0.1, true},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsFloat(tt.input))
+	}
 }
 
 func TestIsInt(t *testing.T) {
@@ -158,11 +234,20 @@ func TestIsInt(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsInt")
 
-	assert.Equal(false, IsInt(""))
+	tests := []struct {
-	assert.Equal(false, IsInt("3"))
+		input    interface{}
-	assert.Equal(false, IsInt(0.1))
+		expected bool
-	assert.Equal(true, IsInt(0))
+	}{
-	assert.Equal(true, IsInt(-1))
+		{"", false},
+		{"3", false},
+		{0.1, false},
+		{0, true},
+		{-1, true},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsInt(tt.input))
+	}
 }
 
 func TestIsNumberStr(t *testing.T) {
@@ -170,11 +255,21 @@ func TestIsNumberStr(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsNumberStr")
 
-	assert.Equal(true, IsNumberStr("3."))
+	tests := []struct {
-	assert.Equal(true, IsNumberStr("+3."))
+		input    string
-	assert.Equal(true, IsNumberStr("-3."))
+		expected bool
-	assert.Equal(true, IsNumberStr("+3e2"))
+	}{
-	assert.Equal(false, IsNumberStr("abc"))
+		{"3", true},
+		{"3.", true},
+		{"+3.", true},
+		{"-3.", true},
+		{"+3e2", true},
+		{"abc", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsNumberStr(tt.input))
+	}
 }
 
 func TestIsFloatStr(t *testing.T) {
@@ -182,11 +277,21 @@ func TestIsFloatStr(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsFloatStr")
 
-	assert.Equal(true, IsFloatStr("3."))
+	tests := []struct {
-	assert.Equal(true, IsFloatStr("+3."))
+		input    string
-	assert.Equal(true, IsFloatStr("-3."))
+		expected bool
-	assert.Equal(true, IsFloatStr("12"))
+	}{
-	assert.Equal(false, IsFloatStr("abc"))
+		{"3", true},
+		{"3.", true},
+		{"+3.", true},
+		{"-3.", true},
+		{"12", true},
+		{"abc", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsFloatStr(tt.input))
+	}
 }
 
 func TestIsIntStr(t *testing.T) {
@@ -194,10 +299,20 @@ func TestIsIntStr(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsIntStr")
 
-	assert.Equal(true, IsIntStr("+3"))
+	tests := []struct {
-	assert.Equal(true, IsIntStr("-3"))
+		input    string
-	assert.Equal(false, IsIntStr("3."))
+		expected bool
-	assert.Equal(false, IsIntStr("abc"))
+	}{
+		{"3", true},
+		{"3.", false},
+		{"+3", true},
+		{"-3", true},
+		{"abc", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsIntStr(tt.input))
+	}
 }
 
 func TestIsPort(t *testing.T) {
@@ -205,13 +320,22 @@ func TestIsPort(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsPort")
 
-	assert.Equal(true, IsPort("1"))
+	tests := []struct {
-	assert.Equal(true, IsPort("65535"))
+		input    string
-	assert.Equal(false, IsPort("abc"))
+		expected bool
-	assert.Equal(false, IsPort("123abc"))
+	}{
-	assert.Equal(false, IsPort(""))
+		{"1", true},
-	assert.Equal(false, IsPort("-1"))
+		{"65535", true},
-	assert.Equal(false, IsPort("65536"))
+		{"abc", false},
+		{"123abc", false},
+		{"", false},
+		{"-1", false},
+		{"65536", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsPort(tt.input))
+	}
 }
 
 func TestIsIp(t *testing.T) {
@@ -219,10 +343,19 @@ func TestIsIp(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsIntStr")
 
-	assert.Equal(true, IsIp("127.0.0.1"))
+	tests := []struct {
-	assert.Equal(true, IsIp("::0:0:0:0:0:0:1"))
+		input    string
-	assert.Equal(false, IsIp("127.0.0"))
+		expected bool
-	assert.Equal(false, IsIp("127"))
+	}{
+		{"127.0.0.1", true},
+		{"::0:0:0:0:0:0:1", true},
+		{"127.0.0", false},
+		{"127", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsIp(tt.input))
+	}
 }
 
 func TestIsIpPort(t *testing.T) {
@@ -230,16 +363,25 @@ func TestIsIpPort(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsIpPort")
 
-	assert.Equal(true, IsIpPort("[0:0:0:0:0:0:0:1]:8080")) // valid IPv6 and port
+	tests := []struct {
-	assert.Equal(true, IsIpPort("127.0.0.1:8080"))         // valid IP and port
+		input    string
+		expected bool
+	}{
+		{"[::0:0:0:0:0:0:1]:8080", true},
+		{"127.0.0.1:8080", true},
 
-	assert.Equal(false, IsIpPort(""))                     // empty string
+		{"", false},
-	assert.Equal(false, IsIpPort(":8080"))                // only port
+		{":8080", false},
-	assert.Equal(false, IsIpPort("127.0.0.1"))            // valid IP without port
+		{"127.0.0.1", false},
-	assert.Equal(false, IsIpPort("0:0:0:0:0:0:0:1"))      // valid IPv6 without port
+		{"0:0:0:0:0:0:0:1", false},
-	assert.Equal(false, IsIpPort("256.256.256.256:8080")) // invalid IP with valid port
+		{"256.256.256.256:8080", false},
-	assert.Equal(false, IsIpPort("256.256.256.256:abc"))  // invalid IP and invalid port
+		{"256.256.256.256:abc", false},
-	assert.Equal(false, IsIpPort("127.0.0.1:70000"))      // valid IP with invalid port
+		{"127.0.0.1:70000", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsIpPort(tt.input))
+	}
 }
 
 func TestIsIpV4(t *testing.T) {
@@ -247,13 +389,23 @@ func TestIsIpV4(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsIpV4")
 
-	assert.Equal(true, IsIpV4("127.0.0.1"))
+	tests := []struct {
+		input    string
+		expected bool
+	}{
+		{"127.0.0.1", true},
+		{"::0:0:0:0:0:0:1", false},
 
-	assert.Equal(false, IsIpV4("::0:0:0:0:0:0:1"))
+		{"::0:0:0:0:0:0:1", false},
-	assert.Equal(false, IsIpV4("127.0.0.1.1"))
+		{"127.0.0.1.1", false},
-	assert.Equal(false, IsIpV4("256.0.0.1"))
+		{"256.0.0.1", false},
-	assert.Equal(false, IsIpV4("127.0.0.a"))
+		{"127.0.0.a", false},
-	assert.Equal(false, IsIpV4(""))
+		{"", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsIpV4(tt.input))
+	}
 }
 
 func TestIsIpV6(t *testing.T) {
@@ -261,14 +413,23 @@ func TestIsIpV6(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsIpV6")
 
-	assert.Equal(true, IsIpV6("::0:0:0:0:0:0:1"))
+	tests := []struct {
-	assert.Equal(true, IsIpV6("::1"))
+		input    string
-	assert.Equal(true, IsIpV6("::"))
+		expected bool
+	}{
+		{"::0:0:0:0:0:0:1", true},
+		{"::1", true},
+		{"::", true},
+		{"127.0.0.1", false},
+		{"2001:db8::8a2e:37023:7334", false},
+		{"2001::25de::cade", false},
+		{"", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsIpV6(tt.input))
+	}
 
-	assert.Equal(false, IsIpV6("127.0.0.1"))
-	assert.Equal(false, IsIpV6("2001:db8::8a2e:37023:7334"))
-	assert.Equal(false, IsIpV6("2001::25de::cade"))
-	assert.Equal(false, IsIpV6(""))
 }
 
 func TestIsUrl(t *testing.T) {
@@ -287,13 +448,21 @@ func TestIsDns(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsDns")
 
-	assert.Equal(true, IsDns("abc.com"))
+	tests := []struct {
-	assert.Equal(true, IsDns("123.cn"))
+		input    string
-	assert.Equal(true, IsDns("a.b.com"))
+		expected bool
+	}{
+		{"abc.com", true},
+		{"123.cn", true},
+		{"a.b.com", true},
+		{"a.b.c", false},
+		{"a@b.com", false},
+		{"http://abc.com", false},
+	}
 
-	assert.Equal(false, IsDns("a.b.c"))
+	for _, tt := range tests {
-	assert.Equal(false, IsDns("a@b.com"))
+		assert.Equal(tt.expected, IsDns(tt.input))
-	assert.Equal(false, IsDns("http://abc.com"))
+	}
 }
 
 func TestIsEmail(t *testing.T) {
@@ -330,11 +499,19 @@ func TestIsChinesePhone(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsChinesePhone")
 
-	assert.Equal(true, IsChinesePhone("010-32116675"))
+	tests := []struct {
-	assert.Equal(true, IsChinesePhone("0464-8756213"))
+		input    string
-	assert.Equal(true, IsChinesePhone("0731-82251545")) // 长沙晚报电话
+		expected bool
-	assert.Equal(false, IsChinesePhone("123-87562"))
+	}{
+		{"010-32116675", true},
+		{"0464-8756213", true},
+		{"0731-82251545", true},
+		{"123-87562", false},
+	}
 
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsChinesePhone(tt.input))
+	}
 }
 
 func TestIsChineseIdNum(t *testing.T) {
@@ -342,13 +519,23 @@ func TestIsChineseIdNum(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsChineseIdNum")
 
-	assert.Equal(true, IsChineseIdNum("210911192105130714"))
+	tests := []struct {
-	assert.Equal(true, IsChineseIdNum("11010519491231002X"))
+		input    string
-	assert.Equal(true, IsChineseIdNum("11010519491231002x"))
+		expected bool
-	assert.Equal(false, IsChineseIdNum("123456"))
+	}{
-	assert.Equal(false, IsChineseIdNum("990911192105130714"))
+		{"210911192105130714", true},
-	assert.Equal(false, IsChineseIdNum("990911189905130714"))
+		{"11010519491231002X", true},
-	assert.Equal(false, IsChineseIdNum("210911222205130714"))
+		{"11010519491231002x", true},
+		{"123456", false},
+		{"990911192105130714", false},
+		{"990911189905130714", false},
+		{"210911222205130714", false},
+		{"", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsChineseIdNum(tt.input))
+	}
 }
 
 func TestIsCreditCard(t *testing.T) {
@@ -407,13 +594,23 @@ func TestIsStrongPassword(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsStrongPassword")
 
-	assert.Equal(false, IsStrongPassword("abc", 3))
+	tests := []struct {
-	assert.Equal(false, IsStrongPassword("abc123", 6))
+		input    string
-	assert.Equal(false, IsStrongPassword("abcABC", 6))
+		length   int
-	assert.Equal(false, IsStrongPassword("abc123@#$", 9))
+		expected bool
-	assert.Equal(false, IsStrongPassword("abcABC123@#$", 16))
+	}{
-	assert.Equal(true, IsStrongPassword("abcABC123@#$", 12))
+		{"abc", 3, false},
-	assert.Equal(true, IsStrongPassword("abcABC123@#$", 10))
+		{"abc123", 6, false},
+		{"abcABC", 6, false},
+		{"abc123@#$", 9, false},
+		{"abcABC123@#$", 16, false},
+		{"abcABC123@#$", 12, true},
+		{"abcABC123@#$", 10, true},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsStrongPassword(tt.input, tt.length))
+	}
 }
 
 func TestIsWeakPassword(t *testing.T) {
@@ -421,11 +618,20 @@ func TestIsWeakPassword(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsWeakPassword")
 
-	assert.Equal(true, IsWeakPassword("abc"))
+	tests := []struct {
-	assert.Equal(true, IsWeakPassword("123"))
+		input    string
-	assert.Equal(true, IsWeakPassword("abc123"))
+		expected bool
-	assert.Equal(true, IsWeakPassword("abcABC123"))
+	}{
-	assert.Equal(false, IsWeakPassword("abc123@#$"))
+		{"abc", true},
+		{"123", true},
+		{"abc123", true},
+		{"abcABC123", true},
+		{"abc123@#$", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsWeakPassword(tt.input))
+	}
 }
 
 func TestIsZeroValue(t *testing.T) {
@@ -566,50 +772,83 @@ func TestIsPrintable(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsPrintable")
 
-	assert.Equal(true, IsPrintable("ABC"))
+	tests := []struct {
-	assert.Equal(true, IsPrintable("{id: 123}"))
+		input    string
-	assert.Equal(true, IsPrintable(""))
+		expected bool
-	assert.Equal(true, IsPrintable("😄"))
+	}{
-	assert.Equal(false, IsPrintable("\u0000"))
+		{"ABC", true},
+		{"123", true},
+		{"你好", true},
+		{"", true},
+		{"😄", true},
+		{"\u0000", false},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, IsPrintable(tt.input))
+	}
 }
 
 func TestIsBin(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestIsBin")
 
-	assert.Equal(true, IsBin("0101"))
+	tests := []struct {
-	assert.Equal(true, IsBin("0b1101"))
+		input    string
+		expected bool
+	}{
+		{"0101", true},
+		{"0b1101", true},
+		{"b1101", false},
+		{"1201", false},
+		{"", false},
+	}
 
-	assert.Equal(false, IsBin("b1101"))
+	for _, tt := range tests {
-	assert.Equal(false, IsBin("1201"))
+		assert.Equal(tt.expected, IsBin(tt.input))
-	assert.Equal(false, IsBin(""))
+	}
 }
 
 func TestIsHex(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestIsHex")
 
-	assert.Equal(true, IsHex("ABCDE"))
+	tests := []struct {
-	assert.Equal(true, IsHex("abcde"))
+		input    string
-	assert.Equal(true, IsHex("0xabcde"))
+		expected bool
-	assert.Equal(true, IsHex("0Xabcde"))
+	}{
-	assert.Equal(true, IsHex("#abcde"))
+		{"ABCDE", true},
+		{"abcde", true},
+		{"0xabcde", true},
+		{"0Xabcde", true},
+		{"#abcde", true},
+		{"cdfeg", false},
+		{"0xcdfeg", false},
+		{"", false},
+	}
 
-	assert.Equal(false, IsHex("cdfeg"))
+	for _, tt := range tests {
-	assert.Equal(false, IsHex("0xcdfeg"))
+		assert.Equal(tt.expected, IsHex(tt.input))
-	assert.Equal(false, IsHex(""))
+	}
 }
 
 func TestIsBase64URL(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestIsBase64URL")
 
-	assert.Equal(true, IsBase64URL("SAGsbG8sIHdvcmxkIQ"))
+	tests := []struct {
-	assert.Equal(true, IsBase64URL("SAGsbG8sIHdvcmxkIQ=="))
+		input    string
+		expected bool
+	}{
+		{"SAGsbG8sIHdvcmxkIQ", true},
+		{"SAGsbG8sIHdvcmxkIQ==", true},
+		{"SAGsbG8sIHdvcmxkIQ=", false},
+		{"SAGsbG8sIHdvcmxkIQ===", false},
+	}
 
-	assert.Equal(false, IsBase64URL("SAGsbG8sIHdvcmxkIQ="))
+	for _, tt := range tests {
-	assert.Equal(false, IsBase64URL("SAGsbG8sIHdvcmxkIQ==="))
+		assert.Equal(tt.expected, IsBase64URL(tt.input))
-	// assert.Equal(false, IsBase64URL(""))
+	}
 }
 
 func TestIsJWT(t *testing.T) {
@@ -665,15 +904,23 @@ func TestIsAlphaNumeric(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsAlphaNumeric")
 
-	assert.Equal(true, IsAlphaNumeric("ABC"))
+	tests := []struct {
-	assert.Equal(true, IsAlphaNumeric("abc"))
+		input    string
-	assert.Equal(true, IsAlphaNumeric("aBC"))
+		expected bool
-	assert.Equal(true, IsAlphaNumeric("1BC"))
+	}{
-	assert.Equal(true, IsAlphaNumeric("1bc"))
+		{"ABC", true},
-	assert.Equal(true, IsAlphaNumeric("123"))
+		{"abc", true},
+		{"aBC", true},
+		{"1BC", true},
+		{"1bc", true},
+		{"123", true},
+		{"你好", false},
+		{"A&", false},
+		{"&@#$%^&*", false},
+		{"", false},
+	}
 
-	assert.Equal(false, IsAlphaNumeric(""))
+	for _, tt := range tests {
-	assert.Equal(false, IsAlphaNumeric("你好"))
+		assert.Equal(tt.expected, IsAlphaNumeric(tt.input))
-	assert.Equal(false, IsAlphaNumeric("A&"))
+	}
-	assert.Equal(false, IsAlphaNumeric("&@#$%^&*"))
 }