From f7be4190f1ebde32d3c15200cb9ac1c33d4a6095 Mon Sep 17 00:00:00 2001 From: dudaodong Date: Thu, 27 Mar 2025 10:49:40 +0800 Subject: [PATCH] test: format test code --- cryptor/rsa_private_example.pem | 98 ++--- cryptor/rsa_public_example.pem | 24 +- validator/validator_test.go | 625 ++++++++++++++++++++++---------- 3 files changed, 497 insertions(+), 250 deletions(-) diff --git a/cryptor/rsa_private_example.pem b/cryptor/rsa_private_example.pem index e9039c8..a111a3c 100644 --- a/cryptor/rsa_private_example.pem +++ b/cryptor/rsa_private_example.pem @@ -1,51 +1,51 @@ -----BEGIN rsa private key----- -MIIJKAIBAAKCAgEA0HaqqGWnNqwRVKoJUUjYiH/dwkSK61La4RGYkvDfcuo9pDgc -zHVhFUb/MYWeb3bAlFAGcZLYSBh6WAGxbeMjSkaLroaXnafhKZ2oXXUy8CzyYxZw -pLCDgJLG7Pf0jer3STZW93ZT8UJixbKwbqD6b8fkpMANwCYrTlXDWBuZVaEKuQNn -C4XufQis4fwRxRgfrZuLMvuQVtnyYmssmnp8JHovYkr87giDjEgvlrC84Lez32Zh -EhORRu5NGEDeZ1OewbkXGyQtbcBQYNAxgnOcO44MTTPhEdz4/A0xwzEe+yIOxWIA -WuEM2rclXpZBW/MEK41gZ3C04KcX5R0KRdj2PTTH7vJ33yRC4hKtWetwMvsUrewr -RKVcUgaeFykDAlgIDoSWvG0nzb70AWSoNcj7krLlwEc2WLGy/kCYWppnfYKafEJX -pgblHrDFKlWvte68yrvGdCsWRLQ2uUF0xokQIg4u2bApyWNroxEtjHwUp1VeJuZB -Qkfg+vIW+t3moQpMtlhy4aai/oGIxI5TIB82nv8TPVczjHmmE3hwL6nZ5OfbFyWp -RFvKLtXcaAKMi2HqOLRkQhqjjJUCO9Wyhu1BkX8RAeKLl3S7gRyhuOB5JNUGEpQ3 -89MdbUX5S12Qp1xTDS+otbC8tYS1gu0OOOWowxbuF5+Ci2SYgSHv/3zXKoMCAwEA -AQKCAgBASCdt0BLVABBEDD7dStpClTNbwWkZEa6e8p8ayJ4OwH6LkiYHQjbSqdbt -fWeStYrC8T5bbU22RZ4MX1FIMl9iewh9o9FC806yV4RgdVBk0WdY+MV5c1jJn/kp -f3hw/sCMWe5NVrah0bfFgMl5A7jWGUy/JN3Yn6yA9l9LXw9UYVl+Hbd7zSvycGdn -NCSCo2K5VRqCeSJUNdbRVH0nkZeQZAESjU8bU5LFAklybUOBBAS6YcaTHWeR+M/b -J72tHRL6Z8nhO7Gqg0AF6o0pzd6iWrYeZF4F9R7uEl+C8jW8eQ8W/JZhb75X/1vN -pAW5heGGUI0muJF+KOhsZR0S1slvHbCSvwaNBQi8HEbOEPa7wVzsrGLfc+re5ysF -X2n5GL4qBwNdMHrADnMWWVa9LEUSr3XmXfpmNDctmdv1ekWpJ44G/qrjKOuimtfk -t9haDjhN5lx3V05k18kb53tYAdi3CqrT4syiibtqZLvTRam/yoFJgSOczO5WxNNk -xnhnEdr/FQcFQhzuQ6gU196SBi8Bqjz1t0cNozNu3wvp8Fu0G8Rr9gjYnH8m5xXz -xb9xevR7X/swfxd+/KUqoenYdU5ZFJpDRCmUMDKWR/3Q7s4SRxMN0+c/uBSaih3J -I9I8urHG6mFW2qWQZTvuostmb7vVHaefx0RZOhX0efJVMZPwiQKCAQEA8BUXRw9k -Ms3tqmBMVM4sMcPgsffJxjAJUdunUgEpaBAqrDQmZ6uBjAYq7iTzLgJJuLI1o1sv -HtEWuGLHRRJpdoEamGweJE/o28OH2MBiiL2ezfRIHsg8RRr6os6KvlKevty6m7d9 -hAvpS6XvZGK2eCSooL6zZ8XTgnDw+Hw8Q4i+dazjb5dDRRL97eHHUqzcYH5vIsAE -EBaNXMKrhf/NyVWCJBVRHg8PZZjGXcrj8ZMx+ejDR0AL5BXUaAX3fYnQyJf6QzrD -t5aNDoU6vPO77CLkqBavTePTToiVeTIMZP5yHZFQuPWtP/y67e0csNA6ezwpWEh4 -4MnpLWzC2YRZ/wKCAQEA3kjpB3977IHFw90Xn8TQu3/SzBMUBqdj5yo6gPBijKNf -4mZ1shUp6vZkFOHbAmoafjqCzOO18tW4ci+UWAQgdXQWXwsQDUM+fZsr/5Z9LoIN -TYuq98Yh/rjKABxkFdMmkLmykuAblDRwVeMf3e4x6/55hAkwvESBRdfnSjjoNmEM -MRVW4v5meDv0W4NS1eyohWPe/IoR09dSsmMhz311b7btBxc97NNqDD4SdxmASnOZ -qsE2QxRHRFjpTvytpZH/lTQH6IYdh9REZgX7uvmlmTQwqLy6wX5T/oEzVPRhXgh9 -rgbPPJuoZwWF+fXipJ8c+laQ/sdzDKCxEEhRZr7HfQKCAQBKflDVtLnjZbA78Fte -6QYffubGcdtCyn7pzl0RfdjKOFH1Us0j17x/pR5G/GIUQZN8YpdwE4gAaOJC3it0 -jCz7Hz4QU2Pa4oyfPAF3yOIKCcQvpX+HRZwl2SQxxiKYwWwOTtD8JiglA8kktt0b -6eEyUDWegu2J4oEpdT/f6jSMw+5M9xMu+eFemnD+EdNWHNrYegKj5q6cC1Nbl+++ -yUuiEA0sgwzDZeriHFBYo+6sc37LS2TkQ8QsxnU8vbU4V73XsAhwOdimq2kjO0Wp -gXsq3vzSBw/n/CwBrzGqBFSCNc1UzVUdvuU9+H5L+wmu9z1eJaGyifIv1ZariJbB -BWcjAoIBACWRJPEDdqot9IJ5pzh1RuGpZLLgto25VIUI+gI4ni8unVHiBxolwYPY -SGnPEfiCfh+/O8Ps6B82R4nkyKlnaSTwjadac0gKiVEpHHKBuH5XtG/anvZpIe2u -xVTnd3LI0Me82pVAEuklQ6cAT65uRzmfNGJAO2BWI5LuPkSpAXXPSQQymxCZ9i9z -0oR02VcWPBTvIAyGOSUYSv2jC1/J0EMlI0IDh4+y20VeaDiAstHiX6IgLU+A6dp/ -PE8BHUfSOOO6e2us3ujJ0xV7BWRANOCDlYWu/9EbzI5Cv64n7xy5SqRSukt/8yIW -KOJpz/gKfBdC8hZdFvCXZ9Vco4U90PECggEBAIwy5zuWqSaJ8kom7kMZj+JYfhVz -rdozFil1CkmWcw4E+rNcq8bKVTa9Er6/3nBTXfKX+4sYzMzbFr6xjFyrPA62wjiT -2MRdHu9iB+Rtxn83Ilnh+Aqu/8bPFQUlYFr7nefy2t1aL76diQnsBu4xHOtEMgSv -F6d/pDFRC+PZN0B7glrz870jRaw9LNcuIBVoKN07hGBwD76EEZhCrn6eLqMI8srH -YESDPUR/wl/PV8ZrA/hNRvjp44PYiLMYRDSQw8kpbLMMc0QgQCvhfMbYVvGteTmG -qdCFyy2x70wSh6Rfzb7WEWl15I4yfBTddXkJX82S+MrZu/Xq4FDtng594h0= +MIIJKQIBAAKCAgEAyA3SmuwPpYGw/JdzJ9Iah+Z09Q27sueuT1DpqFTYKeJmYQxe +I7N8STbmC3dYctsT3Fd+bcfLF2EMscRaae1DAEjli56e41VYvVXPgTSMPWboETDg +TtPssl0wZHZ23+cKhK9wBgLQ66mzFRM/ro+OLvydO8jZeaRvG5eATrUaB4ywnXp3 +j8r42qTlR05EJWbzwPKkW61vePgOyObRwJrF47WGZG6cPCQMd5zSJPQw5o3xOEuh +n0FD/GPtM8f+0dxjXpLkcJwnXyUbuAU2WWweJHaYOA2s2anlG6V8ZTUZvbdsKi24 +byCzHbKwhI48vKvnPRnJt5wxvg1PsiAYAalWDrIhod+Atdxp4LXzqM5Nyxfp9+BR +nxJZASrzqd/z3ZpZJ8q9g9A7XPpGgfSB6H9tcjoy5gD+jVJqN26PBqsiW5RyckI3 +TXPAXRMnr2xshZ4pze6mDPyiHHruLUrnvHnVgg62g/MB0p/bipVxd18418yZ2gRl +0PtmqD7EfKwgREcA20zWeQtYkioOUclX30uG3vVSf0j2KyoAqWmES52KqUp9pwNd +opWvRtQGAey2b9mpdSgl69rM2RmbzFOIDrfw/1ftPpaUi2CVILviSeYtN2egkeB+ +ghCPCcIS9VUpnNTYcW8Y+cTnfi9FwSEwn13WpjiYO/K2412uWjNVNvvW3RECAwEA +AQKCAgA8KMv4gpyB7OpIS1L52pjX3Vm2h5a2Si2E9JQPZtRKZCbdcFau7b6mVbgA +Ireacn8ad8UxRi+wrCKhIqb9y7emUkWVIvIs8vFonnF0LVUu8c8/vC74BYrcaGGx +FF7THitvk0JgzF//Plz4LX2tBMaBIr41yER97BDtfzW6dYOKWaiS8s0ZlLQZLBU2 +yDZ9+OO8VjtOxm0LN61ahO72uJRh0ajEcu7QtxZ4sdQQAM7jxjOP9k54EaxcLcCb +Hb1nZpsLSakgpBTC6+nWANtDMNwvoupLkPE1031uPumVlc5T2uDQHkekQ3UZrS6f +7hYdtqQnH6YlbPcYa/BXZIdTmJSj9pYKz5Ml1of1KqB6KRxe2vUDtVkTJUwRkZC4 +G8//taLRuaA1vC5bHaseI0uYlTPxueXSDStj7VcUS27nSRWdGxe24EVrIjsA9CNB +RCVDeU6W4r1eGrvgM8QFNWi1jUMr1rRI7EFHV+24hsfiSWZQwhltzWZ3mn99i9VD +BmqI/JvX5d8+8/JlPOVG3HuuxNbU2tzHLhgLADfINvi3TpbdgAY8zm5NqumdwXp6 +JqQ6TXnO/G07fBuZnBP9+Qt5VBQV9rGF5HGpzznbBzSGgBPUNBYqFOyWrdp05J2X +bpO23G+2RM0ufXbukF3mI45NJUWOeHOGrxWTEI60Uy0Vf/+/MQKCAQEA5YXXfpHo +z72IMQGwEUMw5vkyaoGd2Oi5g+Jjv1q/CKbmCw5sD+mfQTYh41mBpDDACbdSLYDu +0wh9zw74HFOY9Jm7GO9LoIjZ76xv+RSBXLN8tpH1MiAQgBrepWhhlhmyTtiIDNXG +crj1Yl76J5hBd4dR+gYlJjB+hWsQvV83RxXIUw6eIM6Ngi7RUNuywI1a9mjSY8H+ +OET4kqDqJ2YUvE22ftEWPlNMxyfsVaJs8ihLGEhS8Sq3sPfbdGx9qs3nABjvX0Ab +MvDdMx7HeLfD2Grn75mClNji0yUdtKNJGvFx33CTdqtOKvELZf9RJmqtBgrfbqQ6 +qGhoJ23SYD3R6wKCAQEA3yG4vmGB1/bBIV8FwmmH9mKGqd1nWBq4BJAv4dSrkEK1 +xDsuc7ssmivqdBCAnhMx7oBObC2j/uaqeHAR/L2Ik9VdUzVB/50aFuedgN9FEQ/a +N3OiQmcYFz5u5On80aSFD4SeuvdDSegFAgSaMYpSKEFziDbESvYmQGe5nWsrxTG7 +MgLRQym5OJjXX+Am7LAgyOgXD7dOCduWdevfUHHXcMg4KPUju5jCd2EuQYX/CYk2 +PkMFime07GL3TQiE2MvhzWsV7qVBqe5T1eBFu2sbpYVkYVmmckrSaKLC8gHDEk1s +7WX0K49sxAAJauktikK4viOVvYkmDnaROSQ6TKgR8wKCAQEAtMo2MeZwgaIDMsbn +jtFkJatIgQhT81VtO2sJsuKh8wizzyWvDOGypcUj8FbCfThBK+YQfvM+K1BW+NAL +sxROOO0WqM9kvLDPKbCkCoiSVRi0NYLGppMHLED9+0A7DeZzwxNgJuwEgr0Z3EB/ +vsx5VNNsSQqqHGi6YBEzgFcNzZpkzreG6sSIRnDmQ1Cqfm1ZpxpuDlHyExSQz76c +cihAUQrNoxrC8Jjgs0bJK7LjKeN/M0NUwc4qHuU9IXmLiwzg1fzOIDL4ualsMyYd +bQMi6sdapio+50vnbvWfbnfnz6c7UQr1vNW2nrB7j/4KR75jR40s7ZPC+IA0+knR +GinXvQKCAQAfsM5oW7jxT16GutQ6lHp3B+9QWN3AqarRGxlx3Z6wUok2YaFrVn4z +N2GJMn7R9K/2y8pXmvPb1C8KBADKALFRLdCfbMT+5PU7o5G/J/bLQZEgpw+4lqPZ +SUi+wmzh6ZfsaE2TCGNKL+XmL3km6BpbFVCvW/ftHaC5LQIz1XDWBQYtSDEodNiV +rT+JonBk1W8SmcQMu2AeDk4EWYfSCRksL4OqbYaxsjSMeAT10W4zkIVfum0jBy+v +Ey9EhZ04nVxorHjk+BunYu4NRlkhEUlP7O4g1XbKbM4NhnBhptZp1w1Nell/hlNQ +UyEDSjLpnChY+PzfeocpLrXZg8ez83r5AoIBAQCrufc7Cu36/WoSKoMwd5n9kOQ9 +W4kzu7ZCv/0PxXj8o3nyNkHD/uZHtGGPowhzt8cZR8JKfmDqrCM28WWyGk79x9bN +s/IVyTc5CHe0/zPJooTgpFA8etMhdc5JIYorSZaAgLiOqzDyGuNi9oyfotbLqiFZ +4uiagMt+hdTP0yEwE1JvzQAwdJvOfMxhiNka6szKb+0QGwBLwCB71OAMXeIfzmBK +i0PLomu7tlogS5cePt45lp3nAowreSru/DnfZobVlVFLV9rV+xFuLmxC4zB86cto +wfZvKgSI/hP6rg0RkcQbBad0ZsVm52NtCWYTB+bISke8wDN552wZVC6lyPat -----END rsa private key----- diff --git a/cryptor/rsa_public_example.pem b/cryptor/rsa_public_example.pem index 6102c1b..f77e141 100644 --- a/cryptor/rsa_public_example.pem +++ b/cryptor/rsa_public_example.pem @@ -1,14 +1,14 @@ -----BEGIN rsa public key----- -MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0HaqqGWnNqwRVKoJUUjY -iH/dwkSK61La4RGYkvDfcuo9pDgczHVhFUb/MYWeb3bAlFAGcZLYSBh6WAGxbeMj -SkaLroaXnafhKZ2oXXUy8CzyYxZwpLCDgJLG7Pf0jer3STZW93ZT8UJixbKwbqD6 -b8fkpMANwCYrTlXDWBuZVaEKuQNnC4XufQis4fwRxRgfrZuLMvuQVtnyYmssmnp8 -JHovYkr87giDjEgvlrC84Lez32ZhEhORRu5NGEDeZ1OewbkXGyQtbcBQYNAxgnOc -O44MTTPhEdz4/A0xwzEe+yIOxWIAWuEM2rclXpZBW/MEK41gZ3C04KcX5R0KRdj2 -PTTH7vJ33yRC4hKtWetwMvsUrewrRKVcUgaeFykDAlgIDoSWvG0nzb70AWSoNcj7 -krLlwEc2WLGy/kCYWppnfYKafEJXpgblHrDFKlWvte68yrvGdCsWRLQ2uUF0xokQ -Ig4u2bApyWNroxEtjHwUp1VeJuZBQkfg+vIW+t3moQpMtlhy4aai/oGIxI5TIB82 -nv8TPVczjHmmE3hwL6nZ5OfbFyWpRFvKLtXcaAKMi2HqOLRkQhqjjJUCO9Wyhu1B -kX8RAeKLl3S7gRyhuOB5JNUGEpQ389MdbUX5S12Qp1xTDS+otbC8tYS1gu0OOOWo -wxbuF5+Ci2SYgSHv/3zXKoMCAwEAAQ== +MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAyA3SmuwPpYGw/JdzJ9Ia +h+Z09Q27sueuT1DpqFTYKeJmYQxeI7N8STbmC3dYctsT3Fd+bcfLF2EMscRaae1D +AEjli56e41VYvVXPgTSMPWboETDgTtPssl0wZHZ23+cKhK9wBgLQ66mzFRM/ro+O +LvydO8jZeaRvG5eATrUaB4ywnXp3j8r42qTlR05EJWbzwPKkW61vePgOyObRwJrF +47WGZG6cPCQMd5zSJPQw5o3xOEuhn0FD/GPtM8f+0dxjXpLkcJwnXyUbuAU2WWwe +JHaYOA2s2anlG6V8ZTUZvbdsKi24byCzHbKwhI48vKvnPRnJt5wxvg1PsiAYAalW +DrIhod+Atdxp4LXzqM5Nyxfp9+BRnxJZASrzqd/z3ZpZJ8q9g9A7XPpGgfSB6H9t +cjoy5gD+jVJqN26PBqsiW5RyckI3TXPAXRMnr2xshZ4pze6mDPyiHHruLUrnvHnV +gg62g/MB0p/bipVxd18418yZ2gRl0PtmqD7EfKwgREcA20zWeQtYkioOUclX30uG +3vVSf0j2KyoAqWmES52KqUp9pwNdopWvRtQGAey2b9mpdSgl69rM2RmbzFOIDrfw +/1ftPpaUi2CVILviSeYtN2egkeB+ghCPCcIS9VUpnNTYcW8Y+cTnfi9FwSEwn13W +pjiYO/K2412uWjNVNvvW3RECAwEAAQ== -----END rsa public key----- diff --git a/validator/validator_test.go b/validator/validator_test.go index cb2c000..0842097 100644 --- a/validator/validator_test.go +++ b/validator/validator_test.go @@ -15,16 +15,25 @@ func TestIsAllUpper(t *testing.T) { assert := internal.NewAssert(t, "TestIsAllUpper") - assert.Equal(true, IsAllUpper("ABC")) - assert.Equal(false, IsAllUpper("")) - assert.Equal(false, IsAllUpper("abc")) - assert.Equal(false, IsAllUpper("aBC")) - assert.Equal(false, IsAllUpper("1BC")) - assert.Equal(false, IsAllUpper("1bc")) - assert.Equal(false, IsAllUpper("123")) - assert.Equal(false, IsAllUpper("你好")) - assert.Equal(false, IsAllUpper("A&")) - assert.Equal(false, IsAllUpper("&@#$%^&*")) + tests := []struct { + input string + expected bool + }{ + {"ABC", true}, + {"", false}, + {"abc", false}, + {"aBC", false}, + {"1BC", false}, + {"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")) - assert.Equal(false, IsAllLower("ABC")) - assert.Equal(false, IsAllLower("")) - assert.Equal(false, IsAllLower("aBC")) - assert.Equal(false, IsAllLower("1BC")) - assert.Equal(false, IsAllLower("1bc")) - assert.Equal(false, IsAllLower("123")) - assert.Equal(false, IsAllLower("你好")) - assert.Equal(false, IsAllLower("A&")) - assert.Equal(false, IsAllLower("&@#$%^&*")) + tests := []struct { + input string + expected bool + }{ + {"abc", true}, + {"", false}, + {"ABC", false}, + {"aBC", false}, + {"1BC", false}, + {"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")) - assert.Equal(true, ContainLower("aBC")) - assert.Equal(true, ContainLower("1bc")) - assert.Equal(true, ContainLower("a&")) + tests := []struct { + input string + expected bool + }{ + {"abc", true}, + {"aBC", true}, + {"1bc", true}, + {"a&", true}, + {"ABC", false}, + {"", false}, + {"1BC", false}, + {"123", false}, + {"你好", false}, + {"&@#$%^&*", false}, + } - assert.Equal(false, ContainLower("ABC")) - assert.Equal(false, ContainLower("")) - assert.Equal(false, ContainLower("1BC")) - assert.Equal(false, ContainLower("123")) - assert.Equal(false, ContainLower("你好")) - assert.Equal(false, ContainLower("&@#$%^&*")) + for _, tt := range tests { + assert.Equal(tt.expected, ContainLower(tt.input)) + } } func TestContainUpper(t *testing.T) { @@ -67,17 +93,25 @@ func TestContainUpper(t *testing.T) { assert := internal.NewAssert(t, "TestContainUpper") - assert.Equal(true, ContainUpper("ABC")) - assert.Equal(true, ContainUpper("aBC")) - assert.Equal(true, ContainUpper("1BC")) - assert.Equal(true, ContainUpper("A&")) + tests := []struct { + input string + expected bool + }{ + {"ABC", true}, + {"aBC", true}, + {"1BC", true}, + {"A&", true}, + {"abc", false}, + {"", false}, + {"1bc", false}, + {"123", false}, + {"你好", false}, + {"&@#$%^&*", false}, + } - assert.Equal(false, ContainUpper("abc")) - assert.Equal(false, ContainUpper("")) - assert.Equal(false, ContainUpper("1bc")) - assert.Equal(false, ContainUpper("123")) - assert.Equal(false, ContainUpper("你好")) - assert.Equal(false, ContainUpper("&@#$%^&*")) + for _, tt := range tests { + assert.Equal(tt.expected, ContainUpper(tt.input)) + } } func TestContainLetter(t *testing.T) { @@ -85,15 +119,23 @@ func TestContainLetter(t *testing.T) { assert := internal.NewAssert(t, "TestContainLetter") - assert.Equal(true, ContainLetter("ABC")) - assert.Equal(true, ContainLetter("1Bc")) - assert.Equal(true, ContainLetter("1ab")) - assert.Equal(true, ContainLetter("A&")) + tests := []struct { + input string + expected bool + }{ + {"ABC", true}, + {"1Bc", true}, + {"1ab", true}, + {"A&", true}, + {"", false}, + {"123", false}, + {"你好", false}, + {"&@#$%^&*", false}, + } - assert.Equal(false, ContainLetter("")) - assert.Equal(false, ContainLetter("123")) - assert.Equal(false, ContainLetter("你好")) - assert.Equal(false, ContainLetter("&@#$%^&*")) + for _, tt := range tests { + assert.Equal(tt.expected, ContainLetter(tt.input)) + } } func TestContainNumber(t *testing.T) { @@ -101,18 +143,26 @@ func TestContainNumber(t *testing.T) { assert := internal.NewAssert(t, "TestContainNumber") - assert.Equal(true, ContainNumber("123")) - assert.Equal(true, ContainNumber("1Bc")) - assert.Equal(true, ContainNumber("a2c")) - assert.Equal(true, ContainNumber("ab3")) - assert.Equal(true, ContainNumber("a23")) - assert.Equal(true, ContainNumber("a23c")) - assert.Equal(true, ContainNumber("1%%%")) + tests := []struct { + input string + expected bool + }{ + {"123", true}, + {"1Bc", true}, + {"a2c", true}, + {"ab3", true}, + {"a23", true}, + {"a23c", true}, + {"1%%%", true}, + {"ABC", false}, + {"", false}, + {"你好", false}, + {"&@#$%^&*", false}, + } - assert.Equal(false, ContainNumber("ABC")) - assert.Equal(false, ContainNumber("")) - assert.Equal(false, ContainNumber("你好")) - assert.Equal(false, ContainNumber("&@#$%^&*")) + for _, tt := range tests { + assert.Equal(tt.expected, ContainNumber(tt.input)) + } } func TestIsJSON(t *testing.T) { @@ -120,15 +170,23 @@ func TestIsJSON(t *testing.T) { assert := internal.NewAssert(t, "TestIsJSON") - assert.Equal(true, IsJSON("{}")) - assert.Equal(true, IsJSON("{\"name\": \"test\"}")) - assert.Equal(true, IsJSON("[]")) - assert.Equal(true, IsJSON("123")) + tests := []struct { + input string + expected bool + }{ + {"{}", true}, + {"{\"name\": \"test\"}", true}, + {"[]", true}, + {"123", true}, + {"", false}, + {"abc", false}, + {"你好", false}, + {"&@#$%^&*", false}, + } - assert.Equal(false, IsJSON("")) - assert.Equal(false, IsJSON("abc")) - assert.Equal(false, IsJSON("你好")) - assert.Equal(false, IsJSON("&@#$%^&*")) + for _, tt := range tests { + assert.Equal(tt.expected, IsJSON(tt.input)) + } } func TestIsNumber(t *testing.T) { @@ -136,10 +194,19 @@ func TestIsNumber(t *testing.T) { assert := internal.NewAssert(t, "TestIsNumber") - assert.Equal(false, IsNumber("")) - assert.Equal(false, IsNumber("3")) - assert.Equal(true, IsNumber(0)) - assert.Equal(true, IsNumber(0.1)) + tests := []struct { + input interface{} + expected bool + }{ + {"", 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("")) - assert.Equal(false, IsFloat("3")) - assert.Equal(false, IsFloat(0)) - assert.Equal(true, IsFloat(0.1)) + tests := []struct { + input interface{} + expected bool + }{ + {"", 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("")) - assert.Equal(false, IsInt("3")) - assert.Equal(false, IsInt(0.1)) - assert.Equal(true, IsInt(0)) - assert.Equal(true, IsInt(-1)) + tests := []struct { + input interface{} + expected bool + }{ + {"", 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.")) - assert.Equal(true, IsNumberStr("+3.")) - assert.Equal(true, IsNumberStr("-3.")) - assert.Equal(true, IsNumberStr("+3e2")) - assert.Equal(false, IsNumberStr("abc")) + tests := []struct { + input string + expected bool + }{ + {"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.")) - assert.Equal(true, IsFloatStr("+3.")) - assert.Equal(true, IsFloatStr("-3.")) - assert.Equal(true, IsFloatStr("12")) - assert.Equal(false, IsFloatStr("abc")) + tests := []struct { + input string + expected bool + }{ + {"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")) - assert.Equal(true, IsIntStr("-3")) - assert.Equal(false, IsIntStr("3.")) - assert.Equal(false, IsIntStr("abc")) + tests := []struct { + input string + expected bool + }{ + {"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")) - assert.Equal(true, IsPort("65535")) - assert.Equal(false, IsPort("abc")) - assert.Equal(false, IsPort("123abc")) - assert.Equal(false, IsPort("")) - assert.Equal(false, IsPort("-1")) - assert.Equal(false, IsPort("65536")) + tests := []struct { + input string + expected bool + }{ + {"1", true}, + {"65535", true}, + {"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")) - assert.Equal(true, IsIp("::0:0:0:0:0:0:1")) - assert.Equal(false, IsIp("127.0.0")) - assert.Equal(false, IsIp("127")) + tests := []struct { + input string + expected bool + }{ + {"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 - assert.Equal(true, IsIpPort("127.0.0.1:8080")) // valid IP and port + tests := []struct { + 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 - assert.Equal(false, IsIpPort(":8080")) // only port - assert.Equal(false, IsIpPort("127.0.0.1")) // valid IP without port - assert.Equal(false, IsIpPort("0:0:0:0:0:0:0:1")) // valid IPv6 without port - assert.Equal(false, IsIpPort("256.256.256.256:8080")) // invalid IP with valid port - assert.Equal(false, IsIpPort("256.256.256.256:abc")) // invalid IP and invalid port - assert.Equal(false, IsIpPort("127.0.0.1:70000")) // valid IP with invalid port + {"", false}, + {":8080", false}, + {"127.0.0.1", false}, + {"0:0:0:0:0:0:0:1", false}, + {"256.256.256.256:8080", false}, + {"256.256.256.256:abc", false}, + {"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")) - assert.Equal(false, IsIpV4("127.0.0.1.1")) - assert.Equal(false, IsIpV4("256.0.0.1")) - assert.Equal(false, IsIpV4("127.0.0.a")) - assert.Equal(false, IsIpV4("")) + {"::0:0:0:0:0:0:1", false}, + {"127.0.0.1.1", false}, + {"256.0.0.1", false}, + {"127.0.0.a", false}, + {"", 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")) - assert.Equal(true, IsIpV6("::1")) - assert.Equal(true, IsIpV6("::")) + tests := []struct { + input string + 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")) - assert.Equal(true, IsDns("123.cn")) - assert.Equal(true, IsDns("a.b.com")) + tests := []struct { + input string + 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")) - assert.Equal(false, IsDns("a@b.com")) - assert.Equal(false, IsDns("http://abc.com")) + for _, tt := range tests { + assert.Equal(tt.expected, IsDns(tt.input)) + } } 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")) - assert.Equal(true, IsChinesePhone("0464-8756213")) - assert.Equal(true, IsChinesePhone("0731-82251545")) // 长沙晚报电话 - assert.Equal(false, IsChinesePhone("123-87562")) + tests := []struct { + input string + expected bool + }{ + {"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")) - assert.Equal(true, IsChineseIdNum("11010519491231002X")) - assert.Equal(true, IsChineseIdNum("11010519491231002x")) - assert.Equal(false, IsChineseIdNum("123456")) - assert.Equal(false, IsChineseIdNum("990911192105130714")) - assert.Equal(false, IsChineseIdNum("990911189905130714")) - assert.Equal(false, IsChineseIdNum("210911222205130714")) + tests := []struct { + input string + expected bool + }{ + {"210911192105130714", true}, + {"11010519491231002X", true}, + {"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)) - assert.Equal(false, IsStrongPassword("abc123", 6)) - assert.Equal(false, IsStrongPassword("abcABC", 6)) - assert.Equal(false, IsStrongPassword("abc123@#$", 9)) - assert.Equal(false, IsStrongPassword("abcABC123@#$", 16)) - assert.Equal(true, IsStrongPassword("abcABC123@#$", 12)) - assert.Equal(true, IsStrongPassword("abcABC123@#$", 10)) + tests := []struct { + input string + length int + expected bool + }{ + {"abc", 3, false}, + {"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")) - assert.Equal(true, IsWeakPassword("123")) - assert.Equal(true, IsWeakPassword("abc123")) - assert.Equal(true, IsWeakPassword("abcABC123")) - assert.Equal(false, IsWeakPassword("abc123@#$")) + tests := []struct { + input string + expected bool + }{ + {"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")) - assert.Equal(true, IsPrintable("{id: 123}")) - assert.Equal(true, IsPrintable("")) - assert.Equal(true, IsPrintable("😄")) - assert.Equal(false, IsPrintable("\u0000")) + tests := []struct { + input string + expected bool + }{ + {"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")) - assert.Equal(true, IsBin("0b1101")) + tests := []struct { + input string + expected bool + }{ + {"0101", true}, + {"0b1101", true}, + {"b1101", false}, + {"1201", false}, + {"", false}, + } - assert.Equal(false, IsBin("b1101")) - assert.Equal(false, IsBin("1201")) - assert.Equal(false, IsBin("")) + for _, tt := range tests { + assert.Equal(tt.expected, IsBin(tt.input)) + } } func TestIsHex(t *testing.T) { t.Parallel() assert := internal.NewAssert(t, "TestIsHex") - assert.Equal(true, IsHex("ABCDE")) - assert.Equal(true, IsHex("abcde")) - assert.Equal(true, IsHex("0xabcde")) - assert.Equal(true, IsHex("0Xabcde")) - assert.Equal(true, IsHex("#abcde")) + tests := []struct { + input string + expected bool + }{ + {"ABCDE", true}, + {"abcde", true}, + {"0xabcde", true}, + {"0Xabcde", true}, + {"#abcde", true}, + {"cdfeg", false}, + {"0xcdfeg", false}, + {"", false}, + } - assert.Equal(false, IsHex("cdfeg")) - assert.Equal(false, IsHex("0xcdfeg")) - assert.Equal(false, IsHex("")) + for _, tt := range tests { + assert.Equal(tt.expected, IsHex(tt.input)) + } } func TestIsBase64URL(t *testing.T) { t.Parallel() assert := internal.NewAssert(t, "TestIsBase64URL") - assert.Equal(true, IsBase64URL("SAGsbG8sIHdvcmxkIQ")) - assert.Equal(true, IsBase64URL("SAGsbG8sIHdvcmxkIQ==")) + tests := []struct { + input string + expected bool + }{ + {"SAGsbG8sIHdvcmxkIQ", true}, + {"SAGsbG8sIHdvcmxkIQ==", true}, + {"SAGsbG8sIHdvcmxkIQ=", false}, + {"SAGsbG8sIHdvcmxkIQ===", false}, + } - assert.Equal(false, IsBase64URL("SAGsbG8sIHdvcmxkIQ=")) - assert.Equal(false, IsBase64URL("SAGsbG8sIHdvcmxkIQ===")) - // assert.Equal(false, IsBase64URL("")) + for _, tt := range tests { + assert.Equal(tt.expected, IsBase64URL(tt.input)) + } } func TestIsJWT(t *testing.T) { @@ -665,15 +904,23 @@ func TestIsAlphaNumeric(t *testing.T) { assert := internal.NewAssert(t, "TestIsAlphaNumeric") - assert.Equal(true, IsAlphaNumeric("ABC")) - assert.Equal(true, IsAlphaNumeric("abc")) - assert.Equal(true, IsAlphaNumeric("aBC")) - assert.Equal(true, IsAlphaNumeric("1BC")) - assert.Equal(true, IsAlphaNumeric("1bc")) - assert.Equal(true, IsAlphaNumeric("123")) + tests := []struct { + input string + expected bool + }{ + {"ABC", true}, + {"abc", true}, + {"aBC", true}, + {"1BC", true}, + {"1bc", true}, + {"123", true}, + {"你好", false}, + {"A&", false}, + {"&@#$%^&*", false}, + {"", false}, + } - assert.Equal(false, IsAlphaNumeric("")) - assert.Equal(false, IsAlphaNumeric("你好")) - assert.Equal(false, IsAlphaNumeric("A&")) - assert.Equal(false, IsAlphaNumeric("&@#$%^&*")) + for _, tt := range tests { + assert.Equal(tt.expected, IsAlphaNumeric(tt.input)) + } }