| #!/usr/bin/python |
| |
| # Copyright 2016, The Android Open Source Project |
| # |
| # Permission is hereby granted, free of charge, to any person |
| # obtaining a copy of this software and associated documentation |
| # files (the "Software"), to deal in the Software without |
| # restriction, including without limitation the rights to use, copy, |
| # modify, merge, publish, distribute, sublicense, and/or sell copies |
| # of the Software, and to permit persons to whom the Software is |
| # furnished to do so, subject to the following conditions: |
| # |
| # The above copyright notice and this permission notice shall be |
| # included in all copies or substantial portions of the Software. |
| # |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| # SOFTWARE. |
| |
| |
| """Unit-test for ImageHandler.""" |
| |
| |
| import imp |
| import os |
| import sys |
| import tempfile |
| import unittest |
| |
| sys.dont_write_bytecode = True |
| avbtool = imp.load_source('avbtool', './avbtool') |
| |
| # The file test_file.bin and test_file.bin.sparse are generated using |
| # the following python code: |
| # |
| # with open('test_file.bin', 'w+b') as f: |
| # f.write('Barfoo43'*128*12) |
| # os.system('img2simg test_file.bin test_file.bin.sparse') |
| # image = avbtool.ImageHandler('test_file.bin.sparse') |
| # image.append_dont_care(12*1024) |
| # image.append_fill('\x01\x02\x03\x04', 12*1024) |
| # image.append_raw('Foobar42'*128*12) |
| # image.append_dont_care(12*1024) |
| # del image |
| # os.system('rm -f test_file.bin') |
| # os.system('simg2img test_file.bin.sparse test_file.bin') |
| # |
| # and manually verified to be correct. The content of the raw and |
| # sparse files are as follows (the line with "Fill with 0x04030201" is |
| # a simg_dump.py bug): |
| # |
| # $ hexdump -C test_file.bin |
| # 00000000 42 61 72 66 6f 6f 34 33 42 61 72 66 6f 6f 34 33 |Barfoo43Barfoo43| |
| # * |
| # 00003000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| |
| # * |
| # 00006000 01 02 03 04 01 02 03 04 01 02 03 04 01 02 03 04 |................| |
| # * |
| # 00009000 46 6f 6f 62 61 72 34 32 46 6f 6f 62 61 72 34 32 |Foobar42Foobar42| |
| # * |
| # 0000c000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| |
| # * |
| # 0000f000 |
| # |
| # $ system/core/libsparse/simg_dump.py -v test_file.bin.sparse |
| # test_file.bin.sparse: Total of 15 4096-byte output blocks in 5 input chunks. |
| # input_bytes output_blocks |
| # chunk offset number offset number |
| # 1 40 12288 0 3 Raw data |
| # 2 12340 0 3 3 Don't care |
| # 3 12352 4 6 3 Fill with 0x04030201 |
| # 4 12368 12288 9 3 Raw data |
| # 5 24668 0 12 3 Don't care |
| # 24668 15 End |
| # |
| |
| |
| class ImageHandler(unittest.TestCase): |
| |
| TEST_FILE_SPARSE_PATH = 'test/data/test_file.bin.sparse' |
| TEST_FILE_PATH = 'test/data/test_file.bin' |
| TEST_FILE_SIZE = 61440 |
| TEST_FILE_BLOCK_SIZE = 4096 |
| |
| def _file_contents_equal(self, path1, path2, size): |
| f1 = open(path1, 'r') |
| f2 = open(path2, 'r') |
| if f1.read(size) != f2.read(size): |
| return False |
| return True |
| |
| def _file_size(self, f): |
| old_pos = f.tell() |
| f.seek(0, os.SEEK_END) |
| size = f.tell() |
| f.seek(old_pos) |
| return size |
| |
| def _clone_sparse_file(self): |
| f = tempfile.NamedTemporaryFile() |
| f.write(open(self.TEST_FILE_SPARSE_PATH).read()) |
| f.flush() |
| return f |
| |
| def _unsparsify(self, path): |
| f = tempfile.NamedTemporaryFile() |
| os.system('simg2img {} {}'.format(path, f.name)) |
| return f |
| |
| def testRead(self): |
| """Checks that reading from a sparse file works as intended.""" |
| ih = avbtool.ImageHandler(self.TEST_FILE_SPARSE_PATH) |
| |
| # Check that we start at offset 0. |
| self.assertEqual(ih.tell(), 0) |
| |
| # Check that reading advances the cursor. |
| self.assertEqual(ih.read(14), bytearray('Barfoo43Barfoo')) |
| self.assertEqual(ih.tell(), 14) |
| self.assertEqual(ih.read(2), bytearray('43')) |
| self.assertEqual(ih.tell(), 16) |
| |
| # Check reading in the middle of a fill chunk gets the right data. |
| ih.seek(0x6000 + 1) |
| self.assertEqual(ih.read(4), bytearray('\x02\x03\x04\x01')) |
| |
| # Check we can cross the chunk boundary correctly. |
| ih.seek(0x3000 - 10) |
| self.assertEqual(ih.read(12), bytearray('43Barfoo43\x00\x00')) |
| ih.seek(0x9000 - 3) |
| self.assertEqual(ih.read(5), bytearray('\x02\x03\x04Fo')) |
| |
| # Check reading at end of file is a partial read. |
| ih.seek(0xf000 - 2) |
| self.assertEqual(ih.read(16), bytearray('\x00\x00')) |
| |
| def testTruncate(self): |
| """Checks that we can truncate a sparse file correctly.""" |
| # Check truncation at all possible boundaries (including start and end). |
| for size in range(0, self.TEST_FILE_SIZE + self.TEST_FILE_BLOCK_SIZE, |
| self.TEST_FILE_BLOCK_SIZE): |
| sparse_file = self._clone_sparse_file() |
| ih = avbtool.ImageHandler(sparse_file.name) |
| ih.truncate(size) |
| unsparse_file = self._unsparsify(sparse_file.name) |
| self.assertEqual(self._file_size(unsparse_file), size) |
| self.assertTrue(self._file_contents_equal(unsparse_file.name, |
| self.TEST_FILE_PATH, |
| size)) |
| |
| # Check truncation to grow the file. |
| grow_size = 8192 |
| sparse_file = self._clone_sparse_file() |
| ih = avbtool.ImageHandler(sparse_file.name) |
| ih.truncate(self.TEST_FILE_SIZE + grow_size) |
| unsparse_file = self._unsparsify(sparse_file.name) |
| self.assertEqual(self._file_size(unsparse_file), |
| self.TEST_FILE_SIZE + grow_size) |
| self.assertTrue(self._file_contents_equal(unsparse_file.name, |
| self.TEST_FILE_PATH, |
| self.TEST_FILE_SIZE)) |
| unsparse_file.seek(self.TEST_FILE_SIZE) |
| self.assertEqual(unsparse_file.read(), '\0'*grow_size) |
| |
| def testAppendRaw(self): |
| """Checks that we can append raw data correctly.""" |
| sparse_file = self._clone_sparse_file() |
| ih = avbtool.ImageHandler(sparse_file.name) |
| data = 'SomeData'*4096 |
| ih.append_raw(data) |
| unsparse_file = self._unsparsify(sparse_file.name) |
| self.assertTrue(self._file_contents_equal(unsparse_file.name, |
| self.TEST_FILE_PATH, |
| self.TEST_FILE_SIZE)) |
| unsparse_file.seek(self.TEST_FILE_SIZE) |
| self.assertEqual(unsparse_file.read(), data) |
| |
| def testAppendFill(self): |
| """Checks that we can append fill data correctly.""" |
| sparse_file = self._clone_sparse_file() |
| ih = avbtool.ImageHandler(sparse_file.name) |
| data = 'ABCD'*4096 |
| ih.append_fill('ABCD', len(data)) |
| unsparse_file = self._unsparsify(sparse_file.name) |
| self.assertTrue(self._file_contents_equal(unsparse_file.name, |
| self.TEST_FILE_PATH, |
| self.TEST_FILE_SIZE)) |
| unsparse_file.seek(self.TEST_FILE_SIZE) |
| self.assertEqual(unsparse_file.read(), data) |
| |
| def testDontCare(self): |
| """Checks that we can append DONT_CARE data correctly.""" |
| sparse_file = self._clone_sparse_file() |
| ih = avbtool.ImageHandler(sparse_file.name) |
| data = '\0'*40960 |
| ih.append_dont_care(len(data)) |
| unsparse_file = self._unsparsify(sparse_file.name) |
| self.assertTrue(self._file_contents_equal(unsparse_file.name, |
| self.TEST_FILE_PATH, |
| self.TEST_FILE_SIZE)) |
| unsparse_file.seek(self.TEST_FILE_SIZE) |
| self.assertEqual(unsparse_file.read(), data) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
