src/third_party/chromite/lib/paygen/gspaths_unittest.py

   1 #!/usr/bin/python
   2 # Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """Test gspaths library."""
   7
   8 from __future__ import print_function
   9
  10 import mox
  11
  12 import fixup_path
  13 fixup_path.FixupPath()
  14
  15 from chromite.lib import cros_test_lib
  16 from chromite.lib.paygen import gspaths
  17
  18
  19 class GsPathsDataTest(mox.MoxTestBase):
  20   """Tests for structs defined in GsPaths."""
  21   def setUp(self):
  22     self.mox = mox.Mox()
  23
  24   def testBuild(self):
  25     default_input = { 'channel': 'foo-channel',
  26                       'board': 'board-name',
  27                       'version': '1.2.3',
  28                     }
  29     default_expected = { 'bucket': None,
  30                          'channel': 'foo-channel',
  31                          'board': 'board-name',
  32                          'version': '1.2.3',
  33                          'uri' : None
  34                        }
  35     expected_str = ("Build definition (board='board-name',"
  36                     " version='1.2.3', channel='foo-channel')")
  37
  38     build = gspaths.Build(default_input)
  39     self.assertEqual(build, default_expected)
  40
  41     self.assertEqual(expected_str, str(build))
  42
  43
  44 class GsPathsChromeosReleasesTest(mox.MoxTestBase):
  45   """Tests for gspaths.ChromeosReleases."""
  46   # Standard Chrome OS releases names.
  47   _CHROMEOS_RELEASES_BUCKET = 'chromeos-releases'
  48   _AU_GENERATOR_FILE_NAME = 'au-generator.zip'
  49
  50   # Google Storage path, image and payload name base templates.
  51   _GS_BUILD_PATH_TEMPLATE = 'gs://%(bucket)s/%(channel)s/%(board)s/%(version)s'
  52   _IMAGE_NAME_TEMPLATE = (
  53       'chromeos_%(image_version)s_%(board)s_recovery_%(image_channel)s_'
  54       '%(key)s.bin')
  55   _UNSIGNED_IMAGE_ARCHIVE_NAME_TEMPLATE = (
  56       'ChromeOS-%(image_type)s-%(milestone)s-%(image_version)s-'
  57       '%(board)s.tar.xz')
  58   _FULL_PAYLOAD_NAME_TEMPLATE = (
  59       'chromeos_%(image_version)s_%(board)s_%(image_channel)s_full_%(key)s.bin-'
  60       '%(random_str)s.signed')
  61   _DELTA_PAYLOAD_NAME_TEMPLATE = (
  62       'chromeos_%(src_version)s-%(image_version)s_%(board)s_%(image_channel)s_'
  63       'delta_%(key)s.bin-%(random_str)s.signed')
  64   _UNSIGNED_FULL_PAYLOAD_NAME_TEMPLATE = (
  65       'chromeos_%(image_version)s_%(board)s_%(image_channel)s_full_'
  66       '%(image_type)s.bin-%(random_str)s')
  67   _UNSIGNED_DELTA_PAYLOAD_NAME_TEMPLATE = (
  68       'chromeos_%(src_version)s-%(image_version)s_%(board)s_%(image_channel)s_'
  69       'delta_%(image_type)s.bin-%(random_str)s')
  70
  71   # Compound templates.
  72   _GS_IMAGE_PATH_TEMPLATE = '/'.join(
  73       (_GS_BUILD_PATH_TEMPLATE, _IMAGE_NAME_TEMPLATE))
  74   _GS_UNSIGNED_IMAGE_ARCHIVE_PATH_TEMPLATE = '/'.join(
  75       (_GS_BUILD_PATH_TEMPLATE, _UNSIGNED_IMAGE_ARCHIVE_NAME_TEMPLATE))
  76   _GS_PAYLOADS_PATH_TEMPLATE = '/'.join((_GS_BUILD_PATH_TEMPLATE, 'payloads'))
  77   _GS_PAYLOADS_SIGNING_PATH_TEMPLATE = '/'.join((_GS_BUILD_PATH_TEMPLATE,
  78                                                 'payloads', 'signing'))
  79   _GS_FULL_PAYLOAD_PATH_TEMPLATE = '/'.join(
  80       (_GS_PAYLOADS_PATH_TEMPLATE, _FULL_PAYLOAD_NAME_TEMPLATE))
  81   _GS_DELTA_PAYLOAD_PATH_TEMPLATE = '/'.join(
  82       (_GS_PAYLOADS_PATH_TEMPLATE, _DELTA_PAYLOAD_NAME_TEMPLATE))
  83
  84   def setUp(self):
  85     self.mox = mox.Mox()
  86
  87     # Shared attributes (signed + unsigned images).
  88     self.bucket = 'crt'
  89     self.channel = 'foo-channel'
  90     self.board = 'board-name'
  91     self.version = '1.2.3'
  92
  93     # Signed image attributes.
  94     self.key = 'mp-v3'
  95
  96     # Unsigned (test) image attributes.
  97     self.milestone = 'R12'
  98     self.image_type = 'test'
  99
 100     # Attributes used for payload testing.
 101     self.src_version = '1.1.1'
 102     self.random_str = '1234567890'
 103
 104     # Dictionaries for populating templates.
 105     self.image_attrs = dict(
 106         bucket=self.bucket,
 107         channel=self.channel,
 108         image_channel=self.channel,
 109         board=self.board,
 110         version=self.version,
 111         image_version=self.version,
 112         key=self.key)
 113     self.unsigned_image_archive_attrs = dict(
 114         bucket=self.bucket,
 115         channel=self.channel,
 116         image_channel=self.channel,
 117         board=self.board,
 118         version=self.version,
 119         image_version=self.version,
 120         milestone=self.milestone,
 121         image_type=self.image_type)
 122     self.all_attrs = dict(self.image_attrs,
 123                           src_version=self.src_version,
 124                           random_str=self.random_str,
 125                           **self.unsigned_image_archive_attrs)
 126
 127   def tearDown(self):
 128     self.mox.UnsetStubs()
 129
 130   def _Populate(self, template, **kwargs):
 131     """Populates a template string with override attributes.
 132
 133     This will use the default test attributes to populate a given string
 134     template. It will further override default field values with the values
 135     provided by the optional named arguments.
 136
 137     Args:
 138       template: a string with named substitution fields
 139       kwargs: named attributes to override the defaults
 140
 141     """
 142     attrs = dict(self.all_attrs, **kwargs)
 143     return template % attrs
 144
 145   def _PopulateGsPath(self, base_path, suffix=None, **kwargs):
 146     """Populates a Google Storage path template w/ optional suffix.
 147
 148     Args:
 149       base_path: a path string template with named substitution fields
 150       suffix: a path suffix to append to the given base path
 151       kwargs: named attributes to override the defaults
 152
 153     """
 154     template = base_path
 155     if suffix:
 156       template += '/' + suffix
 157
 158     return self._Populate(template, **kwargs)
 159
 160   def testBuildUri(self):
 161     self.assertEquals(
 162         gspaths.ChromeosReleases.BuildUri(self.channel,
 163                                           self.board,
 164                                           self.version,
 165                                           bucket=self.bucket),
 166         self._PopulateGsPath(self._GS_BUILD_PATH_TEMPLATE))
 167
 168     self.assertEquals(
 169         gspaths.ChromeosReleases.BuildUri(self.channel,
 170                                           self.board,
 171                                           self.version),
 172         self._PopulateGsPath(self._GS_BUILD_PATH_TEMPLATE,
 173                              bucket=self._CHROMEOS_RELEASES_BUCKET))
 174
 175   def testGeneratorUri(self):
 176     self.assertEquals(
 177         gspaths.ChromeosReleases.GeneratorUri(self.channel,
 178                                               self.board,
 179                                               self.version,
 180                                               bucket=self.bucket),
 181         self._PopulateGsPath(self._GS_BUILD_PATH_TEMPLATE,
 182                              suffix=self._AU_GENERATOR_FILE_NAME))
 183
 184     self.assertEquals(
 185         gspaths.ChromeosReleases.GeneratorUri(self.channel,
 186                                               self.board,
 187                                               self.version),
 188         self._PopulateGsPath(self._GS_BUILD_PATH_TEMPLATE,
 189                              suffix=self._AU_GENERATOR_FILE_NAME,
 190                              bucket=self._CHROMEOS_RELEASES_BUCKET))
 191
 192   def testBuildPayloadsUri(self):
 193     self.assertEquals(
 194         gspaths.ChromeosReleases.BuildPayloadsUri(self.channel,
 195                                                   self.board,
 196                                                   self.version,
 197                                                   bucket=self.bucket),
 198         self._PopulateGsPath(self._GS_PAYLOADS_PATH_TEMPLATE))
 199
 200     self.assertEquals(
 201         gspaths.ChromeosReleases.BuildPayloadsUri(self.channel,
 202                                                   self.board,
 203                                                   self.version),
 204         self._PopulateGsPath(self._GS_PAYLOADS_PATH_TEMPLATE,
 205                              bucket=self._CHROMEOS_RELEASES_BUCKET))
 206
 207   def testBuildPayloadsSigningUri(self):
 208     self.assertEquals(
 209         gspaths.ChromeosReleases.BuildPayloadsSigningUri(self.channel,
 210                                                   self.board,
 211                                                   self.version,
 212                                                   bucket=self.bucket),
 213         self._PopulateGsPath(self._GS_PAYLOADS_SIGNING_PATH_TEMPLATE))
 214
 215     self.assertEquals(
 216         gspaths.ChromeosReleases.BuildPayloadsSigningUri(self.channel,
 217                                                   self.board,
 218                                                   self.version),
 219         self._PopulateGsPath(self._GS_PAYLOADS_SIGNING_PATH_TEMPLATE,
 220                              bucket=self._CHROMEOS_RELEASES_BUCKET))
 221
 222   def testBuildPayloadsFlagUri(self):
 223     self.assertEquals(
 224         gspaths.ChromeosReleases.BuildPayloadsFlagUri(
 225             self.channel,
 226             self.board,
 227             self.version,
 228             gspaths.ChromeosReleases.SKIP,
 229             bucket=self.bucket),
 230         self._PopulateGsPath(self._GS_PAYLOADS_PATH_TEMPLATE,
 231                              suffix='SKIP_flag'))
 232
 233     self.assertEquals(
 234         gspaths.ChromeosReleases.BuildPayloadsFlagUri(
 235             self.channel,
 236             self.board,
 237             self.version,
 238             gspaths.ChromeosReleases.FINISHED,
 239             bucket=self.bucket),
 240         self._PopulateGsPath(self._GS_PAYLOADS_PATH_TEMPLATE,
 241                              suffix='FINISHED_flag'))
 242
 243     self.assertEquals(
 244         gspaths.ChromeosReleases.BuildPayloadsFlagUri(
 245             self.channel,
 246             self.board,
 247             self.version,
 248             gspaths.ChromeosReleases.LOCK,
 249             bucket=self.bucket),
 250         self._PopulateGsPath(self._GS_PAYLOADS_PATH_TEMPLATE,
 251                              suffix='LOCK_flag'))
 252
 253     # Default bucket
 254     self.assertEquals(
 255         gspaths.ChromeosReleases.BuildPayloadsFlagUri(
 256             self.channel,
 257             self.board,
 258             self.version,
 259             gspaths.ChromeosReleases.SKIP),
 260         self._PopulateGsPath(self._GS_PAYLOADS_PATH_TEMPLATE,
 261                              suffix='SKIP_flag',
 262                              bucket=self._CHROMEOS_RELEASES_BUCKET))
 263
 264   def testImageName(self):
 265     self.assertEquals(
 266         gspaths.ChromeosReleases.ImageName(self.channel,
 267                                            self.board,
 268                                            self.version,
 269                                            self.key),
 270         self._Populate(self._IMAGE_NAME_TEMPLATE))
 271
 272   def testUnsignedImageArchiveName(self):
 273     self.assertEquals(
 274         gspaths.ChromeosReleases.UnsignedImageArchiveName(
 275             self.board,
 276             self.version,
 277             self.milestone,
 278             self.image_type),
 279         self._Populate(self._UNSIGNED_IMAGE_ARCHIVE_NAME_TEMPLATE))
 280
 281   def testImageUri(self):
 282     self.assertEquals(
 283         gspaths.ChromeosReleases.ImageUri(self.channel,
 284                                           self.board,
 285                                           self.version,
 286                                           self.key,
 287                                           bucket=self.bucket),
 288         self._Populate(self._GS_IMAGE_PATH_TEMPLATE))
 289
 290   def testUnsignedImageArchiveUri(self):
 291     self.assertEquals(
 292         gspaths.ChromeosReleases.UnsignedImageArchiveUri(
 293             self.channel, self.board, self.version, self.milestone,
 294             self.image_type, bucket=self.bucket),
 295         self._Populate(self._GS_UNSIGNED_IMAGE_ARCHIVE_PATH_TEMPLATE))
 296
 297   @staticmethod
 298   def _IncrementVersion(version, inc_amount=1):
 299     version_part = version.rpartition('.')
 300     return '.'.join((version_part[0], str(int(version_part[2]) + inc_amount)))
 301
 302   def testParseImageUri(self):
 303     npo_version = self._IncrementVersion(self.version)
 304     npo_channel = 'nplusone-channel'
 305
 306     basic_dict = dict(self.image_attrs)
 307     npo_dict = dict(self.image_attrs,
 308                     bucket=self._CHROMEOS_RELEASES_BUCKET,
 309                     image_version=npo_version,
 310                     image_channel=npo_channel)
 311     basic_dict['uri'] = uri_basic = self._GS_IMAGE_PATH_TEMPLATE % basic_dict
 312     npo_dict['uri'] = uri_npo = self._GS_IMAGE_PATH_TEMPLATE % npo_dict
 313
 314     expected_basic = gspaths.Image(bucket=self.bucket,
 315                                    channel=self.channel,
 316                                    board=self.board,
 317                                    version=self.version,
 318                                    key=self.key,
 319                                    uri=uri_basic)
 320     expected_basic_str = gspaths.ChromeosReleases.ImageName(
 321         expected_basic.channel, expected_basic.board, expected_basic.version,
 322         expected_basic.key)
 323
 324     expected_npo = gspaths.Image(channel=self.channel,
 325                                  board=self.board,
 326                                  version=self.version,
 327                                  key=self.key,
 328                                  image_channel=npo_channel,
 329                                  image_version=npo_version,
 330                                  uri=uri_npo)
 331
 332     expected_npo_str = gspaths.ChromeosReleases.ImageName(
 333         expected_npo.image_channel, expected_npo.board,
 334         expected_npo.image_version, expected_npo.key)
 335
 336     basic_image = gspaths.ChromeosReleases.ParseImageUri(uri_basic)
 337     self.assertEqual(basic_image, expected_basic)
 338     self.assertEqual(str(basic_image), expected_basic_str)
 339
 340     npo_image = gspaths.ChromeosReleases.ParseImageUri(uri_npo)
 341     self.assertEqual(npo_image, expected_npo)
 342     self.assertEqual(str(npo_image), expected_npo_str)
 343
 344     signer_output = ('gs://chromeos-releases/dev-channel/link/4537.7.0/'
 345                      'chromeos_4537.7.1_link_recovery_nplusone-channel_'
 346                      'mp-v4.bin.1.payload.hash.update_signer.signed.bin')
 347
 348     bad_image = gspaths.ChromeosReleases.ParseImageUri(signer_output)
 349     self.assertEqual(bad_image, None)
 350
 351   def testParseUnsignedImageArchiveUri(self):
 352     attr_dict = dict(self.unsigned_image_archive_attrs)
 353     attr_dict['uri'] = uri = (
 354         self._GS_UNSIGNED_IMAGE_ARCHIVE_PATH_TEMPLATE % attr_dict)
 355
 356     expected = gspaths.UnsignedImageArchive(bucket=self.bucket,
 357                                             channel=self.channel,
 358                                             board=self.board,
 359                                             version=self.version,
 360                                             milestone=self.milestone,
 361                                             image_type=self.image_type,
 362                                             uri=uri)
 363     expected_str = gspaths.ChromeosReleases.UnsignedImageArchiveName(
 364         expected.board, expected.version, expected.milestone,
 365         expected.image_type)
 366
 367     image = gspaths.ChromeosReleases.ParseUnsignedImageArchiveUri(uri)
 368     self.assertEqual(image, expected)
 369     self.assertEqual(str(image), expected_str)
 370
 371   def testPayloadNamePreset(self):
 372     full = gspaths.ChromeosReleases.PayloadName(channel=self.channel,
 373                                                 board=self.board,
 374                                                 version=self.version,
 375                                                 key=self.key,
 376                                                 random_str=self.random_str)
 377
 378     delta = gspaths.ChromeosReleases.PayloadName(channel=self.channel,
 379                                                  board=self.board,
 380                                                  version=self.version,
 381                                                  key=self.key,
 382                                                  src_version=self.src_version,
 383                                                  random_str=self.random_str)
 384
 385     full_unsigned = gspaths.ChromeosReleases.PayloadName(
 386         channel=self.channel,
 387         board=self.board,
 388         version=self.version,
 389         random_str=self.random_str,
 390         unsigned_image_type=self.image_type)
 391
 392     delta_unsigned = gspaths.ChromeosReleases.PayloadName(
 393         channel=self.channel,
 394         board=self.board,
 395         version=self.version,
 396         src_version=self.src_version,
 397         random_str=self.random_str,
 398         unsigned_image_type=self.image_type)
 399
 400     self.assertEqual(full, self._Populate(self._FULL_PAYLOAD_NAME_TEMPLATE))
 401     self.assertEqual(delta, self._Populate(self._DELTA_PAYLOAD_NAME_TEMPLATE))
 402     self.assertEqual(full_unsigned,
 403                      self._Populate(self._UNSIGNED_FULL_PAYLOAD_NAME_TEMPLATE))
 404     self.assertEqual(delta_unsigned,
 405                      self._Populate(self._UNSIGNED_DELTA_PAYLOAD_NAME_TEMPLATE))
 406
 407   def testPayloadNameRandom(self):
 408     full = gspaths.ChromeosReleases.PayloadName(channel=self.channel,
 409                                                 board=self.board,
 410                                                 version=self.version,
 411                                                 key=self.key)
 412
 413     delta = gspaths.ChromeosReleases.PayloadName(channel=self.channel,
 414                                                  board=self.board,
 415                                                  version=self.version,
 416                                                  key=self.key,
 417                                                  src_version=self.src_version)
 418
 419     # Isolate the actual random string, transplant it in the reference template.
 420     full_random_str = full.split('-')[-1].partition('.')[0]
 421     self.assertEqual(
 422         full,
 423         self._Populate(self._FULL_PAYLOAD_NAME_TEMPLATE,
 424                        random_str=full_random_str))
 425     delta_random_str = delta.split('-')[-1].partition('.')[0]
 426     self.assertEqual(
 427         delta,
 428         self._Populate(self._DELTA_PAYLOAD_NAME_TEMPLATE,
 429                        random_str=delta_random_str))
 430
 431   def testPayloadUri(self):
 432     test_random_channel = 'test_random_channel'
 433     test_max_version = '4.5.6'
 434     test_min_version = '0.12.1.0'
 435
 436     min_full = gspaths.ChromeosReleases.PayloadUri(
 437         channel=self.channel,
 438         board=self.board,
 439         version=self.version,
 440         random_str=self.random_str,
 441         key=self.key)
 442
 443     self.assertEqual(
 444         min_full,
 445         self._Populate(self._GS_FULL_PAYLOAD_PATH_TEMPLATE,
 446                        bucket=self._CHROMEOS_RELEASES_BUCKET))
 447
 448     max_full = gspaths.ChromeosReleases.PayloadUri(
 449         channel=self.channel,
 450         board=self.board,
 451         version=self.version,
 452         random_str=self.random_str,
 453         key=self.key,
 454         image_channel=test_random_channel,
 455         image_version=test_max_version,
 456         bucket=self.bucket)
 457
 458     self.assertEqual(
 459         max_full,
 460         self._Populate(self._GS_FULL_PAYLOAD_PATH_TEMPLATE,
 461                        image_channel=test_random_channel,
 462                        image_version=test_max_version))
 463
 464     min_delta = gspaths.ChromeosReleases.PayloadUri(
 465         channel=self.channel,
 466         board=self.board,
 467         version=self.version,
 468         random_str=self.random_str,
 469         key=self.key,
 470         src_version=test_min_version)
 471
 472     self.assertEqual(
 473         min_delta,
 474         self._Populate(self._GS_DELTA_PAYLOAD_PATH_TEMPLATE,
 475                        bucket=self._CHROMEOS_RELEASES_BUCKET,
 476                        src_version=test_min_version))
 477
 478     max_delta = gspaths.ChromeosReleases.PayloadUri(
 479         channel=self.channel,
 480         board=self.board,
 481         version=self.version,
 482         random_str=self.random_str,
 483         key=self.key,
 484         image_channel=test_random_channel,
 485         image_version=test_max_version,
 486         src_version=test_min_version,
 487         bucket=self.bucket)
 488
 489     self.assertEqual(
 490         max_delta,
 491         self._Populate(self._GS_DELTA_PAYLOAD_PATH_TEMPLATE,
 492                        src_version=test_min_version,
 493                        image_version=test_max_version,
 494                        image_channel=test_random_channel))
 495
 496   def testParsePayloadUri(self):
 497     """Test gsutils.ChromeosReleases.ParsePayloadUri()."""
 498
 499     image_version = '1.2.4'
 500
 501     full_uri = self._Populate(self._GS_FULL_PAYLOAD_PATH_TEMPLATE,
 502                               bucket='chromeos-releases')
 503
 504     delta_uri = self._Populate(self._GS_DELTA_PAYLOAD_PATH_TEMPLATE,
 505                                bucket='chromeos-releases')
 506
 507     max_full_uri = self._Populate(self._GS_FULL_PAYLOAD_PATH_TEMPLATE,
 508                                   image_channel='image-channel',
 509                                   image_version=image_version)
 510
 511     max_delta_uri = self._Populate(self._GS_DELTA_PAYLOAD_PATH_TEMPLATE,
 512                                   image_channel='image-channel',
 513                                   image_version=image_version)
 514
 515     self.assertDictEqual(
 516         gspaths.ChromeosReleases.ParsePayloadUri(full_uri),
 517         {
 518           'tgt_image': gspaths.Image(board=self.board,
 519                                      channel=self.channel,
 520                                      version=self.version,
 521                                      key=self.key),
 522           'src_image': None,
 523           'uri': full_uri,
 524         })
 525
 526     self.assertDictEqual(
 527         gspaths.ChromeosReleases.ParsePayloadUri(delta_uri),
 528         {
 529           'src_image': gspaths.Image(board=self.board,
 530                                      channel=self.channel,
 531                                      version=self.src_version),
 532           'tgt_image': gspaths.Image(board=self.board,
 533                                      channel=self.channel,
 534                                      version=self.version,
 535                                      key=self.key),
 536           'uri': delta_uri,
 537         })
 538
 539     self.assertDictEqual(
 540         gspaths.ChromeosReleases.ParsePayloadUri(max_full_uri),
 541         {
 542           'tgt_image': gspaths.Image(bucket=self.bucket,
 543                                      board=self.board,
 544                                      channel=self.channel,
 545                                      version=self.version,
 546                                      key=self.key,
 547                                      image_version=image_version,
 548                                      image_channel='image-channel'),
 549           'src_image': None,
 550           'uri': max_full_uri,
 551         })
 552
 553     self.assertDictEqual(
 554         gspaths.ChromeosReleases.ParsePayloadUri(max_delta_uri),
 555         {
 556           'src_image': gspaths.Image(bucket=self.bucket,
 557                                      board=self.board,
 558                                      channel=self.channel,
 559                                      version=self.src_version),
 560           'tgt_image': gspaths.Image(bucket=self.bucket,
 561                                      board=self.board,
 562                                      channel=self.channel,
 563                                      version=self.version,
 564                                      key=self.key,
 565                                      image_version=image_version,
 566                                      image_channel='image-channel'),
 567           'uri': max_delta_uri,
 568         })
 569
 570
 571 class GsPathsTest(mox.MoxTestBase):
 572   """Test general gspaths utilities."""
 573   def testVersionKey(self):
 574     """Test VersionKey, especially for new-style versus old-style."""
 575
 576     values = ['1.2.3', '1.2.2', '2.0.0', '1.1.4',
 577               '1.2.3.4', '1.2.3.3', '1.2.4.4', '1.2.4.5', '1.3.3.4',
 578               '0.1.2.3', '0.14.45.32']
 579
 580     sorted_values = sorted(values, key=gspaths.VersionKey)
 581     reverse_sorted_values = sorted(reversed(values), key=gspaths.VersionKey)
 582
 583     expected_values = ['0.1.2.3', '0.14.45.32',
 584                        '1.2.3.3', '1.2.3.4', '1.2.4.4', '1.2.4.5', '1.3.3.4',
 585                        '1.1.4', '1.2.2', '1.2.3', '2.0.0',]
 586
 587     self.assertEquals(sorted_values, expected_values)
 588     self.assertEquals(reverse_sorted_values, expected_values)
 589
 590   def testVersionGreater(self):
 591     """Test VersionGreater, especially for new-style versus old-style."""
 592
 593     self.assertTrue(gspaths.VersionGreater('1.2.3', '1.2.2'))
 594     self.assertTrue(gspaths.VersionGreater('1.2.3', '1.1.4'))
 595     self.assertTrue(gspaths.VersionGreater('2.0.0', '1.2.3'))
 596
 597     self.assertFalse(gspaths.VersionGreater('1.2.3', '1.2.3'))
 598
 599     self.assertFalse(gspaths.VersionGreater('1.2.2', '1.2.3'))
 600     self.assertFalse(gspaths.VersionGreater('1.1.4', '1.2.3'))
 601     self.assertFalse(gspaths.VersionGreater('1.2.3', '2.0.0'))
 602
 603     self.assertTrue(gspaths.VersionGreater('1.2.3.4', '1.2.3.3'))
 604     self.assertTrue(gspaths.VersionGreater('1.2.4.4', '1.2.3.4'))
 605     self.assertTrue(gspaths.VersionGreater('1.3.3.4', '1.2.4.5'))
 606     self.assertTrue(gspaths.VersionGreater('2.0.0.0', '1.2.3.4'))
 607
 608     self.assertFalse(gspaths.VersionGreater('1.2.3.4', '1.2.3.4'))
 609
 610     self.assertFalse(gspaths.VersionGreater('1.2.3.3', '1.2.3.4'))
 611     self.assertFalse(gspaths.VersionGreater('1.2.3.4', '1.2.4.4'))
 612     self.assertFalse(gspaths.VersionGreater('1.2.4.5', '1.3.3.4'))
 613     self.assertFalse(gspaths.VersionGreater('1.2.3.4', '2.0.0.0'))
 614
 615     self.assertTrue(gspaths.VersionGreater('1.2.3', '1.2.3.4'))
 616     self.assertTrue(gspaths.VersionGreater('1.2.3', '0.1.2.3'))
 617
 618     self.assertFalse(gspaths.VersionGreater('1.2.3.4', '1.2.3'))
 619     self.assertFalse(gspaths.VersionGreater('0.1.2.3', '1.2.3'))
 620
 621
 622 if __name__ == '__main__':
 623   cros_test_lib.main()