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