Updating Security String to 2017-01-05 on nyc-dev am: 190129bc61 am: b9085822a5 am: 091dea5c83
am: 223b79e356
Change-Id: Ib8479d61177d014774b704d9cb416df303d1f766
diff --git a/core/version_defaults.mk b/core/version_defaults.mk
index 550fc70..0258bf7 100644
--- a/core/version_defaults.mk
+++ b/core/version_defaults.mk
@@ -43,7 +43,7 @@
# which is the version that we reveal to the end user.
# Update this value when the platform version changes (rather
# than overriding it somewhere else). Can be an arbitrary string.
- PLATFORM_VERSION := 7.1.1
+ PLATFORM_VERSION := 7.1.2
endif
ifeq "" "$(PLATFORM_SDK_VERSION)"
diff --git a/tools/releasetools/blockimgdiff.py b/tools/releasetools/blockimgdiff.py
index 31dabc7..cc06a42 100644
--- a/tools/releasetools/blockimgdiff.py
+++ b/tools/releasetools/blockimgdiff.py
@@ -1000,8 +1000,11 @@
heap.append(xf.heap_item)
heapq.heapify(heap)
- sinks = set(u for u in G if not u.outgoing)
- sources = set(u for u in G if not u.incoming)
+ # Use OrderedDict() instead of set() to preserve the insertion order. Need
+ # to use 'sinks[key] = None' to add key into the set. sinks will look like
+ # { key1: None, key2: None, ... }.
+ sinks = OrderedDict.fromkeys(u for u in G if not u.outgoing)
+ sources = OrderedDict.fromkeys(u for u in G if not u.incoming)
def adjust_score(iu, delta):
iu.score += delta
@@ -1012,26 +1015,28 @@
while G:
# Put all sinks at the end of the sequence.
while sinks:
- new_sinks = set()
+ new_sinks = OrderedDict()
for u in sinks:
if u not in G: continue
s2.appendleft(u)
del G[u]
for iu in u.incoming:
adjust_score(iu, -iu.outgoing.pop(u))
- if not iu.outgoing: new_sinks.add(iu)
+ if not iu.outgoing:
+ new_sinks[iu] = None
sinks = new_sinks
# Put all the sources at the beginning of the sequence.
while sources:
- new_sources = set()
+ new_sources = OrderedDict()
for u in sources:
if u not in G: continue
s1.append(u)
del G[u]
for iu in u.outgoing:
adjust_score(iu, +iu.incoming.pop(u))
- if not iu.incoming: new_sources.add(iu)
+ if not iu.incoming:
+ new_sources[iu] = None
sources = new_sources
if not G: break
@@ -1050,11 +1055,13 @@
del G[u]
for iu in u.outgoing:
adjust_score(iu, +iu.incoming.pop(u))
- if not iu.incoming: sources.add(iu)
+ if not iu.incoming:
+ sources[iu] = None
for iu in u.incoming:
adjust_score(iu, -iu.outgoing.pop(u))
- if not iu.outgoing: sinks.add(iu)
+ if not iu.outgoing:
+ sinks[iu] = None
# Now record the sequence in the 'order' field of each transfer,
# and by rearranging self.transfers to be in the chosen sequence.
@@ -1073,8 +1080,7 @@
# Each item of source_ranges will be:
# - None, if that block is not used as a source,
- # - a transfer, if one transfer uses it as a source, or
- # - a set of transfers.
+ # - an ordered set of transfers.
source_ranges = []
for b in self.transfers:
for s, e in b.src_ranges:
@@ -1082,23 +1088,19 @@
source_ranges.extend([None] * (e-len(source_ranges)))
for i in range(s, e):
if source_ranges[i] is None:
- source_ranges[i] = b
+ source_ranges[i] = OrderedDict.fromkeys([b])
else:
- if not isinstance(source_ranges[i], set):
- source_ranges[i] = set([source_ranges[i]])
- source_ranges[i].add(b)
+ source_ranges[i][b] = None
for a in self.transfers:
- intersections = set()
+ intersections = OrderedDict()
for s, e in a.tgt_ranges:
for i in range(s, e):
if i >= len(source_ranges): break
- b = source_ranges[i]
- if b is not None:
- if isinstance(b, set):
- intersections.update(b)
- else:
- intersections.add(b)
+ # Add all the Transfers in source_ranges[i] to the (ordered) set.
+ if source_ranges[i] is not None:
+ for j in source_ranges[i]:
+ intersections[j] = None
for b in intersections:
if a is b: continue
diff --git a/tools/releasetools/test_blockimgdiff.py b/tools/releasetools/test_blockimgdiff.py
new file mode 100644
index 0000000..03e8c8b
--- /dev/null
+++ b/tools/releasetools/test_blockimgdiff.py
@@ -0,0 +1,77 @@
+#
+# 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.
+#
+
+from __future__ import print_function
+
+import common
+import unittest
+
+from collections import OrderedDict
+from blockimgdiff import BlockImageDiff, EmptyImage, DataImage, Transfer
+from rangelib import RangeSet
+
+class BlockImageDiffTest(unittest.TestCase):
+
+ def test_GenerateDigraphOrder(self):
+ """Make sure GenerateDigraph preserves the order.
+
+ t0: <0-5> => <...>
+ t1: <0-7> => <...>
+ t2: <0-4> => <...>
+ t3: <...> => <0-10>
+
+ t0, t1 and t2 must go before t3, i.e. t3.goes_after =
+ { t0:..., t1:..., t2:... }. But the order of t0-t2 must be preserved.
+ """
+
+ src = EmptyImage()
+ tgt = EmptyImage()
+ block_image_diff = BlockImageDiff(tgt, src)
+
+ transfers = block_image_diff.transfers
+ t0 = Transfer(
+ "t1", "t1", RangeSet("10-15"), RangeSet("0-5"), "move", transfers)
+ t1 = Transfer(
+ "t2", "t2", RangeSet("20-25"), RangeSet("0-7"), "move", transfers)
+ t2 = Transfer(
+ "t3", "t3", RangeSet("30-35"), RangeSet("0-4"), "move", transfers)
+ t3 = Transfer(
+ "t4", "t4", RangeSet("0-10"), RangeSet("40-50"), "move", transfers)
+
+ block_image_diff.GenerateDigraph()
+ t3_goes_after_copy = t3.goes_after.copy()
+
+ # Elements in the set must be in the transfer evaluation order.
+ elements = list(t3_goes_after_copy)
+ self.assertEqual(t0, elements[0])
+ self.assertEqual(t1, elements[1])
+ self.assertEqual(t2, elements[2])
+
+ # Now switch the order of t0, t1 and t2.
+ transfers[0], transfers[1], transfers[2] = (
+ transfers[2], transfers[0], transfers[1])
+ t3.goes_after.clear()
+ t3.goes_before.clear()
+ block_image_diff.GenerateDigraph()
+
+ # The goes_after must be different from last run.
+ self.assertNotEqual(t3_goes_after_copy, t3.goes_after)
+
+ # Assert that each element must agree with the transfer order.
+ elements = list(t3.goes_after)
+ self.assertEqual(t2, elements[0])
+ self.assertEqual(t0, elements[1])
+ self.assertEqual(t1, elements[2])