Merge "releasetools: Add a common base class for unittests."

import os

import os.path

import unittest

import zipfile

import common

OPTIONS = common.OPTIONS

class AddImagesToTargetFilesTest(unittest.TestCase):

class AddImagesToTargetFilesTest(test_utils.ReleaseToolsTestCase):

  def setUp(self):

    OPTIONS.input_tmp = common.MakeTempDir()

  def tearDown(self):

    common.Cleanup()

  def _verifyCareMap(self, expected, file_name):

    """Parses the care_map.pb; and checks the content in plain text."""

    text_file = common.MakeTempFile(prefix="caremap-", suffix=".txt")

# limitations under the License.

#

from __future__ import print_function

import unittest

import common

from blockimgdiff import (BlockImageDiff, EmptyImage, HeapItem, ImgdiffStats,

                          Transfer)

from blockimgdiff import (

    BlockImageDiff, EmptyImage, HeapItem, ImgdiffStats, Transfer)

from rangelib import RangeSet

from test_utils import ReleaseToolsTestCase

class HealpItemTest(unittest.TestCase):

class HealpItemTest(ReleaseToolsTestCase):

  class Item(object):

    def __init__(self, score):

    self.assertFalse(item)

class BlockImageDiffTest(unittest.TestCase):

class BlockImageDiffTest(ReleaseToolsTestCase):

  def test_GenerateDigraphOrder(self):

    """Make sure GenerateDigraph preserves the order.

        block_image_diff.imgdiff_stats.stats)

class ImgdiffStatsTest(unittest.TestCase):

class ImgdiffStatsTest(ReleaseToolsTestCase):

  def test_Log(self):

    imgdiff_stats = ImgdiffStats()

import math

import os.path

import random

import unittest

import common

from build_image import (

    AVBCalcMinPartitionSize, BLOCK_SIZE, BuildImageError, CheckHeadroom,

    SetUpInDirAndFsConfig)

from test_utils import ReleaseToolsTestCase

class BuildImageTest(unittest.TestCase):

class BuildImageTest(ReleaseToolsTestCase):

  # Available: 1000 blocks.

  EXT4FS_OUTPUT = (

    self._image_sizes = [BLOCK_SIZE * random.randint(51200, 524288) + offset

                         for offset in range(BLOCK_SIZE)]

  def tearDown(self):

    common.Cleanup()

  def test_CheckHeadroom_SizeUnderLimit(self):

    # Required headroom: 1000 blocks.

    prop_dict = {

import subprocess

import tempfile

import time

import unittest

import zipfile

from hashlib import sha1

    yield '\0' * (step_size - block_size)

class CommonZipTest(unittest.TestCase):

class CommonZipTest(test_utils.ReleaseToolsTestCase):

  def _verify(self, zip_file, zip_file_name, arcname, expected_hash,

              test_file_name=None, expected_stat=None, expected_mode=0o644,

              expected_compress_type=zipfile.ZIP_STORED):

      os.remove(zip_file.name)

class CommonApkUtilsTest(unittest.TestCase):

class CommonApkUtilsTest(test_utils.ReleaseToolsTestCase):

  """Tests the APK utils related functions."""

  APKCERTS_TXT1 = (

  def setUp(self):

    self.testdata_dir = test_utils.get_testdata_dir()

  def tearDown(self):

    common.Cleanup()

  @staticmethod

  def _write_apkcerts_txt(apkcerts_txt, additional=None):

    if additional is None:

        {})

class CommonUtilsTest(unittest.TestCase):

class CommonUtilsTest(test_utils.ReleaseToolsTestCase):

  def setUp(self):

    self.testdata_dir = test_utils.get_testdata_dir()

  def tearDown(self):

    common.Cleanup()

  def test_GetSparseImage_emptyBlockMapFile(self):

    target_files = common.MakeTempFile(prefix='target_files-', suffix='.zip')

    with zipfile.ZipFile(target_files, 'w') as target_files_zip:

          AssertionError, common.LoadInfoDict, target_files_zip, True)

class InstallRecoveryScriptFormatTest(unittest.TestCase):

class InstallRecoveryScriptFormatTest(test_utils.ReleaseToolsTestCase):

  """Checks the format of install-recovery.sh.

  Its format should match between common.py and validate_target_files.py.

                             recovery_image, boot_image, self._info)

    validate_target_files.ValidateInstallRecoveryScript(self._tempdir,

                                                        self._info)

  def tearDown(self):

    common.Cleanup()

import copy

import os

import os.path

import unittest

import zipfile

import common

    self.script.append(('AssertSomeThumbprint',) + args)

class BuildInfoTest(unittest.TestCase):

class BuildInfoTest(test_utils.ReleaseToolsTestCase):

  TEST_INFO_DICT = {

      'build.prop' : {

        script_writer.script)

class LoadOemDictsTest(unittest.TestCase):

  def tearDown(self):

    common.Cleanup()

class LoadOemDictsTest(test_utils.ReleaseToolsTestCase):

  def test_NoneDict(self):

    self.assertIsNone(_LoadOemDicts(None))

      self.assertEqual('{}'.format(i), oem_dict['ro.build.index'])

class OtaFromTargetFilesTest(unittest.TestCase):

class OtaFromTargetFilesTest(test_utils.ReleaseToolsTestCase):

  TEST_TARGET_INFO_DICT = {

      'build.prop' : {

    common.OPTIONS.search_path = test_utils.get_search_path()

    self.assertIsNotNone(common.OPTIONS.search_path)

  def tearDown(self):

    common.Cleanup()

  def test_GetPackageMetadata_abOta_full(self):

    target_info_dict = copy.deepcopy(self.TEST_TARGET_INFO_DICT)

    target_info_dict['ab_update'] = 'true'

    )

class PropertyFilesTest(unittest.TestCase):

class PropertyFilesTest(test_utils.ReleaseToolsTestCase):

  def setUp(self):

    common.OPTIONS.no_signing = False

  def tearDown(self):

    common.Cleanup()

  @staticmethod

  def construct_zip_package(entries):

    zip_file = common.MakeTempFile(suffix='.zip')

      property_files.Verify(zip_fp, raw_metadata)

class PayloadSignerTest(unittest.TestCase):

class PayloadSignerTest(test_utils.ReleaseToolsTestCase):

  SIGFILE = 'sigfile.bin'

  SIGNED_SIGFILE = 'signed-sigfile.bin'

        common.OPTIONS.package_key : None,

    }

  def tearDown(self):

    common.Cleanup()

  def _assertFilesEqual(self, file1, file2):

    with open(file1, 'rb') as fp1, open(file2, 'rb') as fp2:

      self.assertEqual(fp1.read(), fp2.read())

    self._assertFilesEqual(verify_file, signed_file)

class PayloadTest(unittest.TestCase):

class PayloadTest(test_utils.ReleaseToolsTestCase):

  def setUp(self):

    self.testdata_dir = test_utils.get_testdata_dir()

        common.OPTIONS.package_key : None,

    }

  def tearDown(self):

    common.Cleanup()

  @staticmethod

  def _create_payload_full(secondary=False):

    target_file = construct_target_files(secondary)