tequilaOS/platform_build_soong
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
platform_build_soong/cc/symbolfile/test_symbolfile.py
Steven Moreland 8d5b9d01e9 validate tags for typos 
it turns out there were typos which are now fixed :D

Bug: 317293882
Test: build tree
Change-Id: I91dc08f00e8dd2e9dcb9101307d9b04bdcadea11
2024-01-03 21:48:03 +00:00

611 lines
21 KiB
Python
Raw Blame History

#
# Copyright (C) 2016 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""Tests for symbolfile."""
import io
import textwrap
import unittest
import symbolfile
from symbolfile import Arch, Tag, Tags, Version, Symbol, Filter
from copy import copy
# pylint: disable=missing-docstring
class DecodeApiLevelTest(unittest.TestCase):
def test_decode_api_level(self) -> None:
self.assertEqual(9, symbolfile.decode_api_level('9', {}))
self.assertEqual(9000, symbolfile.decode_api_level('O', {'O': 9000}))
with self.assertRaises(KeyError):
symbolfile.decode_api_level('O', {})
class TagsTest(unittest.TestCase):
def test_get_tags_no_tags(self) -> None:
self.assertEqual(Tags(), symbolfile.get_tags('', {}))
self.assertEqual(Tags(), symbolfile.get_tags('foo bar baz', {}))
def test_get_tags(self) -> None:
self.assertEqual(Tags.from_strs(['llndk', 'apex']),
symbolfile.get_tags('# llndk apex', {}))
self.assertEqual(Tags.from_strs(['llndk', 'apex']),
symbolfile.get_tags('foo # llndk apex', {}))
def test_get_unrecognized_tags(self) -> None:
with self.assertRaises(symbolfile.ParseError):
symbolfile.get_tags('# bar', {})
with self.assertRaises(symbolfile.ParseError):
symbolfile.get_tags('foo # bar', {})
with self.assertRaises(symbolfile.ParseError):
symbolfile.get_tags('# #', {})
with self.assertRaises(symbolfile.ParseError):
symbolfile.get_tags('# apex # llndk', {})
def test_split_tag(self) -> None:
self.assertTupleEqual(('foo', 'bar'),
symbolfile.split_tag(Tag('foo=bar')))
self.assertTupleEqual(('foo', 'bar=baz'),
symbolfile.split_tag(Tag('foo=bar=baz')))
with self.assertRaises(ValueError):
symbolfile.split_tag(Tag('foo'))
def test_get_tag_value(self) -> None:
self.assertEqual('bar', symbolfile.get_tag_value(Tag('foo=bar')))
self.assertEqual('bar=baz',
symbolfile.get_tag_value(Tag('foo=bar=baz')))
with self.assertRaises(ValueError):
symbolfile.get_tag_value(Tag('foo'))
def test_is_api_level_tag(self) -> None:
self.assertTrue(symbolfile.is_api_level_tag(Tag('introduced=24')))
self.assertTrue(symbolfile.is_api_level_tag(Tag('introduced-arm=24')))
self.assertTrue(symbolfile.is_api_level_tag(Tag('versioned=24')))
# Shouldn't try to process things that aren't a key/value tag.
self.assertFalse(symbolfile.is_api_level_tag(Tag('arm')))
self.assertFalse(symbolfile.is_api_level_tag(Tag('introduced')))
self.assertFalse(symbolfile.is_api_level_tag(Tag('versioned')))
# We don't support arch specific `versioned` tags.
self.assertFalse(symbolfile.is_api_level_tag(Tag('versioned-arm=24')))
def test_decode_api_level_tags(self) -> None:
api_map = {
'O': 9000,
'P': 9001,
}
tags = [
symbolfile.decode_api_level_tag(t, api_map) for t in (
Tag('introduced=9'),
Tag('introduced-arm=14'),
Tag('versioned=16'),
Tag('arm'),
Tag('introduced=O'),
Tag('introduced=P'),
)
]
expected_tags = [
Tag('introduced=9'),
Tag('introduced-arm=14'),
Tag('versioned=16'),
Tag('arm'),
Tag('introduced=9000'),
Tag('introduced=9001'),
]
self.assertListEqual(expected_tags, tags)
with self.assertRaises(symbolfile.ParseError):
symbolfile.decode_api_level_tag(Tag('introduced=O'), {})
class PrivateVersionTest(unittest.TestCase):
def test_version_is_private(self) -> None:
def mock_version(name: str) -> Version:
return Version(name, base=None, tags=Tags(), symbols=[])
self.assertFalse(mock_version('foo').is_private)
self.assertFalse(mock_version('PRIVATE').is_private)
self.assertFalse(mock_version('PLATFORM').is_private)
self.assertFalse(mock_version('foo_private').is_private)
self.assertFalse(mock_version('foo_platform').is_private)
self.assertFalse(mock_version('foo_PRIVATE_').is_private)
self.assertFalse(mock_version('foo_PLATFORM_').is_private)
self.assertTrue(mock_version('foo_PRIVATE').is_private)
self.assertTrue(mock_version('foo_PLATFORM').is_private)
class SymbolPresenceTest(unittest.TestCase):
def test_symbol_in_arch(self) -> None:
self.assertTrue(symbolfile.symbol_in_arch(Tags(), Arch('arm')))
self.assertTrue(
symbolfile.symbol_in_arch(Tags.from_strs(['arm']), Arch('arm')))
self.assertFalse(
symbolfile.symbol_in_arch(Tags.from_strs(['x86']), Arch('arm')))
def test_symbol_in_api(self) -> None:
self.assertTrue(symbolfile.symbol_in_api([], Arch('arm'), 9))
self.assertTrue(
symbolfile.symbol_in_api([Tag('introduced=9')], Arch('arm'), 9))
self.assertTrue(
symbolfile.symbol_in_api([Tag('introduced=9')], Arch('arm'), 14))
self.assertTrue(
symbolfile.symbol_in_api([Tag('introduced-arm=9')], Arch('arm'),
14))
self.assertTrue(
symbolfile.symbol_in_api([Tag('introduced-arm=9')], Arch('arm'),
14))
self.assertTrue(
symbolfile.symbol_in_api([Tag('introduced-x86=14')], Arch('arm'),
9))
self.assertTrue(
symbolfile.symbol_in_api(
[Tag('introduced-arm=9'),
Tag('introduced-x86=21')], Arch('arm'), 14))
self.assertTrue(
symbolfile.symbol_in_api(
[Tag('introduced=9'),
Tag('introduced-x86=21')], Arch('arm'), 14))
self.assertTrue(
symbolfile.symbol_in_api(
[Tag('introduced=21'),
Tag('introduced-arm=9')], Arch('arm'), 14))
self.assertTrue(
symbolfile.symbol_in_api([Tag('future')], Arch('arm'),
symbolfile.FUTURE_API_LEVEL))
self.assertFalse(
symbolfile.symbol_in_api([Tag('introduced=14')], Arch('arm'), 9))
self.assertFalse(
symbolfile.symbol_in_api([Tag('introduced-arm=14')], Arch('arm'),
9))
self.assertFalse(
symbolfile.symbol_in_api([Tag('future')], Arch('arm'), 9))
self.assertFalse(
symbolfile.symbol_in_api(
[Tag('introduced=9'), Tag('future')], Arch('arm'), 14))
self.assertFalse(
symbolfile.symbol_in_api([Tag('introduced-arm=9'),
Tag('future')], Arch('arm'), 14))
self.assertFalse(
symbolfile.symbol_in_api(
[Tag('introduced-arm=21'),
Tag('introduced-x86=9')], Arch('arm'), 14))
self.assertFalse(
symbolfile.symbol_in_api(
[Tag('introduced=9'),
Tag('introduced-arm=21')], Arch('arm'), 14))
self.assertFalse(
symbolfile.symbol_in_api(
[Tag('introduced=21'),
Tag('introduced-x86=9')], Arch('arm'), 14))
# Interesting edge case: this symbol should be omitted from the
# library, but this call should still return true because none of the
# tags indiciate that it's not present in this API level.
self.assertTrue(symbolfile.symbol_in_api([Tag('x86')], Arch('arm'), 9))
def test_verioned_in_api(self) -> None:
self.assertTrue(symbolfile.symbol_versioned_in_api([], 9))
self.assertTrue(
symbolfile.symbol_versioned_in_api([Tag('versioned=9')], 9))
self.assertTrue(
symbolfile.symbol_versioned_in_api([Tag('versioned=9')], 14))
self.assertFalse(
symbolfile.symbol_versioned_in_api([Tag('versioned=14')], 9))
class OmitVersionTest(unittest.TestCase):
def setUp(self) -> None:
self.filter = Filter(arch = Arch('arm'), api = 9)
self.version = Version('foo', None, Tags(), [])
def assertOmit(self, f: Filter, v: Version) -> None:
self.assertTrue(f.should_omit_version(v))
def assertInclude(self, f: Filter, v: Version) -> None:
self.assertFalse(f.should_omit_version(v))
def test_omit_private(self) -> None:
f = self.filter
v = self.version
self.assertInclude(f, v)
v.name = 'foo_PRIVATE'
self.assertOmit(f, v)
v.name = 'foo_PLATFORM'
self.assertOmit(f, v)
v.name = 'foo'
v.tags = Tags.from_strs(['platform-only'])
self.assertOmit(f, v)
def test_omit_llndk(self) -> None:
f = self.filter
v = self.version
v_llndk = copy(v)
v_llndk.tags = Tags.from_strs(['llndk'])
self.assertOmit(f, v_llndk)
f.llndk = True
self.assertInclude(f, v)
self.assertInclude(f, v_llndk)
def test_omit_apex(self) -> None:
f = self.filter
v = self.version
v_apex = copy(v)
v_apex.tags = Tags.from_strs(['apex'])
v_systemapi = copy(v)
v_systemapi.tags = Tags.from_strs(['systemapi'])
self.assertOmit(f, v_apex)
f.apex = True
self.assertInclude(f, v)
self.assertInclude(f, v_apex)
self.assertOmit(f, v_systemapi)
def test_omit_systemapi(self) -> None:
f = self.filter
v = self.version
v_apex = copy(v)
v_apex.tags = Tags.from_strs(['apex'])
v_systemapi = copy(v)
v_systemapi.tags = Tags.from_strs(['systemapi'])
self.assertOmit(f, v_systemapi)
f.systemapi = True
self.assertInclude(f, v)
self.assertInclude(f, v_systemapi)
self.assertOmit(f, v_apex)
def test_omit_arch(self) -> None:
f_arm = self.filter
v_none = self.version
self.assertInclude(f_arm, v_none)
v_arm = copy(v_none)
v_arm.tags = Tags.from_strs(['arm'])
self.assertInclude(f_arm, v_arm)
v_x86 = copy(v_none)
v_x86.tags = Tags.from_strs(['x86'])
self.assertOmit(f_arm, v_x86)
def test_omit_api(self) -> None:
f_api9 = self.filter
v_none = self.version
self.assertInclude(f_api9, v_none)
v_api9 = copy(v_none)
v_api9.tags = Tags.from_strs(['introduced=9'])
self.assertInclude(f_api9, v_api9)
v_api14 = copy(v_none)
v_api14.tags = Tags.from_strs(['introduced=14'])
self.assertOmit(f_api9, v_api14)
class OmitSymbolTest(unittest.TestCase):
def setUp(self) -> None:
self.filter = Filter(arch = Arch('arm'), api = 9)
def assertOmit(self, f: Filter, s: Symbol) -> None:
self.assertTrue(f.should_omit_symbol(s))
def assertInclude(self, f: Filter, s: Symbol) -> None:
self.assertFalse(f.should_omit_symbol(s))
def test_omit_ndk(self) -> None:
f_ndk = self.filter
f_nondk = copy(f_ndk)
f_nondk.ndk = False
f_nondk.apex = True
s_ndk = Symbol('foo', Tags())
s_nonndk = Symbol('foo', Tags.from_strs(['apex']))
self.assertInclude(f_ndk, s_ndk)
self.assertOmit(f_ndk, s_nonndk)
self.assertOmit(f_nondk, s_ndk)
self.assertInclude(f_nondk, s_nonndk)
def test_omit_llndk(self) -> None:
f_none = self.filter
f_llndk = copy(f_none)
f_llndk.llndk = True
s_none = Symbol('foo', Tags())
s_llndk = Symbol('foo', Tags.from_strs(['llndk']))
self.assertOmit(f_none, s_llndk)
self.assertInclude(f_llndk, s_none)
self.assertInclude(f_llndk, s_llndk)
def test_omit_apex(self) -> None:
f_none = self.filter
f_apex = copy(f_none)
f_apex.apex = True
s_none = Symbol('foo', Tags())
s_apex = Symbol('foo', Tags.from_strs(['apex']))
s_systemapi = Symbol('foo', Tags.from_strs(['systemapi']))
self.assertOmit(f_none, s_apex)
self.assertInclude(f_apex, s_none)
self.assertInclude(f_apex, s_apex)
self.assertOmit(f_apex, s_systemapi)
def test_omit_systemapi(self) -> None:
f_none = self.filter
f_systemapi = copy(f_none)
f_systemapi.systemapi = True
s_none = Symbol('foo', Tags())
s_apex = Symbol('foo', Tags.from_strs(['apex']))
s_systemapi = Symbol('foo', Tags.from_strs(['systemapi']))
self.assertOmit(f_none, s_systemapi)
self.assertInclude(f_systemapi, s_none)
self.assertInclude(f_systemapi, s_systemapi)
self.assertOmit(f_systemapi, s_apex)
def test_omit_apex_and_systemapi(self) -> None:
f = self.filter
f.systemapi = True
f.apex = True
s_none = Symbol('foo', Tags())
s_apex = Symbol('foo', Tags.from_strs(['apex']))
s_systemapi = Symbol('foo', Tags.from_strs(['systemapi']))
self.assertInclude(f, s_none)
self.assertInclude(f, s_apex)
self.assertInclude(f, s_systemapi)
def test_omit_arch(self) -> None:
f_arm = self.filter
s_none = Symbol('foo', Tags())
s_arm = Symbol('foo', Tags.from_strs(['arm']))
s_x86 = Symbol('foo', Tags.from_strs(['x86']))
self.assertInclude(f_arm, s_none)
self.assertInclude(f_arm, s_arm)
self.assertOmit(f_arm, s_x86)
def test_omit_api(self) -> None:
f_api9 = self.filter
s_none = Symbol('foo', Tags())
s_api9 = Symbol('foo', Tags.from_strs(['introduced=9']))
s_api14 = Symbol('foo', Tags.from_strs(['introduced=14']))
self.assertInclude(f_api9, s_none)
self.assertInclude(f_api9, s_api9)
self.assertOmit(f_api9, s_api14)
class SymbolFileParseTest(unittest.TestCase):
def setUp(self) -> None:
self.filter = Filter(arch = Arch('arm'), api = 16)
def test_next_line(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
foo
bar
# baz
qux
"""))
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
self.assertIsNone(parser.current_line)
self.assertEqual('foo', parser.next_line().strip())
assert parser.current_line is not None
self.assertEqual('foo', parser.current_line.strip())
self.assertEqual('bar', parser.next_line().strip())
self.assertEqual('bar', parser.current_line.strip())
self.assertEqual('qux', parser.next_line().strip())
self.assertEqual('qux', parser.current_line.strip())
self.assertEqual('', parser.next_line())
self.assertEqual('', parser.current_line)
def test_parse_version(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
VERSION_1 { # weak introduced=35
baz;
qux; # apex llndk
};
VERSION_2 {
} VERSION_1; # not-a-tag
"""))
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
parser.next_line()
version = parser.parse_version()
self.assertEqual('VERSION_1', version.name)
self.assertIsNone(version.base)
self.assertEqual(Tags.from_strs(['weak', 'introduced=35']), version.tags)
expected_symbols = [
Symbol('baz', Tags()),
Symbol('qux', Tags.from_strs(['apex', 'llndk'])),
]
self.assertEqual(expected_symbols, version.symbols)
parser.next_line()
version = parser.parse_version()
self.assertEqual('VERSION_2', version.name)
self.assertEqual('VERSION_1', version.base)
self.assertEqual(Tags(), version.tags)
def test_parse_version_eof(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
VERSION_1 {
"""))
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
parser.next_line()
with self.assertRaises(symbolfile.ParseError):
parser.parse_version()
def test_unknown_scope_label(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
VERSION_1 {
foo:
}
"""))
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
parser.next_line()
with self.assertRaises(symbolfile.ParseError):
parser.parse_version()
def test_parse_symbol(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
foo;
bar; # llndk apex
"""))
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
parser.next_line()
symbol = parser.parse_symbol()
self.assertEqual('foo', symbol.name)
self.assertEqual(Tags(), symbol.tags)
parser.next_line()
symbol = parser.parse_symbol()
self.assertEqual('bar', symbol.name)
self.assertEqual(Tags.from_strs(['llndk', 'apex']), symbol.tags)
def test_wildcard_symbol_global(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
VERSION_1 {
*;
};
"""))
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
parser.next_line()
with self.assertRaises(symbolfile.ParseError):
parser.parse_version()
def test_wildcard_symbol_local(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
VERSION_1 {
local:
*;
};
"""))
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
parser.next_line()
version = parser.parse_version()
self.assertEqual([], version.symbols)
def test_missing_semicolon(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
VERSION_1 {
foo
};
"""))
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
parser.next_line()
with self.assertRaises(symbolfile.ParseError):
parser.parse_version()
def test_parse_fails_invalid_input(self) -> None:
with self.assertRaises(symbolfile.ParseError):
input_file = io.StringIO('foo')
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
parser.parse()
def test_parse(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
VERSION_1 {
local:
hidden1;
global:
foo;
bar; # llndk
};
VERSION_2 { # weak
# Implicit global scope.
woodly;
doodly; # llndk
local:
qwerty;
} VERSION_1;
"""))
parser = symbolfile.SymbolFileParser(input_file, {}, self.filter)
versions = parser.parse()
expected = [
symbolfile.Version('VERSION_1', None, Tags(), [
Symbol('foo', Tags()),
Symbol('bar', Tags.from_strs(['llndk'])),
]),
symbolfile.Version(
'VERSION_2', 'VERSION_1', Tags.from_strs(['weak']), [
Symbol('woodly', Tags()),
Symbol('doodly', Tags.from_strs(['llndk'])),
]),
]
self.assertEqual(expected, versions)
def test_parse_llndk_apex_symbol(self) -> None:
input_file = io.StringIO(textwrap.dedent("""\
VERSION_1 {
foo;
bar; # llndk
baz; # llndk apex
qux; # apex
};
"""))
f = copy(self.filter)
f.llndk = True
parser = symbolfile.SymbolFileParser(input_file, {}, f)
parser.next_line()
version = parser.parse_version()
self.assertEqual('VERSION_1', version.name)
self.assertIsNone(version.base)
expected_symbols = [
Symbol('foo', Tags()),
Symbol('bar', Tags.from_strs(['llndk'])),
Symbol('baz', Tags.from_strs(['llndk', 'apex'])),
Symbol('qux', Tags.from_strs(['apex'])),
]
self.assertEqual(expected_symbols, version.symbols)
def main() -> None:
suite = unittest.TestLoader().loadTestsFromName(__name__)
unittest.TextTestRunner(verbosity=3).run(suite)
if __name__ == '__main__':
main()
Reference in a new issue View git blame Copy permalink