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_version_code = output['TRICHROME_64_VERSION_CODE'] 504 arch_trichrome_auto_64_32_version_code = output[ 505 'TRICHROME_AUTO_64_32_VERSION_CODE'] 506 507 self.assertEqual(arch_monochrome_32_version_code, '575000020') 508 self.assertEqual(arch_monochrome_32_64_version_code, '575000021') 509 self.assertEqual(arch_monochrome_version_code, '575000021') 510 self.assertEqual(arch_monochrome_64_32_version_code, '575000022') 511 self.assertEqual(arch_monochrome_64_version_code, '575000024') 512 self.assertEqual(arch_trichrome_32_version_code, '575000030') 513 self.assertEqual(arch_trichrome_32_64_version_code, '575000031') 514 self.assertEqual(arch_trichrome_version_code, '575000031') 515 self.assertEqual(arch_trichrome_64_32_version_code, '575000032') 516 self.assertEqual(arch_trichrome_64_version_code, '575000034') 517 self.assertEqual(arch_trichrome_auto_64_32_version_code, '575000052') 518 519 def testGenerateVersionCodesAndroidArchX64(self): 520 """Assert it handles different architectures correctly. 521 522 Version codes for different builds need to be distinct and maintain a 523 certain ordering. 524 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 525 reasoning. 526 """ 527 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 528 arch='x64', 529 is_next_build=False) 530 arch_chrome_version_code = output['CHROME_VERSION_CODE'] 531 532 self.assertEqual(arch_chrome_version_code, '575000009') 533 534 def testGenerateVersionCodesAndroidArchX64Variants(self): 535 """Assert it handles 64-bit-specific additional version codes correctly. 536 537 Some additional version codes are generated for 64-bit architectures. 538 See docstring on android_chrome_version.ARCH64_APK_VARIANTS for more info. 539 """ 540 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 541 arch='x64', 542 is_next_build=False) 543 arch_monochrome_32_version_code = output['MONOCHROME_32_VERSION_CODE'] 544 arch_monochrome_32_64_version_code = output['MONOCHROME_32_64_VERSION_CODE'] 545 arch_monochrome_version_code = output['MONOCHROME_VERSION_CODE'] 546 arch_monochrome_64_32_version_code = output['MONOCHROME_64_32_VERSION_CODE'] 547 arch_monochrome_64_version_code = output['MONOCHROME_64_VERSION_CODE'] 548 arch_trichrome_32_version_code = output['TRICHROME_32_VERSION_CODE'] 549 arch_trichrome_32_64_version_code = output['TRICHROME_32_64_VERSION_CODE'] 550 arch_trichrome_version_code = output['TRICHROME_VERSION_CODE'] 551 arch_trichrome_64_32_version_code = output['TRICHROME_64_32_VERSION_CODE'] 552 arch_trichrome_64_version_code = output['TRICHROME_64_VERSION_CODE'] 553 arch_trichrome_auto_64_32_version_code = output[ 554 'TRICHROME_AUTO_64_32_VERSION_CODE'] 555 556 self.assertEqual(arch_monochrome_32_version_code, '575000026') 557 self.assertEqual(arch_monochrome_32_64_version_code, '575000027') 558 self.assertEqual(arch_monochrome_version_code, '575000027') 559 self.assertEqual(arch_monochrome_64_32_version_code, '575000028') 560 self.assertEqual(arch_monochrome_64_version_code, '575000029') 561 self.assertEqual(arch_trichrome_32_version_code, '575000036') 562 self.assertEqual(arch_trichrome_32_64_version_code, '575000037') 563 self.assertEqual(arch_trichrome_version_code, '575000037') 564 self.assertEqual(arch_trichrome_64_32_version_code, '575000038') 565 self.assertEqual(arch_trichrome_64_version_code, '575000039') 566 self.assertEqual(arch_trichrome_auto_64_32_version_code, '575000058') 567 568 def testGenerateVersionCodesAndroidArchOrderArm(self): 569 """Assert it handles different architectures correctly. 570 571 Version codes for different builds need to be distinct and maintain a 572 certain ordering. 573 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 574 reasoning. 575 576 Test arm-related values. 577 """ 578 arm_output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 579 arch='arm', 580 is_next_build=False) 581 arm64_output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 582 arch='arm64', 583 is_next_build=False) 584 585 arm_chrome_version_code = arm_output['CHROME_VERSION_CODE'] 586 arm64_chrome_version_code = arm64_output['CHROME_VERSION_CODE'] 587 588 self.assertLess(arm_chrome_version_code, arm64_chrome_version_code) 589 590 def testGenerateVersionCodesAndroidArchOrderX86(self): 591 """Assert it handles different architectures correctly. 592 593 Version codes for different builds need to be distinct and maintain a 594 certain ordering. 595 See docstring on android_chrome_version._ABIS_TO_BIT_MASK for 596 reasoning. 597 598 Test x86-related values. 599 """ 600 x86_output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 601 arch='x86', 602 is_next_build=False) 603 x64_output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 604 arch='x64', 605 is_next_build=False) 606 607 x86_chrome_version_code = x86_output['CHROME_VERSION_CODE'] 608 x64_chrome_version_code = x64_output['CHROME_VERSION_CODE'] 609 610 self.assertLess(x86_chrome_version_code, x64_chrome_version_code) 611 612 def testGenerateVersionCodesAndroidWebviewChannelOrderBeta(self): 613 """Assert webview beta channel is higher than stable. 614 615 The channel-specific version codes for standalone webview needs to follow 616 the order stable < beta < dev. 617 618 This allows that if a user opts into beta track, they will always have the 619 beta apk, including any finch experiments targeted at beta users, even when 620 beta and stable channels are otherwise on the same version. 621 """ 622 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 623 arch='arm', 624 is_next_build=False) 625 626 webview_stable_version_code = output['WEBVIEW_STABLE_VERSION_CODE'] 627 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 628 629 self.assertGreater(webview_beta_version_code, webview_stable_version_code) 630 631 def testGenerateVersionCodesAndroidWebviewChannelOrderDev(self): 632 """Assert webview dev channel is higher than beta. 633 634 The channel-specific version codes for standalone webview needs to follow 635 the order stable < beta < dev. 636 637 This allows that if a user opts into dev track, they will always have the 638 dev apk, including any finch experiments targeted at dev users, even when 639 dev and beta channels are otherwise on the same version. 640 """ 641 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 642 arch='arm', 643 is_next_build=False) 644 645 webview_beta_version_code = output['WEBVIEW_BETA_VERSION_CODE'] 646 webview_dev_version_code = output['WEBVIEW_DEV_VERSION_CODE'] 647 648 self.assertGreater(webview_dev_version_code, webview_beta_version_code) 649 650 def testGenerateVersionCodesTrichromeChannelOrderBeta(self): 651 """Assert Trichrome beta channel is higher than stable. 652 653 When Trichrome channels are compiled to use the stable channel's package 654 name, their version codes need to follow the order stable < beta. 655 656 This allows that if a user opts into beta track, they will always have the 657 beta apk, including any finch experiments targeted at beta users, even when 658 beta and stable channels are otherwise on the same version. 659 """ 660 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 661 arch='arm', 662 is_next_build=False) 663 664 trichrome_stable_version_code = output['TRICHROME_VERSION_CODE'] 665 trichrome_beta_version_code = output['TRICHROME_BETA_VERSION_CODE'] 666 667 self.assertGreater(trichrome_beta_version_code, 668 trichrome_stable_version_code) 669 670 671class _VersionCodeTest(unittest.TestCase): 672 def testGenerateThenTranslate(self): 673 """Assert it gives correct values for a version code that we generated.""" 674 output = GenerateVersionCodes(EXAMPLE_VERSION_VALUES, 675 arch='arm', 676 is_next_build=False) 677 678 version_code = output['MONOCHROME_VERSION_CODE'] 679 680 build, patch, package, abi, is_next_build = TranslateVersionCode( 681 version_code) 682 self.assertEqual(build, int(EXAMPLE_VERSION_VALUES['BUILD'])) 683 self.assertEqual(patch, int(EXAMPLE_VERSION_VALUES['PATCH'])) 684 self.assertEqual(package, 'MONOCHROME') 685 self.assertEqual(abi, 'arm') 686 self.assertEqual(is_next_build, False) 687 688 def testPre3992Translate(self): 689 """Test for an old build when the abi and apk bits were swapped.""" 690 build, patch, package, abi, is_next_build = TranslateVersionCode( 691 '378100010') 692 self.assertEqual(build, 3781) 693 self.assertEqual(patch, 0) 694 self.assertEqual(package, 'CHROME') 695 self.assertEqual(abi, 'x86') 696 self.assertEqual(is_next_build, False) 697 698 def testNextBuildTranslate(self): 699 """Test for a build with next.""" 700 build, patch, package, abi, is_next_build = TranslateVersionCode( 701 '499961210') 702 self.assertEqual(build, 4999) 703 self.assertEqual(patch, 112) 704 self.assertEqual(package, 'CHROME_MODERN') 705 self.assertEqual(abi, 'arm') 706 self.assertEqual(is_next_build, True) 707 708 def testPre4844NextBuildTranslate(self): 709 """Test for a build with next when we added 50 to version code.""" 710 build, patch, package, abi, is_next_build = TranslateVersionCode( 711 '400011260') 712 self.assertEqual(build, 4000) 713 self.assertEqual(patch, 112) 714 self.assertEqual(package, 'CHROME_MODERN') 715 self.assertEqual(abi, 'arm') 716 self.assertEqual(is_next_build, True) 717 718 def testPre3992NextBuildTranslate(self): 719 """Test for a build with next when we added 5 to version code.""" 720 build, patch, package, abi, is_next_build = TranslateVersionCode( 721 '300011206') 722 self.assertEqual(build, 3000) 723 self.assertEqual(patch, 112) 724 self.assertEqual(package, 'CHROME_MODERN') 725 self.assertEqual(abi, 'arm') 726 self.assertEqual(is_next_build, True) 727 728 def testArm_64BuildTranslate(self): 729 """Test for a build with arm_64.""" 730 build, patch, package, abi, is_next_build = TranslateVersionCode( 731 '499911215') 732 self.assertEqual(build, 4999) 733 self.assertEqual(patch, 112) 734 self.assertEqual(package, 'CHROME_MODERN') 735 self.assertEqual(abi, 'arm_64') 736 self.assertEqual(is_next_build, False) 737 738 def testArm_32_64Translate(self): 739 """Test for a build with arm_32_64.""" 740 build, patch, package, abi, is_next_build = TranslateVersionCode( 741 '499900013') 742 self.assertEqual(build, 4999) 743 self.assertEqual(patch, 0) 744 self.assertEqual(package, 'CHROME_MODERN') 745 self.assertEqual(abi, 'arm_32_64') 746 self.assertEqual(is_next_build, False) 747 748 def testArm_64_32Translate(self): 749 """Test for a build with Trichrome and arm_64_32.""" 750 build, patch, package, abi, is_next_build = TranslateVersionCode( 751 '499900034') 752 self.assertEqual(build, 4999) 753 self.assertEqual(patch, 0) 754 self.assertEqual(package, 'TRICHROME') 755 self.assertEqual(abi, 'arm_64_32') 756 self.assertEqual(is_next_build, False) 757 758 def testArm_Auto_64_32Translate(self): 759 """Test for an auto build with Trichrome and arm_64_32.""" 760 build, patch, package, abi, is_next_build = TranslateVersionCode( 761 '499900054') 762 self.assertEqual(build, 4999) 763 self.assertEqual(patch, 0) 764 self.assertEqual(package, 'TRICHROME_AUTO') 765 self.assertEqual(abi, 'arm_64_32') 766 self.assertEqual(is_next_build, False) 767 768 def testArm_64_32HighTranslate(self): 769 """Test for a build with Trichrome and arm_64_32_high.""" 770 build, patch, package, abi, is_next_build = TranslateVersionCode( 771 '534613739') 772 self.assertEqual(build, 5346) 773 self.assertEqual(patch, 137) 774 self.assertEqual(package, 'TRICHROME') 775 self.assertEqual(abi, 'arm_64_32_high') 776 self.assertEqual(is_next_build, False) 777 778 def testX86_64Translate(self): 779 """Test for a build with x86_64.""" 780 build, patch, package, abi, is_next_build = TranslateVersionCode( 781 '499900018') 782 self.assertEqual(build, 4999) 783 self.assertEqual(patch, 0) 784 self.assertEqual(package, 'CHROME_MODERN') 785 self.assertEqual(abi, 'x86_64') 786 self.assertEqual(is_next_build, False) 787 788 def testX86_32_64Translate(self): 789 """Test for a build with x86_32_64.""" 790 build, patch, package, abi, is_next_build = TranslateVersionCode( 791 '499900016') 792 self.assertEqual(build, 4999) 793 self.assertEqual(patch, 0) 794 self.assertEqual(package, 'CHROME_MODERN') 795 self.assertEqual(abi, 'x86_32_64') 796 self.assertEqual(is_next_build, False) 797 798 def testX86_64_32Translate(self): 799 """Test for a build with x86_64_32.""" 800 build, patch, package, abi, is_next_build = TranslateVersionCode( 801 '499900017') 802 self.assertEqual(build, 4999) 803 self.assertEqual(patch, 0) 804 self.assertEqual(package, 'CHROME_MODERN') 805 self.assertEqual(abi, 'x86_64_32') 806 self.assertEqual(is_next_build, False) 807 808 def testX86_Auto_64_32Translate(self): 809 """Test for an auto build with x86_64_32.""" 810 build, patch, package, abi, is_next_build = TranslateVersionCode( 811 '499900057') 812 self.assertEqual(build, 4999) 813 self.assertEqual(patch, 0) 814 self.assertEqual(package, 'TRICHROME_AUTO') 815 self.assertEqual(abi, 'x86_64_32') 816 self.assertEqual(is_next_build, False) 817 818 def testWebviewTranslate(self): 819 """Test for a build with Webview.""" 820 build, patch, package, abi, is_next_build = TranslateVersionCode( 821 '499900000', is_webview=True) 822 self.assertEqual(build, 4999) 823 self.assertEqual(patch, 0) 824 self.assertEqual(package, 'WEBVIEW_STABLE') 825 self.assertEqual(abi, 'arm') 826 self.assertEqual(is_next_build, False) 827 828 829class _VersionCodeGroupedTest(unittest.TestCase): 830 def testGenerateThenTranslate(self): 831 """Assert it gives correct values for a version code that we generated.""" 832 output = GenerateVersionCodes(EXAMPLE_GROUPED_VERSION_VALUES, 833 arch='arm', 834 is_next_build=False) 835 836 version_code = output['MONOCHROME_VERSION_CODE'] 837 838 build, patch, package, abi, is_next_build = TranslateVersionCode( 839 version_code) 840 self.assertEqual(build, int(EXAMPLE_GROUPED_VERSION_VALUES['BUILD'])) 841 self.assertEqual(patch, int(EXAMPLE_GROUPED_VERSION_VALUES['PATCH'])) 842 self.assertEqual(package, 'MONOCHROME') 843 self.assertEqual(abi, 'arm') 844 self.assertEqual(is_next_build, False) 845 846 def testNextBuildTranslate(self): 847 """Test for a build with next.""" 848 build, patch, package, abi, is_next_build = TranslateVersionCode( 849 '575061210') 850 self.assertEqual(build, 5750) 851 self.assertEqual(patch, 112) 852 self.assertEqual(package, 'CHROME_MODERN') 853 self.assertEqual(abi, 'arm') 854 self.assertEqual(is_next_build, True) 855 856 def testArm_64BuildTranslate(self): 857 """Test for a build with arm_64.""" 858 build, patch, package, abi, is_next_build = TranslateVersionCode( 859 '575011214') 860 self.assertEqual(build, 5750) 861 self.assertEqual(patch, 112) 862 self.assertEqual(package, 'CHROME_MODERN') 863 self.assertEqual(abi, 'arm_64') 864 self.assertEqual(is_next_build, False) 865 866 def testArm_32_64Translate(self): 867 """Test for a build with arm_32_64.""" 868 build, patch, package, abi, is_next_build = TranslateVersionCode( 869 '575000011') 870 self.assertEqual(build, 5750) 871 self.assertEqual(patch, 0) 872 self.assertEqual(package, 'CHROME_MODERN') 873 self.assertEqual(abi, 'arm_32_64') 874 self.assertEqual(is_next_build, False) 875 876 def testArm_64_32Translate(self): 877 """Test for a build with Trichrome and arm_64_32.""" 878 build, patch, package, abi, is_next_build = TranslateVersionCode( 879 '575000032') 880 self.assertEqual(build, 5750) 881 self.assertEqual(patch, 0) 882 self.assertEqual(package, 'TRICHROME') 883 self.assertEqual(abi, 'arm_64_32') 884 self.assertEqual(is_next_build, False) 885 886 def testArm_Auto_64_32Translate(self): 887 """Test for an auto build with Trichrome and arm_64_32.""" 888 build, patch, package, abi, is_next_build = TranslateVersionCode( 889 '575000052') 890 self.assertEqual(build, 5750) 891 self.assertEqual(patch, 0) 892 self.assertEqual(package, 'TRICHROME_AUTO') 893 self.assertEqual(abi, 'arm_64_32') 894 self.assertEqual(is_next_build, False) 895 896 def testArm_64_32HighTranslate(self): 897 """Test for a build with Trichrome and arm_64_32_high.""" 898 build, patch, package, abi, is_next_build = TranslateVersionCode( 899 '534613739') 900 self.assertEqual(build, 5346) 901 self.assertEqual(patch, 137) 902 self.assertEqual(package, 'TRICHROME') 903 self.assertEqual(abi, 'arm_64_32_high') 904 self.assertEqual(is_next_build, False) 905 906 def testX86_64Translate(self): 907 """Test for a build with x86_64.""" 908 build, patch, package, abi, is_next_build = TranslateVersionCode( 909 '575000019') 910 self.assertEqual(build, 5750) 911 self.assertEqual(patch, 0) 912 self.assertEqual(package, 'CHROME_MODERN') 913 self.assertEqual(abi, 'x86_64') 914 self.assertEqual(is_next_build, False) 915 916 def testX86_32_64Translate(self): 917 """Test for a build with x86_32_64.""" 918 build, patch, package, abi, is_next_build = TranslateVersionCode( 919 '575000017') 920 self.assertEqual(build, 5750) 921 self.assertEqual(patch, 0) 922 self.assertEqual(package, 'CHROME_MODERN') 923 self.assertEqual(abi, 'x86_32_64') 924 self.assertEqual(is_next_build, False) 925 926 def testX86_64_32Translate(self): 927 """Test for a build with x86_64_32.""" 928 build, patch, package, abi, is_next_build = TranslateVersionCode( 929 '575000018') 930 self.assertEqual(build, 5750) 931 self.assertEqual(patch, 0) 932 self.assertEqual(package, 'CHROME_MODERN') 933 self.assertEqual(abi, 'x86_64_32') 934 self.assertEqual(is_next_build, False) 935 936 def testX86_Auto_64_32Translate(self): 937 """Test for an auto build with x86_64_32.""" 938 build, patch, package, abi, is_next_build = TranslateVersionCode( 939 '575000058') 940 self.assertEqual(build, 5750) 941 self.assertEqual(patch, 0) 942 self.assertEqual(package, 'TRICHROME_AUTO') 943 self.assertEqual(abi, 'x86_64_32') 944 self.assertEqual(is_next_build, False) 945 946 def testWebviewTranslate(self): 947 """Test for a build with Webview.""" 948 build, patch, package, abi, is_next_build = TranslateVersionCode( 949 '575000000', is_webview=True) 950 self.assertEqual(build, 5750) 951 self.assertEqual(patch, 0) 952 self.assertEqual(package, 'WEBVIEW_STABLE') 953 self.assertEqual(abi, 'arm') 954 self.assertEqual(is_next_build, False) 955 956 957if __name__ == '__main__': 958 unittest.main() 959