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  }