麒麟系统QT自动化测试解决方案-如何高效快捷实现菜单操作

 根据菜单路径去操作菜单：例如：clickmenu（path="file->new->python")

 这样就大大提高了脚本的效率。

import pyatspi

import time
import gi
from gi.repository import GLib

def get_children_by_name(self, name, recursive = False):
        return CSMElementUtil().get_children_by_name(self.accessible_element, name, recursive)

def get_child_by_path(self, path = []):
        found_child = None
        if path and len(path) > 0:
            try:
                layer_index = 0
                layer_count = len(path)
                current_element = self
                child_elements = []
                while layer_index < layer_count:
                    child_name = path[layer_index]
                    child_elements = current_element.get_children_by_name(child_name)
                    if child_elements and len(child_elements) > 0:
                        current_element = child_elements[0]
                        layer_index = layer_index + 1
                    else:
                        print("can't find child element, current element name=%s, child element name=%s, path=%s"\
                                           , current_element.get_name(), child_name, path)
                        break
                if layer_index == layer_count:
                    found_child = current_element
            except (GLib.GError, TypeError) as err:
                print("get_child_by_path, error: %s", err)
        else:
            print("get_child_by_path, the parameter: path was None or empty. class=%s", __class__)
        
        return found_child
    
    def click_child_by_path(self, path = [], recursive_click = False):
        success = False
        if path and len(path) > 0:
            try:
                layer_index = 0
                layer_count = len(path)
                current_element = self
                child_elements = []
                while layer_index < layer_count:
                    if recursive_click:
                        current_element.do_action(CSMActionType.click)
                
                    child_name = path[layer_index]
                    child_elements = current_element.get_children_by_name(child_name)
                    if child_elements and len(child_elements) > 0:
                        current_element = child_elements[0]
                        if recursive_click:
                            current_element.do_action(CSMActionType.click)
                        layer_index = layer_index + 1
                    else:
                        print("can't find child element, current element name=%s, child element name=%s, path=%s"\
                                           , current_element.get_name(), child_name, path)
                        break
                if layer_index == layer_count:
                    current_element.do_action(CSMActionType.click)
                    success = True
            except (GLib.GError, TypeError) as err:
                print("click_child_by_path, error: %s", err)
        else:
            print("click_child_by_path, the parameter: path was None or empty. class=%s", __class__)
        return success
    
    def select_child_by_path(self, path = [], recursive_select = False):
        success = False
        if path and len(path) > 0:
            try:
                layer_index = 0
                layer_count = len(path)
                current_element = self
                child_elements = []
                
                while layer_index < layer_count:
                    if recursive_select:
                        current_element.select_self()
                    child_name = path[layer_index]
                    child_elements = current_element.get_children_by_name(child_name)
                    if child_elements and len(child_elements) > 0:
                        current_element = child_elements[0]
                        layer_index = layer_index + 1
                    else:
                        print("can't find child element, current element name=%s, child element name=%s, path=%s"\
                                           , current_element.get_name(), child_name, path)
                        break
                if layer_index == layer_count:
                    current_element.select_self()
                    success = True
            except (GLib.GError, TypeError) as err:
                print("select_child_by_path, error: %s", err)
        else:
            print("select_child_by_path, the parameter: path was None or empty. class=%s", __class__)
        return success

class CSMElementUtil(object):
   def get_children_by_name(self, accessible_node, name = "", recursive = True):
        
        def predicate_name(x):
            if name and len(name) > 0:
                if name != x.name:
                    return False
                else:
                    print("predicate_name_role: matched element name, name=", name, ", x.name=", x.name
                          , ", x.getRole()=", x.getRole())
                    return True
            else:
                return False
        
        children_list = []
        if name and len(name) > 0:
            if recursive:
                try:
                    predicate = predicate_name
                    found_accessibles = pyatspi.utils.findAllDescendants(accessible_node, predicate)
                    
                    for element in found_accessibles:
                        found_element = CSMElementFactory().create_element(CSMElementType.element, element)
                        children_list.append(found_element)
                except (GLib.GError, TypeError) as err:
                    print(__class__)
                    print(err)
            else:
                for child in accessible_node:
                    if name == child.name:
                        found_element = CSMElementFactory().create_element(CSMElementType.element, child)
                        children_list.append(found_element)
        
        return children_list