pkg.re/essentialkaos/ek.10@v12.41.0+incompatible/fmtutil/fmtutil_test.go (about) 1 package fmtutil 2 3 // ////////////////////////////////////////////////////////////////////////////////// // 4 // // 5 // Copyright (c) 2022 ESSENTIAL KAOS // 6 // Apache License, Version 2.0 <https://www.apache.org/licenses/LICENSE-2.0> // 7 // // 8 // ////////////////////////////////////////////////////////////////////////////////// // 9 10 import ( 11 "math" 12 "testing" 13 14 . "pkg.re/essentialkaos/check.v1" 15 ) 16 17 // ////////////////////////////////////////////////////////////////////////////////// // 18 19 func Test(t *testing.T) { TestingT(t) } 20 21 type FmtUtilSuite struct{} 22 23 // ////////////////////////////////////////////////////////////////////////////////// // 24 25 var _ = Suite(&FmtUtilSuite{}) 26 27 // ////////////////////////////////////////////////////////////////////////////////// // 28 29 func (s *FmtUtilSuite) TestPretyNum(c *C) { 30 c.Assert(PrettyNum(999), Equals, "999") 31 c.Assert(PrettyNum(1000), Equals, "1,000") 32 c.Assert(PrettyNum(1234567890), Equals, "1,234,567,890") 33 c.Assert(PrettyNum(100000), Equals, "100,000") 34 c.Assert(PrettyNum(100000, "|"), Equals, "100|000") 35 c.Assert(PrettyNum(0), Equals, "0") 36 c.Assert(PrettyNum(2500.50), Equals, "2,500.5") 37 c.Assert(PrettyNum(2500.00), Equals, "2,500") 38 c.Assert(PrettyNum(1.23), Equals, "1.23") 39 c.Assert(PrettyNum(-1000), Equals, "-1,000") 40 c.Assert(PrettyNum(-123456789), Equals, "-123,456,789") 41 c.Assert(PrettyNum(-123456789.15), Equals, "-123,456,789.15") 42 c.Assert(PrettyNum(math.NaN()), Equals, "0") 43 c.Assert(PrettyNum("abcd"), Equals, "abcd") 44 } 45 46 func (s *FmtUtilSuite) TestPretyDiff(c *C) { 47 c.Assert(PrettyDiff(0), Equals, "0") 48 c.Assert(PrettyDiff(100), Equals, "+100") 49 c.Assert(PrettyDiff(15620), Equals, "+15,620") 50 c.Assert(PrettyDiff(-15620), Equals, "-15,620") 51 } 52 53 func (s *FmtUtilSuite) TestPretyPerc(c *C) { 54 c.Assert(PrettyPerc(0.12), Equals, "0.12%") 55 c.Assert(PrettyPerc(1), Equals, "1%") 56 c.Assert(PrettyPerc(1.123), Equals, "1.12%") 57 c.Assert(PrettyPerc(12.100), Equals, "12.1%") 58 c.Assert(PrettyPerc(123.123), Equals, "123.1%") 59 c.Assert(PrettyPerc(0.0002), Equals, "< 0.01%") 60 } 61 62 func (s *FmtUtilSuite) TestPretySize(c *C) { 63 c.Assert(PrettySize(0), Equals, "0B") 64 c.Assert(PrettySize(345), Equals, "345B") 65 c.Assert(PrettySize(1025), Equals, "1KB") 66 c.Assert(PrettySize(1025, " "), Equals, "1 KB") 67 c.Assert(PrettySize(3000125), Equals, "2.86MB") 68 c.Assert(PrettySize(1024*1024), Equals, "1MB") 69 c.Assert(PrettySize(1024*1024*1024), Equals, "1GB") 70 c.Assert(PrettySize(int64(1024*1024*1024*1024)), Equals, "1TB") 71 c.Assert(PrettySize(1052500000), Equals, "1003.7MB") 72 73 c.Assert(PrettySize(int32(3000125)), Equals, "2.86MB") 74 c.Assert(PrettySize(int64(3000125)), Equals, "2.86MB") 75 c.Assert(PrettySize(uint(3000125)), Equals, "2.86MB") 76 c.Assert(PrettySize(uint32(3000125)), Equals, "2.86MB") 77 c.Assert(PrettySize(uint64(3000125)), Equals, "2.86MB") 78 c.Assert(PrettySize(float32(3000125)), Equals, "2.86MB") 79 c.Assert(PrettySize(float64(3000125)), Equals, "2.86MB") 80 c.Assert(PrettySize(float64(1.1)), Equals, "1B") 81 c.Assert(PrettySize(float64(1.6)), Equals, "2B") 82 c.Assert(PrettySize(math.NaN()), Equals, "0B") 83 } 84 85 func (s *FmtUtilSuite) TestPretyBool(c *C) { 86 c.Assert(PrettyBool(true), Equals, "Y") 87 c.Assert(PrettyBool(false), Equals, "N") 88 c.Assert(PrettyBool(true, "Yes"), Equals, "Yes") 89 c.Assert(PrettyBool(false, "Yes"), Equals, "N") 90 c.Assert(PrettyBool(false, "Yes", "No"), Equals, "No") 91 } 92 93 func (s *FmtUtilSuite) TestParseSize(c *C) { 94 c.Assert(ParseSize("1 MB"), Equals, uint64(1024*1024)) 95 c.Assert(ParseSize("1 M"), Equals, uint64(1000*1000)) 96 c.Assert(ParseSize("2tb"), Equals, uint64(2*1024*1024*1024*1024)) 97 c.Assert(ParseSize("2t"), Equals, uint64(2*1000*1000*1000*1000)) 98 c.Assert(ParseSize("5gB"), Equals, uint64(5*1024*1024*1024)) 99 c.Assert(ParseSize("5g"), Equals, uint64(5*1000*1000*1000)) 100 c.Assert(ParseSize("13kb"), Equals, uint64(13*1024)) 101 c.Assert(ParseSize("13k"), Equals, uint64(13*1000)) 102 c.Assert(ParseSize("512"), Equals, uint64(512)) 103 c.Assert(ParseSize("kb"), Equals, uint64(0)) 104 c.Assert(ParseSize("123!"), Equals, uint64(0)) 105 106 c.Assert(ParseSize(PrettySize(345)), Equals, uint64(345)) 107 c.Assert(ParseSize(PrettySize(1025)), Equals, uint64(1024)) 108 c.Assert(ParseSize(PrettySize(1024*1024)), Equals, uint64(1024*1024)) 109 } 110 111 func (s *FmtUtilSuite) TestFloat(c *C) { 112 c.Assert(Float(1.0), Equals, 1.0) 113 c.Assert(Float(0.1), Equals, 0.1) 114 c.Assert(Float(0.01), Equals, 0.01) 115 c.Assert(Float(0.001), Equals, 0.0) 116 c.Assert(Float(0.0001), Equals, 0.0) 117 c.Assert(Float(math.NaN()), Equals, 0.0) 118 } 119 120 func (s *FmtUtilSuite) TestWrap(c *C) { 121 input := `Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, 122 eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam 123 voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione 124 voluptatem sequi nesciunt, cum soluta nobis est caparet. 125 126 Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci 127 velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. 128 129 Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea 130 commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae 131 consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?` 132 133 result := ` Sed ut perspiciatis unde omnis iste 134 natus error sit voluptatem accusantium 135 doloremque laudantium, totam rem 136 aperiam, eaque ipsa quae ab illo 137 inventore veritatis et quasi 138 architecto beatae vitae dicta sunt 139 explicabo. Nemo enim ipsam voluptatem 140 quia voluptas sit aspernatur aut odit 141 aut fugit, sed quia consequuntur magni 142 dolores eos qui ratione voluptatem 143 sequi nesciunt, cum soluta nobis est 144 caparet. 145 146 Neque porro quisquam est, qui dolorem 147 ipsum quia dolor sit amet, 148 consectetur, adipisci velit, sed quia 149 non numquam eius modi tempora incidunt 150 ut labore et dolore magnam aliquam 151 quaerat voluptatem. 152 153 Ut enim ad minima veniam, quis nostrum 154 exercitationem ullam corporis suscipit 155 laboriosam, nisi ut aliquid ex ea 156 commodi consequatur? Quis autem vel 157 eum iure reprehenderit qui in ea 158 voluptate velit esse quam nihil 159 molestiae consequatur, vel illum qui 160 dolorem eum fugiat quo voluptas nulla 161 pariatur?` 162 163 c.Assert(Wrap(input, " ", 40), Equals, result) 164 165 input = "Sed ut \033[40;38;5;82mperspiciatis \x1b[30;48;5;82munde\x1B[0m omnis iste natus error sit voluptatem accusantium doloremque" 166 result = " Sed ut \x1b[40;38;5;82mperspiciatis \x1b[30;48;5;82munde\x1b[0m\n" + 167 " omnis iste natus error sit\n" + 168 " voluptatem accusantium\n" + 169 " doloremque" 170 171 c.Assert(Wrap(input, " ", 30), Equals, result) 172 173 input = "abcd1234abcd1234abcd1234abcd1234 abcd abcd abcd 1234 1234" 174 result = " abcd1234abcd1234abcd1234abcd1234\n" + 175 " abcd abcd abcd\n" + 176 " 1234 1234" 177 178 c.Assert(Wrap(input, " ", 20), Equals, result) 179 } 180 181 func (s *FmtUtilSuite) TestSeparator(c *C) { 182 SeparatorSize = 1 183 184 Separator(true) 185 Separator(false) 186 Separator(true, "test") 187 Separator(false, "test") 188 Separator(false, "TEST1234TEST1234TEST1234TEST1234TEST1234TEST1234TEST1234TEST1234TEST1234TEST1234TEST1234") 189 190 SeparatorFullscreen = true 191 192 Separator(true) 193 194 c.Assert(between(0, 1, 3), Equals, 1) 195 c.Assert(between(2, 1, 3), Equals, 2) 196 c.Assert(between(10, 1, 3), Equals, 3) 197 } 198 199 func (s *FmtUtilSuite) TestCountDigits(c *C) { 200 c.Assert(CountDigits(1), Equals, 1) 201 c.Assert(CountDigits(999), Equals, 3) 202 c.Assert(CountDigits(45999), Equals, 5) 203 c.Assert(CountDigits(-45999), Equals, 6) 204 } 205 206 func (s *FmtUtilSuite) TestColorizePassword(c *C) { 207 p1 := "acbdabcd" 208 p2 := "ABcd12AB" 209 p3 := "AB[3a=c_" 210 211 c.Assert(ColorizePassword(p1, "{r}", "{g}", "{y}"), Equals, "{r}acbdabcd{!}") 212 c.Assert(ColorizePassword(p2, "{r}", "{g}", "{y}"), Equals, "{r}ABcd{g}12{r}AB{!}") 213 c.Assert(ColorizePassword(p3, "{r}", "{g}", "{y}"), Equals, "{r}AB{y}[{g}3{r}a{y}={r}c{y}_{!}") 214 215 c.Assert(ColorizePassword(p3, "{r}", "", ""), Equals, "{r}AB{!}[3{r}a{!}={r}c{!}_{!}") 216 c.Assert(ColorizePassword(p3, "", "{g}", ""), Equals, "{!}AB[{g}3{!}a=c_{!}") 217 c.Assert(ColorizePassword(p3, "", "", "{y}"), Equals, "{!}AB{y}[{!}3a{y}={!}c{y}_{!}") 218 } 219 220 // ////////////////////////////////////////////////////////////////////////////////// // 221 222 func (s *FmtUtilSuite) BenchmarkPrettyNum(c *C) { 223 for i := 0; i < c.N; i++ { 224 PrettyNum(-123456) 225 } 226 } 227 228 func (s *FmtUtilSuite) BenchmarkPrettyNumFloat(c *C) { 229 for i := 0; i < c.N; i++ { 230 PrettyNum(-123456.15) 231 } 232 } 233 234 func (s *FmtUtilSuite) BenchmarkWrap(c *C) { 235 for i := 0; i < c.N; i++ { 236 Wrap("0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", " ", 10) 237 } 238 }