tests/bootloader/bootloadertest.py

# 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.

import adb
import argparse
import os
import unittest
import fastboot
import subprocess
import sys

# Default values for arguments
device_type = "phone"

class ShellTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.fastboot = fastboot.FastbootDevice()

    def exists_validvals(self, varname, varlist, validlist):
        self.assertIn(varname, varlist)
        self.assertIn(varlist[varname], validlist)
        return varlist[varname]

    def exists_yes_no(self, varname, varlist):
        return self.exists_validvals(varname, varlist, ["yes", "no"])

    def exists_nonempty(self, varname, varlist):
        self.assertIn(varname, varlist)
        self.assertGreater(len(varlist[varname]), 0)
        return varlist[varname]

    def exists_integer(self, varname, varlist, base=10):
        val = 0
        self.assertIn(varname, varlist)
        try:
            val = int(varlist[varname], base)
        except ValueError:
            self.fail("%s (%s) is not an integer" % (varname, varlist[varname]))
        return val

    def get_exists(self, varname):
        val = self.fastboot.getvar(varname)
        self.assertIsNotNone(val)
        return val

    def get_exists_validvals(self, varname, validlist):
        val = self.get_exists(varname)
        self.assertIn(val, validlist)
        return val

    def get_exists_yes_no(self, varname):
        return self.get_exists_validvals(varname, ["yes", "no"])

    def get_exists_nonempty(self, varname):
        val = self.get_exists(varname)
        self.assertGreater(len(val), 0)
        return val

    def get_exists_integer(self, varname, base=10):
        val = self.get_exists(varname)
        try:
            num = int(val, base)
        except ValueError:
            self.fail("%s (%s) is not an integer" % (varname, val))
        return num

    def get_slotcount(self):
        slotcount = 0
        try:
            val = self.fastboot.getvar("slot-count")
            if val != None:
                slotcount = int(val)
        except ValueError:
            self.fail("slot-count (%s) is not an integer" % val)
        except subprocess.CalledProcessError:
            print "Does not appear to be an A/B device."
        if not slotcount:
            print "Does not appear to be an A/B device."
        return slotcount

    def test_getvarall(self):
        """Tests that required variables are reported by getvar all"""

        var_all = self.fastboot.getvar_all()
        self.exists_nonempty("version-baseband", var_all)
        self.exists_nonempty("version-bootloader", var_all)
        self.exists_nonempty("product", var_all)
        self.exists_yes_no("secure", var_all)
        self.exists_yes_no("unlocked", var_all)
        self.exists_validvals("off-mode-charge", var_all, ["0", "1"])
        self.assertIn("variant", var_all)
        voltage = self.exists_nonempty("battery-voltage", var_all)
        if voltage[-2:].lower() == "mv":
            voltage = voltage[:-2]
        try:
            voltnum = float(voltage)
        except ValueError:
            self.fail("battery-voltage (%s) is not a number" % (varname, voltage))
        self.exists_yes_no("battery-soc-ok", var_all)
        maxdl = self.exists_integer("max-download-size", var_all, 16)
        self.assertGreater(maxdl, 0)

        if "slot-count" in var_all:
            try:
                slotcount = int(var_all["slot-count"])
            except ValueError:
                self.fail("slot-count (%s) is not an integer" % var_all["slot-count"])
            if slotcount > 1:
                # test for A/B variables
                slots = [chr(slotnum+ord('a')) for slotnum in range(slotcount)]
                self.exists_validvals("current-slot", var_all, slots)

                # test for slot metadata
                for slot in slots:
                    self.exists_yes_no("slot-unbootable:"+slot, var_all)
                    self.exists_yes_no("slot-unbootable:"+slot, var_all)
                    self.exists_integer("slot-retry-count:"+slot, var_all)
            else:
                print "This does not appear to be an A/B device."

    def test_getvar_nonexistent(self):
        """Tests behaviour of nonexistent variables."""

        self.assertIsNone(self.fastboot.getvar("fhqwhgads"))

    def test_getvar(self):
        """Tests all variables separately"""

        self.get_exists_nonempty("version-baseband")
        self.get_exists_nonempty("version-bootloader")
        self.get_exists_nonempty("product")
        self.get_exists_yes_no("secure")
        self.get_exists_yes_no("unlocked")
        self.get_exists_validvals("off-mode-charge", ["0", "1"])
        self.get_exists("variant")
        voltage = self.get_exists_nonempty("battery-voltage")
        if voltage[-2:].lower() == "mv":
            voltage = voltage[:-2]
        try:
            voltnum = float(voltage)
        except ValueError:
            self.fail("battery-voltage (%s) is not a number" % voltage)
        self.get_exists_yes_no("battery-soc-ok")
        maxdl = self.get_exists_integer("max-download-size", 16)
        self.assertGreater(maxdl, 0)

        slotcount = self.get_slotcount()
        if slotcount  > 1:
            # test for A/B variables
            slots = [chr(slotnum+ord('a')) for slotnum in range(slotcount)]
            self.get_exists_validvals("current-slot", slots)

            # test for slot metadata
            for slot in slots:
                self.get_exists_yes_no("slot-unbootable:"+slot)
                self.get_exists_yes_no("slot-successful:"+slot)
                self.get_exists_integer("slot-retry-count:"+slot)

    def test_setactive(self):
        """Tests that A/B devices can switch to each slot, and the change persists over a reboot."""
        # Test invalid if not an A/B device
        slotcount = self.get_slotcount()
        if not slotcount:
            return

        maxtries = 0
        slots = [chr(slotnum+ord('a')) for slotnum in range(slotcount)]
        for slot in slots:
            self.fastboot.set_active(slot)
            self.assertEqual(slot, self.fastboot.getvar("current-slot"))
            self.assertEqual("no", self.fastboot.getvar("slot-unbootable:"+slot))
            self.assertEqual("no", self.fastboot.getvar("slot-successful:"+slot))
            retry = self.get_exists_integer("slot-retry-count:"+slot)
            if maxtries == 0:
                maxtries = retry
            else:
                self.assertEqual(maxtries, retry)
            self.fastboot.reboot(True)
            self.assertEqual(slot, self.fastboot.getvar("current-slot"))
            self.assertEqual("no", self.fastboot.getvar("slot-unbootable:"+slot))
            self.assertEqual("no", self.fastboot.getvar("slot-successful:"+slot))
            retry = self.get_exists_integer("slot-retry-count:"+slot)
            if maxtries == 0:
                maxtries = retry
            else:
                self.assertEqual(maxtries, retry)

    def test_hasslot(self):
        """Tests that A/B devices report partitions that have slots."""
        # Test invalid if not an A/B device
        if not self.get_slotcount():
            return

        self.assertEqual("yes", self.fastboot.getvar("has-slot:system"))
        self.assertEqual("yes", self.fastboot.getvar("has-slot:boot"))

        # Additional partition on AndroidThings (IoT) devices
        if device_type == "iot":
            self.assertEqual("yes", self.fastboot.getvar("has-slot:oem"))

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("--device-type", default="phone",
                        help="Type of device ('phone' or 'iot').")
    parser.add_argument("extra_args", nargs="*")
    args = parser.parse_args()

    if args.device_type.lower() not in ("phone", "iot"):
        raise ValueError("Unsupported device type '%s'." % args.device_type)
    device_type = args.device_type.lower()

    sys.argv[1:] = args.extra_args
    unittest.main(verbosity=3)