pkg.re/essentialkaos/ek.10@v12.41.0+incompatible/progress/progress_test.go (about)

     1  package progress
     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  	"io"
    12  	"testing"
    13  	"time"
    14  
    15  	. "pkg.re/essentialkaos/check.v1"
    16  )
    17  
    18  // ////////////////////////////////////////////////////////////////////////////////// //
    19  
    20  type ProgressSuite struct{}
    21  
    22  type DummyReader struct {
    23  	io.Reader
    24  }
    25  
    26  type DummyWriter struct {
    27  	io.Writer
    28  }
    29  
    30  // ////////////////////////////////////////////////////////////////////////////////// //
    31  
    32  func Test(t *testing.T) { TestingT(t) }
    33  
    34  // ////////////////////////////////////////////////////////////////////////////////// //
    35  
    36  var _ = Suite(&ProgressSuite{})
    37  
    38  // ////////////////////////////////////////////////////////////////////////////////// //
    39  
    40  func (s *ProgressSuite) TestBar(c *C) {
    41  	pb := New(-1, "ABCD")
    42  
    43  	c.Assert(pb, NotNil)
    44  
    45  	pbs := DefaultSettings
    46  	pbs.Width = 60
    47  	pbs.RefreshRate = time.Millisecond
    48  
    49  	pb.UpdateSettings(pbs)
    50  
    51  	pb.SetName("ABC")
    52  	c.Assert(pb.Name(), Equals, "ABC")
    53  
    54  	pb.SetTotal(2000)
    55  	c.Assert(pb.Total(), Equals, int64(2000))
    56  	c.Assert(pb.passThruCalc, NotNil)
    57  	pb.SetTotal(2200)
    58  	c.Assert(pb.Total(), Equals, int64(2200))
    59  
    60  	pb.SetCurrent(100)
    61  	c.Assert(pb.Current(), Equals, int64(100))
    62  
    63  	pb.Add(1)
    64  	c.Assert(pb.Current(), Equals, int64(101))
    65  
    66  	pb.Add64(1)
    67  	c.Assert(pb.Current(), Equals, int64(102))
    68  
    69  	c.Assert(pb.IsFinished(), Equals, false)
    70  	c.Assert(pb.IsStarted(), Equals, false)
    71  
    72  	pb.Reader(&DummyReader{Reader: nil})
    73  	c.Assert(pb.reader, NotNil)
    74  
    75  	pb.Writer(&DummyWriter{Writer: nil})
    76  	c.Assert(pb.writer, NotNil)
    77  
    78  	pr := pb.Reader(&DummyReader{Reader: nil})
    79  	pw := pb.Writer(&DummyWriter{Writer: nil})
    80  
    81  	pr.Read(nil)
    82  	c.Assert(pb.Current(), Equals, int64(202))
    83  
    84  	pw.Write(nil)
    85  	c.Assert(pb.Current(), Equals, int64(302))
    86  
    87  	pb.Finish() // should be skipped
    88  	pb.Start()
    89  	pb.renderElements()
    90  	pb.Start() // should be skipped
    91  	pb.Finish()
    92  
    93  	time.Sleep(time.Millisecond * 10)
    94  
    95  	pb = New(100, "ABCD")
    96  	pb.settings.RefreshRate = time.Millisecond
    97  	pb.Start()
    98  	pb.SetCurrent(1000)
    99  	time.Sleep(time.Millisecond * 100)
   100  }
   101  
   102  func (s *ProgressSuite) TestBarRender(c *C) {
   103  	pb := New(100, "ABCD")
   104  	c.Assert(pb, NotNil)
   105  
   106  	pb.current = 50
   107  
   108  	vl := pb.renderBar(80)
   109  	c.Assert(vl, Equals, "{r}————{s-}————{!}")
   110  
   111  	vl = pb.renderBar(100)
   112  	c.Assert(vl, Equals, "{r}——{s-}———{!}")
   113  
   114  	pb.settings.BarFgColorTag = ""
   115  
   116  	vl = pb.renderBar(80)
   117  	c.Assert(vl, Equals, "————    ")
   118  
   119  	pb.current = 150
   120  	pb.settings.BarFgColorTag = "{r}"
   121  
   122  	vl = pb.renderBar(80)
   123  	c.Assert(vl, Equals, "{r}————————{!}")
   124  
   125  	pb.settings.BarFgColorTag = ""
   126  
   127  	vl = pb.renderBar(80)
   128  	c.Assert(vl, Equals, "————————")
   129  }
   130  
   131  func (s *ProgressSuite) TestBarPlaceholderRender(c *C) {
   132  	pb := New(-1, "ABCD")
   133  	c.Assert(pb, NotNil)
   134  
   135  	vl := pb.renderBar(80)
   136  	c.Assert(vl, Equals, "{r}—{s-}—{s-}—{r}—{s-}—{s-}—{r}—{s-}—{!}")
   137  
   138  	pb.settings.BarFgColorTag = ""
   139  
   140  	vl = pb.renderBar(80)
   141  	c.Assert(vl, Equals, " —  —  —")
   142  	vl = pb.renderBar(80)
   143  	c.Assert(vl, Equals, "  —  —  ")
   144  }
   145  
   146  func (s *ProgressSuite) TestNameRender(c *C) {
   147  	pb := New(1000, "ABCD")
   148  	c.Assert(pb, NotNil)
   149  
   150  	vl, sz := pb.renderName()
   151  
   152  	c.Assert(vl, Equals, "{b}ABCD{!}")
   153  	c.Assert(sz, Equals, 4)
   154  
   155  	pb.settings.NameSize = 10
   156  
   157  	vl, sz = pb.renderName()
   158  
   159  	c.Assert(vl, Equals, "{b}      ABCD{!}")
   160  	c.Assert(sz, Equals, 10)
   161  
   162  	pb.settings.NameColorTag = ""
   163  
   164  	vl, sz = pb.renderName()
   165  
   166  	c.Assert(vl, Equals, "      ABCD")
   167  	c.Assert(sz, Equals, 10)
   168  }
   169  
   170  func (s *ProgressSuite) TestPercRender(c *C) {
   171  	pb := New(1000, "ABCD")
   172  	c.Assert(pb, NotNil)
   173  
   174  	pb.current = 123
   175  
   176  	vl, sz := pb.renderPercentage()
   177  
   178  	c.Assert(vl, Equals, "{m} 12.3%%{!}")
   179  	c.Assert(sz, Equals, 7)
   180  
   181  	pb.total = -1
   182  
   183  	vl, sz = pb.renderPercentage()
   184  
   185  	c.Assert(vl, Equals, "{m}  0.0%%{!}")
   186  	c.Assert(sz, Equals, 7)
   187  
   188  	pb.total = 100
   189  	pb.current = 1000
   190  
   191  	vl, sz = pb.renderPercentage()
   192  
   193  	c.Assert(vl, Equals, "{m}100%%{!}")
   194  	c.Assert(sz, Equals, 5)
   195  
   196  	pb.settings.PercentColorTag = ""
   197  
   198  	vl, sz = pb.renderPercentage()
   199  
   200  	c.Assert(vl, Equals, "100%%")
   201  	c.Assert(sz, Equals, 5)
   202  }
   203  
   204  func (s *ProgressSuite) TestProgressRender(c *C) {
   205  	pb := New(10000000, "ABCD")
   206  	c.Assert(pb, NotNil)
   207  
   208  	pb.current = 123456
   209  
   210  	vl, sz := pb.renderProgress()
   211  
   212  	c.Assert(vl, Equals, "{g}0.1/9.5 MB{!}")
   213  	c.Assert(sz, Equals, 10)
   214  
   215  	pb.settings.IsSize = false
   216  
   217  	vl, sz = pb.renderProgress()
   218  
   219  	c.Assert(vl, Equals, "{g} 0.1/10.0M{!}")
   220  	c.Assert(sz, Equals, 10)
   221  
   222  	pb.settings.ProgressColorTag = ""
   223  
   224  	vl, sz = pb.renderProgress()
   225  
   226  	c.Assert(vl, Equals, " 0.1/10.0M")
   227  	c.Assert(sz, Equals, 10)
   228  
   229  	pb.current = 1
   230  	pb.total = 10
   231  
   232  	vl, sz = pb.renderProgress()
   233  
   234  	c.Assert(vl, Equals, " 1/10")
   235  	c.Assert(sz, Equals, 5)
   236  }
   237  
   238  func (s *ProgressSuite) TestSpeedRender(c *C) {
   239  	pb := New(10000000, "ABCD")
   240  	c.Assert(pb, NotNil)
   241  
   242  	vl, sz := pb.renderSpeed(123456.0)
   243  
   244  	c.Assert(vl, Equals, "{r} 120.6 KB/s{!}")
   245  	c.Assert(sz, Equals, 11)
   246  
   247  	pb.settings.IsSize = false
   248  
   249  	vl, sz = pb.renderSpeed(123456.0)
   250  
   251  	c.Assert(vl, Equals, "{r} 123.5K/s{!}")
   252  	c.Assert(sz, Equals, 9)
   253  
   254  	pb.settings.SpeedColorTag = ""
   255  
   256  	vl, sz = pb.renderSpeed(123456.0)
   257  
   258  	c.Assert(vl, Equals, " 123.5K/s")
   259  	c.Assert(sz, Equals, 9)
   260  }
   261  
   262  func (s *ProgressSuite) TestRemainingRender(c *C) {
   263  	pb := New(10000000, "ABCD")
   264  	c.Assert(pb, NotNil)
   265  
   266  	vl, sz := pb.renderRemaining(8 * time.Second)
   267  
   268  	c.Assert(vl, Equals, "{c} 0:08{!}")
   269  	c.Assert(sz, Equals, 5)
   270  
   271  	vl, sz = pb.renderRemaining(148 * time.Second)
   272  
   273  	c.Assert(vl, Equals, "{c} 2:28{!}")
   274  	c.Assert(sz, Equals, 5)
   275  
   276  	pb.settings.RemainingColorTag = ""
   277  
   278  	vl, sz = pb.renderRemaining(148 * time.Second)
   279  
   280  	c.Assert(vl, Equals, " 2:28")
   281  	c.Assert(sz, Equals, 5)
   282  }
   283  
   284  func (s *ProgressSuite) TestPassThruCalc(c *C) {
   285  	ptc := NewPassThruCalc(1000, 0.5)
   286  
   287  	c.Assert(ptc, NotNil)
   288  
   289  	ptc.SetTotal(20000)
   290  
   291  	c.Assert(ptc.total, Equals, float64(20000))
   292  
   293  	sp, dr := ptc.Calculate(1)
   294  
   295  	time.Sleep(time.Second)
   296  
   297  	sp, dr = ptc.Calculate(2)
   298  
   299  	c.Assert(sp, Not(Equals), 0.0)
   300  	c.Assert(dr, Not(Equals), time.Duration(0))
   301  
   302  	sp2, dr2 := ptc.Calculate(2)
   303  
   304  	c.Assert(sp2, Equals, sp)
   305  	c.Assert(dr2, Equals, dr)
   306  }
   307  
   308  func (s *ProgressSuite) TestAux(c *C) {
   309  	ct, tt, lt := getPrettyCTSize(1, 15)
   310  
   311  	c.Assert(ct, Equals, "1.0")
   312  	c.Assert(tt, Equals, "15.0")
   313  	c.Assert(lt, Equals, " B")
   314  
   315  	ct, tt, lt = getPrettyCTSize(123, 15*1024)
   316  
   317  	c.Assert(ct, Equals, "0.1")
   318  	c.Assert(tt, Equals, "15.0")
   319  	c.Assert(lt, Equals, " KB")
   320  
   321  	ct, tt, lt = getPrettyCTSize(123123, 16*1024*1024)
   322  
   323  	c.Assert(ct, Equals, "0.1")
   324  	c.Assert(tt, Equals, "16.0")
   325  	c.Assert(lt, Equals, " MB")
   326  
   327  	ct, tt, lt = getPrettyCTSize(123123123, 17*1024*1024*1024)
   328  
   329  	c.Assert(ct, Equals, "0.1")
   330  	c.Assert(tt, Equals, "17.0")
   331  	c.Assert(lt, Equals, " GB")
   332  
   333  	ct, tt, lt = getPrettyCTNum(1, 15)
   334  
   335  	c.Assert(ct, Equals, "1")
   336  	c.Assert(tt, Equals, "15")
   337  	c.Assert(lt, Equals, "")
   338  
   339  	ct, tt, lt = getPrettyCTNum(123, 15*1000)
   340  
   341  	c.Assert(ct, Equals, "0.1")
   342  	c.Assert(tt, Equals, "15.0")
   343  	c.Assert(lt, Equals, "K")
   344  
   345  	ct, tt, lt = getPrettyCTNum(123123, 16*1000*1000)
   346  
   347  	c.Assert(ct, Equals, "0.1")
   348  	c.Assert(tt, Equals, "16.0")
   349  	c.Assert(lt, Equals, "M")
   350  
   351  	ct, tt, lt = getPrettyCTNum(123123123, 17*1000*1000*1000)
   352  
   353  	c.Assert(ct, Equals, "0.1")
   354  	c.Assert(tt, Equals, "17.0")
   355  	c.Assert(lt, Equals, "B")
   356  
   357  	c.Assert(formatSpeedNum(123.0), Equals, "   123/s")
   358  	c.Assert(formatSpeedNum(123.0*1000.0), Equals, "   123K/s")
   359  	c.Assert(formatSpeedNum(123.0*1000.0*1000.0), Equals, "   123M/s")
   360  	c.Assert(formatSpeedNum(123.0*1000.0*1000.0*1000.0), Equals, "   123B/s")
   361  }
   362  
   363  // ////////////////////////////////////////////////////////////////////////////////// //
   364  
   365  func (r *DummyReader) Read(p []byte) (int, error) {
   366  	return 100, nil
   367  }
   368  
   369  func (w *DummyWriter) Write(p []byte) (int, error) {
   370  	return 100, nil
   371  }