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