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