#!/usr/bin/python
# Copyright 2014 Google Inc. All Rights Reserved.
#
# 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.

"""Tests for ginstall.py."""

__author__ = 'dgentry@google.com (Denton Gentry)'

import os
import shutil
import StringIO
import struct
import sys
import tempfile
import unittest
import ginstall


class FakeImgWManifest(object):

  def __init__(self, manifest):
    self.manifest = ginstall.ParseManifest(manifest)

  def ManifestVersion(self):
    return int(self.manifest['installer_version'])


class GinstallTest(unittest.TestCase):

  def setUp(self):
    self.tmpdir = tempfile.mkdtemp()
    self.hnvram_dir = self.tmpdir + '/hnvram'
    self.script_out = self.tmpdir + '/out'
    self.old_path = os.environ['PATH']
    self.old_bufsize = ginstall.BUFSIZE
    self.old_files = ginstall.F
    os.environ['GINSTALL_HNVRAM_DIR'] = self.hnvram_dir
    os.environ['GINSTALL_OUT_FILE'] = self.script_out
    os.environ['GINSTALL_TEST_FAIL'] = ''
    os.environ['PATH'] = 'testdata/bin:' + self.old_path
    os.makedirs(self.hnvram_dir)
    os.makedirs(self.tmpdir + '/dev')
    ginstall.F['ETCPLATFORM'] = 'testdata/etc/platform'
    ginstall.F['DEV'] = self.tmpdir + '/dev'
    ginstall.F['MMCBLK'] = self.tmpdir + '/dev/mmcblk0'
    ginstall.F['MTD_PREFIX'] = self.tmpdir + '/dev/mtd'
    ginstall.F['PROC_MTD'] = 'testdata/proc/mtd.GFHD100'
    ginstall.F['SECUREBOOT'] = 'testdata/tmp/gpio/ledcontrol/secure_boot'
    ginstall.F['SGDISK'] = 'testdata/bin/sgdisk'
    ginstall.F['SIGNINGKEY'] = 'testdata/signing_key.der'
    ginstall.F['SYSBLOCK'] = self.tmpdir + '/sys/block'
    os.makedirs(ginstall.F['SYSBLOCK'])
    ginstall.F['SYSCLASSMTD'] = 'testdata/sys/class/mtd'
    for i in range(0, 10):
      open(ginstall.F['MTD_PREFIX'] + str(i), 'w').write('1')

    os.mkdir(self.tmpdir + '/mmcblk0boot0')
    os.mkdir(self.tmpdir + '/mmcblk0boot1')
    ginstall.MMC_RO_LOCK['MMCBLK0BOOT0'] = (
        self.tmpdir + '/mmcblk0boot0/force_ro')
    ginstall.MMC_RO_LOCK['MMCBLK0BOOT1'] = (
        self.tmpdir + '/mmcblk0boot1/force_ro')
    ginstall.PROGRESS_EXPORT_PATH = os.path.join(self.tmpdir, 'ginstall')

    # default OS to 'fiberos'
    self.WriteOsFile('fiberos')

  def tearDown(self):
    os.environ['PATH'] = self.old_path
    shutil.rmtree(self.tmpdir, ignore_errors=True)
    ginstall.F = self.old_files

  def WriteVersionFile(self, version):
    """Create a fake /etc/version file in /tmp."""
    filename = self.tmpdir + '/version'
    open(filename, 'w').write(version)
    ginstall.F['ETCVERSION'] = filename

  def WriteOsFile(self, os_name):
    """Create a fake /etc/os file in /tmp."""
    filename = self.tmpdir + '/os'
    open(filename, 'w').write(os_name)
    ginstall.F['ETCOS'] = filename

  def WriteHnvramAttr(self, attr, val):
    filename = self.hnvram_dir + '/%s' % attr
    open(filename, 'w').write(val)

  def ReadHnvramAttr(self, attr):
    filename = self.hnvram_dir + '/%s' % attr
    try:
      return open(filename).read()
    except IOError:
      return None

  def testVerify(self):
    self.assertTrue(ginstall.Verify(
        open('testdata/img/loader.bin'),
        open('testdata/img/loader.sig'),
        open('testdata/etc/google_public.der')))

  def testVerifyFailure(self):
    self.assertFalse(ginstall.Verify(
        open('testdata/img/loader.bin'),
        open('testdata/img/loader_bad.sig'),
        open('testdata/etc/google_public.der')))

  def testIsIdenticalAndProgressBar(self):
    ginstall.BUFSIZE = 1
    ginstall.ProgressBar.DOTSIZE = 1
    loader = 'testdata/img/loader.bin'
    loader1 = 'testdata/img/loader1.bin'
    self.assertTrue(ginstall.IsIdentical(
        'testloader', open(loader), open(loader)))
    self.assertFalse(ginstall.IsIdentical(
        'testloader', open(loader), open(loader1)))

    # Test exported progress bar.
    success_line = '.' * (len(open(loader).read()) - 1) + '\n'
    failure_line = ''
    for a, b in zip(open(loader).read(), open(loader1).read()):
      if a != b:
        break
      failure_line += '.'
    progress_file = open(
        os.path.join(ginstall.PROGRESS_EXPORT_PATH, 'progress')).read()
    self.assertEqual(progress_file, success_line + failure_line)

  def testVerifyAndIsIdentical(self):
    loader = open('testdata/img/loader.bin')
    self.assertTrue(ginstall.Verify(
        loader,
        open('testdata/img/loader.sig'),
        open('testdata/etc/google_public.der')))
    self.assertRaises(IOError, ginstall.IsIdentical,
                      'loader', loader, open('testdata/img/loader.bin'))
    loader.seek(0)
    self.assertTrue(ginstall.IsIdentical(
        'loader', loader, open('testdata/img/loader.bin')))
    loader.seek(0)
    self.assertFalse(ginstall.IsIdentical(
        'loader', loader, open('testdata/img/loader1.bin')))

  def testIsMtdNand(self):
    mtd = ginstall.F['MTD_PREFIX']
    self.assertFalse(ginstall.IsMtdNand(mtd + '6'))
    self.assertTrue(ginstall.IsMtdNand(mtd + '7'))

  def testInstallToMtdNandFails(self):
    # A nanddump that writes incorrect data to stdout
    ginstall.NANDDUMP = 'testdata/bin/nanddump.wrong'
    in_f = StringIO.StringIO('Testing123')
    mtdfile = self.tmpdir + '/mtd'
    self.assertRaises(IOError, ginstall.InstallToMtd, in_f, mtdfile)

  def testWriteMtd(self):
    origfile = open('testdata/random', 'r')
    origsize = os.fstat(origfile.fileno())[6]

    ginstall.BUFSIZE = 1024

    mtd = ginstall.F['MTD_PREFIX']
    open(mtd + '4', 'w').close()
    writesize = ginstall.InstallToMtd(origfile, mtd + '4')
    self.assertEqual(writesize, origsize)

    # check that data was written to MTDBLOCK
    origfile.seek(0, os.SEEK_SET)
    self.assertEqual(origfile.read(), open(mtd + '4').read())

  def testWriteMtdEraseException(self):
    origfile = open('testdata/random', 'r')
    self.assertRaises(IOError, ginstall.InstallToMtd, origfile, '/dev/mtd0')

  def testWriteMtdVerifyException(self):
    origfile = open('testdata/random', 'r')
    ginstall.MTDBLOCK = '/dev/zero'
    # verify should fail, destfile will read back zero.
    self.assertRaises(IOError, ginstall.InstallToMtd, origfile, '/dev/mtd4')

  def testWriteUbiException(self):
    os.environ['GINSTALL_TEST_FAIL'] = 'fail'
    os.system('ubiformat')
    origfile = open('testdata/random', 'r')
    self.assertRaises(IOError, ginstall.InstallRawFileToUbi,
                      origfile, 'mtd0.tmp')

  def testSetBootPartition(self):
    self.WriteOsFile('fiberos')
    ginstall.SetBootPartition('fiberos', 0)
    self.assertEqual('kernel0', self.ReadHnvramAttr('ACTIVATED_KERNEL_NAME'))
    ginstall.SetBootPartition('fiberos', 1)
    self.assertEqual('kernel1', self.ReadHnvramAttr('ACTIVATED_KERNEL_NAME'))
    ginstall.SetBootPartition('android', 0)
    self.assertEqual('a', self.ReadHnvramAttr('ANDROID_ACTIVE_PARTITION'))
    self.assertEqual('android', self.ReadHnvramAttr('BOOT_TARGET'))
    ginstall.SetBootPartition('android', 1)
    self.assertEqual('b', self.ReadHnvramAttr('ANDROID_ACTIVE_PARTITION'))
    self.assertEqual('android', self.ReadHnvramAttr('BOOT_TARGET'))

    self.WriteOsFile('android')
    ginstall.SetBootPartition('fiberos', 0)
    self.assertEqual('kernel0', self.ReadHnvramAttr('ACTIVATED_KERNEL_NAME'))
    self.assertEqual('fiberos', self.ReadHnvramAttr('BOOT_TARGET'))
    ginstall.SetBootPartition('fiberos', 1)
    self.assertEqual('kernel1', self.ReadHnvramAttr('ACTIVATED_KERNEL_NAME'))
    self.assertEqual('fiberos', self.ReadHnvramAttr('BOOT_TARGET'))
    ginstall.SetBootPartition('android', 0)
    self.assertEqual('a', self.ReadHnvramAttr('ANDROID_ACTIVE_PARTITION'))
    ginstall.SetBootPartition('android', 1)
    self.assertEqual('b', self.ReadHnvramAttr('ANDROID_ACTIVE_PARTITION'))

    # also verify the hnvram command history for good measures
    out = open(self.script_out).read().splitlines()
    self.assertEqual(out[0], 'hnvram -q -w ACTIVATED_KERNEL_NAME=kernel0')
    self.assertEqual(out[1], 'hnvram -q -w ACTIVATED_KERNEL_NAME=kernel1')
    self.assertEqual(out[2], 'hnvram -q -w ANDROID_ACTIVE_PARTITION=a')
    self.assertEqual(out[3], 'hnvram -q -w BOOT_TARGET=android')
    self.assertEqual(out[4], 'hnvram -q -w ANDROID_ACTIVE_PARTITION=b')
    self.assertEqual(out[5], 'hnvram -q -w BOOT_TARGET=android')
    self.assertEqual(out[6], 'hnvram -q -w ACTIVATED_KERNEL_NAME=kernel0')
    self.assertEqual(out[7], 'hnvram -q -w BOOT_TARGET=fiberos')
    self.assertEqual(out[8], 'hnvram -q -w ACTIVATED_KERNEL_NAME=kernel1')
    self.assertEqual(out[9], 'hnvram -q -w BOOT_TARGET=fiberos')
    self.assertEqual(out[10], 'hnvram -q -w ANDROID_ACTIVE_PARTITION=a')
    self.assertEqual(out[11], 'hnvram -q -w ANDROID_ACTIVE_PARTITION=b')

  def testParseManifest(self):
    l = ('installer_version: 99\nimage_type: fake\n'
         'platforms: [ GFHD100, GFMS100 ]\n')
    in_f = StringIO.StringIO(l)
    actual = ginstall.ParseManifest(in_f)
    expected = {'installer_version': '99', 'image_type': 'fake',
                'platforms': ['GFHD100', 'GFMS100']}
    self.assertEqual(actual, expected)
    l = 'installer_version: 99\nimage_type: fake\nplatforms: GFHD007\n'
    in_f = StringIO.StringIO(l)
    actual = ginstall.ParseManifest(in_f)
    expected = {'installer_version': '99', 'image_type': 'fake',
                'platforms': 'GFHD007'}
    self.assertEqual(actual, expected)

  def testGetKey(self):
    key = ginstall.GetKey()
    self.assertEqual(key, 'This is a signing key.\n')

  def testPlatformRoutines(self):
    self.assertEqual(ginstall.GetPlatform(), 'GFUNITTEST')
    in_f = StringIO.StringIO('platforms: [ GFUNITTEST, GFFOOBAR ]\n')
    manifest = ginstall.ParseManifest(in_f)
    self.assertTrue(ginstall.CheckPlatform(manifest))

  def testGetOs(self):
    self.WriteOsFile('fiberos')
    self.assertEqual('fiberos', ginstall.GetOs())
    self.WriteOsFile('android')
    self.assertEqual('android', ginstall.GetOs())
    # in case file doesn't exist, default is 'fiberos'
    os.remove(self.tmpdir + '/os')
    self.assertEqual('fiberos', ginstall.GetOs())

  def testGetMtdPrefix(self):
    self.WriteOsFile('fiberos')
    self.assertEqual(ginstall.F['MTD_PREFIX'], ginstall.GetMtdPrefix())
    self.WriteOsFile('android')
    self.assertEqual(ginstall.F['MTD_PREFIX-ANDROID'], ginstall.GetMtdPrefix())
    # unknown OS returns 'fiberos'
    self.WriteOsFile('windows')
    self.assertEqual(ginstall.F['MTD_PREFIX'], ginstall.GetMtdPrefix())

  def testGetMmcblk0Prefix(self):
    self.WriteOsFile('fiberos')
    self.assertEqual(ginstall.F['MMCBLK0'], ginstall.GetMmcblk0Prefix())
    self.WriteOsFile('android')
    self.assertEqual(ginstall.F['MMCBLK0-ANDROID'],
                     ginstall.GetMmcblk0Prefix())
    # unknown OS returns 'fiberos'
    self.WriteOsFile('windows')
    self.assertEqual(ginstall.F['MMCBLK0'], ginstall.GetMmcblk0Prefix())

  def testGetInternalHarddisk(self):
    self.assertEqual(ginstall.GetInternalHarddisk(), None)

    os.mkdir(ginstall.F['SYSBLOCK'] + '/sda')
    os.symlink(ginstall.F['SYSBLOCK'] + '/sda/usb_disk',
               ginstall.F['SYSBLOCK'] + '/sda/device')
    os.mkdir(ginstall.F['SYSBLOCK'] + '/sdc')
    os.symlink(ginstall.F['SYSBLOCK'] + '/sdc/sata_disk',
               ginstall.F['SYSBLOCK'] + '/sdc/device')
    expected = ginstall.F['DEV'] + '/sdc'
    self.assertEqual(ginstall.GetInternalHarddisk(), expected)

    os.mkdir(ginstall.F['SYSBLOCK'] + '/sdb')
    expected = ginstall.F['DEV'] + '/sdb'
    self.assertEqual(ginstall.GetInternalHarddisk(), expected)

  def MakeImgWManifestVersion(self, version):
    in_f = StringIO.StringIO('installer_version: %s\n' % version)
    return FakeImgWManifest(in_f)

  def testCheckManifestVersion(self):
    manifest = {}
    for v in ['2', '3', '4']:
      manifest['installer_version'] = v
      self.assertTrue(ginstall.CheckManifestVersion(manifest))
    for v in ['1', '5']:
      manifest['installer_version'] = v
      self.assertRaises(ginstall.Fatal, ginstall.CheckManifestVersion, manifest)
    for v in ['3junk']:
      manifest['installer_version'] = v
      self.assertRaises(ValueError, ginstall.CheckManifestVersion, manifest)

  def MakeManifestWMinimumVersion(self, version):
    in_f = StringIO.StringIO('minimum_version: %s\n' % version)
    return ginstall.ParseManifest(in_f)

  def testCheckMinimumVersion(self):
    self.WriteVersionFile('gftv200-38.10')
    for v in [
        'gftv200-38.5',
        'gftv200-38-pre2-58-g72b3037-da',
        'gftv200-38-pre2']:
      manifest = self.MakeManifestWMinimumVersion(v)
      self.assertTrue(ginstall.CheckMinimumVersion(manifest))
    for v in [
        'gftv200-39-pre0-58-g72b3037-da',
        'gftv200-39-pre0',
        'gftv200-39-pre1-58-g72b3037-da',
        'gftv200-39-pre1',
        'gftv200-38.11',
        ]:
      manifest = self.MakeManifestWMinimumVersion(v)
      self.assertRaises(ginstall.Fatal, ginstall.CheckMinimumVersion,
                        manifest)
    manifest = self.MakeManifestWMinimumVersion('junk')
    self.assertRaises(ginstall.Fatal, ginstall.CheckMinimumVersion,
                      manifest)

  def testCheckMisc(self):
    ginstall.F['ETCPLATFORM'] = 'testdata/etc/platform.GFHD200'

    for v in [
        'gftv200-38.11',
        'gftv200-39-pre2-58-g72b3037-da',
        'gftv200-39-pre2']:
      manifest = {'version': v}
      ginstall.CheckMisc(manifest)  # checking that it does not raise exception

    for v in [
        'gftv200-39-pre0-58-g72b3037-da',
        'gftv200-39-pre0',
        'gftv200-39-pre1-58-g72b3037-da',
        'gftv200-39-pre1',
        'gftv200-38.9',
        'gftv200-38.10'
        ]:
      manifest = {'version': v}
      self.assertRaises(ginstall.Fatal, ginstall.CheckMisc, manifest)

  def MakeManifestWithFilenameSha1s(self, filename):
    m = ('installer_version: 4\n'
         'image_type: unlocked\n'
         'version: gftv254-48-pre2-1100-g25ff8d0-ck\n'
         'platforms: [ GFHD254 ]\n')
    if filename is not None:
      m += '%s-sha1: 9b5236c282b8c11b38a630361b6c690d6aaa50cb\n' % filename

    in_f = StringIO.StringIO(m)
    return ginstall.ParseManifest(in_f)

  def testGetOsFromManifest(self):
    # android specific image names return 'android'
    for img in ginstall.ANDROID_IMAGES:
      manifest = self.MakeManifestWithFilenameSha1s(img)
      self.assertEqual('android', ginstall.GetOsFromManifest(manifest))

    # fiberos image names or anything non-android returns 'fiberos'
    for img in ['rootfs.img', 'kernel.img', 'whatever.img']:
      manifest = self.MakeManifestWithFilenameSha1s(img)
      self.assertEqual('fiberos', ginstall.GetOsFromManifest(manifest))

    # no sha1 entry in the manifest returns 'fiberos'
    manifest = self.MakeManifestWithFilenameSha1s(None)
    self.assertEqual('fiberos', ginstall.GetOsFromManifest(manifest))

  def testGetBootedPartition(self):
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.none'
    self.assertEqual(None, ginstall.GetBootedPartition())
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.0'
    self.assertEqual(0, ginstall.GetBootedPartition())
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.1'
    self.assertEqual(1, ginstall.GetBootedPartition())

    # Android
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.android.none'
    self.assertEqual(None, ginstall.GetBootedPartition())
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.android.0'
    self.assertEqual(0, ginstall.GetBootedPartition())
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.android.1'
    self.assertEqual(1, ginstall.GetBootedPartition())

    # Prowl
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.prowl.none'
    self.assertEqual(ginstall.GetBootedPartition(), None)
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.prowl.0'
    self.assertEqual(ginstall.GetBootedPartition(), 0)
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.prowl.1'
    self.assertEqual(ginstall.GetBootedPartition(), 1)

  def testGetActivePartitionFromHNVRAM(self):
    # FiberOS looks at ACTIVATED_KERNEL_NAME, not ANDROID_ACTIVE_PARTITION
    # 0
    self.WriteHnvramAttr('ACTIVATED_KERNEL_NAME', '0')
    self.assertEqual(0, ginstall.GetActivePartitionFromHNVRAM('fiberos'))
    self.WriteHnvramAttr('ANDROID_ACTIVE_PARTITION', '0')
    self.assertEqual(0, ginstall.GetActivePartitionFromHNVRAM('fiberos'))
    self.WriteHnvramAttr('ANDROID_ACTIVE_PARTITION', '1')
    self.assertEqual(0, ginstall.GetActivePartitionFromHNVRAM('fiberos'))
    # 1
    self.WriteHnvramAttr('ACTIVATED_KERNEL_NAME', '1')
    self.assertEqual(1, ginstall.GetActivePartitionFromHNVRAM('fiberos'))
    self.WriteHnvramAttr('ANDROID_ACTIVE_PARTITION', '0')
    self.assertEqual(1, ginstall.GetActivePartitionFromHNVRAM('fiberos'))

    # Android looks at ANDROID_ACTIVE_PARTITION, not ACTIVATED_KERNEL_NAME
    # 0
    self.WriteHnvramAttr('ANDROID_ACTIVE_PARTITION', '0')
    self.assertEqual(0, ginstall.GetActivePartitionFromHNVRAM('android'))
    self.WriteHnvramAttr('ACTIVATED_KERNEL_NAME', '0')
    self.assertEqual(0, ginstall.GetActivePartitionFromHNVRAM('android'))
    self.WriteHnvramAttr('ACTIVATED_KERNEL_NAME', '1')
    self.assertEqual(0, ginstall.GetActivePartitionFromHNVRAM('android'))
    # 1
    self.WriteHnvramAttr('ANDROID_ACTIVE_PARTITION', '1')
    self.assertEqual(1, ginstall.GetActivePartitionFromHNVRAM('android'))
    self.WriteHnvramAttr('ACTIVATED_KERNEL_NAME', '0')
    self.assertEqual(1, ginstall.GetActivePartitionFromHNVRAM('android'))

  def TestGetPartition(self):
    self.assertEqual(0, ginstall.GetPartition('primary', 'fiberos'))
    self.assertEqual(0, ginstall.GetPartition(0, 'fiberos'))
    self.assertEqual(1, ginstall.GetPartition('secondary', 'fiberos'))
    self.assertEqual(1, ginstall.GetPartition(1, 'fiberos'))
    self.assertEqual(0, ginstall.GetPartition('primary', 'android'))
    self.assertEqual(0, ginstall.GetPartition(0, 'android'))
    self.assertEqual(1, ginstall.GetPartition('secondary', 'android'))
    self.assertEqual(1, ginstall.GetPartition(1, 'android'))

    # other: FiberOS->FiberOS
    self.WriteOsFile('fiberos')
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.none'
    self.assertEqual(1, ginstall.GetPartition('other', 'fiberos'))
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.0'
    self.assertEqual(1, ginstall.GetPartition('other', 'fiberos'))
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.1'
    self.assertEqual(0, ginstall.GetPartition('other', 'fiberos'))
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.prowl.none'
    self.assertEqual(1, ginstall.GetPartition('other', 'fiberos'))
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.prowl.0'
    self.assertEqual(1, ginstall.GetPartition('other', 'fiberos'))
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.prowl.1'
    self.assertEqual(0, ginstall.GetPartition('other', 'fiberos'))

    # other: FiberOS->Android
    self.WriteHnvramAttr('ANDROID_ACTIVE_PARTITION', 'a')
    self.assertEqual(1, ginstall.GetPartition('other', 'android'))
    self.WriteHnvramAttr('ANDROID_ACTIVE_PARTITION', 'b')
    self.assertEqual(0, ginstall.GetPartition('other', 'android'))
    self.WriteHnvramAttr('ANDROID_ACTIVE_PARTITION', 'bla')
    self.assertEqual(1, ginstall.GetPartition('other', 'android'))

    # other: Android->FiberOS
    self.WriteOsFile('android')
    self.WriteHnvramAttr('ACTIVATED_KERNEL_NAME', '0')
    self.assertEqual(1, ginstall.GetPartition('other', 'fiberos'))
    self.WriteHnvramAttr('ACTIVATED_KERNEL_NAME', '1')
    self.assertEqual(0, ginstall.GetPartition('other', 'fiberos'))
    self.WriteHnvramAttr('ACTIVATED_KERNEL_NAME', 'bla')
    self.assertEqual(1, ginstall.GetPartition('other', 'fiberos'))

    # other: Android->Android
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.android.none'
    self.assertEqual(1, ginstall.GetPartition('other', 'android'))
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.android.0'
    self.assertEqual(1, ginstall.GetPartition('other', 'android'))
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.android.1'
    self.assertEqual(0, ginstall.GetPartition('other', 'android'))

    # Test prowl and gfactive
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.prowl.none'
    self.assertEqual(ginstall.GetBootedPartition(), None)
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.prowl.0'
    self.assertEqual(ginstall.GetBootedPartition(), 0)
    ginstall.F['PROC_CMDLINE'] = 'testdata/proc/cmdline.prowl.1'
    self.assertEqual(ginstall.GetBootedPartition(), 1)

  def testUloaderSigned(self):
    magic_num = 0xDEADBEEF
    timestamp = 0x5627148C
    crc = 0x12345678
    key_len = 0x00000000
    signed_key_type = 0x00000002
    unsigned_key_type = 0x00000000
    image_len = 0x0000A344

    signed_uloader, _ = self._CreateUloader(
        magic_num, timestamp, crc, key_len, signed_key_type, image_len)

    self.assertTrue(ginstall.UloaderSigned(signed_uloader))
    self.assertEqual(signed_uloader.tell(), 0)

    unsigned_uloader, _ = self._CreateUloader(
        magic_num, timestamp, crc, key_len, unsigned_key_type, image_len)

    self.assertFalse(ginstall.UloaderSigned(unsigned_uloader))
    self.assertEqual(unsigned_uloader.tell(), 0)

  def testStripUloader(self):
    magic_num = 0xDEADBEEF
    timestamp = 0x5627148C
    crc = 0x12345678
    key_len = 0x00000000
    key_type = 0x00000002
    image_len = 0x0000A344

    signed_uloader, uloader_data = self._CreateUloader(
        magic_num, timestamp, crc, key_len, key_type, image_len)

    stripped_uloader, _ = ginstall.StripUloader(signed_uloader, 0)
    stripped_uloader_bytes = stripped_uloader.read()

    header = struct.unpack('<IIIIII', stripped_uloader_bytes[:24])
    self.assertEqual(header[0], magic_num)
    self.assertEqual(header[1], timestamp)
    self.assertEqual(header[3], key_len)
    self.assertEqual(header[4], 0)  # key type should have been set to 0
    self.assertEqual(header[5], image_len)

    self.assertEqual(stripped_uloader_bytes[24:56], '\x00' * 32)

    self.assertEqual(stripped_uloader_bytes[56:], uloader_data)

  def testLockUnlockMmcBoot(self):
    ginstall.UnlockMMC('MMCBLK0BOOT0')
    ginstall.UnlockMMC('MMCBLK0BOOT1')
    self.assertEqual(open(ginstall.MMC_RO_LOCK['MMCBLK0BOOT0']).read(), '0')
    self.assertEqual(open(ginstall.MMC_RO_LOCK['MMCBLK0BOOT1']).read(), '0')

    ginstall.LockMMC('MMCBLK0BOOT0')
    self.assertEqual(open(ginstall.MMC_RO_LOCK['MMCBLK0BOOT0']).read(), '1')
    self.assertEqual(open(ginstall.MMC_RO_LOCK['MMCBLK0BOOT1']).read(), '0')

    ginstall.LockMMC('MMCBLK0BOOT1')
    self.assertEqual(open(ginstall.MMC_RO_LOCK['MMCBLK0BOOT1']).read(), '1')
    self.assertEqual(open(ginstall.MMC_RO_LOCK['MMCBLK0BOOT0']).read(), '1')

  def _CreateUloader(self, magic_num, time, crc, key_len, key_type, image_len):
    """Helper method that creates a memory-backed uloader file."""

    uloader_data = os.urandom(image_len)
    if key_type == 0:
      # Unsigned; 32 bytes of padding.
      extra = '\x00' * 32
    elif key_type == 2:
      # Signed; a 256 byte signature.
      extra = os.urandom(256)
    else:
      raise ValueError('Key type must be 0 (unsigned) or 2 (signed)')

    uloader = StringIO.StringIO()
    uloader.write(struct.pack(
        '<IIIIII', magic_num, time, crc, key_len, key_type, image_len))
    uloader.write(extra)
    uloader.write(uloader_data)
    uloader.seek(0)

    return uloader, uloader_data

  def testGetMemTotal(self):
    ginstall.F['MEMINFO'] = 'testdata/proc/meminfo1'
    total = ginstall.GetMemTotal()
    self.assertTrue(total > 4*1e9)
    ginstall.F['MEMINFO'] = 'testdata/proc/meminfo2'
    total = ginstall.GetMemTotal()
    self.assertTrue(total < 4*1e9)

  def testOpenPathOrUrl(self):
    # URL
    two_oh_four = ginstall.OpenPathOrUrl('http://www.gstatic.com/generate_204')
    self.assertEqual(204, two_oh_four.getcode())

    # on-disk file
    on_disk_file = tempfile.NamedTemporaryFile()
    testdata = os.urandom(16)
    on_disk_file.write(testdata)
    on_disk_file.flush()
    self.assertEqual(ginstall.OpenPathOrUrl(on_disk_file.name).read(), testdata)

    # stdin (-)
    self.assertEqual(ginstall.OpenPathOrUrl('-'), sys.stdin)


if __name__ == '__main__':
  unittest.main()