1# Copyright 2019 The Chromium Authors 2# Use of this source code is governed by a BSD-style license that can be 3# found in the LICENSE file. 4 5import unittest 6 7from android_chrome_version import GenerateVersionCodes 8from android_chrome_version import TranslateVersionCode 9 10EXAMPLE_VERSION_VALUES = { 11 'MAJOR': '99', 12 'MINOR': '0', 13 'BUILD': '4844', 14 'PATCH': '0', 15} 16 17EXAMPLE_GROUPED_VERSION_VALUES = { 18 'MAJOR': '99', 19 'MINOR': '0', 20 'BUILD': '5750', 21 'PATCH': '0', 22} 23 24 25class _VersionTest(unittest.TestCase): 26 """Unittests for the android_chrome_version module. 27 """ 28 29 def testGenerateVersionCodesAndroidChrome(self): 30 """Assert it gives correct values for standard/example inputs""" 31 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 32 arch='arm', 33 is_next_build=False) 34 35 chrome_version_code = output['CHROME_VERSION_CODE'] 36 37 self.assertEqual(chrome_version_code, '484400000') 38 39 def testGenerateVersionCodesAndroidChromeModern(self): 40 """Assert it gives correct values for standard/example inputs""" 41 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 42 arch='arm', 43 is_next_build=False) 44 45 chrome_modern_version_code = output['CHROME_MODERN_VERSION_CODE'] 46 47 self.assertEqual(chrome_modern_version_code, '484400010') 48 49 def testGenerateVersionCodesAndroidMonochrome(self): 50 """Assert it gives correct values for standard/example inputs""" 51 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 52 arch='arm', 53 is_next_build=False) 54 55 monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 56 57 self.assertEqual(monochrome_version_code, '484400020') 58 59 def testGenerateVersionCodesAndroidTrichrome(self): 60 """Assert it gives correct values for standard/example inputs""" 61 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 62 arch='arm', 63 is_next_build=False) 64 65 trichrome_version_code = output['TRICHROME_VERSION_CODE'] 66 trichrome_auto_version_code = output['TRICHROME_AUTO_VERSION_CODE'] 67 68 self.assertEqual(trichrome_version_code, '484400030') 69 self.assertEqual(trichrome_auto_version_code, '484400050') 70 71 def testGenerateVersionCodesAndroidWebviewStable(self): 72 """Assert it gives correct values for standard/example inputs""" 73 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 74 arch='arm', 75 is_next_build=False) 76 77 webview_stable_version_code = output['WEBVIEW_STABLE_VERSION_CODE'] 78 79 self.assertEqual(webview_stable_version_code, '484400000') 80 81 def testGenerateVersionCodesAndroidWebviewBeta(self): 82 """Assert it gives correct values for standard/example inputs""" 83 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 84 arch='arm', 85 is_next_build=False) 86 87 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 88 89 self.assertEqual(webview_beta_version_code, '484400010') 90 91 def testGenerateVersionCodesAndroidWebviewDev(self): 92 """Assert it gives correct values for standard/example inputs""" 93 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 94 arch='arm', 95 is_next_build=False) 96 97 webview_dev_version_code = output['WEBVIEW_DEV_VERSION_CODE'] 98 99 self.assertEqual(webview_dev_version_code, '484400020') 100 101 def testGenerateVersionCodesAndroidNextBuild(self): 102 """Assert it handles "next" builds correctly""" 103 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 104 arch='arm', 105 is_next_build=True) 106 107 # Get just a sample of values 108 chrome_version_code = output['CHROME_VERSION_CODE'] 109 monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 110 webview_stable_version_code = output['WEBVIEW_STABLE_VERSION_CODE'] 111 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 112 113 self.assertEqual(chrome_version_code, '484450000') 114 self.assertEqual(monochrome_version_code, '484450020') 115 self.assertEqual(webview_stable_version_code, '484450000') 116 self.assertEqual(webview_beta_version_code, '484450010') 117 118 def testGenerateVersionCodesAndroidArchArm(self): 119 """Assert it handles different architectures correctly. 120 121 Version codes for different builds need to be distinct and maintain a 122 certain ordering. 123 See docs in android_chrome_version._ABIS_TO_BIT_MASK for 124 reasoning. 125 """ 126 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 127 arch='arm', 128 is_next_build=False) 129 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 130 131 self.assertEqual(arch_chrome_version_code, '484400000') 132 133 def testGenerateVersionCodesAndroidArchX86(self): 134 """Assert it handles different architectures correctly. 135 136 Version codes for different builds need to be distinct and maintain a 137 certain ordering. 138 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 139 reasoning. 140 """ 141 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 142 arch='x86', 143 is_next_build=False) 144 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 145 146 self.assertEqual(arch_chrome_version_code, '484400001') 147 148 def testGenerateVersionCodesAndroidArchArm64(self): 149 """Assert it handles different architectures correctly. 150 151 Version codes for different builds need to be distinct and maintain a 152 certain ordering. 153 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 154 reasoning. 155 """ 156 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 157 arch='arm64', 158 is_next_build=False) 159 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 160 161 self.assertEqual(arch_chrome_version_code, '484400005') 162 163 def testGenerateVersionCodesAndroidArchArm64Variants(self): 164 """Assert it handles 64-bit-specific additional version codes correctly. 165 166 Some additional version codes are generated for 64-bit architectures. 167 See docstring on android_chrome_version.ARCH64_APK_VARIANTS for more info. 168 """ 169 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 170 arch='arm64', 171 is_next_build=False) 172 arch_monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 173 arch_monochrome_32_version_code = output['MONOCHROME_32_VERSION_CODE'] 174 arch_monochrome_32_64_version_code = output['MONOCHROME_32_64_VERSION_CODE'] 175 arch_monochrome_64_32_version_code = output['MONOCHROME_64_32_VERSION_CODE'] 176 arch_monochrome_64_version_code = output['MONOCHROME_64_VERSION_CODE'] 177 arch_trichrome_version_code = output['TRICHROME_VERSION_CODE'] 178 arch_trichrome_32_version_code = output['TRICHROME_32_VERSION_CODE'] 179 arch_trichrome_32_64_version_code = output['TRICHROME_32_64_VERSION_CODE'] 180 arch_trichrome_64_32_version_code = output['TRICHROME_64_32_VERSION_CODE'] 181 arch_trichrome_64_32_high_version_code = output[ 182 'TRICHROME_64_32_HIGH_VERSION_CODE'] 183 arch_trichrome_64_version_code = output['TRICHROME_64_VERSION_CODE'] 184 arch_trichrome_auto_version_code = output['TRICHROME_AUTO_VERSION_CODE'] 185 arch_trichrome_auto_32_version_code = output['TRICHROME_AUTO_32_VERSION_CODE'] 186 arch_trichrome_auto_32_64_version_code = output['TRICHROME_AUTO_32_64_VERSION_CODE'] 187 arch_trichrome_auto_64_version_code = output[ 188 'TRICHROME_AUTO_64_VERSION_CODE'] 189 arch_trichrome_auto_64_32_version_code = output[ 190 'TRICHROME_AUTO_64_32_VERSION_CODE'] 191 192 self.assertEqual(arch_monochrome_32_version_code, '484400020') 193 self.assertEqual(arch_monochrome_32_64_version_code, '484400023') 194 self.assertEqual(arch_monochrome_version_code, '484400023') 195 self.assertEqual(arch_monochrome_64_32_version_code, '484400024') 196 self.assertEqual(arch_monochrome_64_version_code, '484400025') 197 self.assertEqual(arch_trichrome_32_version_code, '484400030') 198 self.assertEqual(arch_trichrome_32_64_version_code, '484400033') 199 self.assertEqual(arch_trichrome_version_code, '484400033') 200 self.assertEqual(arch_trichrome_64_32_version_code, '484400034') 201 self.assertEqual(arch_trichrome_64_32_high_version_code, '484400039') 202 self.assertEqual(arch_trichrome_64_version_code, '484400035') 203 self.assertEqual(arch_trichrome_auto_version_code, '484400053') 204 self.assertEqual(arch_trichrome_auto_32_version_code, '484400050') 205 self.assertEqual(arch_trichrome_auto_32_64_version_code, '484400053') 206 self.assertEqual(arch_trichrome_auto_64_version_code, '484400055') 207 self.assertEqual(arch_trichrome_auto_64_32_version_code, '484400054') 208 209 def testGenerateVersionCodesAndroidArchX64(self): 210 """Assert it handles different architectures correctly. 211 212 Version codes for different builds need to be distinct and maintain a 213 certain ordering. 214 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 215 reasoning. 216 """ 217 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 218 arch='x64', 219 is_next_build=False) 220 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 221 222 self.assertEqual(arch_chrome_version_code, '484400008') 223 224 def testGenerateVersionCodesAndroidArchX64Variants(self): 225 """Assert it handles 64-bit-specific additional version codes correctly. 226 227 Some additional version codes are generated for 64-bit architectures. 228 See docstring on android_chrome_version.ARCH64_APK_VARIANTS for more info. 229 """ 230 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 231 arch='x64', 232 is_next_build=False) 233 arch_monochrome_32_version_code = output['MONOCHROME_32_VERSION_CODE'] 234 arch_monochrome_32_64_version_code = output['MONOCHROME_32_64_VERSION_CODE'] 235 arch_monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 236 arch_monochrome_64_32_version_code = output['MONOCHROME_64_32_VERSION_CODE'] 237 arch_monochrome_64_version_code = output['MONOCHROME_64_VERSION_CODE'] 238 arch_trichrome_32_version_code = output['TRICHROME_32_VERSION_CODE'] 239 arch_trichrome_32_64_version_code = output['TRICHROME_32_64_VERSION_CODE'] 240 arch_trichrome_version_code = output['TRICHROME_VERSION_CODE'] 241 arch_trichrome_64_32_version_code = output['TRICHROME_64_32_VERSION_CODE'] 242 arch_trichrome_64_version_code = output['TRICHROME_64_VERSION_CODE'] 243 arch_trichrome_auto_version_code = output['TRICHROME_AUTO_VERSION_CODE'] 244 arch_trichrome_auto_32_version_code = output['TRICHROME_AUTO_32_VERSION_CODE'] 245 arch_trichrome_auto_32_64_version_code = output['TRICHROME_AUTO_32_64_VERSION_CODE'] 246 arch_trichrome_auto_64_version_code = output[ 247 'TRICHROME_AUTO_64_VERSION_CODE'] 248 arch_trichrome_auto_64_32_version_code = output[ 249 'TRICHROME_AUTO_64_32_VERSION_CODE'] 250 251 self.assertEqual(arch_monochrome_32_version_code, '484400021') 252 self.assertEqual(arch_monochrome_32_64_version_code, '484400026') 253 self.assertEqual(arch_monochrome_version_code, '484400026') 254 self.assertEqual(arch_monochrome_64_32_version_code, '484400027') 255 self.assertEqual(arch_monochrome_64_version_code, '484400028') 256 self.assertEqual(arch_trichrome_32_version_code, '484400031') 257 self.assertEqual(arch_trichrome_32_64_version_code, '484400036') 258 self.assertEqual(arch_trichrome_version_code, '484400036') 259 self.assertEqual(arch_trichrome_64_32_version_code, '484400037') 260 self.assertEqual(arch_trichrome_64_version_code, '484400038') 261 self.assertEqual(arch_trichrome_auto_version_code, '484400056') 262 self.assertEqual(arch_trichrome_auto_32_version_code, '484400051') 263 self.assertEqual(arch_trichrome_auto_32_64_version_code, '484400056') 264 self.assertEqual(arch_trichrome_auto_64_version_code, '484400058') 265 self.assertEqual(arch_trichrome_auto_64_32_version_code, '484400057') 266 267 def testGenerateVersionCodesAndroidArchOrderArm(self): 268 """Assert it handles different architectures correctly. 269 270 Version codes for different builds need to be distinct and maintain a 271 certain ordering. 272 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 273 reasoning. 274 275 Test arm-related values. 276 """ 277 arm_output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 278 arch='arm', 279 is_next_build=False) 280 arm64_output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 281 arch='arm64', 282 is_next_build=False) 283 284 arm_chrome_version_code = arm_output['CHROME_VERSION_CODE'] 285 arm64_chrome_version_code = arm64_output['CHROME_VERSION_CODE'] 286 287 self.assertLess(arm_chrome_version_code, arm64_chrome_version_code) 288 289 def testGenerateVersionCodesAndroidArchOrderX86(self): 290 """Assert it handles different architectures correctly. 291 292 Version codes for different builds need to be distinct and maintain a 293 certain ordering. 294 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 295 reasoning. 296 297 Test x86-related values. 298 """ 299 x86_output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 300 arch='x86', 301 is_next_build=False) 302 x64_output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 303 arch='x64', 304 is_next_build=False) 305 306 x86_chrome_version_code = x86_output['CHROME_VERSION_CODE'] 307 x64_chrome_version_code = x64_output['CHROME_VERSION_CODE'] 308 309 self.assertLess(x86_chrome_version_code, x64_chrome_version_code) 310 311 def testGenerateVersionCodesAndroidWebviewChannelOrderBeta(self): 312 """Assert webview beta channel is higher than stable. 313 314 The channel-specific version codes for standalone webview needs to follow 315 the order stable < beta < dev. 316 317 This allows that if a user opts into beta track, they will always have the 318 beta apk, including any finch experiments targeted at beta users, even when 319 beta and stable channels are otherwise on the same version. 320 """ 321 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 322 arch='arm', 323 is_next_build=False) 324 325 webview_stable_version_code = output['WEBVIEW_STABLE_VERSION_CODE'] 326 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 327 328 self.assertGreater(webview_beta_version_code, webview_stable_version_code) 329 330 def testGenerateVersionCodesAndroidWebviewChannelOrderDev(self): 331 """Assert webview dev channel is higher than beta. 332 333 The channel-specific version codes for standalone webview needs to follow 334 the order stable < beta < dev. 335 336 This allows that if a user opts into dev track, they will always have the 337 dev apk, including any finch experiments targeted at dev users, even when 338 dev and beta channels are otherwise on the same version. 339 """ 340 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 341 arch='arm', 342 is_next_build=False) 343 344 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 345 webview_dev_version_code = output['WEBVIEW_DEV_VERSION_CODE'] 346 347 self.assertGreater(webview_dev_version_code, webview_beta_version_code) 348 349 def testGenerateVersionCodesTrichromeChannelOrderBeta(self): 350 """Assert Trichrome beta channel is higher than stable. 351 352 When Trichrome channels are compiled to use the stable channel's package 353 name, their version codes need to follow the order stable < beta. 354 355 This allows that if a user opts into beta track, they will always have the 356 beta apk, including any finch experiments targeted at beta users, even when 357 beta and stable channels are otherwise on the same version. 358 """ 359 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 360 arch='arm', 361 is_next_build=False) 362 363 trichrome_stable_version_code = output['TRICHROME_VERSION_CODE'] 364 trichrome_beta_version_code = output['TRICHROME_BETA_VERSION_CODE'] 365 366 self.assertGreater(trichrome_beta_version_code, 367 trichrome_stable_version_code) 368 369 370class _VersionGroupedTest(unittest.TestCase): 371 """Unittests for the android_chrome_version module (grouped). 372 """ 373 def testGenerateVersionCodesAndroidChrome(self): 374 """Assert it gives correct values for standard/example inputs""" 375 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 376 arch='arm', 377 is_next_build=False) 378 379 chrome_version_code = output['CHROME_VERSION_CODE'] 380 381 self.assertEqual(chrome_version_code, '575000000') 382 383 def testGenerateVersionCodesAndroidChromeModern(self): 384 """Assert it gives correct values for standard/example inputs""" 385 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 386 arch='arm', 387 is_next_build=False) 388 389 chrome_modern_version_code = output['CHROME_MODERN_VERSION_CODE'] 390 391 self.assertEqual(chrome_modern_version_code, '575000010') 392 393 def testGenerateVersionCodesAndroidMonochrome(self): 394 """Assert it gives correct values for standard/example inputs""" 395 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 396 arch='arm', 397 is_next_build=False) 398 399 monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 400 401 self.assertEqual(monochrome_version_code, '575000020') 402 403 def testGenerateVersionCodesAndroidTrichrome(self): 404 """Assert it gives correct values for standard/example inputs""" 405 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 406 arch='arm', 407 is_next_build=False) 408 409 trichrome_version_code = output['TRICHROME_VERSION_CODE'] 410 411 self.assertEqual(trichrome_version_code, '575000030') 412 413 def testGenerateVersionCodesAndroidWebviewStable(self): 414 """Assert it gives correct values for standard/example inputs""" 415 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 416 arch='arm', 417 is_next_build=False) 418 419 webview_stable_version_code = output['WEBVIEW_STABLE_VERSION_CODE'] 420 421 self.assertEqual(webview_stable_version_code, '575000000') 422 423 def testGenerateVersionCodesAndroidWebviewBeta(self): 424 """Assert it gives correct values for standard/example inputs""" 425 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 426 arch='arm', 427 is_next_build=False) 428 429 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 430 431 self.assertEqual(webview_beta_version_code, '575000010') 432 433 def testGenerateVersionCodesAndroidWebviewDev(self): 434 """Assert it gives correct values for standard/example inputs""" 435 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 436 arch='arm', 437 is_next_build=False) 438 439 webview_dev_version_code = output['WEBVIEW_DEV_VERSION_CODE'] 440 441 self.assertEqual(webview_dev_version_code, '575000020') 442 443 def testGenerateVersionCodesAndroidNextBuild(self): 444 """Assert it handles "next" builds correctly""" 445 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 446 arch='arm', 447 is_next_build=True) 448 449 # Get just a sample of values 450 chrome_version_code = output['CHROME_VERSION_CODE'] 451 monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 452 webview_stable_version_code = output['WEBVIEW_STABLE_VERSION_CODE'] 453 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 454 455 self.assertEqual(chrome_version_code, '575050000') 456 self.assertEqual(monochrome_version_code, '575050020') 457 self.assertEqual(webview_stable_version_code, '575050000') 458 self.assertEqual(webview_beta_version_code, '575050010') 459 460 def testGenerateVersionCodesAndroidArchArm(self): 461 """Assert it handles different architectures correctly. 462 463 Version codes for different builds need to be distinct and maintain a 464 certain ordering. 465 See docs in android_chrome_version._ABIS_TO_BIT_MASK for 466 reasoning. 467 """ 468 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 469 arch='arm', 470 is_next_build=False) 471 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 472 473 self.assertEqual(arch_chrome_version_code, '575000000') 474 475 def testGenerateVersionCodesAndroidArchX86(self): 476 """Assert it handles different architectures correctly. 477 478 Version codes for different builds need to be distinct and maintain a 479 certain ordering. 480 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 481 reasoning. 482 """ 483 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 484 arch='x86', 485 is_next_build=False) 486 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 487 488 self.assertEqual(arch_chrome_version_code, '575000006') 489 490 def testGenerateVersionCodesAndroidArchArm64(self): 491 """Assert it handles different architectures correctly. 492 493 Version codes for different builds need to be distinct and maintain a 494 certain ordering. 495 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 496 reasoning. 497 """ 498 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 499 arch='arm64', 500 is_next_build=False) 501 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 502 503 self.assertEqual(arch_chrome_version_code, '575000004') 504 505 def testGenerateVersionCodesAndroidArchArm64Variants(self): 506 """Assert it handles 64-bit-specific additional version codes correctly. 507 508 Some additional version codes are generated for 64-bit architectures. 509 See docstring on android_chrome_version.ARCH64_APK_VARIANTS for more info. 510 """ 511 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 512 arch='arm64', 513 is_next_build=False) 514 arch_monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 515 arch_monochrome_32_version_code = output['MONOCHROME_32_VERSION_CODE'] 516 arch_monochrome_32_64_version_code = output['MONOCHROME_32_64_VERSION_CODE'] 517 arch_monochrome_64_32_version_code = output['MONOCHROME_64_32_VERSION_CODE'] 518 arch_monochrome_64_version_code = output['MONOCHROME_64_VERSION_CODE'] 519 arch_trichrome_version_code = output['TRICHROME_VERSION_CODE'] 520 arch_trichrome_32_version_code = output['TRICHROME_32_VERSION_CODE'] 521 arch_trichrome_32_64_version_code = output['TRICHROME_32_64_VERSION_CODE'] 522 arch_trichrome_64_32_version_code = output['TRICHROME_64_32_VERSION_CODE'] 523 arch_trichrome_64_32_high_version_code = output[ 524 'TRICHROME_64_32_HIGH_VERSION_CODE'] 525 arch_trichrome_auto_version_code = output['TRICHROME_AUTO_VERSION_CODE'] 526 arch_trichrome_auto_32_version_code = output['TRICHROME_AUTO_32_VERSION_CODE'] 527 arch_trichrome_auto_32_64_version_code = output['TRICHROME_AUTO_32_64_VERSION_CODE'] 528 arch_trichrome_auto_64_version_code = output[ 529 'TRICHROME_AUTO_64_VERSION_CODE'] 530 arch_trichrome_64_version_code = output['TRICHROME_64_VERSION_CODE'] 531 arch_trichrome_auto_64_32_version_code = output[ 532 'TRICHROME_AUTO_64_32_VERSION_CODE'] 533 arch_trichrome_auto_64_32_high_version_code = output[ 534 'TRICHROME_AUTO_64_32_HIGH_VERSION_CODE'] 535 536 self.assertEqual(arch_monochrome_32_version_code, '575000020') 537 self.assertEqual(arch_monochrome_32_64_version_code, '575000021') 538 self.assertEqual(arch_monochrome_version_code, '575000021') 539 self.assertEqual(arch_monochrome_64_32_version_code, '575000022') 540 self.assertEqual(arch_monochrome_64_version_code, '575000024') 541 self.assertEqual(arch_trichrome_32_version_code, '575000030') 542 self.assertEqual(arch_trichrome_32_64_version_code, '575000031') 543 self.assertEqual(arch_trichrome_version_code, '575000031') 544 self.assertEqual(arch_trichrome_64_32_version_code, '575000032') 545 self.assertEqual(arch_trichrome_64_32_high_version_code, '575000033') 546 self.assertEqual(arch_trichrome_64_version_code, '575000034') 547 self.assertEqual(arch_trichrome_auto_64_32_version_code, '575000052') 548 self.assertEqual(arch_trichrome_auto_64_32_high_version_code, '575000053') 549 self.assertEqual(arch_trichrome_auto_64_version_code, '575000054') 550 self.assertEqual(arch_trichrome_auto_version_code, '575000051') 551 self.assertEqual(arch_trichrome_auto_32_version_code, '575000050') 552 self.assertEqual(arch_trichrome_auto_32_64_version_code, '575000051') 553 554 def testGenerateVersionCodesAndroidArchX64(self): 555 """Assert it handles different architectures correctly. 556 557 Version codes for different builds need to be distinct and maintain a 558 certain ordering. 559 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 560 reasoning. 561 """ 562 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 563 arch='x64', 564 is_next_build=False) 565 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 566 567 self.assertEqual(arch_chrome_version_code, '575000009') 568 569 def testGenerateVersionCodesAndroidArchX64Variants(self): 570 """Assert it handles 64-bit-specific additional version codes correctly. 571 572 Some additional version codes are generated for 64-bit architectures. 573 See docstring on android_chrome_version.ARCH64_APK_VARIANTS for more info. 574 """ 575 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 576 arch='x64', 577 is_next_build=False) 578 arch_monochrome_32_version_code = output['MONOCHROME_32_VERSION_CODE'] 579 arch_monochrome_32_64_version_code = output['MONOCHROME_32_64_VERSION_CODE'] 580 arch_monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 581 arch_monochrome_64_32_version_code = output['MONOCHROME_64_32_VERSION_CODE'] 582 arch_monochrome_64_version_code = output['MONOCHROME_64_VERSION_CODE'] 583 arch_trichrome_32_version_code = output['TRICHROME_32_VERSION_CODE'] 584 arch_trichrome_32_64_version_code = output['TRICHROME_32_64_VERSION_CODE'] 585 arch_trichrome_version_code = output['TRICHROME_VERSION_CODE'] 586 arch_trichrome_64_32_version_code = output['TRICHROME_64_32_VERSION_CODE'] 587 arch_trichrome_64_version_code = output['TRICHROME_64_VERSION_CODE'] 588 arch_trichrome_auto_64_32_version_code = output[ 589 'TRICHROME_AUTO_64_32_VERSION_CODE'] 590 arch_trichrome_auto_version_code = output['TRICHROME_AUTO_VERSION_CODE'] 591 arch_trichrome_auto_32_version_code = output['TRICHROME_AUTO_32_VERSION_CODE'] 592 arch_trichrome_auto_32_64_version_code = output['TRICHROME_AUTO_32_64_VERSION_CODE'] 593 arch_trichrome_64_version_code = output['TRICHROME_64_VERSION_CODE'] 594 arch_trichrome_auto_64_32_version_code = output[ 595 'TRICHROME_AUTO_64_32_VERSION_CODE'] 596 arch_trichrome_auto_64_version_code = output[ 597 'TRICHROME_AUTO_64_VERSION_CODE'] 598 599 self.assertEqual(arch_monochrome_32_version_code, '575000026') 600 self.assertEqual(arch_monochrome_32_64_version_code, '575000027') 601 self.assertEqual(arch_monochrome_version_code, '575000027') 602 self.assertEqual(arch_monochrome_64_32_version_code, '575000028') 603 self.assertEqual(arch_monochrome_64_version_code, '575000029') 604 self.assertEqual(arch_trichrome_32_version_code, '575000036') 605 self.assertEqual(arch_trichrome_32_64_version_code, '575000037') 606 self.assertEqual(arch_trichrome_version_code, '575000037') 607 self.assertEqual(arch_trichrome_64_32_version_code, '575000038') 608 self.assertEqual(arch_trichrome_64_version_code, '575000039') 609 self.assertEqual(arch_trichrome_auto_version_code, '575000057') 610 self.assertEqual(arch_trichrome_auto_32_version_code, '575000056') 611 self.assertEqual(arch_trichrome_auto_32_64_version_code, '575000057') 612 self.assertEqual(arch_trichrome_auto_64_version_code, '575000059') 613 self.assertEqual(arch_trichrome_auto_64_32_version_code, '575000058') 614 615 def testGenerateVersionCodesAndroidArchRiscv64(self): 616 """Assert it handles different architectures correctly. 617 618 Version codes for different builds need to be distinct and maintain a 619 certain ordering. 620 See docs in android_chrome_version._ABIS_TO_BIT_MASK for 621 reasoning. 622 """ 623 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 624 arch='riscv64', 625 is_next_build=False) 626 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 627 628 self.assertEqual(arch_chrome_version_code, '575000004') 629 630 def testGenerateVersionCodesAndroidArchRiscv64Variants(self): 631 """Assert it handles 64-bit-specific additional version codes correctly. 632 633 Some additional version codes are generated for 64-bit architectures. 634 See docstring on android_chrome_version.ARCH64_APK_VARIANTS for more info. 635 """ 636 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 637 arch='riscv64', 638 is_next_build=False) 639 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 640 arch_chrome_modern_version_code = output['CHROME_MODERN_VERSION_CODE'] 641 arch_monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 642 arch_trichrome_version_code = output['TRICHROME_VERSION_CODE'] 643 arch_trichrome_beta_version_code = output['TRICHROME_BETA_VERSION_CODE'] 644 arch_webview_stable_version_code = output['WEBVIEW_STABLE_VERSION_CODE'] 645 arch_webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 646 arch_webview_dev_version_code = output['WEBVIEW_DEV_VERSION_CODE'] 647 648 self.assertEqual(arch_chrome_version_code, '575000004') 649 self.assertEqual(arch_chrome_modern_version_code, '575000014') 650 self.assertEqual(arch_monochrome_version_code, '575000024') 651 self.assertFalse('MONOCHROME_32_VERSION_CODE' in output) 652 self.assertFalse('MONOCHROME_32_64_VERSION_CODE' in output) 653 self.assertFalse('MONOCHROME_64_32_VERSION_CODE' in output) 654 self.assertFalse('MONOCHROME_64_VERSION_CODE' in output) 655 self.assertEqual(arch_trichrome_version_code, '575000034') 656 self.assertFalse('TRICHROME_32_VERSION_CODE' in output) 657 self.assertFalse('TRICHROME_32_64_VERSION_CODE' in output) 658 self.assertFalse('TRICHROME_64_32_VERSION_CODE' in output) 659 self.assertFalse('TRICHROME_64_32_HIGH_VERSION_CODE' in output) 660 self.assertFalse('TRICHROME_AUTO_64_32_VERSION_CODE' in output) 661 self.assertFalse('TRICHROME_64_VERSION_CODE' in output) 662 self.assertEqual(arch_trichrome_beta_version_code, '575000044') 663 self.assertFalse('TRICHROME_32_BETA_VERSION_CODE' in output) 664 self.assertFalse('TRICHROME_32_64_BETA_VERSION_CODE' in output) 665 self.assertFalse('TRICHROME_64_32_BETA_VERSION_CODE' in output) 666 self.assertFalse('TRICHROME_64_32_HIGH_BETA_VERSION_CODE' in output) 667 self.assertFalse('TRICHROME_64_BETA_VERSION_CODE' in output) 668 self.assertEqual(arch_webview_stable_version_code, '575000004') 669 self.assertEqual(arch_webview_beta_version_code, '575000014') 670 self.assertEqual(arch_webview_dev_version_code, '575000024') 671 self.assertFalse('WEBVIEW_64_STABLE_VERSION_CODE' in output) 672 self.assertFalse('WEBVIEW_64_BETA_VERSION_CODE' in output) 673 self.assertFalse('WEBVIEW_64_DEV_VERSION_CODE' in output) 674 self.assertFalse('WEBVIEW_32_STABLE_VERSION_CODE' in output) 675 self.assertFalse('WEBVIEW_32_BETA_VERSION_CODE' in output) 676 self.assertFalse('WEBVIEW_32_DEV_VERSION_CODE' in output) 677 678 def testGenerateVersionCodesAndroidArchOrderArm(self): 679 """Assert it handles different architectures correctly. 680 681 Version codes for different builds need to be distinct and maintain a 682 certain ordering. 683 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 684 reasoning. 685 686 Test arm-related values. 687 """ 688 arm_output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 689 arch='arm', 690 is_next_build=False) 691 arm64_output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 692 arch='arm64', 693 is_next_build=False) 694 695 arm_chrome_version_code = arm_output['CHROME_VERSION_CODE'] 696 arm64_chrome_version_code = arm64_output['CHROME_VERSION_CODE'] 697 698 self.assertLess(arm_chrome_version_code, arm64_chrome_version_code) 699 700 def testGenerateVersionCodesAndroidArchOrderX86(self): 701 """Assert it handles different architectures correctly. 702 703 Version codes for different builds need to be distinct and maintain a 704 certain ordering. 705 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 706 reasoning. 707 708 Test x86-related values. 709 """ 710 x86_output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 711 arch='x86', 712 is_next_build=False) 713 x64_output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 714 arch='x64', 715 is_next_build=False) 716 717 x86_chrome_version_code = x86_output['CHROME_VERSION_CODE'] 718 x64_chrome_version_code = x64_output['CHROME_VERSION_CODE'] 719 720 self.assertLess(x86_chrome_version_code, x64_chrome_version_code) 721 722 def testGenerateVersionCodesAndroidWebviewChannelOrderBeta(self): 723 """Assert webview beta channel is higher than stable. 724 725 The channel-specific version codes for standalone webview needs to follow 726 the order stable < beta < dev. 727 728 This allows that if a user opts into beta track, they will always have the 729 beta apk, including any finch experiments targeted at beta users, even when 730 beta and stable channels are otherwise on the same version. 731 """ 732 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 733 arch='arm', 734 is_next_build=False) 735 736 webview_stable_version_code = output['WEBVIEW_STABLE_VERSION_CODE'] 737 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 738 739 self.assertGreater(webview_beta_version_code, webview_stable_version_code) 740 741 def testGenerateVersionCodesAndroidWebviewChannelOrderDev(self): 742 """Assert webview dev channel is higher than beta. 743 744 The channel-specific version codes for standalone webview needs to follow 745 the order stable < beta < dev. 746 747 This allows that if a user opts into dev track, they will always have the 748 dev apk, including any finch experiments targeted at dev users, even when 749 dev and beta channels are otherwise on the same version. 750 """ 751 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 752 arch='arm', 753 is_next_build=False) 754 755 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 756 webview_dev_version_code = output['WEBVIEW_DEV_VERSION_CODE'] 757 758 self.assertGreater(webview_dev_version_code, webview_beta_version_code) 759 760 def testGenerateVersionCodesTrichromeChannelOrderBeta(self): 761 """Assert Trichrome beta channel is higher than stable. 762 763 When Trichrome channels are compiled to use the stable channel's package 764 name, their version codes need to follow the order stable < beta. 765 766 This allows that if a user opts into beta track, they will always have the 767 beta apk, including any finch experiments targeted at beta users, even when 768 beta and stable channels are otherwise on the same version. 769 """ 770 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 771 arch='arm', 772 is_next_build=False) 773 774 trichrome_stable_version_code = output['TRICHROME_VERSION_CODE'] 775 trichrome_beta_version_code = output['TRICHROME_BETA_VERSION_CODE'] 776 777 self.assertGreater(trichrome_beta_version_code, 778 trichrome_stable_version_code) 779 780 781class _VersionCodeTest(unittest.TestCase): 782 def testGenerateThenTranslate(self): 783 """Assert it gives correct values for a version code that we generated.""" 784 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 785 arch='arm', 786 is_next_build=False) 787 788 version_code = output['MONOCHROME_VERSION_CODE'] 789 790 build, patch, package, abi, is_next_build = TranslateVersionCode( 791 version_code) 792 self.assertEqual(build, int(EXAMPLE_VERSION_VALUES['BUILD'])) 793 self.assertEqual(patch, int(EXAMPLE_VERSION_VALUES['PATCH'])) 794 self.assertEqual(package, 'MONOCHROME') 795 self.assertEqual(abi, 'arm') 796 self.assertEqual(is_next_build, False) 797 798 def testPre3992Translate(self): 799 """Test for an old build when the abi and apk bits were swapped.""" 800 build, patch, package, abi, is_next_build = TranslateVersionCode( 801 '378100010') 802 self.assertEqual(build, 3781) 803 self.assertEqual(patch, 0) 804 self.assertEqual(package, 'CHROME') 805 self.assertEqual(abi, 'x86') 806 self.assertEqual(is_next_build, False) 807 808 def testNextBuildTranslate(self): 809 """Test for a build with next.""" 810 build, patch, package, abi, is_next_build = TranslateVersionCode( 811 '499961210') 812 self.assertEqual(build, 4999) 813 self.assertEqual(patch, 112) 814 self.assertEqual(package, 'CHROME_MODERN') 815 self.assertEqual(abi, 'arm') 816 self.assertEqual(is_next_build, True) 817 818 def testPre4844NextBuildTranslate(self): 819 """Test for a build with next when we added 50 to version code.""" 820 build, patch, package, abi, is_next_build = TranslateVersionCode( 821 '400011260') 822 self.assertEqual(build, 4000) 823 self.assertEqual(patch, 112) 824 self.assertEqual(package, 'CHROME_MODERN') 825 self.assertEqual(abi, 'arm') 826 self.assertEqual(is_next_build, True) 827 828 def testPre3992NextBuildTranslate(self): 829 """Test for a build with next when we added 5 to version code.""" 830 build, patch, package, abi, is_next_build = TranslateVersionCode( 831 '300011206') 832 self.assertEqual(build, 3000) 833 self.assertEqual(patch, 112) 834 self.assertEqual(package, 'CHROME_MODERN') 835 self.assertEqual(abi, 'arm') 836 self.assertEqual(is_next_build, True) 837 838 def testArm_64BuildTranslate(self): 839 """Test for a build with arm_64.""" 840 build, patch, package, abi, is_next_build = TranslateVersionCode( 841 '499911215') 842 self.assertEqual(build, 4999) 843 self.assertEqual(patch, 112) 844 self.assertEqual(package, 'CHROME_MODERN') 845 self.assertEqual(abi, 'arm_64') 846 self.assertEqual(is_next_build, False) 847 848 def testArm_32_64Translate(self): 849 """Test for a build with arm_32_64.""" 850 build, patch, package, abi, is_next_build = TranslateVersionCode( 851 '499900013') 852 self.assertEqual(build, 4999) 853 self.assertEqual(patch, 0) 854 self.assertEqual(package, 'CHROME_MODERN') 855 self.assertEqual(abi, 'arm_32_64') 856 self.assertEqual(is_next_build, False) 857 858 def testArm_Auto_32_64Translate(self): 859 """Test for an auto build with Trichrome and arm_32_64.""" 860 build, patch, package, abi, is_next_build = TranslateVersionCode( 861 '499900053') 862 self.assertEqual(build, 4999) 863 self.assertEqual(patch, 0) 864 self.assertEqual(package, 'TRICHROME_AUTO') 865 self.assertEqual(abi, 'arm_32_64') 866 self.assertEqual(is_next_build, False) 867 868 def testArm_64_32Translate(self): 869 """Test for a build with Trichrome and arm_64_32.""" 870 build, patch, package, abi, is_next_build = TranslateVersionCode( 871 '499900034') 872 self.assertEqual(build, 4999) 873 self.assertEqual(patch, 0) 874 self.assertEqual(package, 'TRICHROME') 875 self.assertEqual(abi, 'arm_64_32') 876 self.assertEqual(is_next_build, False) 877 878 def testArm_Auto_64_32Translate(self): 879 """Test for an auto build with Trichrome and arm_64_32.""" 880 build, patch, package, abi, is_next_build = TranslateVersionCode( 881 '499900054') 882 self.assertEqual(build, 4999) 883 self.assertEqual(patch, 0) 884 self.assertEqual(package, 'TRICHROME_AUTO') 885 self.assertEqual(abi, 'arm_64_32') 886 self.assertEqual(is_next_build, False) 887 888 889 def testArm_Auto_64_32HighTranslate(self): 890 """Test for an auto build with Trichrome and arm_64_32_high.""" 891 build, patch, package, abi, is_next_build = TranslateVersionCode( 892 '584500053') 893 self.assertEqual(build, 5845) 894 self.assertEqual(patch, 0) 895 self.assertEqual(package, 'TRICHROME_AUTO') 896 self.assertEqual(abi, 'arm_64_32_high') 897 self.assertEqual(is_next_build, False) 898 899 def testArm_64_32HighTranslate(self): 900 """Test for a build with Trichrome and arm_64_32_high.""" 901 build, patch, package, abi, is_next_build = TranslateVersionCode( 902 '534613739') 903 self.assertEqual(build, 5346) 904 self.assertEqual(patch, 137) 905 self.assertEqual(package, 'TRICHROME') 906 self.assertEqual(abi, 'arm_64_32_high') 907 self.assertEqual(is_next_build, False) 908 909 def testArm_64_32HighTranslateM113(self): 910 """Test for a build with Trichrome and arm_64_32_high.""" 911 build, patch, package, abi, is_next_build = TranslateVersionCode( 912 '567217639') 913 self.assertEqual(abi, 'x86_64') 914 915 build, patch, package, abi, is_next_build = TranslateVersionCode( 916 '567217539') 917 self.assertEqual(abi, 'arm_64_32_high') 918 919 def testArm_64_32HighTranslateM114(self): 920 """Test for a build with Trichrome and arm_64_32_high.""" 921 build, patch, package, abi, is_next_build = TranslateVersionCode( 922 '573505339') 923 self.assertEqual(abi, 'x86_64') 924 925 build, patch, package, abi, is_next_build = TranslateVersionCode( 926 '573505239') 927 self.assertEqual(abi, 'arm_64_32_high') 928 929 def testX86_64Translate(self): 930 """Test for a build with x86_64.""" 931 build, patch, package, abi, is_next_build = TranslateVersionCode( 932 '499900018') 933 self.assertEqual(build, 4999) 934 self.assertEqual(patch, 0) 935 self.assertEqual(package, 'CHROME_MODERN') 936 self.assertEqual(abi, 'x86_64') 937 self.assertEqual(is_next_build, False) 938 939 def testX86_32_64Translate(self): 940 """Test for a build with x86_32_64.""" 941 build, patch, package, abi, is_next_build = TranslateVersionCode( 942 '499900016') 943 self.assertEqual(build, 4999) 944 self.assertEqual(patch, 0) 945 self.assertEqual(package, 'CHROME_MODERN') 946 self.assertEqual(abi, 'x86_32_64') 947 self.assertEqual(is_next_build, False) 948 949 def testX86_Auto_32_64Translate(self): 950 """Test for an auto build with x86_32_64.""" 951 build, patch, package, abi, is_next_build = TranslateVersionCode( 952 '499900056') 953 self.assertEqual(build, 4999) 954 self.assertEqual(patch, 0) 955 self.assertEqual(package, 'TRICHROME_AUTO') 956 self.assertEqual(abi, 'x86_32_64') 957 self.assertEqual(is_next_build, False) 958 959 def testX86_64_32Translate(self): 960 """Test for a build with x86_64_32.""" 961 build, patch, package, abi, is_next_build = TranslateVersionCode( 962 '499900017') 963 self.assertEqual(build, 4999) 964 self.assertEqual(patch, 0) 965 self.assertEqual(package, 'CHROME_MODERN') 966 self.assertEqual(abi, 'x86_64_32') 967 self.assertEqual(is_next_build, False) 968 969 def testX86_Auto_64_32Translate(self): 970 """Test for an auto build with x86_64_32.""" 971 build, patch, package, abi, is_next_build = TranslateVersionCode( 972 '499900057') 973 self.assertEqual(build, 4999) 974 self.assertEqual(patch, 0) 975 self.assertEqual(package, 'TRICHROME_AUTO') 976 self.assertEqual(abi, 'x86_64_32') 977 self.assertEqual(is_next_build, False) 978 979 def testX86_Auto_64Translate(self): 980 """Test for an auto build with x86_64.""" 981 build, patch, package, abi, is_next_build = TranslateVersionCode( 982 '499900058') 983 self.assertEqual(build, 4999) 984 self.assertEqual(patch, 0) 985 self.assertEqual(package, 'TRICHROME_AUTO') 986 self.assertEqual(abi, 'x86_64') 987 self.assertEqual(is_next_build, False) 988 989 def testWebviewTranslate(self): 990 """Test for a build with Webview.""" 991 build, patch, package, abi, is_next_build = TranslateVersionCode( 992 '499900000', is_webview=True) 993 self.assertEqual(build, 4999) 994 self.assertEqual(patch, 0) 995 self.assertEqual(package, 'WEBVIEW_STABLE') 996 self.assertEqual(abi, 'arm') 997 self.assertEqual(is_next_build, False) 998 999 1000class _VersionCodeGroupedTest(unittest.TestCase): 1001 def testGenerateThenTranslate(self): 1002 """Assert it gives correct values for a version code that we generated.""" 1003 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 1004 arch='arm', 1005 is_next_build=False) 1006 1007 version_code = output['MONOCHROME_VERSION_CODE'] 1008 1009 build, patch, package, abi, is_next_build = TranslateVersionCode( 1010 version_code) 1011 self.assertEqual(build, int(EXAMPLE_GROUPED_VERSION_VALUES['BUILD'])) 1012 self.assertEqual(patch, int(EXAMPLE_GROUPED_VERSION_VALUES['PATCH'])) 1013 self.assertEqual(package, 'MONOCHROME') 1014 self.assertEqual(abi, 'arm') 1015 self.assertEqual(is_next_build, False) 1016 1017 def testNextBuildTranslate(self): 1018 """Test for a build with next.""" 1019 build, patch, package, abi, is_next_build = TranslateVersionCode( 1020 '575061210') 1021 self.assertEqual(build, 5750) 1022 self.assertEqual(patch, 112) 1023 self.assertEqual(package, 'CHROME_MODERN') 1024 self.assertEqual(abi, 'arm') 1025 self.assertEqual(is_next_build, True) 1026 1027 def testArm_64BuildTranslate(self): 1028 """Test for a build with arm_64.""" 1029 build, patch, package, abi, is_next_build = TranslateVersionCode( 1030 '575011214') 1031 self.assertEqual(build, 5750) 1032 self.assertEqual(patch, 112) 1033 self.assertEqual(package, 'CHROME_MODERN') 1034 self.assertEqual(abi, 'arm_64') 1035 self.assertEqual(is_next_build, False) 1036 1037 def testArm_32_64Translate(self): 1038 """Test for a build with arm_32_64.""" 1039 build, patch, package, abi, is_next_build = TranslateVersionCode( 1040 '575000011') 1041 self.assertEqual(build, 5750) 1042 self.assertEqual(patch, 0) 1043 self.assertEqual(package, 'CHROME_MODERN') 1044 self.assertEqual(abi, 'arm_32_64') 1045 self.assertEqual(is_next_build, False) 1046 1047 def testArm_64_32Translate(self): 1048 """Test for a build with Trichrome and arm_64_32.""" 1049 build, patch, package, abi, is_next_build = TranslateVersionCode( 1050 '575000032') 1051 self.assertEqual(build, 5750) 1052 self.assertEqual(patch, 0) 1053 self.assertEqual(package, 'TRICHROME') 1054 self.assertEqual(abi, 'arm_64_32') 1055 self.assertEqual(is_next_build, False) 1056 1057 def testArm_Auto_64_32Translate(self): 1058 """Test for an auto build with Trichrome and arm_64_32.""" 1059 build, patch, package, abi, is_next_build = TranslateVersionCode( 1060 '575000052') 1061 self.assertEqual(build, 5750) 1062 self.assertEqual(patch, 0) 1063 self.assertEqual(package, 'TRICHROME_AUTO') 1064 self.assertEqual(abi, 'arm_64_32') 1065 self.assertEqual(is_next_build, False) 1066 1067 def testArm_64_32HighTranslate(self): 1068 """Test for a build with Trichrome and arm_64_32_high.""" 1069 build, patch, package, abi, is_next_build = TranslateVersionCode( 1070 '534613739') 1071 self.assertEqual(build, 5346) 1072 self.assertEqual(patch, 137) 1073 self.assertEqual(package, 'TRICHROME') 1074 self.assertEqual(abi, 'arm_64_32_high') 1075 self.assertEqual(is_next_build, False) 1076 1077 def testX86_64Translate(self): 1078 """Test for a build with x86_64.""" 1079 build, patch, package, abi, is_next_build = TranslateVersionCode( 1080 '575000019') 1081 self.assertEqual(build, 5750) 1082 self.assertEqual(patch, 0) 1083 self.assertEqual(package, 'CHROME_MODERN') 1084 self.assertEqual(abi, 'x86_64') 1085 self.assertEqual(is_next_build, False) 1086 1087 def testX86_32_64Translate(self): 1088 """Test for a build with x86_32_64.""" 1089 build, patch, package, abi, is_next_build = TranslateVersionCode( 1090 '575000017') 1091 self.assertEqual(build, 5750) 1092 self.assertEqual(patch, 0) 1093 self.assertEqual(package, 'CHROME_MODERN') 1094 self.assertEqual(abi, 'x86_32_64') 1095 self.assertEqual(is_next_build, False) 1096 1097 def testX86_64_32Translate(self): 1098 """Test for a build with x86_64_32.""" 1099 build, patch, package, abi, is_next_build = TranslateVersionCode( 1100 '575000018') 1101 self.assertEqual(build, 5750) 1102 self.assertEqual(patch, 0) 1103 self.assertEqual(package, 'CHROME_MODERN') 1104 self.assertEqual(abi, 'x86_64_32') 1105 self.assertEqual(is_next_build, False) 1106 1107 def testX86_Auto_64_32Translate(self): 1108 """Test for an auto build with x86_64_32.""" 1109 build, patch, package, abi, is_next_build = TranslateVersionCode( 1110 '575000058') 1111 self.assertEqual(build, 5750) 1112 self.assertEqual(patch, 0) 1113 self.assertEqual(package, 'TRICHROME_AUTO') 1114 self.assertEqual(abi, 'x86_64_32') 1115 self.assertEqual(is_next_build, False) 1116 1117 def testWebviewTranslate(self): 1118 """Test for a build with Webview.""" 1119 build, patch, package, abi, is_next_build = TranslateVersionCode( 1120 '575000000', is_webview=True) 1121 self.assertEqual(build, 5750) 1122 self.assertEqual(patch, 0) 1123 self.assertEqual(package, 'WEBVIEW_STABLE') 1124 self.assertEqual(abi, 'arm') 1125 self.assertEqual(is_next_build, False) 1126 1127 1128if __name__ == '__main__': 1129 unittest.main() 1130