xref: /aosp_15_r20/build/bazel/rules/common/api_test.bzl (revision 7594170e27e0732bc44b93d1440d87a54b6ffe7c) 
1load("@bazel_skylib//lib:unittest.bzl", "asserts", "unittest")
2load("//build/bazel/rules/common:api.bzl", "api_from_product")
3
4def _is_preview_test_impl(ctx):
5    env = unittest.begin(ctx)
6    platform_sdk_variables = struct(
7        platform_version_active_codenames = ["UpsideDownCake"],
8    )
9    api = api_from_product(platform_sdk_variables)
10
11    # schema: version string to parse: is preview api
12    _LEVELS_UNDER_TEST = {
13        # numbers
14        "9": False,  # earliest released number
15        # codenames
16        "Tiramisu": False,
17        "UpsideDownCake": True,  # preview
18        "current": True,  # future (considered as preview)
19        "(no version)": True,
20        # preview numbers
21        "9000": True,  # preview
22        "10000": True,  # future (considered as preview)
23    }
24
25    for level, expected in _LEVELS_UNDER_TEST.items():
26        asserts.equals(env, expected, api.is_preview(level), "unexpected is_preview value for %s" % level)
27
28    return unittest.end(env)
29
30is_preview_test = unittest.make(_is_preview_test_impl)
31
32def _default_app_target_sdk_string_test_impl(ctx):
33    env = unittest.begin(ctx)
34
35    asserts.equals(
36        env,
37        "33",
38        api_from_product(struct(
39            platform_sdk_final = True,
40            platform_sdk_version = 33,
41            platform_sdk_codename = "REL",
42            platform_version_active_codenames = [],
43        )).default_app_target_sdk_string(),
44        "unexpected default_app_target_sdk_string value with platform_sdk_final True and platform_sdk_version 33.",
45    )
46    asserts.equals(
47        env,
48        "VanillaIceCream",
49        api_from_product(struct(
50            platform_sdk_final = False,
51            platform_sdk_version = 33,
52            platform_sdk_codename = "VanillaIceCream",
53            platform_version_active_codenames = ["VanillaIceCream"],
54        )).default_app_target_sdk_string(),
55        "unexpected default_app_target_sdk_string value with platform_sdk_final False and platform_sdk_codename VanillaIceCream.",
56    )
57
58    return unittest.end(env)
59
60default_app_target_sdk_string_test = unittest.make(_default_app_target_sdk_string_test_impl)
61
62def _effective_version_string_test_impl(ctx):
63    env = unittest.begin(ctx)
64
65    asserts.equals(
66        env,
67        "32",
68        api_from_product(struct(
69            platform_sdk_final = True,
70            platform_sdk_version = 33,
71            platform_sdk_codename = "REL",
72            platform_version_active_codenames = [],
73        )).effective_version_string("32"),
74        "unexpected effective version string when input version (32) is not preview",
75    )
76    asserts.equals(
77        env,
78        "33",
79        api_from_product(struct(
80            platform_sdk_final = True,
81            platform_sdk_version = 33,
82            platform_sdk_codename = "REL",
83            platform_version_active_codenames = [],
84        )).effective_version_string("current"),
85        "unexpected effective version string when input version (current) is preview and default_app_target_sdk (33) is not.",
86    )
87    asserts.equals(
88        env,
89        "VanillaIceCream",
90        api_from_product(struct(
91            platform_sdk_final = False,
92            platform_sdk_version = 33,
93            platform_sdk_codename = "UpsideDownCake",
94            platform_version_active_codenames = ["UpsideDownCake", "VanillaIceCream"],
95        )).effective_version_string("VanillaIceCream"),
96        "unexpected effective version string when both input version (VanillaIceCream) and default_app_target_sdk (UpsideDownCake) are preview.",
97    )
98    asserts.equals(
99        env,
100        "UpsideDownCake",
101        api_from_product(struct(
102            platform_sdk_final = False,
103            platform_sdk_version = 33,
104            platform_sdk_codename = "UpsideDownCake",
105            platform_version_active_codenames = ["UpsideDownCake", "VanillaIceCream"],
106        )).effective_version_string("current"),
107        "unexpected effective version string when both input version (current) and default_app_target_sdk (UpsideDownCake) are preview.",
108    )
109
110    return unittest.end(env)
111
112effective_version_string_test = unittest.make(_effective_version_string_test_impl)
113
114def _api_levels_test_impl(ctx):
115    env = unittest.begin(ctx)
116    api = api_from_product(struct(
117        platform_sdk_final = False,
118        platform_sdk_version = 33,
119        platform_sdk_codename = "UpsideDownCake",
120        platform_version_active_codenames = ["UpsideDownCake"],
121    ))
122
123    # schema: version string to parse: expected api int
124    _LEVELS_UNDER_TEST = {
125        # numbers
126        "9": 9,  # earliest released number
127        "21": 21,
128        "30": 30,
129        "33": 33,
130        # unchecked non final api level (not finalized, not preview, not current)
131        "1234": 1234,
132        "8999": 8999,
133        "9999": 9999,
134        "10001": 10001,
135        # letters
136        "G": 9,  # earliest released letter
137        "J-MR1": 17,
138        "R": 30,
139        "S": 31,
140        "S-V2": 32,
141        # codenames
142        "Tiramisu": 33,
143        "UpsideDownCake": 9000,
144        "current": 10000,
145        "9000": 9000,
146        "10000": 10000,
147    }
148
149    for level, expected in _LEVELS_UNDER_TEST.items():
150        asserts.equals(env, expected, api.parse_api_level_from_version(level), "unexpected api level parsed for %s" % level)
151
152    return unittest.end(env)
153
154api_levels_test = unittest.make(_api_levels_test_impl)
155
156def _final_or_future_test_impl(ctx):
157    env = unittest.begin(ctx)
158    api = api_from_product(struct(
159        platform_sdk_final = False,
160        platform_sdk_version = 33,
161        platform_sdk_codename = "UpsideDownCake",
162        platform_version_active_codenames = ["UpsideDownCake"],
163    ))
164
165    # schema: version string to parse: expected api int
166    _LEVELS_UNDER_TEST = {
167        # finalized
168        "30": 30,
169        "33": 33,
170        "S": 31,
171        "S-V2": 32,
172        "Tiramisu": 33,
173        # not finalized
174        "UpsideDownCake": 10000,
175        "current": 10000,
176        "9000": 10000,
177        "10000": 10000,
178    }
179
180    for level, expected in _LEVELS_UNDER_TEST.items():
181        asserts.equals(
182            env,
183            expected,
184            api.final_or_future(api.parse_api_level_from_version(level)),
185            "unexpected final or future api for %s" % level,
186        )
187
188    return unittest.end(env)
189
190final_or_future_test = unittest.make(_final_or_future_test_impl)
191
192def api_levels_test_suite(name):
193    tests = {
194        "api_levels": api_levels_test,
195        "final_or_future": final_or_future_test,
196        "is_preview": is_preview_test,
197        "default_app_target_sdk_string": default_app_target_sdk_string_test,
198        "effective_version_string": effective_version_string_test,
199    }
200
201    for test_name, test_function in tests.items():
202        test_function(name = name + "_" + test_name)
203
204    native.test_suite(
205        name = name,
206        tests = [name + "_" + test_name for test_name in tests.keys()],
207    )
208