24d9cad563
foo=true
foo=true
foo?=false
Consider the above case: Then the duplication of foo is allowed because
they have the same value (true). However, there was a bug that the
optional assirgnment foo?=false is left unmodified.
This fixes the bug by commenting such optional assignments.
Exempt-From-Owner-Approval: fixes a broken build
Bug: 117892318
Bug: 158735147
Test: atest test_post_process_props
Test: m out/target/product/vsoc_x86/vendor/build.prop for cf_x86_auto
Exempt-From-Owner-Approval: cherry-pick from master
Merged-In: Iba9b61d9779d93e86d9bead2286f945f8d51ab1d
(cherry picked from commit 9a32636759)
Change-Id: Iba9b61d9779d93e86d9bead2286f945f8d51ab1d
255 lines
8.4 KiB
Python
255 lines
8.4 KiB
Python
#!/usr/bin/env python3
|
|
#
|
|
# Copyright (C) 2020 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.
|
|
|
|
import contextlib
|
|
import io
|
|
import unittest
|
|
|
|
from unittest.mock import *
|
|
from post_process_props import *
|
|
|
|
class PropTestCase(unittest.TestCase):
|
|
def test_createFromLine(self):
|
|
p = Prop.from_line("# this is comment")
|
|
self.assertTrue(p.is_comment())
|
|
self.assertEqual("", p.name)
|
|
self.assertEqual("", p.value)
|
|
self.assertFalse(p.is_optional())
|
|
self.assertEqual("# this is comment", str(p))
|
|
|
|
for line in ["a=b", "a = b", "a= b", "a =b", " a=b "]:
|
|
p = Prop.from_line(line)
|
|
self.assertFalse(p.is_comment())
|
|
self.assertEqual("a", p.name)
|
|
self.assertEqual("b", p.value)
|
|
self.assertFalse(p.is_optional())
|
|
self.assertEqual("a=b", str(p))
|
|
|
|
for line in ["a?=b", "a ?= b", "a?= b", "a ?=b", " a?=b "]:
|
|
p = Prop.from_line(line)
|
|
self.assertFalse(p.is_comment())
|
|
self.assertEqual("a", p.name)
|
|
self.assertEqual("b", p.value)
|
|
self.assertTrue(p.is_optional())
|
|
self.assertEqual("a?=b", str(p))
|
|
|
|
def test_makeAsComment(self):
|
|
p = Prop.from_line("a=b")
|
|
p.comments.append("# a comment")
|
|
self.assertFalse(p.is_comment())
|
|
|
|
p.make_as_comment()
|
|
self.assertTrue(p.is_comment())
|
|
self.assertTrue("# a comment\n#a=b", str(p))
|
|
|
|
class PropListTestcase(unittest.TestCase):
|
|
def setUp(self):
|
|
content = """
|
|
# comment
|
|
foo=true
|
|
bar=false
|
|
qux?=1
|
|
# another comment
|
|
foo?=false
|
|
"""
|
|
self.patcher = patch("post_process_props.open", mock_open(read_data=content))
|
|
self.mock_open = self.patcher.start()
|
|
self.props = PropList("file")
|
|
|
|
def tearDown(self):
|
|
self.patcher.stop()
|
|
self.props = None
|
|
|
|
def test_readFromFile(self):
|
|
self.assertEqual(4, len(self.props.get_all_props()))
|
|
expected = [
|
|
("foo", "true", False),
|
|
("bar", "false", False),
|
|
("qux", "1", True),
|
|
("foo", "false", True)
|
|
]
|
|
for i,p in enumerate(self.props.get_all_props()):
|
|
self.assertEqual(expected[i][0], p.name)
|
|
self.assertEqual(expected[i][1], p.value)
|
|
self.assertEqual(expected[i][2], p.is_optional())
|
|
self.assertFalse(p.is_comment())
|
|
|
|
self.assertEqual(set(["foo", "bar", "qux"]), self.props.get_all_names())
|
|
|
|
self.assertEqual("true", self.props.get_value("foo"))
|
|
self.assertEqual("false", self.props.get_value("bar"))
|
|
self.assertEqual("1", self.props.get_value("qux"))
|
|
|
|
# there are two assignments for 'foo'
|
|
self.assertEqual(2, len(self.props.get_props("foo")))
|
|
|
|
def test_putNewProp(self):
|
|
self.props.put("new", "30")
|
|
|
|
self.assertEqual(5, len(self.props.get_all_props()))
|
|
last_prop = self.props.get_all_props()[-1]
|
|
self.assertEqual("new", last_prop.name)
|
|
self.assertEqual("30", last_prop.value)
|
|
self.assertFalse(last_prop.is_optional())
|
|
|
|
def test_putExistingNonOptionalProp(self):
|
|
self.props.put("foo", "NewValue")
|
|
|
|
self.assertEqual(4, len(self.props.get_all_props()))
|
|
foo_prop = self.props.get_props("foo")[0]
|
|
self.assertEqual("foo", foo_prop.name)
|
|
self.assertEqual("NewValue", foo_prop.value)
|
|
self.assertFalse(foo_prop.is_optional())
|
|
self.assertEqual("# Value overridden by post_process_props.py. " +
|
|
"Original value: true\nfoo=NewValue", str(foo_prop))
|
|
|
|
def test_putExistingOptionalProp(self):
|
|
self.props.put("qux", "2")
|
|
|
|
self.assertEqual(5, len(self.props.get_all_props()))
|
|
last_prop = self.props.get_all_props()[-1]
|
|
self.assertEqual("qux", last_prop.name)
|
|
self.assertEqual("2", last_prop.value)
|
|
self.assertFalse(last_prop.is_optional())
|
|
self.assertEqual("# Auto-added by post_process_props.py\nqux=2",
|
|
str(last_prop))
|
|
|
|
def test_deleteNonOptionalProp(self):
|
|
props_to_delete = self.props.get_props("foo")[0]
|
|
props_to_delete.delete(reason="testing")
|
|
|
|
self.assertEqual(3, len(self.props.get_all_props()))
|
|
self.assertEqual("# Removed by post_process_props.py because testing\n" +
|
|
"#foo=true", str(props_to_delete))
|
|
|
|
def test_deleteOptionalProp(self):
|
|
props_to_delete = self.props.get_props("qux")[0]
|
|
props_to_delete.delete(reason="testing")
|
|
|
|
self.assertEqual(3, len(self.props.get_all_props()))
|
|
self.assertEqual("# Removed by post_process_props.py because testing\n" +
|
|
"#qux?=1", str(props_to_delete))
|
|
|
|
def test_overridingNonOptional(self):
|
|
props_to_be_overridden = self.props.get_props("foo")[1]
|
|
self.assertTrue("true", props_to_be_overridden.value)
|
|
|
|
self.assertTrue(override_optional_props(self.props))
|
|
|
|
# size reduced to 3 because foo?=false was overridden by foo=true
|
|
self.assertEqual(3, len(self.props.get_all_props()))
|
|
|
|
self.assertEqual(1, len(self.props.get_props("foo")))
|
|
self.assertEqual("true", self.props.get_props("foo")[0].value)
|
|
|
|
self.assertEqual("# Removed by post_process_props.py because " +
|
|
"overridden by foo=true\n#foo?=false",
|
|
str(props_to_be_overridden))
|
|
|
|
def test_overridingOptional(self):
|
|
content = """
|
|
# comment
|
|
qux?=2
|
|
foo=true
|
|
bar=false
|
|
qux?=1
|
|
# another comment
|
|
foo?=false
|
|
"""
|
|
with patch('post_process_props.open', mock_open(read_data=content)) as m:
|
|
props = PropList("hello")
|
|
|
|
props_to_be_overridden = props.get_props("qux")[0]
|
|
self.assertEqual("2", props_to_be_overridden.value)
|
|
|
|
self.assertTrue(override_optional_props(props))
|
|
|
|
self.assertEqual(1, len(props.get_props("qux")))
|
|
self.assertEqual("1", props.get_props("qux")[0].value)
|
|
# the only left optional assignment becomes non-optional
|
|
self.assertFalse(props.get_props("qux")[0].is_optional())
|
|
|
|
self.assertEqual("# Removed by post_process_props.py because " +
|
|
"overridden by qux?=1\n#qux?=2",
|
|
str(props_to_be_overridden))
|
|
|
|
def test_overridingDuplicated(self):
|
|
content = """
|
|
# comment
|
|
foo=true
|
|
bar=false
|
|
qux?=1
|
|
foo=false
|
|
# another comment
|
|
foo?=false
|
|
"""
|
|
with patch("post_process_props.open", mock_open(read_data=content)) as m:
|
|
stderr_redirect = io.StringIO()
|
|
with contextlib.redirect_stderr(stderr_redirect):
|
|
props = PropList("hello")
|
|
|
|
# fails due to duplicated foo=true and foo=false
|
|
self.assertFalse(override_optional_props(props))
|
|
|
|
self.assertEqual("error: found duplicate sysprop assignments:\n" +
|
|
"foo=true\nfoo=false\n", stderr_redirect.getvalue())
|
|
|
|
def test_overridingDuplicatedWithSameValue(self):
|
|
content = """
|
|
# comment
|
|
foo=true
|
|
bar=false
|
|
qux?=1
|
|
foo=true
|
|
# another comment
|
|
foo?=false
|
|
"""
|
|
with patch("post_process_props.open", mock_open(read_data=content)) as m:
|
|
stderr_redirect = io.StringIO()
|
|
with contextlib.redirect_stderr(stderr_redirect):
|
|
props = PropList("hello")
|
|
optional_prop = props.get_props("foo")[2] # the last foo?=false one
|
|
|
|
# we have duplicated foo=true and foo=true, but that's allowed
|
|
# since they have the same value
|
|
self.assertTrue(override_optional_props(props))
|
|
|
|
# foo?=false should be commented out
|
|
self.assertEqual("# Removed by post_process_props.py because " +
|
|
"overridden by foo=true\n#foo?=false",
|
|
str(optional_prop))
|
|
|
|
def test_allowDuplicates(self):
|
|
content = """
|
|
# comment
|
|
foo=true
|
|
bar=false
|
|
qux?=1
|
|
foo=false
|
|
# another comment
|
|
foo?=false
|
|
"""
|
|
with patch("post_process_props.open", mock_open(read_data=content)) as m:
|
|
stderr_redirect = io.StringIO()
|
|
with contextlib.redirect_stderr(stderr_redirect):
|
|
props = PropList("hello")
|
|
|
|
# we have duplicated foo=true and foo=false, but that's allowed
|
|
# because it's explicitly allowed
|
|
self.assertTrue(override_optional_props(props, allow_dup=True))
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(verbosity=2)
|