1 # 2 # Copyright (C) 2016 The Android Open Source Project 3 # 4 # Licensed under the Apache License, Version 2.0 (the "License"); 5 # you may not use this file except in compliance with the License. 6 # You may obtain a copy of the License at 7 # 8 # http://www.apache.org/licenses/LICENSE-2.0 9 # 10 # Unless required by applicable law or agreed to in writing, software 11 # distributed under the License is distributed on an "AS IS" BASIS, 12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 # See the License for the specific language governing permissions and 14 # limitations under the License. 15 # 16 17 import os 18 from hashlib import sha1 19 20 import common 21 from blockimgdiff import ( 22 BlockImageDiff, DataImage, EmptyImage, FileImage, HeapItem, ImgdiffStats, 23 Transfer) 24 from rangelib import RangeSet 25 from test_utils import ReleaseToolsTestCase 26 27 28 class HealpItemTest(ReleaseToolsTestCase): 29 30 class Item(object): 31 def __init__(self, score): 32 self.score = score 33 34 def test_init(self): 35 item1 = HeapItem(self.Item(15)) 36 item2 = HeapItem(self.Item(20)) 37 item3 = HeapItem(self.Item(15)) 38 self.assertTrue(item1) 39 self.assertTrue(item2) 40 self.assertTrue(item3) 41 42 self.assertNotEqual(item1, item2) 43 self.assertEqual(item1, item3) 44 # HeapItem uses negated scores. 45 self.assertGreater(item1, item2) 46 self.assertLessEqual(item1, item3) 47 self.assertTrue(item1 <= item3) 48 self.assertFalse(item2 >= item1) 49 50 def test_clear(self): 51 item = HeapItem(self.Item(15)) 52 self.assertTrue(item) 53 54 item.clear() 55 self.assertFalse(item) 56 57 58 class BlockImageDiffTest(ReleaseToolsTestCase): 59 60 def test_GenerateDigraphOrder(self): 61 """Make sure GenerateDigraph preserves the order. 62 63 t0: <0-5> => <...> 64 t1: <0-7> => <...> 65 t2: <0-4> => <...> 66 t3: <...> => <0-10> 67 68 t0, t1 and t2 must go before t3, i.e. t3.goes_after = 69 { t0:..., t1:..., t2:... }. But the order of t0-t2 must be preserved. 70 """ 71 72 src = EmptyImage() 73 tgt = EmptyImage() 74 block_image_diff = BlockImageDiff(tgt, src) 75 76 transfers = block_image_diff.transfers 77 t0 = Transfer("t1", "t1", RangeSet("10-15"), RangeSet("0-5"), "t1hash", 78 "t1hash", "move", transfers) 79 t1 = Transfer("t2", "t2", RangeSet("20-25"), RangeSet("0-7"), "t2hash", 80 "t2hash", "move", transfers) 81 t2 = Transfer("t3", "t3", RangeSet("30-35"), RangeSet("0-4"), "t3hash", 82 "t3hash", "move", transfers) 83 t3 = Transfer("t4", "t4", RangeSet("0-10"), RangeSet("40-50"), "t4hash", 84 "t4hash", "move", transfers) 85 86 block_image_diff.GenerateDigraph() 87 t3_goes_after_copy = t3.goes_after.copy() 88 89 # Elements in the set must be in the transfer evaluation order. 90 elements = list(t3_goes_after_copy) 91 self.assertEqual(t0, elements[0]) 92 self.assertEqual(t1, elements[1]) 93 self.assertEqual(t2, elements[2]) 94 95 # Now switch the order of t0, t1 and t2. 96 transfers[0], transfers[1], transfers[2] = ( 97 transfers[2], transfers[0], transfers[1]) 98 t3.goes_after.clear() 99 t3.goes_before.clear() 100 block_image_diff.GenerateDigraph() 101 102 # The goes_after must be different from last run. 103 self.assertNotEqual(t3_goes_after_copy, t3.goes_after) 104 105 # Assert that each element must agree with the transfer order. 106 elements = list(t3.goes_after) 107 self.assertEqual(t2, elements[0]) 108 self.assertEqual(t0, elements[1]) 109 self.assertEqual(t1, elements[2]) 110 111 def test_ReviseStashSize(self): 112 """ReviseStashSize should convert transfers to 'new' commands as needed. 113 114 t1: diff <20-29> => <11-15> 115 t2: diff <11-15> => <20-29> 116 """ 117 118 src = EmptyImage() 119 tgt = EmptyImage() 120 block_image_diff = BlockImageDiff(tgt, src, version=3) 121 122 transfers = block_image_diff.transfers 123 Transfer("t1", "t1", RangeSet("11-15"), RangeSet("20-29"), "t1hash", 124 "t1hash", "diff", transfers) 125 Transfer("t2", "t2", RangeSet("20-29"), RangeSet("11-15"), "t2hash", 126 "t2hash", "diff", transfers) 127 128 block_image_diff.GenerateDigraph() 129 block_image_diff.FindVertexSequence() 130 block_image_diff.ReverseBackwardEdges() 131 132 # Sufficient cache to stash 5 blocks (size * 0.8 >= 5). 133 common.OPTIONS.cache_size = 7 * 4096 134 self.assertEqual((0, 5), block_image_diff.ReviseStashSize()) 135 136 # Insufficient cache to stash 5 blocks (size * 0.8 < 5). 137 common.OPTIONS.cache_size = 6 * 4096 138 self.assertEqual((10, 0), block_image_diff.ReviseStashSize()) 139 140 def test_ReviseStashSize_bug_33687949(self): 141 """ReviseStashSize() should "free" the used stash _after_ the command. 142 143 t1: diff <1-5> => <11-15> 144 t2: diff <11-15> => <21-25> 145 t3: diff <11-15 30-39> => <1-5 30-39> 146 147 For transfer t3, the used stash "11-15" should not be freed until the 148 command finishes. Assume the allowed cache size is 12-block, it should 149 convert the command to 'new' due to insufficient cache (12 < 5 + 10). 150 """ 151 152 src = EmptyImage() 153 tgt = EmptyImage() 154 block_image_diff = BlockImageDiff(tgt, src, version=3) 155 156 transfers = block_image_diff.transfers 157 t1 = Transfer("t1", "t1", RangeSet("11-15"), RangeSet("1-5"), "t1hash", 158 "t1hash", "diff", transfers) 159 t2 = Transfer("t2", "t2", RangeSet("21-25"), RangeSet("11-15"), "t2hash", 160 "t2hash", "diff", transfers) 161 t3 = Transfer("t3", "t3", RangeSet("1-5 30-39"), RangeSet("11-15 30-39"), 162 "t3hash", "t3hash", "diff", transfers) 163 164 block_image_diff.GenerateDigraph() 165 166 # Instead of calling FindVertexSequence() and ReverseBackwardEdges(), we 167 # just set up the stash_before and use_stash manually. Otherwise it will 168 # reorder the transfer, which makes testing ReviseStashSize() harder. 169 t1.stash_before.append((0, RangeSet("11-15"))) 170 t2.use_stash.append((0, RangeSet("11-15"))) 171 t1.stash_before.append((1, RangeSet("11-15"))) 172 t3.use_stash.append((1, RangeSet("11-15"))) 173 174 # Insufficient cache to stash 15 blocks (size * 0.8 < 15). 175 common.OPTIONS.cache_size = 15 * 4096 176 self.assertEqual((15, 5), block_image_diff.ReviseStashSize()) 177 178 def test_FileTypeSupportedByImgdiff(self): 179 self.assertTrue( 180 BlockImageDiff.FileTypeSupportedByImgdiff( 181 "/system/priv-app/Settings/Settings.apk")) 182 self.assertTrue( 183 BlockImageDiff.FileTypeSupportedByImgdiff( 184 "/system/framework/am.jar")) 185 self.assertTrue( 186 BlockImageDiff.FileTypeSupportedByImgdiff( 187 "/system/etc/security/otacerts.zip")) 188 189 self.assertFalse( 190 BlockImageDiff.FileTypeSupportedByImgdiff( 191 "/system/framework/arm/boot.oat")) 192 self.assertFalse( 193 BlockImageDiff.FileTypeSupportedByImgdiff( 194 "/system/priv-app/notanapk")) 195 196 def test_CanUseImgdiff(self): 197 block_image_diff = BlockImageDiff(EmptyImage(), EmptyImage()) 198 self.assertTrue( 199 block_image_diff.CanUseImgdiff( 200 "/system/app/app1.apk", RangeSet("10-15"), RangeSet("0-5"))) 201 self.assertTrue( 202 block_image_diff.CanUseImgdiff( 203 "/vendor/app/app2.apk", RangeSet("20 25"), RangeSet("30-31"), True)) 204 205 self.assertDictEqual( 206 { 207 ImgdiffStats.USED_IMGDIFF: {"/system/app/app1.apk"}, 208 ImgdiffStats.USED_IMGDIFF_LARGE_APK: {"/vendor/app/app2.apk"}, 209 }, 210 block_image_diff.imgdiff_stats.stats) 211 212 213 def test_CanUseImgdiff_ineligible(self): 214 # Disabled by caller. 215 block_image_diff = BlockImageDiff(EmptyImage(), EmptyImage(), 216 disable_imgdiff=True) 217 self.assertFalse( 218 block_image_diff.CanUseImgdiff( 219 "/system/app/app1.apk", RangeSet("10-15"), RangeSet("0-5"))) 220 221 # Unsupported file type. 222 block_image_diff = BlockImageDiff(EmptyImage(), EmptyImage()) 223 self.assertFalse( 224 block_image_diff.CanUseImgdiff( 225 "/system/bin/gzip", RangeSet("10-15"), RangeSet("0-5"))) 226 227 # At least one of the ranges is in non-monotonic order. 228 self.assertFalse( 229 block_image_diff.CanUseImgdiff( 230 "/system/app/app2.apk", RangeSet("10-15"), 231 RangeSet("15-20 30 10-14"))) 232 233 # At least one of the ranges is incomplete. 234 src_ranges = RangeSet("0-5") 235 src_ranges.extra['incomplete'] = True 236 self.assertFalse( 237 block_image_diff.CanUseImgdiff( 238 "/vendor/app/app4.apk", RangeSet("10-15"), src_ranges)) 239 240 # The stats are correctly logged. 241 self.assertDictEqual( 242 { 243 ImgdiffStats.SKIPPED_NONMONOTONIC: {'/system/app/app2.apk'}, 244 ImgdiffStats.SKIPPED_INCOMPLETE: {'/vendor/app/app4.apk'}, 245 }, 246 block_image_diff.imgdiff_stats.stats) 247 248 249 class ImgdiffStatsTest(ReleaseToolsTestCase): 250 251 def test_Log(self): 252 imgdiff_stats = ImgdiffStats() 253 imgdiff_stats.Log("/system/app/app2.apk", ImgdiffStats.USED_IMGDIFF) 254 self.assertDictEqual( 255 { 256 ImgdiffStats.USED_IMGDIFF: {'/system/app/app2.apk'}, 257 }, 258 imgdiff_stats.stats) 259 260 def test_Log_invalidInputs(self): 261 imgdiff_stats = ImgdiffStats() 262 263 self.assertRaises(AssertionError, imgdiff_stats.Log, "/system/bin/gzip", 264 ImgdiffStats.USED_IMGDIFF) 265 266 self.assertRaises(AssertionError, imgdiff_stats.Log, "/system/app/app1.apk", 267 "invalid reason") 268 269 270 class DataImageTest(ReleaseToolsTestCase): 271 def test_read_range_set(self): 272 data = "file" + ('\0' * 4092) 273 image = DataImage(data) 274 self.assertEqual(data, "".join(image.ReadRangeSet(image.care_map))) 275 276 277 class FileImageTest(ReleaseToolsTestCase): 278 def setUp(self): 279 self.file_path = common.MakeTempFile() 280 self.data = os.urandom(4096 * 4) 281 with open(self.file_path, 'w') as f: 282 f.write(self.data) 283 self.file = FileImage(self.file_path) 284 285 def test_totalsha1(self): 286 self.assertEqual(sha1(self.data).hexdigest(), self.file.TotalSha1()) 287 288 def test_ranges(self): 289 blocksize = self.file.blocksize 290 for s in range(4): 291 for e in range(s, 4): 292 expected_data = self.data[s * blocksize : e * blocksize] 293 294 rs = RangeSet([s, e]) 295 data = "".join(self.file.ReadRangeSet(rs)) 296 self.assertEqual(expected_data, data) 297 298 sha1sum = self.file.RangeSha1(rs) 299 self.assertEqual(sha1(expected_data).hexdigest(), sha1sum) 300 301 tmpfile = common.MakeTempFile() 302 with open(tmpfile, 'w') as f: 303 self.file.WriteRangeDataToFd(rs, f) 304 with open(tmpfile, 'r') as f: 305 self.assertEqual(expected_data, f.read()) 306 307 def test_read_all(self): 308 data = "".join(self.file.ReadRangeSet(self.file.care_map)) 309 self.assertEqual(self.data, data) 310
