测试人工智能自动语音识别系统之IOS

idevicename -u [udid]

Could not connect to lockdownd. Exiting.

brew uninstall -f libimobiledevice ideviceinstaller usbmuxd

brew uninstall --ignore-dependencies libimobiledevice ideviceinstaller usbmuxd

brew install -v --HEAD --fetch --build-from-source usbmuxd libimobiledevice ideviceinstaller

npm i -g cnpm --registry=https://registry.npm.taobao.org

cnpm install -g appium

import subprocess


def cmd(cmd):
    return subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)


def get_device_udid():
    if cmd('idevice_id -l').stdout != "":
        result = cmd('idevice_id -l').stdout.readline()
        return result.decode("utf-8").strip()


def get_version():
    if cmd('ideviceinfo -k ProductVersion').stdout != "":
        result = cmd('ideviceinfo -k ProductVersion').stdout.readline()
        return result.decode("utf-8").strip()


def get_device_show_name():
    if cmd('idevicename').stdout != "":
        result = cmd('idevicename').stdout.readline()
        return result.decode("utf-8").strip()


def get_device_name():
    if cmd('ideviceinfo -k ProductType').stdout != "":
        result = cmd('ideviceinfo -k ProductType').stdout.readline()
        return result.decode("utf-8").strip()

from appium import webdriver
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
from time import sleep
import arrow
import datetime
# import pygame
import os
import numpy as np
import pandas as pd

from playsound import playsound

TIME_OUT = 30
TIMES = 30
element_max_wait_time = 10
DURATION = 0.5
SLEEPTIME = 13

current_path = os.path.dirname(os.path.abspath(__file__))

audio_file_path = os.path.join(current_path, "audio")
sentence_file = current_path + "/sentence.txt"
result_path = current_path + "/result"
log_path = current_path + "/result/log.txt"

import subprocess


def cmd(cmd):
    return subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)


def get_device_udid():
    if cmd('idevice_id -l').stdout != "":
        result = cmd('idevice_id -l').stdout.readline()
        return result.decode("utf-8").strip()


def get_version():
    if cmd('ideviceinfo -k ProductVersion').stdout != "":
        result = cmd('ideviceinfo -k ProductVersion').stdout.readline()
        return result.decode("utf-8").strip()


def get_device_show_name():
    if cmd('idevicename').stdout != "":
        result = cmd('idevicename').stdout.readline()
        return result.decode("utf-8").strip()


def get_device_name():
    if cmd('ideviceinfo -k ProductType').stdout != "":
        result = cmd('ideviceinfo -k ProductType').stdout.readline()
        return result.decode("utf-8").strip()


desired_caps = {}
desired_caps["automationName"] = "XCUITest"
desired_caps["platformName"] = "ios"
desired_caps["platformVersion"] = "13.1.1"
desired_caps["udid"] = "00008030-000164D41428802E"
desired_caps["deviceName"] = "iPhone 11 Pro"
desired_caps["bundleId"] = "com.ScoringSample"
desired_caps["xcodeOrgId"] = "Anderson"
desired_caps["xcodeSigningId"] = "iPhone Developer"
desired_caps["updatedWDABundleId"] = "com.SpeechScoringSample"

driver = webdriver.Remote("http://localhost:4723/wd/hub", desired_caps)

result = []


def play_audio(mp3):
    playsound(mp3)


def is_element_appear(driver, element):
    try:
        driver.find_element_by_accessibility_id(element)
        return True
    except:
        return False


def wait_element_appear(driver, element):
    try:
        wait = WebDriverWait(driver, element_max_wait_time, DURATION)
        wait.until(lambda driver: driver.find_element_by_accessibility_id(element))
        return True
    except:
        return False


def type_texts(text):
    input = driver.find_element_by_accessibility_id("txt_phrase")
    input.clear()
    input.send_keys(text)
    # driver.hide_keyboard()
    sleep(1)
    driver.find_element_by_accessibility_id("Load from file").click()

def start_record(file, each_time):
    record = "btn_recod"
    if wait_element_appear(driver, record):
        driver.find_element_by_accessibility_id(record).click()

    play_audio(file)
    sleep(SLEEPTIME)

    sent_record = "btn_recod"

    if wait_element_appear(driver, sent_record):
        driver.find_element_by_accessibility_id(sent_record).click()

    start_time = datetime.datetime.now()

    score = "lbl_message"

    #  Get the end time from judge the score whether appear or not
    while not is_element_appear(driver, score):
        print("please wait, the response still didn't back at {}".format(arrow.now()))
        timeout_diff = arrow.now() - start_time
        print(timeout_diff.seconds)
        if timeout_diff.seconds >= TIME_OUT:
            print("overtime")
            # end_time = start_time.shift(seconds=+TIME_OUT)
            break

    end_time = datetime.datetime.now()

    used_time = (end_time - start_time).total_seconds()
    print("time is {}".format(used_time))
    each_time.append(used_time)
    sleep(1)

    # write log in case break out occur even it will lost some performance
    # content = get_brand() + get_version() + ": run {}".format(text) + "used time: {}".format(used_time)+"\r\n"
    # write_log(content)


def write_log(content):
    # write a log in case crash or any breakout
    with open(log_path, 'a+') as f:
        f.writelines(content)


def get_sentence_audio():
    # get each sentence and mp3 map
    mp3_length = []
    with open(sentence_file, "r") as f:
        for index, line in enumerate(f.readlines()):
            line = line.strip("\n")
            file = audio_file_path + "/" + str(index + 1) + ".mp3"
            mutiply_times(line, file)


def mutiply_times(text, audio_file):
    # play mutiply times
    each_audio_play_time = []
    type_texts(text)
    for i in range(TIMES):
        start_record(audio_file, each_audio_play_time)

    result.append(each_audio_play_time)
    # in case it was crash.
    write_log("current result is {} {}".format(text, each_audio_play_time))


if __name__ == "__main__":
    get_sentence_audio()

    device_name = "iPhone11Pro"
    device_version = "13.1.1"

    # get result for each device
    result_arrary = np.array(result)
    result_pd = pd.DataFrame(result_arrary, columns=range(1, TIMES + 1))
    # add the average result
    result_pd['AVG'] = result_pd.mean(axis=1)  # axis 0为列，1为行

    # add the sample in result
    sentences = open(sentence_file, 'r')
    text = sentences.readlines()
    sentences.close()
    sentence_pd = pd.DataFrame(text, columns=["sentence"])
    result_final = sentence_pd.join(result_pd)

    # add the device type in result

    device_arrary = np.array([device_name + "_" + device_version] * len(text)).T
    device_pd = pd.DataFrame(device_arrary)
    result_final = device_pd.join(result_final)

    # write the result to excel
    result_final.to_excel(result_path + "/" + device_name + "_" + device_version + ".xlsx", index=False)