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

     1  package version
     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  	"testing"
    12  
    13  	. "pkg.re/essentialkaos/check.v1"
    14  )
    15  
    16  // ////////////////////////////////////////////////////////////////////////////////// //
    17  
    18  func Test(t *testing.T) { TestingT(t) }
    19  
    20  type VersionSuite struct{}
    21  
    22  // ////////////////////////////////////////////////////////////////////////////////// //
    23  
    24  var _ = Suite(&VersionSuite{})
    25  
    26  // ////////////////////////////////////////////////////////////////////////////////// //
    27  
    28  func (s *VersionSuite) TestParsing(c *C) {
    29  	_, err1 := Parse("1")
    30  	_, err2 := Parse("2.1")
    31  	_, err3 := Parse("3.4.5")
    32  	_, err4 := Parse("4-alpha1")
    33  	_, err5 := Parse("5-beta1+sha:5114f85")
    34  	_, err6 := Parse("6.12.1-beta2+exp.sha.5114f85")
    35  
    36  	c.Assert(err1, IsNil)
    37  	c.Assert(err2, IsNil)
    38  	c.Assert(err3, IsNil)
    39  	c.Assert(err4, IsNil)
    40  	c.Assert(err5, IsNil)
    41  	c.Assert(err6, IsNil)
    42  }
    43  
    44  func (s *VersionSuite) TestMajor(c *C) {
    45  	v1, _ := Parse("1")
    46  	v2, _ := Parse("2.0.0")
    47  	v3, _ := Parse("3.4.5")
    48  	v4, _ := Parse("4-beta1")
    49  	v5, _ := Parse("5-beta2+exp.sha.5114f85")
    50  
    51  	c.Assert(v1.Major(), Equals, 1)
    52  	c.Assert(v2.Major(), Equals, 2)
    53  	c.Assert(v3.Major(), Equals, 3)
    54  	c.Assert(v4.Major(), Equals, 4)
    55  	c.Assert(v5.Major(), Equals, 5)
    56  }
    57  
    58  func (s *VersionSuite) TestMinor(c *C) {
    59  	v1, _ := Parse("1")
    60  	v2, _ := Parse("2.1")
    61  	v3, _ := Parse("3.4.5")
    62  	v4, _ := Parse("4-alpha1")
    63  	v5, _ := Parse("5-beta1+sha:5114f85")
    64  	v6, _ := Parse("6.12.1-beta2+exp.sha.5114f85")
    65  
    66  	c.Assert(v1.Minor(), Equals, 0)
    67  	c.Assert(v2.Minor(), Equals, 1)
    68  	c.Assert(v3.Minor(), Equals, 4)
    69  	c.Assert(v4.Minor(), Equals, 0)
    70  	c.Assert(v5.Minor(), Equals, 0)
    71  	c.Assert(v6.Minor(), Equals, 12)
    72  }
    73  
    74  func (s *VersionSuite) TestPatch(c *C) {
    75  	v1, _ := Parse("1")
    76  	v2, _ := Parse("2.1")
    77  	v3, _ := Parse("3.4.5")
    78  	v4, _ := Parse("4-alpha1")
    79  	v5, _ := Parse("5-beta1+sha:5114f85")
    80  	v6, _ := Parse("6.12.1-beta2+exp.sha.5114f85")
    81  
    82  	c.Assert(v1.Patch(), Equals, 0)
    83  	c.Assert(v2.Patch(), Equals, 0)
    84  	c.Assert(v3.Patch(), Equals, 5)
    85  	c.Assert(v4.Patch(), Equals, 0)
    86  	c.Assert(v5.Patch(), Equals, 0)
    87  	c.Assert(v6.Patch(), Equals, 1)
    88  }
    89  
    90  func (s *VersionSuite) TestPre(c *C) {
    91  	v1, _ := Parse("1")
    92  	v2, _ := Parse("2.1")
    93  	v3, _ := Parse("3.4.5")
    94  	v4, _ := Parse("4-alpha1")
    95  	v5, _ := Parse("5-beta1+sha:5114f85")
    96  	v6, _ := Parse("6.12.1-beta2+exp.sha.5114f85")
    97  
    98  	c.Assert(v1.PreRelease(), Equals, "")
    99  	c.Assert(v2.PreRelease(), Equals, "")
   100  	c.Assert(v3.PreRelease(), Equals, "")
   101  	c.Assert(v4.PreRelease(), Equals, "alpha1")
   102  	c.Assert(v5.PreRelease(), Equals, "beta1")
   103  	c.Assert(v6.PreRelease(), Equals, "beta2")
   104  }
   105  
   106  func (s *VersionSuite) TestBuild(c *C) {
   107  	v1, _ := Parse("1")
   108  	v2, _ := Parse("2.1")
   109  	v3, _ := Parse("3.4.5")
   110  	v4, _ := Parse("4-alpha1")
   111  	v5, _ := Parse("5-beta1+sha:5114f85")
   112  	v6, _ := Parse("6.12.1-beta2+exp.sha.5114f85")
   113  
   114  	c.Assert(v1.Build(), Equals, "")
   115  	c.Assert(v2.Build(), Equals, "")
   116  	c.Assert(v3.Build(), Equals, "")
   117  	c.Assert(v4.Build(), Equals, "")
   118  	c.Assert(v5.Build(), Equals, "sha:5114f85")
   119  	c.Assert(v6.Build(), Equals, "exp.sha.5114f85")
   120  }
   121  
   122  func (s *VersionSuite) TestSimple(c *C) {
   123  	v1, _ := Parse("1")
   124  	v2, _ := Parse("2.1")
   125  	v3, _ := Parse("3.4.5")
   126  	v4, _ := Parse("4-alpha1")
   127  	v5, _ := Parse("5-beta1+sha:5114f85")
   128  	v6, _ := Parse("6.12.1-beta2+exp.sha.5114f85")
   129  
   130  	c.Assert(v1.Simple(), Equals, "1.0.0")
   131  	c.Assert(v2.Simple(), Equals, "2.1.0")
   132  	c.Assert(v3.Simple(), Equals, "3.4.5")
   133  	c.Assert(v4.Simple(), Equals, "4.0.0")
   134  	c.Assert(v5.Simple(), Equals, "5.0.0")
   135  	c.Assert(v6.Simple(), Equals, "6.12.1")
   136  }
   137  
   138  func (s *VersionSuite) TestString(c *C) {
   139  	v1, _ := Parse("1")
   140  	v2, _ := Parse("2.1")
   141  	v3, _ := Parse("3.4.5")
   142  	v4, _ := Parse("5-beta1+sha:5114f85")
   143  	v5, _ := Parse("6.12.1-beta2+exp.sha.5114f85")
   144  
   145  	c.Assert(v1.String(), Equals, "1")
   146  	c.Assert(v2.String(), Equals, "2.1")
   147  	c.Assert(v3.String(), Equals, "3.4.5")
   148  	c.Assert(v4.String(), Equals, "5-beta1+sha:5114f85")
   149  	c.Assert(v5.String(), Equals, "6.12.1-beta2+exp.sha.5114f85")
   150  }
   151  
   152  func (s *VersionSuite) TestIsZero(c *C) {
   153  	var v1 Version
   154  
   155  	v2, _ := Parse("1")
   156  
   157  	c.Assert(v1.IsZero(), Equals, true)
   158  	c.Assert(v2.IsZero(), Equals, false)
   159  }
   160  
   161  func (s *VersionSuite) TestErrors(c *C) {
   162  	var err error
   163  
   164  	var v1 Version
   165  	var v2 = Version{}
   166  
   167  	_, err = Parse("A")
   168  	c.Assert(err, NotNil)
   169  
   170  	_, err = Parse(" ")
   171  	c.Assert(err, NotNil)
   172  
   173  	_, err = Parse("")
   174  	c.Assert(err, NotNil)
   175  
   176  	_, err = Parse("1.2.B")
   177  	c.Assert(err, NotNil)
   178  
   179  	_, err = Parse("1.2.8-")
   180  	c.Assert(err, NotNil)
   181  
   182  	_, err = Parse("1.2.8-1+")
   183  	c.Assert(err, NotNil)
   184  
   185  	c.Assert(v1.Major(), Equals, -1)
   186  	c.Assert(v1.Minor(), Equals, -1)
   187  	c.Assert(v1.Patch(), Equals, -1)
   188  	c.Assert(v1.PreRelease(), Equals, "")
   189  	c.Assert(v1.Build(), Equals, "")
   190  	c.Assert(v1.String(), Equals, "")
   191  	c.Assert(v1.Simple(), Equals, "0.0.0")
   192  
   193  	c.Assert(v2.Major(), Equals, -1)
   194  	c.Assert(v2.Minor(), Equals, -1)
   195  	c.Assert(v2.Patch(), Equals, -1)
   196  	c.Assert(v2.PreRelease(), Equals, "")
   197  	c.Assert(v2.Build(), Equals, "")
   198  	c.Assert(v2.String(), Equals, "")
   199  	c.Assert(v2.Simple(), Equals, "0.0.0")
   200  }
   201  
   202  func (s *VersionSuite) TestComparison(c *C) {
   203  	var P = func(version string) Version {
   204  		v, _ := Parse(version)
   205  		return v
   206  	}
   207  
   208  	c.Assert(P("1").Equal(P("1")), Equals, true)
   209  	c.Assert(P("1").Equal(P("2")), Equals, false)
   210  	c.Assert(P("1").Equal(P("1.0")), Equals, true)
   211  	c.Assert(P("1").Equal(P("1.1")), Equals, false)
   212  	c.Assert(P("1").Equal(P("1.0.0")), Equals, true)
   213  	c.Assert(P("1").Equal(P("1.0.1")), Equals, false)
   214  	c.Assert(P("1").Equal(P("1.0.0-alpha1")), Equals, false)
   215  	c.Assert(P("1").Equal(P("1.0.0+sha:5114f85")), Equals, false)
   216  	c.Assert(P("1.0.0+sha:5114f85").Equal(P("1.0.0+sha:5114f85")), Equals, true)
   217  
   218  	c.Assert(P("1").Less(P("1")), Equals, false)
   219  	c.Assert(P("1").Less(P("1.0")), Equals, false)
   220  	c.Assert(P("1").Less(P("1.0.0")), Equals, false)
   221  	c.Assert(P("1").Less(P("2")), Equals, true)
   222  	c.Assert(P("1").Less(P("1.1")), Equals, true)
   223  	c.Assert(P("1").Less(P("1.0.1")), Equals, true)
   224  	c.Assert(P("1.0.1-alpha").Less(P("1.0.1")), Equals, true)
   225  	c.Assert(P("1.0.1").Less(P("1.0.1-alpha")), Equals, false)
   226  	c.Assert(P("1.0.1-alpha").Less(P("1.0.1-beta")), Equals, true)
   227  	c.Assert(P("1.0.1-gamma").Less(P("1.0.1-beta")), Equals, false)
   228  	c.Assert(P("1.0.1-alpha").Less(P("1.0.1-alpha1")), Equals, true)
   229  	c.Assert(P("1.0.1-a4").Less(P("1.0.1-a5")), Equals, true)
   230  	c.Assert(P("1.0.1-a5").Less(P("1.0.1-a5")), Equals, false)
   231  	c.Assert(P("1.11.0").Less(P("1.10.0")), Equals, false)
   232  	c.Assert(P("1.0.11").Less(P("1.0.10")), Equals, false)
   233  	c.Assert(P("2.0.0").Less(P("1.1.0")), Equals, false)
   234  
   235  	c.Assert(P("1").Greater(P("1")), Equals, false)
   236  	c.Assert(P("1").Greater(P("1.0")), Equals, false)
   237  	c.Assert(P("1").Greater(P("1.0.0")), Equals, false)
   238  	c.Assert(P("2").Greater(P("1")), Equals, true)
   239  	c.Assert(P("1.1").Greater(P("1")), Equals, true)
   240  	c.Assert(P("1.0.1").Greater(P("1")), Equals, true)
   241  	c.Assert(P("1.0.1-alpha").Greater(P("1.0.1")), Equals, false)
   242  	c.Assert(P("1.0.1").Greater(P("1.0.1-alpha")), Equals, true)
   243  	c.Assert(P("1.0.1-alpha").Greater(P("1.0.1-beta")), Equals, false)
   244  	c.Assert(P("1.0.1-gamma").Greater(P("1.0.1-beta")), Equals, true)
   245  	c.Assert(P("1.0.1-alpha").Greater(P("1.0.1-alpha1")), Equals, false)
   246  	c.Assert(P("1.0.1-a4").Greater(P("1.0.1-a5")), Equals, false)
   247  	c.Assert(P("1.0.1-a5").Greater(P("1.0.1-a5")), Equals, false)
   248  	c.Assert(P("1.10.0").Greater(P("1.11.0")), Equals, false)
   249  	c.Assert(P("1.0.10").Greater(P("1.0.11")), Equals, false)
   250  	c.Assert(P("2.0.0").Greater(P("1.1.0")), Equals, true)
   251  
   252  	c.Assert(P("1").Contains(P("1")), Equals, true)
   253  	c.Assert(P("1").Contains(P("1.1")), Equals, true)
   254  	c.Assert(P("1").Contains(P("1.0.1")), Equals, true)
   255  	c.Assert(P("2").Contains(P("1")), Equals, false)
   256  	c.Assert(P("1.1").Contains(P("1.2")), Equals, false)
   257  	c.Assert(P("1.0").Contains(P("1.0.2")), Equals, true)
   258  	c.Assert(P("1.0.1").Contains(P("1.0.2")), Equals, false)
   259  	c.Assert(P("1.0.1").Contains(P("1.0.1-alpha")), Equals, false)
   260  
   261  	c.Assert(P("0.10.8").Greater(P("1.0.0")), Equals, false)
   262  	c.Assert(P("1.0.0").Less(P("0.10.8")), Equals, false)
   263  }