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