Beispiel #1
0
    def do(self):
        # Turn off the device
        power_off_device(serial=self.serial,
                         except_charging=True,
                         **self.kwargs)()

        # Power on the device
        power_on_device(serial=self.serial, **self.kwargs)()

        # Press volume down
        self.relay.relay.on(self.relay.v_down_port)

        # Wait for UI processes
        adb_steps.wait_for_ui_processes(serial=self.serial)()

        # Release volume down button
        self.relay.relay.off(self.relay.v_down_port)
Beispiel #2
0
 def check_condition(self):
     wait_time = 0
     while self.serial not in local_utils.get_connected_android_devices()['android'] and\
           wait_time < self.timeout:
         time.sleep(2)
         wait_time += 2
     if self.wait_ui:
         return adb_steps.wait_for_ui_processes(serial=self.serial)()
     return self.serial in local_utils.get_connected_android_devices(
     )['android']
Beispiel #3
0
        local_steps.wait_for_cos(serial=serial)()

# disconnect adb
relay_steps.connect_disconnect_usb(serial=serial,
                                   relay_type=relay_type,
                                   relay_port=relay_port,
                                   connect=False,
                                   USB_VC_cut_port=USB_VC_cut_port)()

# power on device
psteps = ParallelSteps(use_control_process=False)
step_id_power_on = psteps.add_step(relay_steps.power_on_device,
                                   serial=serial,
                                   timeout=120,
                                   relay_type=relay_type,
                                   relay_port=relay_port,
                                   power_port=power_port)
# wait for a while without USB connection
time.sleep(60)

# reconnect adb
relay_steps.connect_disconnect_usb(serial=serial,
                                   relay_type=relay_type,
                                   relay_port=relay_port,
                                   connect=True,
                                   USB_VC_cut_port=USB_VC_cut_port)()
# finalize the power on step
psteps.interpret_step(step_id_power_on)

adb_steps.wait_for_ui_processes(serial=serial)()
##### test end #####
# @description: Checks of screen lock appears at boot time.
#
# @author:      [email protected]
#
##############################################################################

from testlib.scripts.android.adb import adb_steps
from testlib.scripts.security.scripts import prerequisites
from testlib.base.base_utils import get_args
import sys
import time
globals().update(vars(get_args(sys.argv)))

# Run Prerequisites
prerequisites.run_prereq(serial=serial,
                         pin="1234",
                         set_screen_lock=True,
                         require_pin_to_start_device=True)()
time.sleep(5)

adb_steps.reboot(serial=serial,
                 no_ui=True,
                 boot_to_Android=False,
                 pin="1234",
                 blocking=True)()

adb_steps.wait_for_ui_processes(serial=serial, imeout=30000)()

adb_steps.wait_for_text(serial=serial,
                        text_to_find="To start Android, enter your PIN")()
Beispiel #5
0
    def do(self):
        # Create panic
        adb_steps.root_connect_device(serial=self.serial)()
        if self.create_crash_mode == "panic":
            # Using local_steps to run the command because adb_steps.command() does not create kernel panic
            local_steps.command("adb -s {0} shell {1}".format(
                self.serial, self.panic_command))()

            # Wait for the device to disconnect
            local_steps.wait_until_disconnected(serial=self.serial)()
            if self.use_combo_button == False:
                print "======================wait 120s======================="
                time.sleep(120)
        else:
            adb_steps.kill_process(serial=self.serial,
                                   process_name=self.watchdog_process_name,
                                   with_reboot=True,
                                   reboot_timeout=60)()

        # Wait for a device state
        if self.wait_for_state == "fastboot":
            # Set the pass and error messages
            self.set_errorm(
                "", "The device with serial {0} is not in fastboot".format(
                    self.serial))
            self.set_passm("The device with serial {0} is in fastboot".format(
                self.serial))

            # If the expected state is fastboot, we need to press the volume down button after the panic is created
            # This will boot the device in fastboot
            # Create a parallel step
            # use_control_process=False
            psteps = ParallelSteps(use_control_process=False)

            step_id_combo = psteps.add_step(
                local_steps.wait_for_fastboot,
                serial=self.serial,
                timeout=self.wait_for_fastboot_timeout)

            self.relay.relay.on(self.relay.v_down_port)
            time.sleep(self.wait_for_fastboot_timeout - 10)
            self.relay.relay.off(self.relay.v_down_port)

            # Interpret the parallel step result
            psteps.interpret_step(step_id_combo)

        elif self.wait_for_state == "android":
            # Set the pass and error messages
            self.set_errorm(
                "",
                "The device with serial {0} is not in MOS".format(self.serial))
            self.set_passm("The device with serial {0} is in MOS".format(
                self.serial))

            # Wait for adb connection
            local_steps.wait_for_adb(serial=self.serial)()

            # Wait for the UI processes
            adb_steps.wait_for_ui_processes(serial=self.serial)()
        elif self.wait_for_state == "crashmode":
            # Set the pass and  error messages
            self.set_errorm(
                "", "The device with serial {0} is not in crash mode".format(
                    self.serial))
            self.set_passm(
                "The device with serial {0} is in crash mode".format(
                    self.serial))

            # Wait for crashmode
            local_steps.wait_for_crashmode(serial=self.serial, timeout=60)()